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