3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
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.
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.
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
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"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
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
97 static const OptionDef options[];
101 static const char *last_asked_format = NULL;
102 static double *ts_scale;
103 static int nb_ts_scale;
105 static AVFormatContext *output_files[MAX_FILES];
106 static AVDictionary *output_opts[MAX_FILES];
107 static int nb_output_files = 0;
109 static StreamMap *stream_maps = NULL;
110 static int nb_stream_maps;
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;
119 static int chapters_input_file = INT_MAX;
121 /* indexed by output file stream index */
122 static int *streamid_map = NULL;
123 static int nb_streamid_map = 0;
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;
148 static char *vfilters = NULL;
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;
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;
166 static int data_disable = 0;
167 static char *data_codec_name = NULL;
168 static unsigned int data_codec_tag = 0;
170 static float mux_preload= 0.5;
171 static float mux_max_delay= 0.7;
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;
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;
199 static int rate_emu = 0;
201 static int audio_volume = 256;
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;
217 static float dts_delta_threshold = 10;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
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 */
242 /* input pts and corresponding output pts
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;
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
256 int resample_pix_fmt;
257 AVRational frame_rate;
259 float frame_aspect_ratio;
261 /* forced key frames */
262 int64_t *forced_kf_pts;
268 ReSampleContext *resample; /* for audio resampling */
269 int resample_sample_fmt;
270 int resample_channels;
271 int resample_sample_rate;
273 AVAudioConvert *reformat_ctx;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
282 AVFilterGraph *graph;
289 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
290 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
292 typedef struct InputStream {
295 int discard; /* true if stream data should be discarded */
296 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
299 int64_t start; /* time when read started */
300 int64_t next_pts; /* synthetic pts for cases where pkt.pts
302 int64_t pts; /* current pts */
303 PtsCorrectionContext pts_ctx;
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;
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 */
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;
326 static int configure_video_filters(InputStream *ist, OutputStream *ost)
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;
337 ost->graph = avfilter_graph_alloc();
339 if (ist->st->sample_aspect_ratio.num){
340 sample_aspect_ratio = ist->st->sample_aspect_ratio;
342 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
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);
348 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
349 "src", args, NULL, ost->graph);
352 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
353 "out", NULL, &ffsink_ctx, ost->graph);
356 last_filter = ost->input_video_filter;
358 if (codec->width != icodec->width || codec->height != icodec->height) {
359 snprintf(args, 255, "%d:%d:flags=0x%X",
363 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
364 NULL, args, NULL, ost->graph)) < 0)
366 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
368 last_filter = filter;
371 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
372 ost->graph->scale_sws_opts = av_strdup(args);
375 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
376 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
378 outputs->name = av_strdup("in");
379 outputs->filter_ctx = last_filter;
380 outputs->pad_idx = 0;
381 outputs->next = NULL;
383 inputs->name = av_strdup("out");
384 inputs->filter_ctx = ost->output_video_filter;
388 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
390 av_freep(&ost->avfilter);
392 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
396 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
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;
408 #endif /* CONFIG_AVFILTER */
410 static void term_exit(void)
412 av_log(NULL, AV_LOG_QUIET, "");
415 static volatile int received_sigterm = 0;
416 static volatile int received_nb_signals = 0;
419 sigterm_handler(int sig)
421 received_sigterm = sig;
422 received_nb_signals++;
426 static void term_init(void)
428 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
429 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
431 signal(SIGXCPU, sigterm_handler);
435 static int decode_interrupt_cb(void)
437 return received_nb_signals > 1;
440 static int exit_program(int ret)
445 for(i=0;i<nb_output_files;i++) {
446 AVFormatContext *s = output_files[i];
447 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
449 avformat_free_context(s);
450 av_free(output_streams_for_file[i]);
451 av_dict_free(&output_opts[i]);
453 for(i=0;i<nb_input_files;i++) {
454 av_close_input_file(input_files[i].ctx);
456 for (i = 0; i < nb_input_streams; i++)
457 av_dict_free(&input_streams[i].opts);
459 av_free(intra_matrix);
460 av_free(inter_matrix);
464 av_free(vstats_filename);
466 av_free(streamid_map);
467 av_free(stream_maps);
468 av_free(meta_data_maps);
470 av_freep(&input_streams);
471 av_freep(&input_files);
473 av_free(video_codec_name);
474 av_free(audio_codec_name);
475 av_free(subtitle_codec_name);
476 av_free(data_codec_name);
481 allocated_audio_buf_size= allocated_audio_out_size= 0;
488 if (received_sigterm) {
490 "Received signal %d: terminating.\n",
491 (int) received_sigterm);
495 exit(ret); /* not all OS-es handle main() return value */
499 static void assert_avoptions(AVDictionary *m)
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);
508 static void assert_codec_experimental(AVCodecContext *c, int encoder)
510 const char *codec_string = encoder ? "encoder" : "decoder";
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);
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)
528 if (new_size >= INT_MAX / elem_size) {
529 fprintf(stderr, "Array too big.\n");
532 if (*size < new_size) {
533 uint8_t *tmp = av_realloc(array, new_size*elem_size);
535 fprintf(stderr, "Could not alloc buffer.\n");
538 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
545 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
547 if(codec && codec->sample_fmts){
548 const enum AVSampleFormat *p= codec->sample_fmts;
550 if(*p == st->codec->sample_fmt)
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),
558 av_get_sample_fmt_name(codec->sample_fmts[0]));
559 st->codec->sample_fmt = codec->sample_fmts[0];
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.
571 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
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)
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;
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;
592 } else if (*p > enc->sample_fmt) {
593 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
595 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
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;
604 static void choose_sample_rate(AVStream *st, AVCodec *codec)
606 if(codec && codec->supported_samplerates){
607 const int *p= codec->supported_samplerates;
609 int best_dist=INT_MAX;
611 int dist= abs(st->codec->sample_rate - *p);
612 if(dist < best_dist){
618 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
620 st->codec->sample_rate= best;
624 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
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};
636 if(*p == st->codec->pix_fmt)
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,
645 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
646 st->codec->pix_fmt = codec->pix_fmts[0];
651 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
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;
658 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
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],
667 ost = output_streams_for_file[file_idx][idx] =
668 av_mallocz(sizeof(OutputStream));
670 fprintf(stderr, "Could not alloc output stream\n");
673 ost->file_index = file_idx;
678 ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
680 avcodec_get_context_defaults3(st->codec, codec);
682 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
686 static int read_avserver_streams(AVFormatContext *s, const char *filename)
689 AVFormatContext *ic = NULL;
692 err = avformat_open_input(&ic, filename, NULL, NULL);
695 /* copy stream format */
696 for(i=0;i<ic->nb_streams;i++) {
701 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
702 ost = new_output_stream(s, nb_output_files, codec);
705 // FIXME: a more elegant solution is needed
706 memcpy(st, ic->streams[i], sizeof(AVStream));
708 avcodec_copy_context(st->codec, ic->streams[i]->codec);
710 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
711 if (audio_stream_copy) {
714 choose_sample_fmt(st, codec);
715 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
716 if (video_stream_copy) {
719 choose_pixel_fmt(st, codec);
722 if(st->codec->flags & CODEC_FLAG_BITEXACT)
726 av_close_input_file(ic);
731 get_sync_ipts(const OutputStream *ost)
733 const InputStream *ist = ost->sync_ist;
734 return (double)(ist->pts - start_time)/AV_TIME_BASE;
737 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *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);
748 new_pkt.destruct= av_destruct_packet;
750 fprintf(stderr, "%s failed for stream %d, codec %s",
751 bsfc->filter->name, pkt->stream_index,
752 avctx->codec ? avctx->codec->name : "copy");
762 ret= av_interleaved_write_frame(s, pkt);
764 print_error("av_interleaved_write_frame()", ret);
769 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
771 static void do_audio_out(AVFormatContext *s,
774 unsigned char *buf, int size)
777 int64_t audio_out_size, audio_buf_size;
778 int64_t allocated_for_size= size;
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);
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;
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;
799 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
800 fprintf(stderr, "Buffer sizes too large\n");
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");
811 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
812 ost->audio_resample = 1;
814 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
815 ost->resample_channels != dec->channels ||
816 ost->resample_sample_rate != dec->sample_rate;
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;
828 audio_resample_close(ost->resample);
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,
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);
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));
866 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
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;
875 //FIXME resample delay
876 if(fabs(delta) > 50){
877 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
879 byte_delta= FFMAX(byte_delta, -size);
883 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
888 static uint8_t *input_tmp= NULL;
889 input_tmp= av_realloc(input_tmp, byte_delta + size);
891 if(byte_delta > allocated_for_size - size){
892 allocated_for_size= byte_delta + (int64_t)size;
897 memset(input_tmp, 0, byte_delta);
898 memcpy(input_tmp + byte_delta, buf, size);
902 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
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);
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);
914 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
915 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
917 if (ost->audio_resample) {
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;
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");
941 size_out = len*osize;
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");
951 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
953 frame_bytes = enc->frame_size * osize * enc->channels;
955 while (av_fifo_size(ost->fifo) >= frame_bytes) {
957 av_init_packet(&pkt);
959 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
961 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
963 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
966 fprintf(stderr, "Audio encoding failed\n");
970 pkt.stream_index= ost->index;
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);
978 ost->sync_opts += enc->frame_size;
982 av_init_packet(&pkt);
984 ost->sync_opts += size_out / (osize * enc->channels);
986 /* output a pcm frame */
987 /* determine the size of the coded buffer */
990 size_out = size_out*coded_bps/8;
992 if(size_out > audio_out_size){
993 fprintf(stderr, "Internal error, buffer size too small\n");
997 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
998 ret = avcodec_encode_audio(enc, audio_out, size_out,
1001 fprintf(stderr, "Audio encoding failed\n");
1005 pkt.stream_index= ost->index;
1006 pkt.data= audio_out;
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);
1015 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1017 AVCodecContext *dec;
1018 AVPicture *picture2;
1019 AVPicture picture_tmp;
1022 dec = ist->st->codec;
1024 /* deinterlace : must be done before any resize */
1025 if (do_deinterlace) {
1028 /* create temporary picture */
1029 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1030 buf = av_malloc(size);
1034 picture2 = &picture_tmp;
1035 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
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");
1049 if (picture != picture2)
1050 *picture = *picture2;
1054 /* we begin to correct av delay at this threshold */
1055 #define AV_DELAY_MAX 0.100
1057 static void do_subtitle_out(AVFormatContext *s,
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;
1069 if (pts == AV_NOPTS_VALUE) {
1070 fprintf(stderr, "Subtitle packets must have a pts\n");
1076 enc = ost->st->codec;
1078 if (!subtitle_out) {
1079 subtitle_out = av_malloc(subtitle_out_max_size);
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)
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");
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 */
1112 pkt.pts += 90 * sub->start_display_time;
1114 pkt.pts += 90 * sub->end_display_time;
1116 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1120 static int bit_buffer_size= 1024*256;
1121 static uint8_t *bit_buffer= NULL;
1123 static void do_video_out(AVFormatContext *s,
1126 AVFrame *in_picture,
1127 int *frame_size, float quality)
1129 int nb_frames, i, ret, resample_changed;
1130 AVFrame *final_picture, *formatted_picture;
1131 AVCodecContext *enc, *dec;
1134 enc = ost->st->codec;
1135 dec = ist->st->codec;
1137 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1139 /* by default, we output a single frame */
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
1149 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
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){
1160 fprintf(stderr, "*** drop!\n");
1161 }else if (nb_frames > 1) {
1162 nb_frames_dup += nb_frames - 1;
1164 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1167 ost->sync_opts= lrintf(sync_ipts);
1169 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1173 formatted_picture = in_picture;
1174 final_picture = formatted_picture;
1176 resample_changed = ost->resample_width != dec->width ||
1177 ost->resample_height != dec->height ||
1178 ost->resample_pix_fmt != dec->pix_fmt;
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)
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");
1209 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1210 0, ost->resample_height, final_picture->data, final_picture->linesize);
1214 /* duplicates frame if needed */
1215 for(i=0;i<nb_frames;i++) {
1217 av_init_packet(&pkt);
1218 pkt.stream_index= ost->index;
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
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;
1231 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232 enc->coded_frame = old_frame;
1234 AVFrame big_picture;
1236 big_picture= *final_picture;
1237 /* better than nothing: use input picture interlaced
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;
1244 big_picture.top_field_first = top_field_first;
1247 /* handles sameq here. This is not correct because it may
1248 not be a global option */
1249 big_picture.quality = quality;
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++;
1261 ret = avcodec_encode_video(enc,
1262 bit_buffer, bit_buffer_size,
1265 fprintf(stderr, "Video encoding failed\n");
1270 pkt.data= bit_buffer;
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);*/
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);
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);
1292 ost->frame_number++;
1296 static double psnr(double d){
1297 return -10.0*log(d)/log(10.0);
1300 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1303 AVCodecContext *enc;
1305 double ti1, bitrate, avg_bitrate;
1307 /* this is executed just the first time do_video_stats is called */
1309 vstats_file = fopen(vstats_filename, "w");
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)));
1323 fprintf(vstats_file,"f_size= %6d ", frame_size);
1324 /* compute pts value */
1325 ti1 = ost->sync_opts * av_q2d(enc->time_base);
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));
1337 static void print_report(AVFormatContext **output_files,
1338 OutputStream **ost_table, int nb_ostreams,
1343 AVFormatContext *oc;
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];
1351 if (!is_last_report) {
1353 /* display the report every 0.5 seconds */
1354 cur_time = av_gettime();
1355 if (last_time == -1) {
1356 last_time = cur_time;
1359 if ((cur_time - last_time) < 500000)
1361 last_time = cur_time;
1365 oc = output_files[0];
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);
1374 for(i=0;i<nb_ostreams;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);
1383 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384 float t = (av_gettime()-timer_start) / 1000000.0;
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);
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1394 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1399 if (enc->flags&CODEC_FLAG_PSNR){
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=");
1407 error= enc->error[j];
1408 scale= enc->width*enc->height*255.0*255.0*frame_number;
1410 error= enc->coded_frame->error[j];
1411 scale= enc->width*enc->height*255.0*255.0;
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1422 /* compute min output value */
1423 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1424 if ((pts < ti1) && (pts > 0))
1430 if (verbose > 0 || is_last_report) {
1431 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
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);
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);
1442 fprintf(stderr, "%s \r", buf);
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",
1454 100.0*(total_size - raw)/raw
1459 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1461 int fill_char = 0x00;
1462 if (sample_fmt == AV_SAMPLE_FMT_U8)
1464 memset(buf, fill_char, size);
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)
1472 AVFormatContext *os;
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;
1482 int frame_available;
1487 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1489 if(ist->next_pts == AV_NOPTS_VALUE)
1490 ist->next_pts= ist->pts;
1494 av_init_packet(&avpkt);
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);
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;
1512 ist->pts= ist->next_pts;
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;
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);
1532 samples= av_malloc(samples_size);
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,
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 */
1548 /* no audio frame */
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);
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;
1563 ret = avcodec_decode_video2(ist->st->codec,
1564 &picture, &got_output, &avpkt);
1565 quality = same_quality ? picture.quality : 0;
1569 /* no picture yet */
1570 goto discard_packet;
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;
1580 buffer_to_free = NULL;
1581 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1583 case AVMEDIA_TYPE_SUBTITLE:
1584 ret = avcodec_decode_subtitle2(ist->st->codec,
1585 &subtitle, &got_output, &avpkt);
1589 goto discard_packet;
1591 subtitle_to_free = &subtitle;
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;
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;
1617 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1618 for (i = 0; i < nb_ostreams; i++) {
1620 if (ost->input_video_filter && ost->source_index == ist_index) {
1622 if (ist->st->sample_aspect_ratio.num)
1623 sar = ist->st->sample_aspect_ratio;
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,
1635 // preprocess audio (volume)
1636 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1637 if (audio_volume != 256) {
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;
1649 /* frame rate emulation */
1651 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1652 int64_t now = av_gettime() - ist->start;
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++) {
1663 if (ost->source_index == ist_index) {
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);
1672 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1674 os = output_files[ost->file_index];
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;
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);
1685 case AVMEDIA_TYPE_VIDEO:
1687 if (ost->picref->video && !ost->frame_aspect_ratio)
1688 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
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);
1695 case AVMEDIA_TYPE_SUBTITLE:
1696 do_subtitle_out(os, ost, ist, &subtitle,
1703 AVFrame avframe; //FIXME/XXX remove this
1705 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1707 av_init_packet(&opkt);
1709 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1710 #if !CONFIG_AVFILTER
1716 /* no reencoding needed : output the packet directly */
1717 /* force the input stream PTS */
1719 avcodec_get_frame_defaults(&avframe);
1720 ost->st->codec->coded_frame= &avframe;
1721 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
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;
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;
1734 opkt.pts= AV_NOPTS_VALUE;
1736 if (pkt->dts == AV_NOPTS_VALUE)
1737 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1739 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1740 opkt.dts -= ost_tb_start_time;
1742 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1743 opkt.flags= pkt->flags;
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
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;
1753 opkt.data = data_buf;
1754 opkt.size = data_size;
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);
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]);
1767 avfilter_unref_buffer(ost->picref);
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;
1784 for(i=0;i<nb_ostreams;i++) {
1786 if (ost->source_index == ist_index) {
1787 AVCodecContext *enc= ost->st->codec;
1788 os = output_files[ost->file_index];
1790 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1792 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1795 if (ost->encoding_needed) {
1799 av_init_packet(&pkt);
1800 pkt.stream_index= ost->index;
1802 switch(ost->st->codec->codec_type) {
1803 case AVMEDIA_TYPE_AUDIO:
1804 fifo_bytes = av_fifo_size(ost->fifo);
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;
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);
1815 int frame_bytes = enc->frame_size*osize*enc->channels;
1816 if (allocated_audio_buf_size < frame_bytes)
1818 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
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;
1827 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1830 fprintf(stderr, "Audio encoding failed\n");
1834 pkt.flags |= AV_PKT_FLAG_KEY;
1836 case AVMEDIA_TYPE_VIDEO:
1837 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1839 fprintf(stderr, "Video encoding failed\n");
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);
1855 pkt.data= bit_buffer;
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);
1869 static void print_sdp(AVFormatContext **avc, int n)
1873 av_sdp_create(avc, n, sdp, sizeof(sdp));
1874 printf("SDP:\n%s\n", sdp);
1878 static int copy_chapters(int infile, int outfile)
1880 AVFormatContext *is = input_files[infile].ctx;
1881 AVFormatContext *os = output_files[outfile];
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);
1892 if (in_ch->end < ts_off)
1894 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1897 out_ch = av_mallocz(sizeof(AVChapter));
1899 return AVERROR(ENOMEM);
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);
1906 if (metadata_chapters_autocopy)
1907 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1910 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1912 return AVERROR(ENOMEM);
1913 os->chapters[os->nb_chapters - 1] = out_ch;
1918 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1919 AVCodecContext *avctx)
1925 for (p = kf; *p; p++)
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");
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);
1942 * The following code is the main loop of the file converter
1944 static int transcode(AVFormatContext **output_files,
1945 int nb_output_files,
1946 InputFile *input_files,
1948 StreamMap *stream_maps, int nb_stream_maps)
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;
1957 uint8_t no_packet[MAX_FILES]={0};
1958 int no_packet_count=0;
1961 for (i = 0; i < nb_input_streams; i++)
1962 input_streams[i].start = av_gettime();
1964 /* output stream init */
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);
1974 nb_ostreams += os->nb_streams;
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);
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;
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);
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);
2003 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2007 for(k=0;k<nb_output_files;k++) {
2008 os = output_files[k];
2009 for(i=0;i<os->nb_streams;i++,n++) {
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;
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);
2027 int best_nb_frames=-1;
2028 /* get corresponding input stream index : we select the first one with the right type */
2030 for (j = 0; j < nb_input_streams; j++) {
2032 ist = &input_streams[j];
2035 AVFormatContext *f = input_files[ist->file_index].ctx;
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)
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;
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;
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);
2077 ist = &input_streams[ost->source_index];
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;
2085 /* for each output stream, we compute the right encoding parameters */
2086 for(i=0;i<nb_ostreams;i++) {
2088 os = output_files[ost->file_index];
2089 ist = &input_streams[ost->source_index];
2091 codec = ost->st->codec;
2092 icodec = ist->st->codec;
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;
2098 if (ost->st->stream_copy) {
2099 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2101 if (extra_size > INT_MAX)
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;
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;
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)
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);
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");
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;
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};
2160 case AVMEDIA_TYPE_SUBTITLE:
2161 codec->width = icodec->width;
2162 codec->height = icodec->height;
2164 case AVMEDIA_TYPE_DATA:
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);
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;
2181 codec->sample_rate >>= icodec->lowres;
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;
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);
2206 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2207 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2211 if (!codec->width || !codec->height) {
2212 codec->width = icodec->width;
2213 codec->height = icodec->height;
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");
2227 ost->img_resample_ctx = sws_getContext(
2234 ost->sws_flags, NULL, NULL, NULL);
2235 if (ost->img_resample_ctx == NULL) {
2236 fprintf(stderr, "Cannot get resampling context\n");
2240 codec->bits_per_raw_sample= 0;
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;
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];
2255 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2258 if (configure_video_filters(ist, ost)) {
2259 fprintf(stderr, "Error opening filters!\n");
2264 case AVMEDIA_TYPE_SUBTITLE:
2265 ost->encoding_needed = 1;
2266 ist->decoding_needed = 1;
2273 if (ost->encoding_needed &&
2274 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2275 char logfilename[1024];
2278 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2279 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2281 if (codec->flags & CODEC_FLAG_PASS1) {
2282 f = fopen(logfilename, "wb");
2284 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
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);
2295 codec->stats_in = logbuffer;
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);
2306 bit_buffer = av_malloc(bit_buffer_size);
2308 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2310 ret = AVERROR(ENOMEM);
2314 /* open each encoder */
2315 for(i=0;i<nb_ostreams;i++) {
2317 if (ost->encoding_needed) {
2318 AVCodec *codec = ost->enc;
2319 AVCodecContext *dec = input_streams[ost->source_index].st->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);
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);
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;
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);
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;
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;
2356 codec = avcodec_find_decoder(ist->st->codec->codec_id);
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);
2364 /* update requested sample format for the decoder based on the
2365 corresponding encoder sample format */
2366 for (j = 0; j < nb_ostreams; j++) {
2368 if (ost->source_index == i) {
2369 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
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);
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;
2388 for (i = 0; i < nb_input_streams; i++) {
2390 ist = &input_streams[i];
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);
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);
2406 assert_avoptions(output_opts[i]);
2407 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2413 /* dump the file output parameters - cannot be done before in case
2415 for(i=0;i<nb_output_files;i++) {
2416 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2419 /* dump the stream mapping */
2421 fprintf(stderr, "Stream mapping:\n");
2422 for(i=0;i<nb_ostreams;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,
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");
2438 fprintf(stderr, "%s\n", error);
2443 print_sdp(output_files, nb_output_files);
2447 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2450 timer_start = av_gettime();
2452 for(; received_sigterm == 0;) {
2453 int file_index, ist_index;
2462 /* select the stream that we must read now by looking at the
2463 smallest output pts */
2465 for(i=0;i<nb_ostreams;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])
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) {
2477 if(input_sync ) file_index = ist->file_index;
2479 if(opts < opts_min) {
2481 if(!input_sync) file_index = ist->file_index;
2484 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2489 /* if none, if is finished */
2490 if (file_index < 0) {
2491 if(no_packet_count){
2493 memset(no_packet, 0, sizeof(no_packet));
2500 /* finish if limit size exhausted */
2501 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
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;
2513 input_files[file_index].eof_reached = 1;
2521 memset(no_packet, 0, sizeof(no_packet));
2524 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2525 is->streams[pkt.stream_index]);
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];
2534 goto discard_packet;
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);
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;
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;
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);
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;
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) {
2575 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2576 ist->file_index, ist->st->index);
2579 av_free_packet(&pkt);
2584 av_free_packet(&pkt);
2586 /* dump report by using the output first video and audio streams */
2587 print_report(output_files, ost_table, nb_ostreams, 0);
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);
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);
2606 /* dump report by using the first video and audio streams */
2607 print_report(output_files, ost_table, nb_ostreams, 1);
2609 /* close each encoder */
2610 for(i=0;i<nb_ostreams;i++) {
2612 if (ost->encoding_needed) {
2613 av_freep(&ost->st->codec->stats_in);
2614 avcodec_close(ost->st->codec);
2617 avfilter_graph_free(&ost->graph);
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);
2633 av_freep(&bit_buffer);
2636 for(i=0;i<nb_ostreams;i++) {
2639 if (ost->st->stream_copy)
2640 av_freep(&ost->st->codec->extradata);
2642 fclose(ost->logfile);
2643 ost->logfile = NULL;
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);
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);
2665 static int opt_format(const char *opt, const char *arg)
2667 last_asked_format = arg;
2671 static int opt_video_rc_override_string(const char *opt, const char *arg)
2673 video_rc_override_string = arg;
2677 static int opt_me_threshold(const char *opt, const char *arg)
2679 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2683 static int opt_verbose(const char *opt, const char *arg)
2685 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2689 static int opt_frame_rate(const char *opt, const char *arg)
2691 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2692 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2698 static int opt_frame_crop(const char *opt, const char *arg)
2700 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2701 return AVERROR(EINVAL);
2704 static int opt_frame_size(const char *opt, const char *arg)
2706 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2707 fprintf(stderr, "Incorrect frame size\n");
2708 return AVERROR(EINVAL);
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);
2718 static int opt_frame_pix_fmt(const char *opt, const char *arg)
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);
2733 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2740 p = strchr(arg, ':');
2742 x = strtol(arg, &end, 10);
2744 y = strtol(end+1, &end, 10);
2746 ar = (double)x / (double)y;
2748 ar = strtod(arg, NULL);
2751 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2752 return AVERROR(EINVAL);
2754 frame_aspect_ratio = ar;
2758 static int opt_metadata(const char *opt, const char *arg)
2760 char *mid= strchr(arg, '=');
2763 fprintf(stderr, "Missing =\n");
2768 av_dict_set(&metadata, arg, mid, 0);
2773 static int opt_qscale(const char *opt, const char *arg)
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);
2783 static int opt_top_field_first(const char *opt, const char *arg)
2785 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2789 static int opt_thread_count(const char *opt, const char *arg)
2791 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2794 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2799 static int opt_audio_sample_fmt(const char *opt, const char *arg)
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);
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));
2817 static int opt_audio_rate(const char *opt, const char *arg)
2819 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2823 static int opt_audio_channels(const char *opt, const char *arg)
2825 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2829 static int opt_codec(int *pstream_copy, char **pcodec_name,
2830 int codec_type, const char *arg)
2832 av_freep(pcodec_name);
2833 if (!strcmp(arg, "copy")) {
2836 *pcodec_name = av_strdup(arg);
2841 static int opt_audio_codec(const char *opt, const char *arg)
2843 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2846 static int opt_video_codec(const char *opt, const char *arg)
2848 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2851 static int opt_subtitle_codec(const char *opt, const char *arg)
2853 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2856 static int opt_data_codec(const char *opt, const char *arg)
2858 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2861 static int opt_codec_tag(const char *opt, const char *arg)
2864 uint32_t *codec_tag;
2866 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2867 !strcmp(opt, "vtag") ? &video_codec_tag :
2868 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2872 *codec_tag = strtol(arg, &tail, 0);
2874 *codec_tag = AV_RL32(arg);
2879 static int opt_map(const char *opt, const char *arg)
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];
2887 m->file_index = strtol(arg, &p, 0);
2891 m->stream_index = strtol(p, &p, 0);
2894 m->sync_file_index = strtol(p, &p, 0);
2897 m->sync_stream_index = strtol(p, &p, 0);
2899 m->sync_file_index = m->file_index;
2900 m->sync_stream_index = m->stream_index;
2905 static void parse_meta_type(char *arg, char *type, int *index)
2915 if (*(++arg) == ':')
2916 *index = strtol(++arg, NULL, 0);
2919 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2926 static int opt_map_metadata(const char *opt, const char *arg)
2928 MetadataMap *m, *m1;
2931 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2932 &nb_meta_data_maps, nb_meta_data_maps + 1);
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);
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);
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;
2954 static int opt_input_ts_scale(const char *opt, const char *arg)
2956 unsigned int stream;
2960 stream = strtol(arg, &p, 0);
2963 scale= strtod(p, &p);
2965 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
2966 ts_scale[stream] = scale;
2970 static int opt_recording_time(const char *opt, const char *arg)
2972 recording_time = parse_time_or_die(opt, arg, 1);
2976 static int opt_start_time(const char *opt, const char *arg)
2978 start_time = parse_time_or_die(opt, arg, 1);
2982 static int opt_input_ts_offset(const char *opt, const char *arg)
2984 input_ts_offset = parse_time_or_die(opt, arg, 1);
2988 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2990 const char *codec_string = encoder ? "encoder" : "decoder";
2994 return CODEC_ID_NONE;
2996 avcodec_find_encoder_by_name(name) :
2997 avcodec_find_decoder_by_name(name);
2999 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3002 if(codec->type != type) {
3003 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3009 static int opt_input_file(const char *opt, const char *filename)
3011 AVFormatContext *ic;
3012 AVInputFormat *file_iformat = NULL;
3013 int err, i, ret, rfps, rfps_base;
3016 AVDictionary **opts;
3017 int orig_nb_streams; // number of streams before avformat_find_stream_info
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);
3024 last_asked_format = NULL;
3027 if (!strcmp(filename, "-"))
3030 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3031 !strcmp(filename, "/dev/stdin");
3033 /* get default parameters from command line */
3034 ic = avformat_alloc_context();
3036 print_error(filename, AVERROR(ENOMEM));
3039 if (audio_sample_rate) {
3040 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3041 av_dict_set(&format_opts, "sample_rate", buf, 0);
3043 if (audio_channels) {
3044 snprintf(buf, sizeof(buf), "%d", audio_channels);
3045 av_dict_set(&format_opts, "channels", buf, 0);
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);
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);
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);
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;
3066 /* open the input file with generic libav function */
3067 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3069 print_error(filename, err);
3072 assert_avoptions(format_opts);
3077 for(i=0; i<ic->nb_streams; i++){
3078 ic->streams[i]->discard= AVDISCARD_ALL;
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;
3086 for(j=0; j<p->nb_stream_indexes; j++){
3087 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3092 fprintf(stderr, "Specified program id not found\n");
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;
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);
3111 timestamp = start_time;
3112 /* add the stream start time */
3113 if (ic->start_time != AV_NOPTS_VALUE)
3114 timestamp += ic->start_time;
3116 /* if seeking requested, we execute it */
3117 if (start_time != 0) {
3118 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3120 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3121 filename, (double)timestamp / AV_TIME_BASE);
3123 /* reset seek info */
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;
3133 dec->thread_count = thread_count;
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];
3138 ist->file_index = nb_input_files;
3140 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3142 if (i < nb_ts_scale)
3143 ist->ts_scale = ts_scale[i];
3145 switch (dec->codec_type) {
3146 case AVMEDIA_TYPE_AUDIO:
3147 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3149 st->discard= AVDISCARD_ALL;
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;
3156 dec->flags |= CODEC_FLAG_EMU_EDGE;
3157 dec->height >>= dec->lowres;
3158 dec->width >>= dec->lowres;
3161 dec->debug |= FF_DEBUG_MV;
3163 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
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,
3169 (float)rfps / rfps_base, rfps, rfps_base);
3173 st->discard= AVDISCARD_ALL;
3174 else if(video_discard)
3175 st->discard= video_discard;
3177 case AVMEDIA_TYPE_DATA:
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;
3184 case AVMEDIA_TYPE_ATTACHMENT:
3185 case AVMEDIA_TYPE_UNKNOWN:
3192 /* dump the file content */
3194 av_dump_format(ic, nb_input_files, filename, 0);
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);
3201 frame_rate = (AVRational){0, 0};
3202 frame_pix_fmt = PIX_FMT_NONE;
3205 audio_sample_rate = 0;
3207 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3208 av_freep(&ts_scale);
3211 for (i = 0; i < orig_nb_streams; i++)
3212 av_dict_free(&opts[i]);
3214 av_freep(&video_codec_name);
3215 av_freep(&audio_codec_name);
3216 av_freep(&subtitle_codec_name);
3222 static void check_inputs(int *has_video_ptr,
3224 int *has_subtitle_ptr,
3227 int has_video, has_audio, has_subtitle, has_data, i, j;
3228 AVFormatContext *ic;
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:
3243 case AVMEDIA_TYPE_VIDEO:
3246 case AVMEDIA_TYPE_SUBTITLE:
3249 case AVMEDIA_TYPE_DATA:
3250 case AVMEDIA_TYPE_ATTACHMENT:
3251 case AVMEDIA_TYPE_UNKNOWN:
3259 *has_video_ptr = has_video;
3260 *has_audio_ptr = has_audio;
3261 *has_subtitle_ptr = has_subtitle;
3262 *has_data_ptr = has_data;
3265 static void new_video_stream(AVFormatContext *oc, int file_idx)
3269 AVCodecContext *video_enc;
3270 enum CodecID codec_id = CODEC_ID_NONE;
3271 AVCodec *codec= NULL;
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);
3278 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3279 codec = avcodec_find_encoder(codec_id);
3283 ost = new_output_stream(oc, file_idx, codec);
3285 if (!video_stream_copy) {
3286 ost->frame_aspect_ratio = frame_aspect_ratio;
3287 frame_aspect_ratio = 0;
3289 ost->avfilter= vfilters;
3294 ost->bitstream_filters = video_bitstream_filters;
3295 video_bitstream_filters= NULL;
3297 st->codec->thread_count= thread_count;
3299 video_enc = st->codec;
3302 video_enc->codec_tag= video_codec_tag;
3304 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3305 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
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);
3318 ost->frame_rate = frame_rate;
3319 video_enc->codec_id = codec_id;
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;
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;
3334 video_enc->intra_matrix = intra_matrix;
3336 video_enc->inter_matrix = inter_matrix;
3338 p= video_rc_override_string;
3341 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3343 fprintf(stderr, "error parsing rc_override\n");
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;
3352 video_enc->rc_override[i].qscale= q;
3353 video_enc->rc_override[i].quality_factor= 1.0;
3356 video_enc->rc_override[i].qscale= 0;
3357 video_enc->rc_override[i].quality_factor= -q/100.0;
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;
3369 video_enc->flags|= CODEC_FLAG_PSNR;
3374 video_enc->flags |= CODEC_FLAG_PASS1;
3376 video_enc->flags |= CODEC_FLAG_PASS2;
3380 if (forced_key_frames)
3381 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3383 if (video_language) {
3384 av_dict_set(&st->metadata, "language", video_language, 0);
3385 av_freep(&video_language);
3388 /* reset some key parameters */
3390 av_freep(&video_codec_name);
3391 av_freep(&forced_key_frames);
3392 video_stream_copy = 0;
3393 frame_pix_fmt = PIX_FMT_NONE;
3396 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3400 AVCodec *codec= NULL;
3401 AVCodecContext *audio_enc;
3402 enum CodecID codec_id = CODEC_ID_NONE;
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);
3409 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3410 codec = avcodec_find_encoder(codec_id);
3413 ost = new_output_stream(oc, file_idx, codec);
3416 ost->bitstream_filters = audio_bitstream_filters;
3417 audio_bitstream_filters= NULL;
3419 st->codec->thread_count= thread_count;
3421 audio_enc = st->codec;
3422 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3425 audio_enc->codec_tag= audio_codec_tag;
3427 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3428 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3430 if (audio_stream_copy) {
3431 st->stream_copy = 1;
3433 audio_enc->codec_id = codec_id;
3435 if (audio_qscale > QSCALE_NONE) {
3436 audio_enc->flags |= CODEC_FLAG_QSCALE;
3437 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
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;
3446 if (audio_language) {
3447 av_dict_set(&st->metadata, "language", audio_language, 0);
3448 av_freep(&audio_language);
3451 /* reset some key parameters */
3453 av_freep(&audio_codec_name);
3454 audio_stream_copy = 0;
3457 static void new_data_stream(AVFormatContext *oc, int file_idx)
3461 AVCodecContext *data_enc;
3463 ost = new_output_stream(oc, file_idx, NULL);
3465 data_enc = st->codec;
3466 if (!data_stream_copy) {
3467 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3471 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3474 data_enc->codec_tag= data_codec_tag;
3476 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3477 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3479 if (data_stream_copy) {
3480 st->stream_copy = 1;
3484 av_freep(&data_codec_name);
3485 data_stream_copy = 0;
3488 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3492 AVCodec *codec=NULL;
3493 AVCodecContext *subtitle_enc;
3494 enum CodecID codec_id = CODEC_ID_NONE;
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);
3501 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3502 codec = avcodec_find_encoder(codec_id);
3505 ost = new_output_stream(oc, file_idx, codec);
3507 subtitle_enc = st->codec;
3509 ost->bitstream_filters = subtitle_bitstream_filters;
3510 subtitle_bitstream_filters= NULL;
3512 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3514 if(subtitle_codec_tag)
3515 subtitle_enc->codec_tag= subtitle_codec_tag;
3517 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3518 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3520 if (subtitle_stream_copy) {
3521 st->stream_copy = 1;
3523 subtitle_enc->codec_id = codec_id;
3526 if (subtitle_language) {
3527 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3528 av_freep(&subtitle_language);
3531 subtitle_disable = 0;
3532 av_freep(&subtitle_codec_name);
3533 subtitle_stream_copy = 0;
3536 static int opt_new_stream(const char *opt, const char *arg)
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");
3544 oc = output_files[file_idx];
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);
3554 /* arg format is "output-stream-index:streamid-value". */
3555 static int opt_streamid(const char *opt, const char *arg)
3561 av_strlcpy(idx_str, arg, sizeof(idx_str));
3562 p = strchr(idx_str, ':');
3565 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
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);
3576 static void opt_output_file(const char *filename)
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;
3583 if (!strcmp(filename, "-"))
3586 oc = avformat_alloc_context();
3588 print_error(filename, AVERROR(ENOMEM));
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);
3598 last_asked_format = NULL;
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",
3608 oc->oformat = file_oformat;
3609 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
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);
3617 print_error(filename, err);
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 */
3626 /* disable if no corresponding type found */
3627 check_inputs(&input_has_video,
3629 &input_has_subtitle,
3632 if (!input_has_video)
3634 if (!input_has_audio)
3636 if (!input_has_subtitle)
3638 if (!input_has_data)
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;
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);
3652 av_dict_copy(&oc->metadata, metadata, 0);
3653 av_dict_free(&metadata);
3656 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3657 output_files[nb_output_files++] = oc;
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));
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) {
3675 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3677 if (!read_yesno()) {
3678 fprintf(stderr, "Not overwriting - exiting\n");
3683 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3690 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3691 print_error(filename, err);
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;
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;
3711 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3712 chapters_input_file);
3716 if (chapters_input_file >= 0)
3717 copy_chapters(chapters_input_file, nb_output_files - 1);
3720 for (i = 0; i < nb_meta_data_maps; i++) {
3721 AVFormatContext *files[2];
3722 AVDictionary **meta[2];
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",\
3732 int in_file_index = meta_data_maps[i][1].file;
3733 if (in_file_index < 0)
3735 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3738 files[1] = input_files[in_file_index].ctx;
3740 for (j = 0; j < 2; j++) {
3741 MetadataMap *map = &meta_data_maps[i][j];
3743 switch (map->type) {
3745 meta[j] = &files[j]->metadata;
3748 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3749 meta[j] = &files[j]->streams[map->index]->metadata;
3752 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3753 meta[j] = &files[j]->chapters[map->index]->metadata;
3756 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3757 meta[j] = &files[j]->programs[map->index]->metadata;
3762 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
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);
3775 frame_rate = (AVRational){0, 0};
3778 audio_sample_rate = 0;
3780 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3781 chapters_input_file = INT_MAX;
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;
3789 av_freep(&forced_key_frames);
3794 /* same option as mencoder */
3795 static int opt_pass(const char *opt, const char *arg)
3797 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3801 static int64_t getutime(void)
3804 struct rusage rusage;
3806 getrusage(RUSAGE_SELF, &rusage);
3807 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3808 #elif HAVE_GETPROCESSTIMES
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;
3815 return av_gettime();
3819 static int64_t getmaxrss(void)
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
3827 PROCESS_MEMORY_COUNTERS memcounters;
3828 proc = GetCurrentProcess();
3829 memcounters.cb = sizeof(memcounters);
3830 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3831 return memcounters.PeakPagefileUsage;
3837 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3840 const char *p = str;
3847 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3854 static void opt_inter_matrix(const char *arg)
3856 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3857 parse_matrix_coeffs(inter_matrix, arg);
3860 static void opt_intra_matrix(const char *arg)
3862 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3863 parse_matrix_coeffs(intra_matrix, arg);
3866 static void show_usage(void)
3868 printf("Hyper fast Audio and Video encoder\n");
3869 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3873 static void show_help(void)
3876 AVOutputFormat *oformat = NULL;
3877 AVInputFormat *iformat = NULL;
3879 av_log_set_callback(log_callback_help);
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,
3886 show_help_options(options, "\nVideo options:\n",
3887 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
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,
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,
3901 show_help_options(options, "\nAudio/Video grab options:\n",
3905 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3908 /* individual codec options */
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);
3917 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
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);
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);
3936 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3939 static int opt_target(const char *opt, const char *arg)
3941 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3942 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3944 if(!strncmp(arg, "pal-", 4)) {
3947 } else if(!strncmp(arg, "ntsc-", 5)) {
3950 } else if(!strncmp(arg, "film-", 5)) {
3955 /* Calculate FR via float to avoid int overflow */
3956 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3959 } else if((fr == 29970) || (fr == 23976)) {
3962 /* Try to determine PAL/NTSC by peeking in the input files */
3963 if(nb_input_files) {
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)
3970 fr = c->time_base.den * 1000 / c->time_base.num;
3974 } else if((fr == 29970) || (fr == 23976)) {
3984 if(verbose > 0 && norm != UNKNOWN)
3985 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
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");
3995 if(!strcmp(arg, "vcd")) {
3996 opt_video_codec("vcodec", "mpeg1video");
3997 opt_audio_codec("vcodec", "mp2");
3998 opt_format("f", "vcd");
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");
4004 opt_default("b", "1150000");
4005 opt_default("maxrate", "1150000");
4006 opt_default("minrate", "1150000");
4007 opt_default("bufsize", "327680"); // 40*1024*8;
4009 opt_default("ab", "224000");
4010 audio_sample_rate = 44100;
4013 opt_default("packetsize", "2324");
4014 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
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")) {
4024 opt_video_codec("vcodec", "mpeg2video");
4025 opt_audio_codec("acodec", "mp2");
4026 opt_format("f", "svcd");
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");
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");
4039 opt_default("ab", "224000");
4040 audio_sample_rate = 44100;
4042 opt_default("packetsize", "2324");
4044 } else if(!strcmp(arg, "dvd")) {
4046 opt_video_codec("vcodec", "mpeg2video");
4047 opt_audio_codec("vcodec", "ac3");
4048 opt_format("f", "dvd");
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");
4054 opt_default("b", "6000000");
4055 opt_default("maxrate", "9000000");
4056 opt_default("minrate", "0"); //1500000;
4057 opt_default("bufsize", "1835008"); //224*1024*8;
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
4062 opt_default("ab", "448000");
4063 audio_sample_rate = 48000;
4065 } else if(!strncmp(arg, "dv", 2)) {
4067 opt_format("f", "dv");
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]);
4074 audio_sample_rate = 48000;
4078 fprintf(stderr, "Unknown target: %s\n", arg);
4079 return AVERROR(EINVAL);
4084 static int opt_vstats_file(const char *opt, const char *arg)
4086 av_free (vstats_filename);
4087 vstats_filename=av_strdup (arg);
4091 static int opt_vstats(const char *opt, const char *arg)
4094 time_t today2 = time(NULL);
4095 struct tm *today = localtime(&today2);
4097 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4099 return opt_vstats_file(opt, filename);
4102 static int opt_bsf(const char *opt, const char *arg)
4104 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4105 AVBitStreamFilterContext **bsfp;
4108 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4112 bsfp= *opt == 'v' ? &video_bitstream_filters :
4113 *opt == 'a' ? &audio_bitstream_filters :
4114 &subtitle_bitstream_filters;
4116 bsfp= &(*bsfp)->next;
4123 static int opt_preset(const char *opt, const char *arg)
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;
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);
4137 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4138 if(line[0] == '#' && !e)
4140 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4142 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
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);
4164 static const OptionDef 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*)©_ts}, "copy timestamps" },
4196 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_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*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
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" },
4235 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
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" },
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" },
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" },