ffmpeg: call pre_process_video_frame() only if decoding is needed
[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, resample_changed;
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     resample_changed = ost->resample_width   != dec->width  ||
1130                        ost->resample_height  != dec->height ||
1131                        ost->resample_pix_fmt != dec->pix_fmt;
1132
1133     if (resample_changed) {
1134         av_log(NULL, AV_LOG_INFO,
1135                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136                ist->file_index, ist->index,
1137                ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1138                dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1139         if(!ost->video_resample)
1140             ffmpeg_exit(1);
1141     }
1142
1143 #if !CONFIG_AVFILTER
1144     if (ost->video_resample) {
1145         final_picture = &ost->pict_tmp;
1146         if (resample_changed) {
1147             /* initialize a new scaler context */
1148             sws_freeContext(ost->img_resample_ctx);
1149             ost->img_resample_ctx = sws_getContext(
1150                 ist->st->codec->width,
1151                 ist->st->codec->height,
1152                 ist->st->codec->pix_fmt,
1153                 ost->st->codec->width,
1154                 ost->st->codec->height,
1155                 ost->st->codec->pix_fmt,
1156                 ost->sws_flags, NULL, NULL, NULL);
1157             if (ost->img_resample_ctx == NULL) {
1158                 fprintf(stderr, "Cannot get resampling context\n");
1159                 ffmpeg_exit(1);
1160             }
1161         }
1162         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1163               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1164     }
1165 #endif
1166
1167     /* duplicates frame if needed */
1168     for(i=0;i<nb_frames;i++) {
1169         AVPacket pkt;
1170         av_init_packet(&pkt);
1171         pkt.stream_index= ost->index;
1172
1173         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1174             /* raw pictures are written as AVPicture structure to
1175                avoid any copies. We support temorarily the older
1176                method. */
1177             AVFrame* old_frame = enc->coded_frame;
1178             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1179             pkt.data= (uint8_t *)final_picture;
1180             pkt.size=  sizeof(AVPicture);
1181             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1182             pkt.flags |= AV_PKT_FLAG_KEY;
1183
1184             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1185             enc->coded_frame = old_frame;
1186         } else {
1187             AVFrame big_picture;
1188
1189             big_picture= *final_picture;
1190             /* better than nothing: use input picture interlaced
1191                settings */
1192             big_picture.interlaced_frame = in_picture->interlaced_frame;
1193             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1194                 if(top_field_first == -1)
1195                     big_picture.top_field_first = in_picture->top_field_first;
1196                 else
1197                     big_picture.top_field_first = top_field_first;
1198             }
1199
1200             /* handles sameq here. This is not correct because it may
1201                not be a global option */
1202             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1203             if(!me_threshold)
1204                 big_picture.pict_type = 0;
1205 //            big_picture.pts = AV_NOPTS_VALUE;
1206             big_picture.pts= ost->sync_opts;
1207 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1208 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1209             if (ost->forced_kf_index < ost->forced_kf_count &&
1210                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1211                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1212                 ost->forced_kf_index++;
1213             }
1214             ret = avcodec_encode_video(enc,
1215                                        bit_buffer, bit_buffer_size,
1216                                        &big_picture);
1217             if (ret < 0) {
1218                 fprintf(stderr, "Video encoding failed\n");
1219                 ffmpeg_exit(1);
1220             }
1221
1222             if(ret>0){
1223                 pkt.data= bit_buffer;
1224                 pkt.size= ret;
1225                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1226                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1227 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1228    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1229    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1230
1231                 if(enc->coded_frame->key_frame)
1232                     pkt.flags |= AV_PKT_FLAG_KEY;
1233                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1234                 *frame_size = ret;
1235                 video_size += ret;
1236                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1237                 //        enc->frame_number-1, ret, enc->pict_type);
1238                 /* if two pass, output log */
1239                 if (ost->logfile && enc->stats_out) {
1240                     fprintf(ost->logfile, "%s", enc->stats_out);
1241                 }
1242             }
1243         }
1244         ost->sync_opts++;
1245         ost->frame_number++;
1246     }
1247 }
1248
1249 static double psnr(double d){
1250     return -10.0*log(d)/log(10.0);
1251 }
1252
1253 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1254                            int frame_size)
1255 {
1256     AVCodecContext *enc;
1257     int frame_number;
1258     double ti1, bitrate, avg_bitrate;
1259
1260     /* this is executed just the first time do_video_stats is called */
1261     if (!vstats_file) {
1262         vstats_file = fopen(vstats_filename, "w");
1263         if (!vstats_file) {
1264             perror("fopen");
1265             ffmpeg_exit(1);
1266         }
1267     }
1268
1269     enc = ost->st->codec;
1270     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1271         frame_number = ost->frame_number;
1272         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1273         if (enc->flags&CODEC_FLAG_PSNR)
1274             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1275
1276         fprintf(vstats_file,"f_size= %6d ", frame_size);
1277         /* compute pts value */
1278         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1279         if (ti1 < 0.01)
1280             ti1 = 0.01;
1281
1282         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1283         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1284         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1285             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1286         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1287     }
1288 }
1289
1290 static void print_report(AVFormatContext **output_files,
1291                          AVOutputStream **ost_table, int nb_ostreams,
1292                          int is_last_report)
1293 {
1294     char buf[1024];
1295     AVOutputStream *ost;
1296     AVFormatContext *oc;
1297     int64_t total_size;
1298     AVCodecContext *enc;
1299     int frame_number, vid, i;
1300     double bitrate, ti1, pts;
1301     static int64_t last_time = -1;
1302     static int qp_histogram[52];
1303
1304     if (!is_last_report) {
1305         int64_t cur_time;
1306         /* display the report every 0.5 seconds */
1307         cur_time = av_gettime();
1308         if (last_time == -1) {
1309             last_time = cur_time;
1310             return;
1311         }
1312         if ((cur_time - last_time) < 500000)
1313             return;
1314         last_time = cur_time;
1315     }
1316
1317
1318     oc = output_files[0];
1319
1320     total_size = avio_size(oc->pb);
1321     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1322         total_size= avio_tell(oc->pb);
1323
1324     buf[0] = '\0';
1325     ti1 = 1e10;
1326     vid = 0;
1327     for(i=0;i<nb_ostreams;i++) {
1328         ost = ost_table[i];
1329         enc = ost->st->codec;
1330         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1331             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1332                      !ost->st->stream_copy ?
1333                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1334         }
1335         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1336             float t = (av_gettime()-timer_start) / 1000000.0;
1337
1338             frame_number = ost->frame_number;
1339             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1340                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1341                      !ost->st->stream_copy ?
1342                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1343             if(is_last_report)
1344                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1345             if(qp_hist){
1346                 int j;
1347                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1349                     qp_histogram[qp]++;
1350                 for(j=0; j<32; j++)
1351                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1352             }
1353             if (enc->flags&CODEC_FLAG_PSNR){
1354                 int j;
1355                 double error, error_sum=0;
1356                 double scale, scale_sum=0;
1357                 char type[3]= {'Y','U','V'};
1358                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1359                 for(j=0; j<3; j++){
1360                     if(is_last_report){
1361                         error= enc->error[j];
1362                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1363                     }else{
1364                         error= enc->coded_frame->error[j];
1365                         scale= enc->width*enc->height*255.0*255.0;
1366                     }
1367                     if(j) scale/=4;
1368                     error_sum += error;
1369                     scale_sum += scale;
1370                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1371                 }
1372                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1373             }
1374             vid = 1;
1375         }
1376         /* compute min output value */
1377         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1378         if ((pts < ti1) && (pts > 0))
1379             ti1 = pts;
1380     }
1381     if (ti1 < 0.01)
1382         ti1 = 0.01;
1383
1384     if (verbose > 0 || is_last_report) {
1385         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1386
1387         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1388             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1389             (double)total_size / 1024, ti1, bitrate);
1390
1391         if (nb_frames_dup || nb_frames_drop)
1392           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1393                   nb_frames_dup, nb_frames_drop);
1394
1395         if (verbose >= 0)
1396             fprintf(stderr, "%s    \r", buf);
1397
1398         fflush(stderr);
1399     }
1400
1401     if (is_last_report && verbose >= 0){
1402         int64_t raw= audio_size + video_size + extra_size;
1403         fprintf(stderr, "\n");
1404         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1405                 video_size/1024.0,
1406                 audio_size/1024.0,
1407                 extra_size/1024.0,
1408                 100.0*(total_size - raw)/raw
1409         );
1410     }
1411 }
1412
1413 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1414 {
1415     int fill_char = 0x00;
1416     if (sample_fmt == AV_SAMPLE_FMT_U8)
1417         fill_char = 0x80;
1418     memset(buf, fill_char, size);
1419 }
1420
1421 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1422 static int output_packet(AVInputStream *ist, int ist_index,
1423                          AVOutputStream **ost_table, int nb_ostreams,
1424                          const AVPacket *pkt)
1425 {
1426     AVFormatContext *os;
1427     AVOutputStream *ost;
1428     int ret, i;
1429     int got_output;
1430     AVFrame picture;
1431     void *buffer_to_free = NULL;
1432     static unsigned int samples_size= 0;
1433     AVSubtitle subtitle, *subtitle_to_free;
1434     int64_t pkt_pts = AV_NOPTS_VALUE;
1435 #if CONFIG_AVFILTER
1436     int frame_available;
1437 #endif
1438
1439     AVPacket avpkt;
1440     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1441
1442     if(ist->next_pts == AV_NOPTS_VALUE)
1443         ist->next_pts= ist->pts;
1444
1445     if (pkt == NULL) {
1446         /* EOF handling */
1447         av_init_packet(&avpkt);
1448         avpkt.data = NULL;
1449         avpkt.size = 0;
1450         goto handle_eof;
1451     } else {
1452         avpkt = *pkt;
1453     }
1454
1455     if(pkt->dts != AV_NOPTS_VALUE)
1456         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1457     if(pkt->pts != AV_NOPTS_VALUE)
1458         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1459
1460     //while we have more to decode or while the decoder did output something on EOF
1461     while (avpkt.size > 0 || (!pkt && got_output)) {
1462         uint8_t *data_buf, *decoded_data_buf;
1463         int data_size, decoded_data_size;
1464     handle_eof:
1465         ist->pts= ist->next_pts;
1466
1467         if(avpkt.size && avpkt.size != pkt->size &&
1468            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1469             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1470             ist->showed_multi_packet_warning=1;
1471         }
1472
1473         /* decode the packet if needed */
1474         decoded_data_buf = NULL; /* fail safe */
1475         decoded_data_size= 0;
1476         data_buf  = avpkt.data;
1477         data_size = avpkt.size;
1478         subtitle_to_free = NULL;
1479         if (ist->decoding_needed) {
1480             switch(ist->st->codec->codec_type) {
1481             case AVMEDIA_TYPE_AUDIO:{
1482                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1483                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1484                     av_free(samples);
1485                     samples= av_malloc(samples_size);
1486                 }
1487                 decoded_data_size= samples_size;
1488                     /* XXX: could avoid copy if PCM 16 bits with same
1489                        endianness as CPU */
1490                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1491                                             &avpkt);
1492                 if (ret < 0)
1493                     goto fail_decode;
1494                 avpkt.data += ret;
1495                 avpkt.size -= ret;
1496                 data_size   = ret;
1497                 got_output  = decoded_data_size > 0;
1498                 /* Some bug in mpeg audio decoder gives */
1499                 /* decoded_data_size < 0, it seems they are overflows */
1500                 if (!got_output) {
1501                     /* no audio frame */
1502                     continue;
1503                 }
1504                 decoded_data_buf = (uint8_t *)samples;
1505                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1506                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1507                 break;}
1508             case AVMEDIA_TYPE_VIDEO:
1509                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1510                     /* XXX: allocate picture correctly */
1511                     avcodec_get_frame_defaults(&picture);
1512                     avpkt.pts = pkt_pts;
1513                     avpkt.dts = ist->pts;
1514                     pkt_pts = AV_NOPTS_VALUE;
1515
1516                     ret = avcodec_decode_video2(ist->st->codec,
1517                                                 &picture, &got_output, &avpkt);
1518                     ist->st->quality= picture.quality;
1519                     if (ret < 0)
1520                         goto fail_decode;
1521                     if (!got_output) {
1522                         /* no picture yet */
1523                         goto discard_packet;
1524                     }
1525                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1526                     if (ist->st->codec->time_base.num != 0) {
1527                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1528                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1529                                           ist->st->codec->time_base.num * ticks) /
1530                             ist->st->codec->time_base.den;
1531                     }
1532                     avpkt.size = 0;
1533                     buffer_to_free = NULL;
1534                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1535                     break;
1536             case AVMEDIA_TYPE_SUBTITLE:
1537                 ret = avcodec_decode_subtitle2(ist->st->codec,
1538                                                &subtitle, &got_output, &avpkt);
1539                 if (ret < 0)
1540                     goto fail_decode;
1541                 if (!got_output) {
1542                     goto discard_packet;
1543                 }
1544                 subtitle_to_free = &subtitle;
1545                 avpkt.size = 0;
1546                 break;
1547             default:
1548                 goto fail_decode;
1549             }
1550         } else {
1551             switch(ist->st->codec->codec_type) {
1552             case AVMEDIA_TYPE_AUDIO:
1553                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1554                     ist->st->codec->sample_rate;
1555                 break;
1556             case AVMEDIA_TYPE_VIDEO:
1557                 if (ist->st->codec->time_base.num != 0) {
1558                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1559                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1560                                       ist->st->codec->time_base.num * ticks) /
1561                         ist->st->codec->time_base.den;
1562                 }
1563                 break;
1564             }
1565             ret = avpkt.size;
1566             avpkt.size = 0;
1567         }
1568
1569 #if CONFIG_AVFILTER
1570         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1571             AVRational sar;
1572             if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1573             else                                  sar = ist->st->codec->sample_aspect_ratio;
1574             // add it to be filtered
1575             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1576                                      ist->pts,
1577                                      sar);
1578         }
1579 #endif
1580
1581         // preprocess audio (volume)
1582         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1583             if (audio_volume != 256) {
1584                 short *volp;
1585                 volp = samples;
1586                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1587                     int v = ((*volp) * audio_volume + 128) >> 8;
1588                     if (v < -32768) v = -32768;
1589                     if (v >  32767) v = 32767;
1590                     *volp++ = v;
1591                 }
1592             }
1593         }
1594
1595         /* frame rate emulation */
1596         if (rate_emu) {
1597             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1598             int64_t now = av_gettime() - ist->start;
1599             if (pts > now)
1600                 usleep(pts - now);
1601         }
1602 #if CONFIG_AVFILTER
1603         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1604             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1605 #endif
1606         /* if output time reached then transcode raw format,
1607            encode packets and output them */
1608         if (start_time == 0 || ist->pts >= start_time)
1609 #if CONFIG_AVFILTER
1610         while (frame_available) {
1611             AVRational ist_pts_tb;
1612             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1613                 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1614             if (ist->picref)
1615                 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1616 #endif
1617             for(i=0;i<nb_ostreams;i++) {
1618                 int frame_size;
1619
1620                 ost = ost_table[i];
1621                 if (ost->source_index == ist_index) {
1622                     os = output_files[ost->file_index];
1623
1624                     /* set the input output pts pairs */
1625                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1626
1627                     if (ost->encoding_needed) {
1628                         av_assert0(ist->decoding_needed);
1629                         switch(ost->st->codec->codec_type) {
1630                         case AVMEDIA_TYPE_AUDIO:
1631                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1632                             break;
1633                         case AVMEDIA_TYPE_VIDEO:
1634 #if CONFIG_AVFILTER
1635                             if (ist->picref->video)
1636                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1637 #endif
1638                             do_video_out(os, ost, ist, &picture, &frame_size);
1639                             if (vstats_filename && frame_size)
1640                                 do_video_stats(os, ost, frame_size);
1641                             break;
1642                         case AVMEDIA_TYPE_SUBTITLE:
1643                             do_subtitle_out(os, ost, ist, &subtitle,
1644                                             pkt->pts);
1645                             break;
1646                         default:
1647                             abort();
1648                         }
1649                     } else {
1650                         AVFrame avframe; //FIXME/XXX remove this
1651                         AVPacket opkt;
1652                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1653
1654                         av_init_packet(&opkt);
1655
1656                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1657                             continue;
1658
1659                         /* no reencoding needed : output the packet directly */
1660                         /* force the input stream PTS */
1661
1662                         avcodec_get_frame_defaults(&avframe);
1663                         ost->st->codec->coded_frame= &avframe;
1664                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1665
1666                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1667                             audio_size += data_size;
1668                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1669                             video_size += data_size;
1670                             ost->sync_opts++;
1671                         }
1672
1673                         opkt.stream_index= ost->index;
1674                         if(pkt->pts != AV_NOPTS_VALUE)
1675                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1676                         else
1677                             opkt.pts= AV_NOPTS_VALUE;
1678
1679                         if (pkt->dts == AV_NOPTS_VALUE)
1680                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1681                         else
1682                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1683                         opkt.dts -= ost_tb_start_time;
1684
1685                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1686                         opkt.flags= pkt->flags;
1687
1688                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1689                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1690                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1691                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1692                            ) {
1693                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1694                                 opkt.destruct= av_destruct_packet;
1695                         } else {
1696                             opkt.data = data_buf;
1697                             opkt.size = data_size;
1698                         }
1699
1700                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1701                         ost->st->codec->frame_number++;
1702                         ost->frame_number++;
1703                         av_free_packet(&opkt);
1704                     }
1705                 }
1706             }
1707
1708 #if CONFIG_AVFILTER
1709             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1710                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1711             if(ist->picref)
1712                 avfilter_unref_buffer(ist->picref);
1713         }
1714 #endif
1715         av_free(buffer_to_free);
1716         /* XXX: allocate the subtitles in the codec ? */
1717         if (subtitle_to_free) {
1718             avsubtitle_free(subtitle_to_free);
1719             subtitle_to_free = NULL;
1720         }
1721     }
1722  discard_packet:
1723     if (pkt == NULL) {
1724         /* EOF handling */
1725
1726         for(i=0;i<nb_ostreams;i++) {
1727             ost = ost_table[i];
1728             if (ost->source_index == ist_index) {
1729                 AVCodecContext *enc= ost->st->codec;
1730                 os = output_files[ost->file_index];
1731
1732                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1733                     continue;
1734                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1735                     continue;
1736
1737                 if (ost->encoding_needed) {
1738                     for(;;) {
1739                         AVPacket pkt;
1740                         int fifo_bytes;
1741                         av_init_packet(&pkt);
1742                         pkt.stream_index= ost->index;
1743
1744                         switch(ost->st->codec->codec_type) {
1745                         case AVMEDIA_TYPE_AUDIO:
1746                             fifo_bytes = av_fifo_size(ost->fifo);
1747                             ret = 0;
1748                             /* encode any samples remaining in fifo */
1749                             if (fifo_bytes > 0) {
1750                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1751                                 int fs_tmp = enc->frame_size;
1752
1753                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1754                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1755                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1756                                 } else { /* pad */
1757                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1758                                     if (allocated_audio_buf_size < frame_bytes)
1759                                         ffmpeg_exit(1);
1760                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1761                                 }
1762
1763                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1764                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1765                                                           ost->st->time_base.num, enc->sample_rate);
1766                                 enc->frame_size = fs_tmp;
1767                             }
1768                             if(ret <= 0) {
1769                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1770                             }
1771                             if (ret < 0) {
1772                                 fprintf(stderr, "Audio encoding failed\n");
1773                                 ffmpeg_exit(1);
1774                             }
1775                             audio_size += ret;
1776                             pkt.flags |= AV_PKT_FLAG_KEY;
1777                             break;
1778                         case AVMEDIA_TYPE_VIDEO:
1779                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1780                             if (ret < 0) {
1781                                 fprintf(stderr, "Video encoding failed\n");
1782                                 ffmpeg_exit(1);
1783                             }
1784                             video_size += ret;
1785                             if(enc->coded_frame && enc->coded_frame->key_frame)
1786                                 pkt.flags |= AV_PKT_FLAG_KEY;
1787                             if (ost->logfile && enc->stats_out) {
1788                                 fprintf(ost->logfile, "%s", enc->stats_out);
1789                             }
1790                             break;
1791                         default:
1792                             ret=-1;
1793                         }
1794
1795                         if(ret<=0)
1796                             break;
1797                         pkt.data= bit_buffer;
1798                         pkt.size= ret;
1799                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1800                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1801                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1802                     }
1803                 }
1804             }
1805         }
1806     }
1807
1808     return 0;
1809  fail_decode:
1810     return -1;
1811 }
1812
1813 static void print_sdp(AVFormatContext **avc, int n)
1814 {
1815     char sdp[2048];
1816
1817     av_sdp_create(avc, n, sdp, sizeof(sdp));
1818     printf("SDP:\n%s\n", sdp);
1819     fflush(stdout);
1820 }
1821
1822 static int copy_chapters(int infile, int outfile)
1823 {
1824     AVFormatContext *is = input_files[infile];
1825     AVFormatContext *os = output_files[outfile];
1826     int i;
1827
1828     for (i = 0; i < is->nb_chapters; i++) {
1829         AVChapter *in_ch = is->chapters[i], *out_ch;
1830         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1831                                       AV_TIME_BASE_Q, in_ch->time_base);
1832         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1833                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1834
1835
1836         if (in_ch->end < ts_off)
1837             continue;
1838         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1839             break;
1840
1841         out_ch = av_mallocz(sizeof(AVChapter));
1842         if (!out_ch)
1843             return AVERROR(ENOMEM);
1844
1845         out_ch->id        = in_ch->id;
1846         out_ch->time_base = in_ch->time_base;
1847         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1848         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1849
1850         if (metadata_chapters_autocopy)
1851             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1852
1853         os->nb_chapters++;
1854         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1855         if (!os->chapters)
1856             return AVERROR(ENOMEM);
1857         os->chapters[os->nb_chapters - 1] = out_ch;
1858     }
1859     return 0;
1860 }
1861
1862 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1863                                     AVCodecContext *avctx)
1864 {
1865     char *p;
1866     int n = 1, i;
1867     int64_t t;
1868
1869     for (p = kf; *p; p++)
1870         if (*p == ',')
1871             n++;
1872     ost->forced_kf_count = n;
1873     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1874     if (!ost->forced_kf_pts) {
1875         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1876         ffmpeg_exit(1);
1877     }
1878     for (i = 0; i < n; i++) {
1879         p = i ? strchr(p, ',') + 1 : kf;
1880         t = parse_time_or_die("force_key_frames", p, 1);
1881         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1882     }
1883 }
1884
1885 /*
1886  * The following code is the main loop of the file converter
1887  */
1888 static int transcode(AVFormatContext **output_files,
1889                      int nb_output_files,
1890                      AVFormatContext **input_files,
1891                      int nb_input_files,
1892                      AVStreamMap *stream_maps, int nb_stream_maps)
1893 {
1894     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1895     AVFormatContext *is, *os;
1896     AVCodecContext *codec, *icodec;
1897     AVOutputStream *ost, **ost_table = NULL;
1898     AVInputStream *ist, **ist_table = NULL;
1899     AVInputFile *file_table;
1900     char error[1024];
1901     int key;
1902     int want_sdp = 1;
1903     uint8_t no_packet[MAX_FILES]={0};
1904     int no_packet_count=0;
1905
1906     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1907     if (!file_table)
1908         goto fail;
1909
1910     /* input stream init */
1911     j = 0;
1912     for(i=0;i<nb_input_files;i++) {
1913         is = input_files[i];
1914         file_table[i].ist_index = j;
1915         file_table[i].nb_streams = is->nb_streams;
1916         j += is->nb_streams;
1917     }
1918     nb_istreams = j;
1919
1920     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1921     if (!ist_table)
1922         goto fail;
1923
1924     for(i=0;i<nb_istreams;i++) {
1925         ist = av_mallocz(sizeof(AVInputStream));
1926         if (!ist)
1927             goto fail;
1928         ist_table[i] = ist;
1929     }
1930     j = 0;
1931     for(i=0;i<nb_input_files;i++) {
1932         is = input_files[i];
1933         for(k=0;k<is->nb_streams;k++) {
1934             ist = ist_table[j++];
1935             ist->st = is->streams[k];
1936             ist->file_index = i;
1937             ist->index = k;
1938             ist->discard = 1; /* the stream is discarded by default
1939                                  (changed later) */
1940
1941             if (rate_emu) {
1942                 ist->start = av_gettime();
1943             }
1944         }
1945     }
1946
1947     /* output stream init */
1948     nb_ostreams = 0;
1949     for(i=0;i<nb_output_files;i++) {
1950         os = output_files[i];
1951         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1952             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1953             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1954             ret = AVERROR(EINVAL);
1955             goto fail;
1956         }
1957         nb_ostreams += os->nb_streams;
1958     }
1959     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1960         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1961         ret = AVERROR(EINVAL);
1962         goto fail;
1963     }
1964
1965     /* Sanity check the mapping args -- do the input files & streams exist? */
1966     for(i=0;i<nb_stream_maps;i++) {
1967         int fi = stream_maps[i].file_index;
1968         int si = stream_maps[i].stream_index;
1969
1970         if (fi < 0 || fi > nb_input_files - 1 ||
1971             si < 0 || si > file_table[fi].nb_streams - 1) {
1972             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1973             ret = AVERROR(EINVAL);
1974             goto fail;
1975         }
1976         fi = stream_maps[i].sync_file_index;
1977         si = stream_maps[i].sync_stream_index;
1978         if (fi < 0 || fi > nb_input_files - 1 ||
1979             si < 0 || si > file_table[fi].nb_streams - 1) {
1980             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1981             ret = AVERROR(EINVAL);
1982             goto fail;
1983         }
1984     }
1985
1986     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1987     if (!ost_table)
1988         goto fail;
1989     n = 0;
1990     for(k=0;k<nb_output_files;k++) {
1991         os = output_files[k];
1992         for(i=0;i<os->nb_streams;i++,n++) {
1993             int found;
1994             ost = ost_table[n] = output_streams_for_file[k][i];
1995             ost->st = os->streams[i];
1996             if (nb_stream_maps > 0) {
1997                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1998                     stream_maps[n].stream_index;
1999
2000                 /* Sanity check that the stream types match */
2001                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2002                     int i= ost->file_index;
2003                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2004                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2005                         stream_maps[n].file_index, stream_maps[n].stream_index,
2006                         ost->file_index, ost->index);
2007                     ffmpeg_exit(1);
2008                 }
2009
2010             } else {
2011                 int best_nb_frames=-1;
2012                 /* get corresponding input stream index : we select the first one with the right type */
2013                 found = 0;
2014                 for(j=0;j<nb_istreams;j++) {
2015                     int skip=0;
2016                     ist = ist_table[j];
2017                     if(opt_programid){
2018                         int pi,si;
2019                         AVFormatContext *f= input_files[ ist->file_index ];
2020                         skip=1;
2021                         for(pi=0; pi<f->nb_programs; pi++){
2022                             AVProgram *p= f->programs[pi];
2023                             if(p->id == opt_programid)
2024                                 for(si=0; si<p->nb_stream_indexes; si++){
2025                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2026                                         skip=0;
2027                                 }
2028                         }
2029                     }
2030                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2031                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2032                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2033                             best_nb_frames= ist->st->codec_info_nb_frames;
2034                             ost->source_index = j;
2035                             found = 1;
2036                         }
2037                     }
2038                 }
2039
2040                 if (!found) {
2041                     if(! opt_programid) {
2042                         /* try again and reuse existing stream */
2043                         for(j=0;j<nb_istreams;j++) {
2044                             ist = ist_table[j];
2045                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2046                                 && ist->st->discard != AVDISCARD_ALL) {
2047                                 ost->source_index = j;
2048                                 found = 1;
2049                             }
2050                         }
2051                     }
2052                     if (!found) {
2053                         int i= ost->file_index;
2054                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2055                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2056                                 ost->file_index, ost->index);
2057                         ffmpeg_exit(1);
2058                     }
2059                 }
2060             }
2061             ist = ist_table[ost->source_index];
2062             ist->discard = 0;
2063             ost->sync_ist = (nb_stream_maps > 0) ?
2064                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2065                          stream_maps[n].sync_stream_index] : ist;
2066         }
2067     }
2068
2069     /* for each output stream, we compute the right encoding parameters */
2070     for(i=0;i<nb_ostreams;i++) {
2071         ost = ost_table[i];
2072         os = output_files[ost->file_index];
2073         ist = ist_table[ost->source_index];
2074
2075         codec = ost->st->codec;
2076         icodec = ist->st->codec;
2077
2078         if (metadata_streams_autocopy)
2079             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2080                              AV_METADATA_DONT_OVERWRITE);
2081
2082         ost->st->disposition = ist->st->disposition;
2083         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2084         codec->chroma_sample_location = icodec->chroma_sample_location;
2085
2086         if (ost->st->stream_copy) {
2087             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2088
2089             if (extra_size > INT_MAX)
2090                 goto fail;
2091
2092             /* if stream_copy is selected, no need to decode or encode */
2093             codec->codec_id = icodec->codec_id;
2094             codec->codec_type = icodec->codec_type;
2095
2096             if(!codec->codec_tag){
2097                 if(   !os->oformat->codec_tag
2098                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2099                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2100                     codec->codec_tag = icodec->codec_tag;
2101             }
2102
2103             codec->bit_rate = icodec->bit_rate;
2104             codec->rc_max_rate    = icodec->rc_max_rate;
2105             codec->rc_buffer_size = icodec->rc_buffer_size;
2106             codec->extradata= av_mallocz(extra_size);
2107             if (!codec->extradata)
2108                 goto fail;
2109             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2110             codec->extradata_size= icodec->extradata_size;
2111             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){
2112                 codec->time_base = icodec->time_base;
2113                 codec->time_base.num *= icodec->ticks_per_frame;
2114                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2115                           codec->time_base.num, codec->time_base.den, INT_MAX);
2116             }else
2117                 codec->time_base = ist->st->time_base;
2118             switch(codec->codec_type) {
2119             case AVMEDIA_TYPE_AUDIO:
2120                 if(audio_volume != 256) {
2121                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2122                     ffmpeg_exit(1);
2123                 }
2124                 codec->channel_layout = icodec->channel_layout;
2125                 codec->sample_rate = icodec->sample_rate;
2126                 codec->channels = icodec->channels;
2127                 codec->frame_size = icodec->frame_size;
2128                 codec->audio_service_type = icodec->audio_service_type;
2129                 codec->block_align= icodec->block_align;
2130                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2131                     codec->block_align= 0;
2132                 if(codec->codec_id == CODEC_ID_AC3)
2133                     codec->block_align= 0;
2134                 break;
2135             case AVMEDIA_TYPE_VIDEO:
2136                 codec->pix_fmt = icodec->pix_fmt;
2137                 codec->width = icodec->width;
2138                 codec->height = icodec->height;
2139                 codec->has_b_frames = icodec->has_b_frames;
2140                 break;
2141             case AVMEDIA_TYPE_SUBTITLE:
2142                 codec->width = icodec->width;
2143                 codec->height = icodec->height;
2144                 break;
2145             case AVMEDIA_TYPE_DATA:
2146                 break;
2147             default:
2148                 abort();
2149             }
2150         } else {
2151             switch(codec->codec_type) {
2152             case AVMEDIA_TYPE_AUDIO:
2153                 ost->fifo= av_fifo_alloc(1024);
2154                 if(!ost->fifo)
2155                     goto fail;
2156                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2157                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2158                 icodec->request_channels = codec->channels;
2159                 ist->decoding_needed = 1;
2160                 ost->encoding_needed = 1;
2161                 ost->resample_sample_fmt  = icodec->sample_fmt;
2162                 ost->resample_sample_rate = icodec->sample_rate;
2163                 ost->resample_channels    = icodec->channels;
2164                 break;
2165             case AVMEDIA_TYPE_VIDEO:
2166                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2167                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2168                     ffmpeg_exit(1);
2169                 }
2170                 ost->video_resample = codec->width   != icodec->width  ||
2171                                       codec->height  != icodec->height ||
2172                                       codec->pix_fmt != icodec->pix_fmt;
2173                 if (ost->video_resample) {
2174 #if !CONFIG_AVFILTER
2175                     avcodec_get_frame_defaults(&ost->pict_tmp);
2176                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2177                                          codec->width, codec->height)) {
2178                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2179                         ffmpeg_exit(1);
2180                     }
2181                     ost->img_resample_ctx = sws_getContext(
2182                         icodec->width,
2183                         icodec->height,
2184                             icodec->pix_fmt,
2185                             codec->width,
2186                             codec->height,
2187                             codec->pix_fmt,
2188                             ost->sws_flags, NULL, NULL, NULL);
2189                     if (ost->img_resample_ctx == NULL) {
2190                         fprintf(stderr, "Cannot get resampling context\n");
2191                         ffmpeg_exit(1);
2192                     }
2193 #endif
2194                     codec->bits_per_raw_sample= 0;
2195                 }
2196                 ost->resample_height = icodec->height;
2197                 ost->resample_width  = icodec->width;
2198                 ost->resample_pix_fmt= icodec->pix_fmt;
2199                 ost->encoding_needed = 1;
2200                 ist->decoding_needed = 1;
2201
2202 #if CONFIG_AVFILTER
2203                 if (configure_video_filters(ist, ost)) {
2204                     fprintf(stderr, "Error opening filters!\n");
2205                     exit(1);
2206                 }
2207 #endif
2208                 break;
2209             case AVMEDIA_TYPE_SUBTITLE:
2210                 ost->encoding_needed = 1;
2211                 ist->decoding_needed = 1;
2212                 break;
2213             default:
2214                 abort();
2215                 break;
2216             }
2217             /* two pass mode */
2218             if (ost->encoding_needed &&
2219                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2220                 char logfilename[1024];
2221                 FILE *f;
2222
2223                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2224                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2225                          i);
2226                 if (codec->flags & CODEC_FLAG_PASS1) {
2227                     f = fopen(logfilename, "wb");
2228                     if (!f) {
2229                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2230                         ffmpeg_exit(1);
2231                     }
2232                     ost->logfile = f;
2233                 } else {
2234                     char  *logbuffer;
2235                     size_t logbuffer_size;
2236                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2237                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2238                         ffmpeg_exit(1);
2239                     }
2240                     codec->stats_in = logbuffer;
2241                 }
2242             }
2243         }
2244         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2245             int size= codec->width * codec->height;
2246             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2247         }
2248     }
2249
2250     if (!bit_buffer)
2251         bit_buffer = av_malloc(bit_buffer_size);
2252     if (!bit_buffer) {
2253         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2254                 bit_buffer_size);
2255         ret = AVERROR(ENOMEM);
2256         goto fail;
2257     }
2258
2259     /* open each encoder */
2260     for(i=0;i<nb_ostreams;i++) {
2261         ost = ost_table[i];
2262         if (ost->encoding_needed) {
2263             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2264             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2265             if (!codec)
2266                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2267             if (!codec) {
2268                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2269                          ost->st->codec->codec_id, ost->file_index, ost->index);
2270                 ret = AVERROR(EINVAL);
2271                 goto dump_format;
2272             }
2273             if (dec->subtitle_header) {
2274                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2275                 if (!ost->st->codec->subtitle_header) {
2276                     ret = AVERROR(ENOMEM);
2277                     goto dump_format;
2278                 }
2279                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2280                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2281             }
2282             if (avcodec_open(ost->st->codec, codec) < 0) {
2283                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2284                         ost->file_index, ost->index);
2285                 ret = AVERROR(EINVAL);
2286                 goto dump_format;
2287             }
2288             extra_size += ost->st->codec->extradata_size;
2289         }
2290     }
2291
2292     /* open each decoder */
2293     for(i=0;i<nb_istreams;i++) {
2294         ist = ist_table[i];
2295         if (ist->decoding_needed) {
2296             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2297             if (!codec)
2298                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2299             if (!codec) {
2300                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2301                         ist->st->codec->codec_id, ist->file_index, ist->index);
2302                 ret = AVERROR(EINVAL);
2303                 goto dump_format;
2304             }
2305             if (avcodec_open(ist->st->codec, codec) < 0) {
2306                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2307                         ist->file_index, ist->index);
2308                 ret = AVERROR(EINVAL);
2309                 goto dump_format;
2310             }
2311             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2312             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2313         }
2314     }
2315
2316     /* init pts */
2317     for(i=0;i<nb_istreams;i++) {
2318         AVStream *st;
2319         ist = ist_table[i];
2320         st= ist->st;
2321         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2322         ist->next_pts = AV_NOPTS_VALUE;
2323         init_pts_correction(&ist->pts_ctx);
2324         ist->is_start = 1;
2325     }
2326
2327     /* set meta data information from input file if required */
2328     for (i=0;i<nb_meta_data_maps;i++) {
2329         AVFormatContext *files[2];
2330         AVMetadata      **meta[2];
2331         int j;
2332
2333 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2334         if ((index) < 0 || (index) >= (nb_elems)) {\
2335             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2336                      (desc), (index));\
2337             ret = AVERROR(EINVAL);\
2338             goto dump_format;\
2339         }
2340
2341         int out_file_index = meta_data_maps[i][0].file;
2342         int in_file_index = meta_data_maps[i][1].file;
2343         if (in_file_index < 0 || out_file_index < 0)
2344             continue;
2345         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2346         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2347
2348         files[0] = output_files[out_file_index];
2349         files[1] = input_files[in_file_index];
2350
2351         for (j = 0; j < 2; j++) {
2352             AVMetaDataMap *map = &meta_data_maps[i][j];
2353
2354             switch (map->type) {
2355             case 'g':
2356                 meta[j] = &files[j]->metadata;
2357                 break;
2358             case 's':
2359                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2360                 meta[j] = &files[j]->streams[map->index]->metadata;
2361                 break;
2362             case 'c':
2363                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2364                 meta[j] = &files[j]->chapters[map->index]->metadata;
2365                 break;
2366             case 'p':
2367                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2368                 meta[j] = &files[j]->programs[map->index]->metadata;
2369                 break;
2370             }
2371         }
2372
2373         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2374     }
2375
2376     /* copy global metadata by default */
2377     if (metadata_global_autocopy) {
2378
2379         for (i = 0; i < nb_output_files; i++)
2380             av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2381                              AV_METADATA_DONT_OVERWRITE);
2382     }
2383
2384     /* copy chapters according to chapter maps */
2385     for (i = 0; i < nb_chapter_maps; i++) {
2386         int infile  = chapter_maps[i].in_file;
2387         int outfile = chapter_maps[i].out_file;
2388
2389         if (infile < 0 || outfile < 0)
2390             continue;
2391         if (infile >= nb_input_files) {
2392             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2393             ret = AVERROR(EINVAL);
2394             goto dump_format;
2395         }
2396         if (outfile >= nb_output_files) {
2397             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2398             ret = AVERROR(EINVAL);
2399             goto dump_format;
2400         }
2401         copy_chapters(infile, outfile);
2402     }
2403
2404     /* copy chapters from the first input file that has them*/
2405     if (!nb_chapter_maps)
2406         for (i = 0; i < nb_input_files; i++) {
2407             if (!input_files[i]->nb_chapters)
2408                 continue;
2409
2410             for (j = 0; j < nb_output_files; j++)
2411                 if ((ret = copy_chapters(i, j)) < 0)
2412                     goto dump_format;
2413             break;
2414         }
2415
2416     /* open files and write file headers */
2417     for(i=0;i<nb_output_files;i++) {
2418         os = output_files[i];
2419         if (av_write_header(os) < 0) {
2420             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2421             ret = AVERROR(EINVAL);
2422             goto dump_format;
2423         }
2424         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2425             want_sdp = 0;
2426         }
2427     }
2428
2429  dump_format:
2430     /* dump the file output parameters - cannot be done before in case
2431        of stream copy */
2432     for(i=0;i<nb_output_files;i++) {
2433         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2434     }
2435
2436     /* dump the stream mapping */
2437     if (verbose >= 0) {
2438         fprintf(stderr, "Stream mapping:\n");
2439         for(i=0;i<nb_ostreams;i++) {
2440             ost = ost_table[i];
2441             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2442                     ist_table[ost->source_index]->file_index,
2443                     ist_table[ost->source_index]->index,
2444                     ost->file_index,
2445                     ost->index);
2446             if (ost->sync_ist != ist_table[ost->source_index])
2447                 fprintf(stderr, " [sync #%d.%d]",
2448                         ost->sync_ist->file_index,
2449                         ost->sync_ist->index);
2450             fprintf(stderr, "\n");
2451         }
2452     }
2453
2454     if (ret) {
2455         fprintf(stderr, "%s\n", error);
2456         goto fail;
2457     }
2458
2459     if (want_sdp) {
2460         print_sdp(output_files, nb_output_files);
2461     }
2462
2463     if (!using_stdin && verbose >= 0) {
2464 #if HAVE_KBHIT
2465         fprintf(stderr, "Press [q] to stop encoding\n");
2466 #else
2467         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2468 #endif
2469         avio_set_interrupt_cb(decode_interrupt_cb);
2470     }
2471     term_init();
2472
2473     timer_start = av_gettime();
2474
2475     for(; received_sigterm == 0;) {
2476         int file_index, ist_index;
2477         AVPacket pkt;
2478         double ipts_min;
2479         double opts_min;
2480
2481     redo:
2482         ipts_min= 1e100;
2483         opts_min= 1e100;
2484         /* if 'q' pressed, exits */
2485         if (!using_stdin) {
2486             if (q_pressed)
2487                 break;
2488             /* read_key() returns 0 on EOF */
2489             key = read_key();
2490             if (key == 'q')
2491                 break;
2492         }
2493
2494         /* select the stream that we must read now by looking at the
2495            smallest output pts */
2496         file_index = -1;
2497         for(i=0;i<nb_ostreams;i++) {
2498             double ipts, opts;
2499             ost = ost_table[i];
2500             os = output_files[ost->file_index];
2501             ist = ist_table[ost->source_index];
2502             if(ist->is_past_recording_time || no_packet[ist->file_index])
2503                 continue;
2504                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2505             ipts = (double)ist->pts;
2506             if (!file_table[ist->file_index].eof_reached){
2507                 if(ipts < ipts_min) {
2508                     ipts_min = ipts;
2509                     if(input_sync ) file_index = ist->file_index;
2510                 }
2511                 if(opts < opts_min) {
2512                     opts_min = opts;
2513                     if(!input_sync) file_index = ist->file_index;
2514                 }
2515             }
2516             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2517                 file_index= -1;
2518                 break;
2519             }
2520         }
2521         /* if none, if is finished */
2522         if (file_index < 0) {
2523             if(no_packet_count){
2524                 no_packet_count=0;
2525                 memset(no_packet, 0, sizeof(no_packet));
2526                 usleep(10000);
2527                 continue;
2528             }
2529             break;
2530         }
2531
2532         /* finish if limit size exhausted */
2533         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2534             break;
2535
2536         /* read a frame from it and output it in the fifo */
2537         is = input_files[file_index];
2538         ret= av_read_frame(is, &pkt);
2539         if(ret == AVERROR(EAGAIN)){
2540             no_packet[file_index]=1;
2541             no_packet_count++;
2542             continue;
2543         }
2544         if (ret < 0) {
2545             file_table[file_index].eof_reached = 1;
2546             if (opt_shortest)
2547                 break;
2548             else
2549                 continue;
2550         }
2551
2552         no_packet_count=0;
2553         memset(no_packet, 0, sizeof(no_packet));
2554
2555         if (do_pkt_dump) {
2556             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2557                              is->streams[pkt.stream_index]);
2558         }
2559         /* the following test is needed in case new streams appear
2560            dynamically in stream : we ignore them */
2561         if (pkt.stream_index >= file_table[file_index].nb_streams)
2562             goto discard_packet;
2563         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2564         ist = ist_table[ist_index];
2565         if (ist->discard)
2566             goto discard_packet;
2567
2568         if (pkt.dts != AV_NOPTS_VALUE)
2569             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2570         if (pkt.pts != AV_NOPTS_VALUE)
2571             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2572
2573         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2574             && input_files_ts_scale[file_index][pkt.stream_index]){
2575             if(pkt.pts != AV_NOPTS_VALUE)
2576                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2577             if(pkt.dts != AV_NOPTS_VALUE)
2578                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2579         }
2580
2581 //        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);
2582         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2583             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2584             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2585             int64_t delta= pkt_dts - ist->next_pts;
2586             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2587                 input_files_ts_offset[ist->file_index]-= delta;
2588                 if (verbose > 2)
2589                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2590                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2591                 if(pkt.pts != AV_NOPTS_VALUE)
2592                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2593             }
2594         }
2595
2596         /* finish if recording time exhausted */
2597         if (recording_time != INT64_MAX &&
2598             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2599             ist->is_past_recording_time = 1;
2600             goto discard_packet;
2601         }
2602
2603         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2604         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2605
2606             if (verbose >= 0)
2607                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2608                         ist->file_index, ist->index);
2609             if (exit_on_error)
2610                 ffmpeg_exit(1);
2611             av_free_packet(&pkt);
2612             goto redo;
2613         }
2614
2615     discard_packet:
2616         av_free_packet(&pkt);
2617
2618         /* dump report by using the output first video and audio streams */
2619         print_report(output_files, ost_table, nb_ostreams, 0);
2620     }
2621
2622     /* at the end of stream, we must flush the decoder buffers */
2623     for(i=0;i<nb_istreams;i++) {
2624         ist = ist_table[i];
2625         if (ist->decoding_needed) {
2626             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2627         }
2628     }
2629
2630     term_exit();
2631
2632     /* write the trailer if needed and close file */
2633     for(i=0;i<nb_output_files;i++) {
2634         os = output_files[i];
2635         av_write_trailer(os);
2636     }
2637
2638     /* dump report by using the first video and audio streams */
2639     print_report(output_files, ost_table, nb_ostreams, 1);
2640
2641     /* close each encoder */
2642     for(i=0;i<nb_ostreams;i++) {
2643         ost = ost_table[i];
2644         if (ost->encoding_needed) {
2645             av_freep(&ost->st->codec->stats_in);
2646             avcodec_close(ost->st->codec);
2647         }
2648     }
2649
2650     /* close each decoder */
2651     for(i=0;i<nb_istreams;i++) {
2652         ist = ist_table[i];
2653         if (ist->decoding_needed) {
2654             avcodec_close(ist->st->codec);
2655         }
2656     }
2657 #if CONFIG_AVFILTER
2658     avfilter_graph_free(&graph);
2659 #endif
2660
2661     /* finished ! */
2662     ret = 0;
2663
2664  fail:
2665     av_freep(&bit_buffer);
2666     av_free(file_table);
2667
2668     if (ist_table) {
2669         for(i=0;i<nb_istreams;i++) {
2670             ist = ist_table[i];
2671             av_free(ist);
2672         }
2673         av_free(ist_table);
2674     }
2675     if (ost_table) {
2676         for(i=0;i<nb_ostreams;i++) {
2677             ost = ost_table[i];
2678             if (ost) {
2679                 if (ost->st->stream_copy)
2680                     av_freep(&ost->st->codec->extradata);
2681                 if (ost->logfile) {
2682                     fclose(ost->logfile);
2683                     ost->logfile = NULL;
2684                 }
2685                 av_fifo_free(ost->fifo); /* works even if fifo is not
2686                                              initialized but set to zero */
2687                 av_freep(&ost->st->codec->subtitle_header);
2688                 av_free(ost->pict_tmp.data[0]);
2689                 av_free(ost->forced_kf_pts);
2690                 if (ost->video_resample)
2691                     sws_freeContext(ost->img_resample_ctx);
2692                 if (ost->resample)
2693                     audio_resample_close(ost->resample);
2694                 if (ost->reformat_ctx)
2695                     av_audio_convert_free(ost->reformat_ctx);
2696                 av_free(ost);
2697             }
2698         }
2699         av_free(ost_table);
2700     }
2701     return ret;
2702 }
2703
2704 static void opt_format(const char *arg)
2705 {
2706     last_asked_format = arg;
2707 }
2708
2709 static void opt_video_rc_override_string(const char *arg)
2710 {
2711     video_rc_override_string = arg;
2712 }
2713
2714 static int opt_me_threshold(const char *opt, const char *arg)
2715 {
2716     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2717     return 0;
2718 }
2719
2720 static int opt_verbose(const char *opt, const char *arg)
2721 {
2722     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2723     return 0;
2724 }
2725
2726 static int opt_frame_rate(const char *opt, const char *arg)
2727 {
2728     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2729         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2730         ffmpeg_exit(1);
2731     }
2732     return 0;
2733 }
2734
2735 static int opt_bitrate(const char *opt, const char *arg)
2736 {
2737     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2738
2739     opt_default(opt, arg);
2740
2741     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2742         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2743
2744     return 0;
2745 }
2746
2747 static int opt_frame_crop(const char *opt, const char *arg)
2748 {
2749     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2750     return AVERROR(EINVAL);
2751 }
2752
2753 static void opt_frame_size(const char *arg)
2754 {
2755     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2756         fprintf(stderr, "Incorrect frame size\n");
2757         ffmpeg_exit(1);
2758     }
2759 }
2760
2761 static int opt_pad(const char *opt, const char *arg) {
2762     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2763     return -1;
2764 }
2765
2766 static void opt_frame_pix_fmt(const char *arg)
2767 {
2768     if (strcmp(arg, "list")) {
2769         frame_pix_fmt = av_get_pix_fmt(arg);
2770         if (frame_pix_fmt == PIX_FMT_NONE) {
2771             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2772             ffmpeg_exit(1);
2773         }
2774     } else {
2775         show_pix_fmts();
2776         ffmpeg_exit(0);
2777     }
2778 }
2779
2780 static void opt_frame_aspect_ratio(const char *arg)
2781 {
2782     int x = 0, y = 0;
2783     double ar = 0;
2784     const char *p;
2785     char *end;
2786
2787     p = strchr(arg, ':');
2788     if (p) {
2789         x = strtol(arg, &end, 10);
2790         if (end == p)
2791             y = strtol(end+1, &end, 10);
2792         if (x > 0 && y > 0)
2793             ar = (double)x / (double)y;
2794     } else
2795         ar = strtod(arg, NULL);
2796
2797     if (!ar) {
2798         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2799         ffmpeg_exit(1);
2800     }
2801     frame_aspect_ratio = ar;
2802
2803 #if CONFIG_AVFILTER
2804     x = vfilters ? strlen(vfilters) : 0;
2805     vfilters = av_realloc(vfilters, x+100);
2806     snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2807 #endif
2808 }
2809
2810 static int opt_metadata(const char *opt, const char *arg)
2811 {
2812     char *mid= strchr(arg, '=');
2813
2814     if(!mid){
2815         fprintf(stderr, "Missing =\n");
2816         ffmpeg_exit(1);
2817     }
2818     *mid++= 0;
2819
2820     av_metadata_set2(&metadata, arg, mid, 0);
2821
2822     return 0;
2823 }
2824
2825 static void opt_qscale(const char *arg)
2826 {
2827     video_qscale = atof(arg);
2828     if (video_qscale <= 0 ||
2829         video_qscale > 255) {
2830         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2831         ffmpeg_exit(1);
2832     }
2833 }
2834
2835 static void opt_top_field_first(const char *arg)
2836 {
2837     top_field_first= atoi(arg);
2838 }
2839
2840 static int opt_thread_count(const char *opt, const char *arg)
2841 {
2842     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2843 #if !HAVE_THREADS
2844     if (verbose >= 0)
2845         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2846 #endif
2847     return 0;
2848 }
2849
2850 static void opt_audio_sample_fmt(const char *arg)
2851 {
2852     if (strcmp(arg, "list")) {
2853         audio_sample_fmt = av_get_sample_fmt(arg);
2854         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2855             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2856             ffmpeg_exit(1);
2857         }
2858     } else {
2859         int i;
2860         char fmt_str[128];
2861         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2862             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2863         ffmpeg_exit(0);
2864     }
2865 }
2866
2867 static int opt_audio_rate(const char *opt, const char *arg)
2868 {
2869     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2870     return 0;
2871 }
2872
2873 static int opt_audio_channels(const char *opt, const char *arg)
2874 {
2875     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2876     return 0;
2877 }
2878
2879 static void opt_video_channel(const char *arg)
2880 {
2881     video_channel = strtol(arg, NULL, 0);
2882 }
2883
2884 static void opt_video_standard(const char *arg)
2885 {
2886     video_standard = av_strdup(arg);
2887 }
2888
2889 static void opt_codec(int *pstream_copy, char **pcodec_name,
2890                       int codec_type, const char *arg)
2891 {
2892     av_freep(pcodec_name);
2893     if (!strcmp(arg, "copy")) {
2894         *pstream_copy = 1;
2895     } else {
2896         *pcodec_name = av_strdup(arg);
2897     }
2898 }
2899
2900 static void opt_audio_codec(const char *arg)
2901 {
2902     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2903 }
2904
2905 static void opt_video_codec(const char *arg)
2906 {
2907     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2908 }
2909
2910 static void opt_subtitle_codec(const char *arg)
2911 {
2912     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2913 }
2914
2915 static void opt_data_codec(const char *arg)
2916 {
2917     opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2918 }
2919
2920 static int opt_codec_tag(const char *opt, const char *arg)
2921 {
2922     char *tail;
2923     uint32_t *codec_tag;
2924
2925     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2926                 !strcmp(opt, "vtag") ? &video_codec_tag :
2927                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2928     if (!codec_tag)
2929         return -1;
2930
2931     *codec_tag = strtol(arg, &tail, 0);
2932     if (!tail || *tail)
2933         *codec_tag = AV_RL32(arg);
2934
2935     return 0;
2936 }
2937
2938 static void opt_map(const char *arg)
2939 {
2940     AVStreamMap *m;
2941     char *p;
2942
2943     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2944     m = &stream_maps[nb_stream_maps-1];
2945
2946     m->file_index = strtol(arg, &p, 0);
2947     if (*p)
2948         p++;
2949
2950     m->stream_index = strtol(p, &p, 0);
2951     if (*p) {
2952         p++;
2953         m->sync_file_index = strtol(p, &p, 0);
2954         if (*p)
2955             p++;
2956         m->sync_stream_index = strtol(p, &p, 0);
2957     } else {
2958         m->sync_file_index = m->file_index;
2959         m->sync_stream_index = m->stream_index;
2960     }
2961 }
2962
2963 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2964 {
2965     *endptr = arg;
2966     if (*arg == ',') {
2967         *type = *(++arg);
2968         switch (*arg) {
2969         case 'g':
2970             break;
2971         case 's':
2972         case 'c':
2973         case 'p':
2974             *index = strtol(++arg, endptr, 0);
2975             break;
2976         default:
2977             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2978             ffmpeg_exit(1);
2979         }
2980     } else
2981         *type = 'g';
2982 }
2983
2984 static void opt_map_metadata(const char *arg)
2985 {
2986     AVMetaDataMap *m, *m1;
2987     char *p;
2988
2989     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2990                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2991
2992     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2993     m->file = strtol(arg, &p, 0);
2994     parse_meta_type(p, &m->type, &m->index, &p);
2995     if (*p)
2996         p++;
2997
2998     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2999     m1->file = strtol(p, &p, 0);
3000     parse_meta_type(p, &m1->type, &m1->index, &p);
3001
3002     if (m->type == 'g' || m1->type == 'g')
3003         metadata_global_autocopy = 0;
3004     if (m->type == 's' || m1->type == 's')
3005         metadata_streams_autocopy = 0;
3006     if (m->type == 'c' || m1->type == 'c')
3007         metadata_chapters_autocopy = 0;
3008 }
3009
3010 static void opt_map_meta_data(const char *arg)
3011 {
3012     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3013                     "Use -map_metadata instead.\n");
3014     opt_map_metadata(arg);
3015 }
3016
3017 static void opt_map_chapters(const char *arg)
3018 {
3019     AVChapterMap *c;
3020     char *p;
3021
3022     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3023                               nb_chapter_maps + 1);
3024     c = &chapter_maps[nb_chapter_maps - 1];
3025     c->out_file = strtol(arg, &p, 0);
3026     if (*p)
3027         p++;
3028
3029     c->in_file = strtol(p, &p, 0);
3030 }
3031
3032 static void opt_input_ts_scale(const char *arg)
3033 {
3034     unsigned int stream;
3035     double scale;
3036     char *p;
3037
3038     stream = strtol(arg, &p, 0);
3039     if (*p)
3040         p++;
3041     scale= strtod(p, &p);
3042
3043     if(stream >= MAX_STREAMS)
3044         ffmpeg_exit(1);
3045
3046     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);
3047     input_files_ts_scale[nb_input_files][stream]= scale;
3048 }
3049
3050 static int opt_recording_time(const char *opt, const char *arg)
3051 {
3052     recording_time = parse_time_or_die(opt, arg, 1);
3053     return 0;
3054 }
3055
3056 static int opt_start_time(const char *opt, const char *arg)
3057 {
3058     start_time = parse_time_or_die(opt, arg, 1);
3059     return 0;
3060 }
3061
3062 static int opt_recording_timestamp(const char *opt, const char *arg)
3063 {
3064     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3065     return 0;
3066 }
3067
3068 static int opt_input_ts_offset(const char *opt, const char *arg)
3069 {
3070     input_ts_offset = parse_time_or_die(opt, arg, 1);
3071     return 0;
3072 }
3073
3074 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3075 {
3076     const char *codec_string = encoder ? "encoder" : "decoder";
3077     AVCodec *codec;
3078
3079     if(!name)
3080         return CODEC_ID_NONE;
3081     codec = encoder ?
3082         avcodec_find_encoder_by_name(name) :
3083         avcodec_find_decoder_by_name(name);
3084     if(!codec) {
3085         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3086         ffmpeg_exit(1);
3087     }
3088     if(codec->type != type) {
3089         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3090         ffmpeg_exit(1);
3091     }
3092     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3093        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3094         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3095                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3096                 codec_string, codec->name);
3097         codec = encoder ?
3098             avcodec_find_encoder(codec->id) :
3099             avcodec_find_decoder(codec->id);
3100         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3101             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3102                     codec_string, codec->name);
3103         ffmpeg_exit(1);
3104     }
3105     return codec->id;
3106 }
3107
3108 static void opt_input_file(const char *filename)
3109 {
3110     AVFormatContext *ic;
3111     AVFormatParameters params, *ap = &params;
3112     AVInputFormat *file_iformat = NULL;
3113     int err, i, ret, rfps, rfps_base;
3114     int64_t timestamp;
3115
3116     if (last_asked_format) {
3117         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3118             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3119             ffmpeg_exit(1);
3120         }
3121         last_asked_format = NULL;
3122     }
3123
3124     if (!strcmp(filename, "-"))
3125         filename = "pipe:";
3126
3127     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3128                     !strcmp(filename, "/dev/stdin");
3129
3130     /* get default parameters from command line */
3131     ic = avformat_alloc_context();
3132     if (!ic) {
3133         print_error(filename, AVERROR(ENOMEM));
3134         ffmpeg_exit(1);
3135     }
3136
3137     memset(ap, 0, sizeof(*ap));
3138     ap->prealloced_context = 1;
3139     ap->sample_rate = audio_sample_rate;
3140     ap->channels = audio_channels;
3141     ap->time_base.den = frame_rate.num;
3142     ap->time_base.num = frame_rate.den;
3143     ap->width = frame_width;
3144     ap->height = frame_height;
3145     ap->pix_fmt = frame_pix_fmt;
3146    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3147     ap->channel = video_channel;
3148     ap->standard = video_standard;
3149
3150     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3151
3152     ic->video_codec_id   =
3153         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3154                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3155     ic->audio_codec_id   =
3156         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3157                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3158     ic->subtitle_codec_id=
3159         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3160                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3161     ic->flags |= AVFMT_FLAG_NONBLOCK;
3162
3163     /* open the input file with generic libav function */
3164     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3165     if (err < 0) {
3166         print_error(filename, err);
3167         ffmpeg_exit(1);
3168     }
3169     if(opt_programid) {
3170         int i, j;
3171         int found=0;
3172         for(i=0; i<ic->nb_streams; i++){
3173             ic->streams[i]->discard= AVDISCARD_ALL;
3174         }
3175         for(i=0; i<ic->nb_programs; i++){
3176             AVProgram *p= ic->programs[i];
3177             if(p->id != opt_programid){
3178                 p->discard = AVDISCARD_ALL;
3179             }else{
3180                 found=1;
3181                 for(j=0; j<p->nb_stream_indexes; j++){
3182                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3183                 }
3184             }
3185         }
3186         if(!found){
3187             fprintf(stderr, "Specified program id not found\n");
3188             ffmpeg_exit(1);
3189         }
3190         opt_programid=0;
3191     }
3192
3193     ic->loop_input = loop_input;
3194
3195     /* If not enough info to get the stream parameters, we decode the
3196        first frames to get it. (used in mpeg case for example) */
3197     ret = av_find_stream_info(ic);
3198     if (ret < 0 && verbose >= 0) {
3199         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3200         av_close_input_file(ic);
3201         ffmpeg_exit(1);
3202     }
3203
3204     timestamp = start_time;
3205     /* add the stream start time */
3206     if (ic->start_time != AV_NOPTS_VALUE)
3207         timestamp += ic->start_time;
3208
3209     /* if seeking requested, we execute it */
3210     if (start_time != 0) {
3211         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3212         if (ret < 0) {
3213             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3214                     filename, (double)timestamp / AV_TIME_BASE);
3215         }
3216         /* reset seek info */
3217         start_time = 0;
3218     }
3219
3220     /* update the current parameters so that they match the one of the input stream */
3221     for(i=0;i<ic->nb_streams;i++) {
3222         AVStream *st = ic->streams[i];
3223         AVCodecContext *dec = st->codec;
3224         dec->thread_count = thread_count;
3225         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3226         switch (dec->codec_type) {
3227         case AVMEDIA_TYPE_AUDIO:
3228             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3229             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]);
3230             channel_layout    = dec->channel_layout;
3231             audio_channels    = dec->channels;
3232             audio_sample_rate = dec->sample_rate;
3233             audio_sample_fmt  = dec->sample_fmt;
3234             if(audio_disable)
3235                 st->discard= AVDISCARD_ALL;
3236             /* Note that av_find_stream_info can add more streams, and we
3237              * currently have no chance of setting up lowres decoding
3238              * early enough for them. */
3239             if (dec->lowres)
3240                 audio_sample_rate >>= dec->lowres;
3241             break;
3242         case AVMEDIA_TYPE_VIDEO:
3243             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3244             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]);
3245             frame_height = dec->height;
3246             frame_width  = dec->width;
3247             if(ic->streams[i]->sample_aspect_ratio.num)
3248                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3249             else
3250                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3251             frame_aspect_ratio *= (float) dec->width / dec->height;
3252             frame_pix_fmt = dec->pix_fmt;
3253             rfps      = ic->streams[i]->r_frame_rate.num;
3254             rfps_base = ic->streams[i]->r_frame_rate.den;
3255             if (dec->lowres) {
3256                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3257                 frame_height >>= dec->lowres;
3258                 frame_width  >>= dec->lowres;
3259                 dec->height = frame_height;
3260                 dec->width  = frame_width;
3261             }
3262             if(me_threshold)
3263                 dec->debug |= FF_DEBUG_MV;
3264
3265             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3266
3267                 if (verbose >= 0)
3268                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3269                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3270
3271                     (float)rfps / rfps_base, rfps, rfps_base);
3272             }
3273             /* update the current frame rate to match the stream frame rate */
3274             frame_rate.num = rfps;
3275             frame_rate.den = rfps_base;
3276
3277             if(video_disable)
3278                 st->discard= AVDISCARD_ALL;
3279             else if(video_discard)
3280                 st->discard= video_discard;
3281             break;
3282         case AVMEDIA_TYPE_DATA:
3283             break;
3284         case AVMEDIA_TYPE_SUBTITLE:
3285             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3286             if(subtitle_disable)
3287                 st->discard = AVDISCARD_ALL;
3288             break;
3289         case AVMEDIA_TYPE_ATTACHMENT:
3290         case AVMEDIA_TYPE_UNKNOWN:
3291             break;
3292         default:
3293             abort();
3294         }
3295     }
3296
3297     input_files[nb_input_files] = ic;
3298     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3299     /* dump the file content */
3300     if (verbose >= 0)
3301         av_dump_format(ic, nb_input_files, filename, 0);
3302
3303     nb_input_files++;
3304
3305     video_channel = 0;
3306
3307     av_freep(&video_codec_name);
3308     av_freep(&audio_codec_name);
3309     av_freep(&subtitle_codec_name);
3310     uninit_opts();
3311     init_opts();
3312 }
3313
3314 static void check_inputs(int *has_video_ptr,
3315                          int *has_audio_ptr,
3316                          int *has_subtitle_ptr,
3317                          int *has_data_ptr)
3318 {
3319     int has_video, has_audio, has_subtitle, has_data, i, j;
3320     AVFormatContext *ic;
3321
3322     has_video = 0;
3323     has_audio = 0;
3324     has_subtitle = 0;
3325     has_data = 0;
3326
3327     for(j=0;j<nb_input_files;j++) {
3328         ic = input_files[j];
3329         for(i=0;i<ic->nb_streams;i++) {
3330             AVCodecContext *enc = ic->streams[i]->codec;
3331             switch(enc->codec_type) {
3332             case AVMEDIA_TYPE_AUDIO:
3333                 has_audio = 1;
3334                 break;
3335             case AVMEDIA_TYPE_VIDEO:
3336                 has_video = 1;
3337                 break;
3338             case AVMEDIA_TYPE_SUBTITLE:
3339                 has_subtitle = 1;
3340                 break;
3341             case AVMEDIA_TYPE_DATA:
3342             case AVMEDIA_TYPE_ATTACHMENT:
3343             case AVMEDIA_TYPE_UNKNOWN:
3344                 has_data = 1;
3345                 break;
3346             default:
3347                 abort();
3348             }
3349         }
3350     }
3351     *has_video_ptr = has_video;
3352     *has_audio_ptr = has_audio;
3353     *has_subtitle_ptr = has_subtitle;
3354     *has_data_ptr = has_data;
3355 }
3356
3357 static void new_video_stream(AVFormatContext *oc, int file_idx)
3358 {
3359     AVStream *st;
3360     AVOutputStream *ost;
3361     AVCodecContext *video_enc;
3362     enum CodecID codec_id = CODEC_ID_NONE;
3363     AVCodec *codec= NULL;
3364
3365     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3366     if (!st) {
3367         fprintf(stderr, "Could not alloc stream\n");
3368         ffmpeg_exit(1);
3369     }
3370     ost = new_output_stream(oc, file_idx);
3371
3372     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3373     if(!video_stream_copy){
3374         if (video_codec_name) {
3375             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3376                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3377             codec = avcodec_find_encoder_by_name(video_codec_name);
3378             output_codecs[nb_output_codecs-1] = codec;
3379         } else {
3380             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3381             codec = avcodec_find_encoder(codec_id);
3382         }
3383     }
3384
3385     avcodec_get_context_defaults3(st->codec, codec);
3386     ost->bitstream_filters = video_bitstream_filters;
3387     video_bitstream_filters= NULL;
3388
3389     st->codec->thread_count= thread_count;
3390
3391     video_enc = st->codec;
3392
3393     if(video_codec_tag)
3394         video_enc->codec_tag= video_codec_tag;
3395
3396     if(   (video_global_header&1)
3397        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3398         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3399         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3400     }
3401     if(video_global_header&2){
3402         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3403         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3404     }
3405
3406     if (video_stream_copy) {
3407         st->stream_copy = 1;
3408         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3409         video_enc->sample_aspect_ratio =
3410         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3411     } else {
3412         const char *p;
3413         int i;
3414         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3415
3416         video_enc->codec_id = codec_id;
3417         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3418
3419         if (codec && codec->supported_framerates && !force_fps)
3420             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3421         video_enc->time_base.den = fps.num;
3422         video_enc->time_base.num = fps.den;
3423
3424         video_enc->width = frame_width;
3425         video_enc->height = frame_height;
3426         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3427         video_enc->pix_fmt = frame_pix_fmt;
3428         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3429
3430         choose_pixel_fmt(st, codec);
3431
3432         if (intra_only)
3433             video_enc->gop_size = 0;
3434         if (video_qscale || same_quality) {
3435             video_enc->flags |= CODEC_FLAG_QSCALE;
3436             video_enc->global_quality=
3437                 st->quality = FF_QP2LAMBDA * video_qscale;
3438         }
3439
3440         if(intra_matrix)
3441             video_enc->intra_matrix = intra_matrix;
3442         if(inter_matrix)
3443             video_enc->inter_matrix = inter_matrix;
3444
3445         p= video_rc_override_string;
3446         for(i=0; p; i++){
3447             int start, end, q;
3448             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3449             if(e!=3){
3450                 fprintf(stderr, "error parsing rc_override\n");
3451                 ffmpeg_exit(1);
3452             }
3453             video_enc->rc_override=
3454                 av_realloc(video_enc->rc_override,
3455                            sizeof(RcOverride)*(i+1));
3456             video_enc->rc_override[i].start_frame= start;
3457             video_enc->rc_override[i].end_frame  = end;
3458             if(q>0){
3459                 video_enc->rc_override[i].qscale= q;
3460                 video_enc->rc_override[i].quality_factor= 1.0;
3461             }
3462             else{
3463                 video_enc->rc_override[i].qscale= 0;
3464                 video_enc->rc_override[i].quality_factor= -q/100.0;
3465             }
3466             p= strchr(p, '/');
3467             if(p) p++;
3468         }
3469         video_enc->rc_override_count=i;
3470         if (!video_enc->rc_initial_buffer_occupancy)
3471             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3472         video_enc->me_threshold= me_threshold;
3473         video_enc->intra_dc_precision= intra_dc_precision - 8;
3474
3475         if (do_psnr)
3476             video_enc->flags|= CODEC_FLAG_PSNR;
3477
3478         /* two pass mode */
3479         if (do_pass) {
3480             if (do_pass == 1) {
3481                 video_enc->flags |= CODEC_FLAG_PASS1;
3482             } else {
3483                 video_enc->flags |= CODEC_FLAG_PASS2;
3484             }
3485         }
3486
3487         if (forced_key_frames)
3488             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3489     }
3490     if (video_language) {
3491         av_metadata_set2(&st->metadata, "language", video_language, 0);
3492         av_freep(&video_language);
3493     }
3494
3495     /* reset some key parameters */
3496     video_disable = 0;
3497     av_freep(&video_codec_name);
3498     av_freep(&forced_key_frames);
3499     video_stream_copy = 0;
3500     frame_pix_fmt = PIX_FMT_NONE;
3501 }
3502
3503 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3504 {
3505     AVStream *st;
3506     AVOutputStream *ost;
3507     AVCodec *codec= NULL;
3508     AVCodecContext *audio_enc;
3509     enum CodecID codec_id = CODEC_ID_NONE;
3510
3511     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3512     if (!st) {
3513         fprintf(stderr, "Could not alloc stream\n");
3514         ffmpeg_exit(1);
3515     }
3516     ost = new_output_stream(oc, file_idx);
3517
3518     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3519     if(!audio_stream_copy){
3520         if (audio_codec_name) {
3521             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3522                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3523             codec = avcodec_find_encoder_by_name(audio_codec_name);
3524             output_codecs[nb_output_codecs-1] = codec;
3525         } else {
3526             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3527             codec = avcodec_find_encoder(codec_id);
3528         }
3529     }
3530
3531     avcodec_get_context_defaults3(st->codec, codec);
3532
3533     ost->bitstream_filters = audio_bitstream_filters;
3534     audio_bitstream_filters= NULL;
3535
3536     st->codec->thread_count= thread_count;
3537
3538     audio_enc = st->codec;
3539     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3540
3541     if(audio_codec_tag)
3542         audio_enc->codec_tag= audio_codec_tag;
3543
3544     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3545         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3546         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3547     }
3548     if (audio_stream_copy) {
3549         st->stream_copy = 1;
3550         audio_enc->channels = audio_channels;
3551         audio_enc->sample_rate = audio_sample_rate;
3552     } else {
3553         audio_enc->codec_id = codec_id;
3554         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3555
3556         if (audio_qscale > QSCALE_NONE) {
3557             audio_enc->flags |= CODEC_FLAG_QSCALE;
3558             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3559         }
3560         audio_enc->channels = audio_channels;
3561         audio_enc->sample_fmt = audio_sample_fmt;
3562         audio_enc->sample_rate = audio_sample_rate;
3563         audio_enc->channel_layout = channel_layout;
3564         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3565             audio_enc->channel_layout = 0;
3566         choose_sample_fmt(st, codec);
3567         choose_sample_rate(st, codec);
3568     }
3569     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3570     if (audio_language) {
3571         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3572         av_freep(&audio_language);
3573     }
3574
3575     /* reset some key parameters */
3576     audio_disable = 0;
3577     av_freep(&audio_codec_name);
3578     audio_stream_copy = 0;
3579 }
3580
3581 static void new_data_stream(AVFormatContext *oc, int file_idx)
3582 {
3583     AVStream *st;
3584     AVOutputStream *ost;
3585     AVCodec *codec=NULL;
3586     AVCodecContext *data_enc;
3587
3588     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3589     if (!st) {
3590         fprintf(stderr, "Could not alloc stream\n");
3591         ffmpeg_exit(1);
3592     }
3593     ost = new_output_stream(oc, file_idx);
3594     data_enc = st->codec;
3595     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3596     if (!data_stream_copy) {
3597         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3598         ffmpeg_exit(1);
3599     }
3600     avcodec_get_context_defaults3(st->codec, codec);
3601
3602     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3603
3604     if (data_codec_tag)
3605         data_enc->codec_tag= data_codec_tag;
3606
3607     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3608         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3609         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3610     }
3611     if (data_stream_copy) {
3612         st->stream_copy = 1;
3613     }
3614
3615     data_disable = 0;
3616     av_freep(&data_codec_name);
3617     data_stream_copy = 0;
3618 }
3619
3620 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3621 {
3622     AVStream *st;
3623     AVOutputStream *ost;
3624     AVCodec *codec=NULL;
3625     AVCodecContext *subtitle_enc;
3626     enum CodecID codec_id = CODEC_ID_NONE;
3627
3628     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3629     if (!st) {
3630         fprintf(stderr, "Could not alloc stream\n");
3631         ffmpeg_exit(1);
3632     }
3633     ost = new_output_stream(oc, file_idx);
3634     subtitle_enc = st->codec;
3635     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3636     if(!subtitle_stream_copy){
3637         if (subtitle_codec_name) {
3638             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3639                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3640             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3641         } else {
3642             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3643             codec = avcodec_find_encoder(codec_id);
3644         }
3645     }
3646     avcodec_get_context_defaults3(st->codec, codec);
3647
3648     ost->bitstream_filters = subtitle_bitstream_filters;
3649     subtitle_bitstream_filters= NULL;
3650
3651     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3652
3653     if(subtitle_codec_tag)
3654         subtitle_enc->codec_tag= subtitle_codec_tag;
3655
3656     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3657         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3658         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3659     }
3660     if (subtitle_stream_copy) {
3661         st->stream_copy = 1;
3662     } else {
3663         subtitle_enc->codec_id = codec_id;
3664         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3665     }
3666
3667     if (subtitle_language) {
3668         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3669         av_freep(&subtitle_language);
3670     }
3671
3672     subtitle_disable = 0;
3673     av_freep(&subtitle_codec_name);
3674     subtitle_stream_copy = 0;
3675 }
3676
3677 static int opt_new_stream(const char *opt, const char *arg)
3678 {
3679     AVFormatContext *oc;
3680     int file_idx = nb_output_files - 1;
3681     if (nb_output_files <= 0) {
3682         fprintf(stderr, "At least one output file must be specified\n");
3683         ffmpeg_exit(1);
3684     }
3685     oc = output_files[file_idx];
3686
3687     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3688     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3689     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3690     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3691     else av_assert0(0);
3692     return 0;
3693 }
3694
3695 /* arg format is "output-stream-index:streamid-value". */
3696 static int opt_streamid(const char *opt, const char *arg)
3697 {
3698     int idx;
3699     char *p;
3700     char idx_str[16];
3701
3702     av_strlcpy(idx_str, arg, sizeof(idx_str));
3703     p = strchr(idx_str, ':');
3704     if (!p) {
3705         fprintf(stderr,
3706                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3707                 arg, opt);
3708         ffmpeg_exit(1);
3709     }
3710     *p++ = '\0';
3711     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3712     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3713     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3714     return 0;
3715 }
3716
3717 static void opt_output_file(const char *filename)
3718 {
3719     AVFormatContext *oc;
3720     int err, use_video, use_audio, use_subtitle, use_data;
3721     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3722     AVFormatParameters params, *ap = &params;
3723     AVOutputFormat *file_oformat;
3724
3725     if (!strcmp(filename, "-"))
3726         filename = "pipe:";
3727
3728     oc = avformat_alloc_context();
3729     if (!oc) {
3730         print_error(filename, AVERROR(ENOMEM));
3731         ffmpeg_exit(1);
3732     }
3733
3734     if (last_asked_format) {
3735         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3736         if (!file_oformat) {
3737             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3738             ffmpeg_exit(1);
3739         }
3740         last_asked_format = NULL;
3741     } else {
3742         file_oformat = av_guess_format(NULL, filename, NULL);
3743         if (!file_oformat) {
3744             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3745                     filename);
3746             ffmpeg_exit(1);
3747         }
3748     }
3749
3750     oc->oformat = file_oformat;
3751     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3752
3753     if (!strcmp(file_oformat->name, "ffm") &&
3754         av_strstart(filename, "http:", NULL)) {
3755         /* special case for files sent to ffserver: we get the stream
3756            parameters from ffserver */
3757         int err = read_ffserver_streams(oc, filename);
3758         if (err < 0) {
3759             print_error(filename, err);
3760             ffmpeg_exit(1);
3761         }
3762     } else {
3763         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3764         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3765         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3766         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 */
3767
3768         /* disable if no corresponding type found and at least one
3769            input file */
3770         if (nb_input_files > 0) {
3771             check_inputs(&input_has_video,
3772                          &input_has_audio,
3773                          &input_has_subtitle,
3774                          &input_has_data);
3775
3776             if (!input_has_video)
3777                 use_video = 0;
3778             if (!input_has_audio)
3779                 use_audio = 0;
3780             if (!input_has_subtitle)
3781                 use_subtitle = 0;
3782             if (!input_has_data)
3783                 use_data = 0;
3784         }
3785
3786         /* manual disable */
3787         if (audio_disable)    use_audio    = 0;
3788         if (video_disable)    use_video    = 0;
3789         if (subtitle_disable) use_subtitle = 0;
3790         if (data_disable)     use_data     = 0;
3791
3792         if (use_video)    new_video_stream(oc, nb_output_files);
3793         if (use_audio)    new_audio_stream(oc, nb_output_files);
3794         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3795         if (use_data)     new_data_stream(oc, nb_output_files);
3796
3797         oc->timestamp = recording_timestamp;
3798
3799         av_metadata_copy(&oc->metadata, metadata, 0);
3800         av_metadata_free(&metadata);
3801     }
3802
3803     output_files[nb_output_files++] = oc;
3804
3805     /* check filename in case of an image number is expected */
3806     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3807         if (!av_filename_number_test(oc->filename)) {
3808             print_error(oc->filename, AVERROR(EINVAL));
3809             ffmpeg_exit(1);
3810         }
3811     }
3812
3813     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3814         /* test if it already exists to avoid loosing precious files */
3815         if (!file_overwrite &&
3816             (strchr(filename, ':') == NULL ||
3817              filename[1] == ':' ||
3818              av_strstart(filename, "file:", NULL))) {
3819             if (avio_check(filename, 0) == 0) {
3820                 if (!using_stdin) {
3821                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3822                     fflush(stderr);
3823                     if (!read_yesno()) {
3824                         fprintf(stderr, "Not overwriting - exiting\n");
3825                         ffmpeg_exit(1);
3826                     }
3827                 }
3828                 else {
3829                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3830                     ffmpeg_exit(1);
3831                 }
3832             }
3833         }
3834
3835         /* open the file */
3836         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3837             print_error(filename, err);
3838             ffmpeg_exit(1);
3839         }
3840     }
3841
3842     memset(ap, 0, sizeof(*ap));
3843     if (av_set_parameters(oc, ap) < 0) {
3844         fprintf(stderr, "%s: Invalid encoding parameters\n",
3845                 oc->filename);
3846         ffmpeg_exit(1);
3847     }
3848
3849     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3850     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3851     oc->loop_output = loop_output;
3852     oc->flags |= AVFMT_FLAG_NONBLOCK;
3853
3854     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3855
3856     av_freep(&forced_key_frames);
3857     uninit_opts();
3858     init_opts();
3859 }
3860
3861 /* same option as mencoder */
3862 static void opt_pass(const char *pass_str)
3863 {
3864     int pass;
3865     pass = atoi(pass_str);
3866     if (pass != 1 && pass != 2) {
3867         fprintf(stderr, "pass number can be only 1 or 2\n");
3868         ffmpeg_exit(1);
3869     }
3870     do_pass = pass;
3871 }
3872
3873 static int64_t getutime(void)
3874 {
3875 #if HAVE_GETRUSAGE
3876     struct rusage rusage;
3877
3878     getrusage(RUSAGE_SELF, &rusage);
3879     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3880 #elif HAVE_GETPROCESSTIMES
3881     HANDLE proc;
3882     FILETIME c, e, k, u;
3883     proc = GetCurrentProcess();
3884     GetProcessTimes(proc, &c, &e, &k, &u);
3885     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3886 #else
3887     return av_gettime();
3888 #endif
3889 }
3890
3891 static int64_t getmaxrss(void)
3892 {
3893 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3894     struct rusage rusage;
3895     getrusage(RUSAGE_SELF, &rusage);
3896     return (int64_t)rusage.ru_maxrss * 1024;
3897 #elif HAVE_GETPROCESSMEMORYINFO
3898     HANDLE proc;
3899     PROCESS_MEMORY_COUNTERS memcounters;
3900     proc = GetCurrentProcess();
3901     memcounters.cb = sizeof(memcounters);
3902     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3903     return memcounters.PeakPagefileUsage;
3904 #else
3905     return 0;
3906 #endif
3907 }
3908
3909 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3910 {
3911     int i;
3912     const char *p = str;
3913     for(i = 0;; i++) {
3914         dest[i] = atoi(p);
3915         if(i == 63)
3916             break;
3917         p = strchr(p, ',');
3918         if(!p) {
3919             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3920             ffmpeg_exit(1);
3921         }
3922         p++;
3923     }
3924 }
3925
3926 static void opt_inter_matrix(const char *arg)
3927 {
3928     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3929     parse_matrix_coeffs(inter_matrix, arg);
3930 }
3931
3932 static void opt_intra_matrix(const char *arg)
3933 {
3934     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3935     parse_matrix_coeffs(intra_matrix, arg);
3936 }
3937
3938 static void show_usage(void)
3939 {
3940     printf("Hyper fast Audio and Video encoder\n");
3941     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3942     printf("\n");
3943 }
3944
3945 static void show_help(void)
3946 {
3947     AVCodec *c;
3948     AVOutputFormat *oformat = NULL;
3949
3950     av_log_set_callback(log_callback_help);
3951     show_usage();
3952     show_help_options(options, "Main options:\n",
3953                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3954     show_help_options(options, "\nAdvanced options:\n",
3955                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3956                       OPT_EXPERT);
3957     show_help_options(options, "\nVideo options:\n",
3958                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3959                       OPT_VIDEO);
3960     show_help_options(options, "\nAdvanced Video options:\n",
3961                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962                       OPT_VIDEO | OPT_EXPERT);
3963     show_help_options(options, "\nAudio options:\n",
3964                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3965                       OPT_AUDIO);
3966     show_help_options(options, "\nAdvanced Audio options:\n",
3967                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3968                       OPT_AUDIO | OPT_EXPERT);
3969     show_help_options(options, "\nSubtitle options:\n",
3970                       OPT_SUBTITLE | OPT_GRAB,
3971                       OPT_SUBTITLE);
3972     show_help_options(options, "\nAudio/Video grab options:\n",
3973                       OPT_GRAB,
3974                       OPT_GRAB);
3975     printf("\n");
3976     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3977     printf("\n");
3978
3979     /* individual codec options */
3980     c = NULL;
3981     while ((c = av_codec_next(c))) {
3982         if (c->priv_class) {
3983             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3984             printf("\n");
3985         }
3986     }
3987
3988     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3989     printf("\n");
3990
3991     /* individual muxer options */
3992     while ((oformat = av_oformat_next(oformat))) {
3993         if (oformat->priv_class) {
3994             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3995             printf("\n");
3996         }
3997     }
3998
3999     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4000 }
4001
4002 static void opt_target(const char *arg)
4003 {
4004     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4005     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4006
4007     if(!strncmp(arg, "pal-", 4)) {
4008         norm = PAL;
4009         arg += 4;
4010     } else if(!strncmp(arg, "ntsc-", 5)) {
4011         norm = NTSC;
4012         arg += 5;
4013     } else if(!strncmp(arg, "film-", 5)) {
4014         norm = FILM;
4015         arg += 5;
4016     } else {
4017         int fr;
4018         /* Calculate FR via float to avoid int overflow */
4019         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4020         if(fr == 25000) {
4021             norm = PAL;
4022         } else if((fr == 29970) || (fr == 23976)) {
4023             norm = NTSC;
4024         } else {
4025             /* Try to determine PAL/NTSC by peeking in the input files */
4026             if(nb_input_files) {
4027                 int i, j;
4028                 for(j = 0; j < nb_input_files; j++) {
4029                     for(i = 0; i < input_files[j]->nb_streams; i++) {
4030                         AVCodecContext *c = input_files[j]->streams[i]->codec;
4031                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4032                             continue;
4033                         fr = c->time_base.den * 1000 / c->time_base.num;
4034                         if(fr == 25000) {
4035                             norm = PAL;
4036                             break;
4037                         } else if((fr == 29970) || (fr == 23976)) {
4038                             norm = NTSC;
4039                             break;
4040                         }
4041                     }
4042                     if(norm != UNKNOWN)
4043                         break;
4044                 }
4045             }
4046         }
4047         if(verbose > 0 && norm != UNKNOWN)
4048             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4049     }
4050
4051     if(norm == UNKNOWN) {
4052         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4053         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4054         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4055         ffmpeg_exit(1);
4056     }
4057
4058     if(!strcmp(arg, "vcd")) {
4059
4060         opt_video_codec("mpeg1video");
4061         opt_audio_codec("mp2");
4062         opt_format("vcd");
4063
4064         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4065         opt_frame_rate(NULL, frame_rates[norm]);
4066         opt_default("g", norm == PAL ? "15" : "18");
4067
4068         opt_default("b", "1150000");
4069         opt_default("maxrate", "1150000");
4070         opt_default("minrate", "1150000");
4071         opt_default("bufsize", "327680"); // 40*1024*8;
4072
4073         opt_default("ab", "224000");
4074         audio_sample_rate = 44100;
4075         audio_channels = 2;
4076
4077         opt_default("packetsize", "2324");
4078         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4079
4080         /* We have to offset the PTS, so that it is consistent with the SCR.
4081            SCR starts at 36000, but the first two packs contain only padding
4082            and the first pack from the other stream, respectively, may also have
4083            been written before.
4084            So the real data starts at SCR 36000+3*1200. */
4085         mux_preload= (36000+3*1200) / 90000.0; //0.44
4086     } else if(!strcmp(arg, "svcd")) {
4087
4088         opt_video_codec("mpeg2video");
4089         opt_audio_codec("mp2");
4090         opt_format("svcd");
4091
4092         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4093         opt_frame_rate(NULL, frame_rates[norm]);
4094         opt_default("g", norm == PAL ? "15" : "18");
4095
4096         opt_default("b", "2040000");
4097         opt_default("maxrate", "2516000");
4098         opt_default("minrate", "0"); //1145000;
4099         opt_default("bufsize", "1835008"); //224*1024*8;
4100         opt_default("flags", "+scan_offset");
4101
4102
4103         opt_default("ab", "224000");
4104         audio_sample_rate = 44100;
4105
4106         opt_default("packetsize", "2324");
4107
4108     } else if(!strcmp(arg, "dvd")) {
4109
4110         opt_video_codec("mpeg2video");
4111         opt_audio_codec("ac3");
4112         opt_format("dvd");
4113
4114         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4115         opt_frame_rate(NULL, frame_rates[norm]);
4116         opt_default("g", norm == PAL ? "15" : "18");
4117
4118         opt_default("b", "6000000");
4119         opt_default("maxrate", "9000000");
4120         opt_default("minrate", "0"); //1500000;
4121         opt_default("bufsize", "1835008"); //224*1024*8;
4122
4123         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4124         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4125
4126         opt_default("ab", "448000");
4127         audio_sample_rate = 48000;
4128
4129     } else if(!strncmp(arg, "dv", 2)) {
4130
4131         opt_format("dv");
4132
4133         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4134         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4135                           (norm == PAL ? "yuv420p" : "yuv411p"));
4136         opt_frame_rate(NULL, frame_rates[norm]);
4137
4138         audio_sample_rate = 48000;
4139         audio_channels = 2;
4140
4141     } else {
4142         fprintf(stderr, "Unknown target: %s\n", arg);
4143         ffmpeg_exit(1);
4144     }
4145 }
4146
4147 static void opt_vstats_file (const char *arg)
4148 {
4149     av_free (vstats_filename);
4150     vstats_filename=av_strdup (arg);
4151 }
4152
4153 static void opt_vstats (void)
4154 {
4155     char filename[40];
4156     time_t today2 = time(NULL);
4157     struct tm *today = localtime(&today2);
4158
4159     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4160              today->tm_sec);
4161     opt_vstats_file(filename);
4162 }
4163
4164 static int opt_bsf(const char *opt, const char *arg)
4165 {
4166     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4167     AVBitStreamFilterContext **bsfp;
4168
4169     if(!bsfc){
4170         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4171         ffmpeg_exit(1);
4172     }
4173
4174     bsfp= *opt == 'v' ? &video_bitstream_filters :
4175           *opt == 'a' ? &audio_bitstream_filters :
4176                         &subtitle_bitstream_filters;
4177     while(*bsfp)
4178         bsfp= &(*bsfp)->next;
4179
4180     *bsfp= bsfc;
4181
4182     return 0;
4183 }
4184
4185 static int opt_preset(const char *opt, const char *arg)
4186 {
4187     FILE *f=NULL;
4188     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4189     char *codec_name = *opt == 'v' ? video_codec_name :
4190                        *opt == 'a' ? audio_codec_name :
4191                                      subtitle_codec_name;
4192
4193     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4194         fprintf(stderr, "File for preset '%s' not found\n", arg);
4195         ffmpeg_exit(1);
4196     }
4197
4198     while(!feof(f)){
4199         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4200         if(line[0] == '#' && !e)
4201             continue;
4202         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4203         if(e){
4204             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4205             ffmpeg_exit(1);
4206         }
4207         if(!strcmp(tmp, "acodec")){
4208             opt_audio_codec(tmp2);
4209         }else if(!strcmp(tmp, "vcodec")){
4210             opt_video_codec(tmp2);
4211         }else if(!strcmp(tmp, "scodec")){
4212             opt_subtitle_codec(tmp2);
4213         }else if(!strcmp(tmp, "dcodec")){
4214             opt_data_codec(tmp2);
4215         }else if(opt_default(tmp, tmp2) < 0){
4216             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4217             ffmpeg_exit(1);
4218         }
4219     }
4220
4221     fclose(f);
4222
4223     return 0;
4224 }
4225
4226 static const OptionDef options[] = {
4227     /* main options */
4228 #include "cmdutils_common_opts.h"
4229     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4230     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4231     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4232     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4233     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4234       "outfile[,metadata]:infile[,metadata]" },
4235     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4236       "outfile[,metadata]:infile[,metadata]" },
4237     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4238     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4239     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4240     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4241     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4242     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4243     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4244     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4245     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4246     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4247       "add timings for benchmarking" },
4248     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4249     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4250       "dump each input packet" },
4251     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4252       "when dumping packets, also dump the payload" },
4253     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4254     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4255     { "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)", "" },
4256     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4257     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4258     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4259     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4260     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4261     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4262     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4263     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4264     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4265     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4266     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4267     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4268     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4269     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4270
4271     /* video options */
4272     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4273     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4274     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4275     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4276     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4277     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4278     { "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" },
4279     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4280     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4281     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4282     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4283     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4284     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4285     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4286     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4287     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4288     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4289     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4290     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4291     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4292     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4293     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4294     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4295     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4296       "use same quantizer as source (implies VBR)" },
4297     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4298     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4299     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4300       "deinterlace pictures" },
4301     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4302     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4303     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" }