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 st->codec->codec_type = codec->type;
679 ost->opts = filter_codec_opts(codec_opts, codec->id, oc, st);
682 avcodec_get_context_defaults3(st->codec, codec);
684 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
688 static int read_avserver_streams(AVFormatContext *s, const char *filename)
691 AVFormatContext *ic = NULL;
694 err = avformat_open_input(&ic, filename, NULL, NULL);
697 /* copy stream format */
698 for(i=0;i<ic->nb_streams;i++) {
703 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
704 ost = new_output_stream(s, nb_output_files, codec);
707 // FIXME: a more elegant solution is needed
708 memcpy(st, ic->streams[i], sizeof(AVStream));
710 avcodec_copy_context(st->codec, ic->streams[i]->codec);
712 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
713 if (audio_stream_copy) {
716 choose_sample_fmt(st, codec);
717 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
718 if (video_stream_copy) {
721 choose_pixel_fmt(st, codec);
724 if(st->codec->flags & CODEC_FLAG_BITEXACT)
728 av_close_input_file(ic);
733 get_sync_ipts(const OutputStream *ost)
735 const InputStream *ist = ost->sync_ist;
736 return (double)(ist->pts - start_time)/AV_TIME_BASE;
739 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
743 AVPacket new_pkt= *pkt;
744 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
745 &new_pkt.data, &new_pkt.size,
746 pkt->data, pkt->size,
747 pkt->flags & AV_PKT_FLAG_KEY);
750 new_pkt.destruct= av_destruct_packet;
752 fprintf(stderr, "%s failed for stream %d, codec %s",
753 bsfc->filter->name, pkt->stream_index,
754 avctx->codec ? avctx->codec->name : "copy");
764 ret= av_interleaved_write_frame(s, pkt);
766 print_error("av_interleaved_write_frame()", ret);
771 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
773 static void do_audio_out(AVFormatContext *s,
776 unsigned char *buf, int size)
779 int64_t audio_out_size, audio_buf_size;
780 int64_t allocated_for_size= size;
782 int size_out, frame_bytes, ret, resample_changed;
783 AVCodecContext *enc= ost->st->codec;
784 AVCodecContext *dec= ist->st->codec;
785 int osize = av_get_bytes_per_sample(enc->sample_fmt);
786 int isize = av_get_bytes_per_sample(dec->sample_fmt);
787 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
790 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
791 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
792 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
793 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
794 audio_buf_size*= osize*enc->channels;
796 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
797 if(coded_bps > 8*osize)
798 audio_out_size= audio_out_size * coded_bps / (8*osize);
799 audio_out_size += FF_MIN_BUFFER_SIZE;
801 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
802 fprintf(stderr, "Buffer sizes too large\n");
806 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
807 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
808 if (!audio_buf || !audio_out){
809 fprintf(stderr, "Out of memory in do_audio_out\n");
813 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
814 ost->audio_resample = 1;
816 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
817 ost->resample_channels != dec->channels ||
818 ost->resample_sample_rate != dec->sample_rate;
820 if ((ost->audio_resample && !ost->resample) || resample_changed) {
821 if (resample_changed) {
822 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",
823 ist->file_index, ist->st->index,
824 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
825 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
826 ost->resample_sample_fmt = dec->sample_fmt;
827 ost->resample_channels = dec->channels;
828 ost->resample_sample_rate = dec->sample_rate;
830 audio_resample_close(ost->resample);
832 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
833 if (audio_sync_method <= 1 &&
834 ost->resample_sample_fmt == enc->sample_fmt &&
835 ost->resample_channels == enc->channels &&
836 ost->resample_sample_rate == enc->sample_rate) {
837 ost->resample = NULL;
838 ost->audio_resample = 0;
839 } else if (ost->audio_resample) {
840 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
841 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
842 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
843 enc->sample_rate, dec->sample_rate,
844 enc->sample_fmt, dec->sample_fmt,
846 if (!ost->resample) {
847 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
848 dec->channels, dec->sample_rate,
849 enc->channels, enc->sample_rate);
855 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
856 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
857 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
858 if (ost->reformat_ctx)
859 av_audio_convert_free(ost->reformat_ctx);
860 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
861 dec->sample_fmt, 1, NULL, 0);
862 if (!ost->reformat_ctx) {
863 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
864 av_get_sample_fmt_name(dec->sample_fmt),
865 av_get_sample_fmt_name(enc->sample_fmt));
868 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
871 if(audio_sync_method){
872 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
873 - av_fifo_size(ost->fifo)/(enc->channels * 2);
874 double idelta= delta*dec->sample_rate / enc->sample_rate;
875 int byte_delta= ((int)idelta)*2*dec->channels;
877 //FIXME resample delay
878 if(fabs(delta) > 50){
879 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
881 byte_delta= FFMAX(byte_delta, -size);
885 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
890 static uint8_t *input_tmp= NULL;
891 input_tmp= av_realloc(input_tmp, byte_delta + size);
893 if(byte_delta > allocated_for_size - size){
894 allocated_for_size= byte_delta + (int64_t)size;
899 memset(input_tmp, 0, byte_delta);
900 memcpy(input_tmp + byte_delta, buf, size);
904 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
906 }else if(audio_sync_method>1){
907 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
908 av_assert0(ost->audio_resample);
910 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
911 // 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));
912 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
916 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
917 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
919 if (ost->audio_resample) {
921 size_out = audio_resample(ost->resample,
922 (short *)buftmp, (short *)buf,
923 size / (dec->channels * isize));
924 size_out = size_out * enc->channels * osize;
930 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
931 const void *ibuf[6]= {buftmp};
932 void *obuf[6]= {audio_buf};
933 int istride[6]= {isize};
934 int ostride[6]= {osize};
935 int len= size_out/istride[0];
936 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
937 printf("av_audio_convert() failed\n");
943 size_out = len*osize;
946 /* now encode as many frames as possible */
947 if (enc->frame_size > 1) {
948 /* output resampled raw samples */
949 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
950 fprintf(stderr, "av_fifo_realloc2() failed\n");
953 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
955 frame_bytes = enc->frame_size * osize * enc->channels;
957 while (av_fifo_size(ost->fifo) >= frame_bytes) {
959 av_init_packet(&pkt);
961 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
963 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
965 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
968 fprintf(stderr, "Audio encoding failed\n");
972 pkt.stream_index= ost->index;
975 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
976 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
977 pkt.flags |= AV_PKT_FLAG_KEY;
978 write_frame(s, &pkt, enc, ost->bitstream_filters);
980 ost->sync_opts += enc->frame_size;
984 av_init_packet(&pkt);
986 ost->sync_opts += size_out / (osize * enc->channels);
988 /* output a pcm frame */
989 /* determine the size of the coded buffer */
992 size_out = size_out*coded_bps/8;
994 if(size_out > audio_out_size){
995 fprintf(stderr, "Internal error, buffer size too small\n");
999 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1000 ret = avcodec_encode_audio(enc, audio_out, size_out,
1003 fprintf(stderr, "Audio encoding failed\n");
1007 pkt.stream_index= ost->index;
1008 pkt.data= audio_out;
1010 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1011 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1012 pkt.flags |= AV_PKT_FLAG_KEY;
1013 write_frame(s, &pkt, enc, ost->bitstream_filters);
1017 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1019 AVCodecContext *dec;
1020 AVPicture *picture2;
1021 AVPicture picture_tmp;
1024 dec = ist->st->codec;
1026 /* deinterlace : must be done before any resize */
1027 if (do_deinterlace) {
1030 /* create temporary picture */
1031 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1032 buf = av_malloc(size);
1036 picture2 = &picture_tmp;
1037 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1039 if(avpicture_deinterlace(picture2, picture,
1040 dec->pix_fmt, dec->width, dec->height) < 0) {
1041 /* if error, do not deinterlace */
1042 fprintf(stderr, "Deinterlacing failed\n");
1051 if (picture != picture2)
1052 *picture = *picture2;
1056 /* we begin to correct av delay at this threshold */
1057 #define AV_DELAY_MAX 0.100
1059 static void do_subtitle_out(AVFormatContext *s,
1065 static uint8_t *subtitle_out = NULL;
1066 int subtitle_out_max_size = 1024 * 1024;
1067 int subtitle_out_size, nb, i;
1068 AVCodecContext *enc;
1071 if (pts == AV_NOPTS_VALUE) {
1072 fprintf(stderr, "Subtitle packets must have a pts\n");
1078 enc = ost->st->codec;
1080 if (!subtitle_out) {
1081 subtitle_out = av_malloc(subtitle_out_max_size);
1084 /* Note: DVB subtitle need one packet to draw them and one other
1085 packet to clear them */
1086 /* XXX: signal it in the codec context ? */
1087 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1092 for(i = 0; i < nb; i++) {
1093 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1094 // start_display_time is required to be 0
1095 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1096 sub->end_display_time -= sub->start_display_time;
1097 sub->start_display_time = 0;
1098 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1099 subtitle_out_max_size, sub);
1100 if (subtitle_out_size < 0) {
1101 fprintf(stderr, "Subtitle encoding failed\n");
1105 av_init_packet(&pkt);
1106 pkt.stream_index = ost->index;
1107 pkt.data = subtitle_out;
1108 pkt.size = subtitle_out_size;
1109 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1110 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1111 /* XXX: the pts correction is handled here. Maybe handling
1112 it in the codec would be better */
1114 pkt.pts += 90 * sub->start_display_time;
1116 pkt.pts += 90 * sub->end_display_time;
1118 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1122 static int bit_buffer_size= 1024*256;
1123 static uint8_t *bit_buffer= NULL;
1125 static void do_video_out(AVFormatContext *s,
1128 AVFrame *in_picture,
1129 int *frame_size, float quality)
1131 int nb_frames, i, ret, resample_changed;
1132 AVFrame *final_picture, *formatted_picture;
1133 AVCodecContext *enc, *dec;
1136 enc = ost->st->codec;
1137 dec = ist->st->codec;
1139 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1141 /* by default, we output a single frame */
1146 if(video_sync_method){
1147 double vdelta = sync_ipts - ost->sync_opts;
1148 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1151 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1154 }else if(vdelta>0.6)
1155 ost->sync_opts= lrintf(sync_ipts);
1156 }else if (vdelta > 1.1)
1157 nb_frames = lrintf(vdelta);
1158 //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);
1159 if (nb_frames == 0){
1162 fprintf(stderr, "*** drop!\n");
1163 }else if (nb_frames > 1) {
1164 nb_frames_dup += nb_frames - 1;
1166 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1169 ost->sync_opts= lrintf(sync_ipts);
1171 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1175 formatted_picture = in_picture;
1176 final_picture = formatted_picture;
1178 resample_changed = ost->resample_width != dec->width ||
1179 ost->resample_height != dec->height ||
1180 ost->resample_pix_fmt != dec->pix_fmt;
1182 if (resample_changed) {
1183 av_log(NULL, AV_LOG_INFO,
1184 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1185 ist->file_index, ist->st->index,
1186 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1187 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1188 if(!ost->video_resample)
1192 #if !CONFIG_AVFILTER
1193 if (ost->video_resample) {
1194 final_picture = &ost->pict_tmp;
1195 if (resample_changed) {
1196 /* initialize a new scaler context */
1197 sws_freeContext(ost->img_resample_ctx);
1198 ost->img_resample_ctx = sws_getContext(
1199 ist->st->codec->width,
1200 ist->st->codec->height,
1201 ist->st->codec->pix_fmt,
1202 ost->st->codec->width,
1203 ost->st->codec->height,
1204 ost->st->codec->pix_fmt,
1205 ost->sws_flags, NULL, NULL, NULL);
1206 if (ost->img_resample_ctx == NULL) {
1207 fprintf(stderr, "Cannot get resampling context\n");
1211 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1212 0, ost->resample_height, final_picture->data, final_picture->linesize);
1216 /* duplicates frame if needed */
1217 for(i=0;i<nb_frames;i++) {
1219 av_init_packet(&pkt);
1220 pkt.stream_index= ost->index;
1222 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1223 /* raw pictures are written as AVPicture structure to
1224 avoid any copies. We support temorarily the older
1226 AVFrame* old_frame = enc->coded_frame;
1227 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1228 pkt.data= (uint8_t *)final_picture;
1229 pkt.size= sizeof(AVPicture);
1230 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1231 pkt.flags |= AV_PKT_FLAG_KEY;
1233 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1234 enc->coded_frame = old_frame;
1236 AVFrame big_picture;
1238 big_picture= *final_picture;
1239 /* better than nothing: use input picture interlaced
1241 big_picture.interlaced_frame = in_picture->interlaced_frame;
1242 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1243 if(top_field_first == -1)
1244 big_picture.top_field_first = in_picture->top_field_first;
1246 big_picture.top_field_first = top_field_first;
1249 /* handles sameq here. This is not correct because it may
1250 not be a global option */
1251 big_picture.quality = quality;
1253 big_picture.pict_type = 0;
1254 // big_picture.pts = AV_NOPTS_VALUE;
1255 big_picture.pts= ost->sync_opts;
1256 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1257 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1258 if (ost->forced_kf_index < ost->forced_kf_count &&
1259 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1260 big_picture.pict_type = AV_PICTURE_TYPE_I;
1261 ost->forced_kf_index++;
1263 ret = avcodec_encode_video(enc,
1264 bit_buffer, bit_buffer_size,
1267 fprintf(stderr, "Video encoding failed\n");
1272 pkt.data= bit_buffer;
1274 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1275 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1276 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1277 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1278 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1280 if(enc->coded_frame->key_frame)
1281 pkt.flags |= AV_PKT_FLAG_KEY;
1282 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1285 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1286 // enc->frame_number-1, ret, enc->pict_type);
1287 /* if two pass, output log */
1288 if (ost->logfile && enc->stats_out) {
1289 fprintf(ost->logfile, "%s", enc->stats_out);
1294 ost->frame_number++;
1298 static double psnr(double d){
1299 return -10.0*log(d)/log(10.0);
1302 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1305 AVCodecContext *enc;
1307 double ti1, bitrate, avg_bitrate;
1309 /* this is executed just the first time do_video_stats is called */
1311 vstats_file = fopen(vstats_filename, "w");
1318 enc = ost->st->codec;
1319 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1320 frame_number = ost->frame_number;
1321 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1322 if (enc->flags&CODEC_FLAG_PSNR)
1323 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1325 fprintf(vstats_file,"f_size= %6d ", frame_size);
1326 /* compute pts value */
1327 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1331 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1332 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1333 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1334 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1335 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1339 static void print_report(AVFormatContext **output_files,
1340 OutputStream **ost_table, int nb_ostreams,
1345 AVFormatContext *oc;
1347 AVCodecContext *enc;
1348 int frame_number, vid, i;
1349 double bitrate, ti1, pts;
1350 static int64_t last_time = -1;
1351 static int qp_histogram[52];
1353 if (!is_last_report) {
1355 /* display the report every 0.5 seconds */
1356 cur_time = av_gettime();
1357 if (last_time == -1) {
1358 last_time = cur_time;
1361 if ((cur_time - last_time) < 500000)
1363 last_time = cur_time;
1367 oc = output_files[0];
1369 total_size = avio_size(oc->pb);
1370 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1371 total_size= avio_tell(oc->pb);
1376 for(i=0;i<nb_ostreams;i++) {
1379 enc = ost->st->codec;
1380 if (!ost->st->stream_copy && enc->coded_frame)
1381 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1382 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1385 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1386 float t = (av_gettime()-timer_start) / 1000000.0;
1388 frame_number = ost->frame_number;
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1390 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1396 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1399 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1401 if (enc->flags&CODEC_FLAG_PSNR){
1403 double error, error_sum=0;
1404 double scale, scale_sum=0;
1405 char type[3]= {'Y','U','V'};
1406 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1409 error= enc->error[j];
1410 scale= enc->width*enc->height*255.0*255.0*frame_number;
1412 error= enc->coded_frame->error[j];
1413 scale= enc->width*enc->height*255.0*255.0;
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1424 /* compute min output value */
1425 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1426 if ((pts < ti1) && (pts > 0))
1432 if (verbose > 0 || is_last_report) {
1433 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1436 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1437 (double)total_size / 1024, ti1, bitrate);
1439 if (nb_frames_dup || nb_frames_drop)
1440 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1441 nb_frames_dup, nb_frames_drop);
1444 fprintf(stderr, "%s \r", buf);
1449 if (is_last_report && verbose >= 0){
1450 int64_t raw= audio_size + video_size + extra_size;
1451 fprintf(stderr, "\n");
1452 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1456 100.0*(total_size - raw)/raw
1461 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1463 int fill_char = 0x00;
1464 if (sample_fmt == AV_SAMPLE_FMT_U8)
1466 memset(buf, fill_char, size);
1469 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1470 static int output_packet(InputStream *ist, int ist_index,
1471 OutputStream **ost_table, int nb_ostreams,
1472 const AVPacket *pkt)
1474 AVFormatContext *os;
1479 void *buffer_to_free = NULL;
1480 static unsigned int samples_size= 0;
1481 AVSubtitle subtitle, *subtitle_to_free;
1482 int64_t pkt_pts = AV_NOPTS_VALUE;
1484 int frame_available;
1489 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1491 if(ist->next_pts == AV_NOPTS_VALUE)
1492 ist->next_pts= ist->pts;
1496 av_init_packet(&avpkt);
1504 if(pkt->dts != AV_NOPTS_VALUE)
1505 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1506 if(pkt->pts != AV_NOPTS_VALUE)
1507 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1509 //while we have more to decode or while the decoder did output something on EOF
1510 while (avpkt.size > 0 || (!pkt && got_output)) {
1511 uint8_t *data_buf, *decoded_data_buf;
1512 int data_size, decoded_data_size;
1514 ist->pts= ist->next_pts;
1516 if(avpkt.size && avpkt.size != pkt->size &&
1517 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1518 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1519 ist->showed_multi_packet_warning=1;
1522 /* decode the packet if needed */
1523 decoded_data_buf = NULL; /* fail safe */
1524 decoded_data_size= 0;
1525 data_buf = avpkt.data;
1526 data_size = avpkt.size;
1527 subtitle_to_free = NULL;
1528 if (ist->decoding_needed) {
1529 switch(ist->st->codec->codec_type) {
1530 case AVMEDIA_TYPE_AUDIO:{
1531 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1532 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1534 samples= av_malloc(samples_size);
1536 decoded_data_size= samples_size;
1537 /* XXX: could avoid copy if PCM 16 bits with same
1538 endianness as CPU */
1539 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1546 got_output = decoded_data_size > 0;
1547 /* Some bug in mpeg audio decoder gives */
1548 /* decoded_data_size < 0, it seems they are overflows */
1550 /* no audio frame */
1553 decoded_data_buf = (uint8_t *)samples;
1554 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1555 (ist->st->codec->sample_rate * ist->st->codec->channels);
1557 case AVMEDIA_TYPE_VIDEO:
1558 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1559 /* XXX: allocate picture correctly */
1560 avcodec_get_frame_defaults(&picture);
1561 avpkt.pts = pkt_pts;
1562 avpkt.dts = ist->pts;
1563 pkt_pts = AV_NOPTS_VALUE;
1565 ret = avcodec_decode_video2(ist->st->codec,
1566 &picture, &got_output, &avpkt);
1567 quality = same_quality ? picture.quality : 0;
1571 /* no picture yet */
1572 goto discard_packet;
1574 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1575 if (ist->st->codec->time_base.num != 0) {
1576 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1577 ist->next_pts += ((int64_t)AV_TIME_BASE *
1578 ist->st->codec->time_base.num * ticks) /
1579 ist->st->codec->time_base.den;
1582 buffer_to_free = NULL;
1583 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1585 case AVMEDIA_TYPE_SUBTITLE:
1586 ret = avcodec_decode_subtitle2(ist->st->codec,
1587 &subtitle, &got_output, &avpkt);
1591 goto discard_packet;
1593 subtitle_to_free = &subtitle;
1600 switch(ist->st->codec->codec_type) {
1601 case AVMEDIA_TYPE_AUDIO:
1602 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1603 ist->st->codec->sample_rate;
1605 case AVMEDIA_TYPE_VIDEO:
1606 if (ist->st->codec->time_base.num != 0) {
1607 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1608 ist->next_pts += ((int64_t)AV_TIME_BASE *
1609 ist->st->codec->time_base.num * ticks) /
1610 ist->st->codec->time_base.den;
1619 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1620 for (i = 0; i < nb_ostreams; i++) {
1622 if (ost->input_video_filter && ost->source_index == ist_index) {
1624 if (ist->st->sample_aspect_ratio.num)
1625 sar = ist->st->sample_aspect_ratio;
1627 sar = ist->st->codec->sample_aspect_ratio;
1628 // add it to be filtered
1629 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1637 // preprocess audio (volume)
1638 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1639 if (audio_volume != 256) {
1642 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1643 int v = ((*volp) * audio_volume + 128) >> 8;
1644 if (v < -32768) v = -32768;
1645 if (v > 32767) v = 32767;
1651 /* frame rate emulation */
1653 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1654 int64_t now = av_gettime() - ist->start;
1658 /* if output time reached then transcode raw format,
1659 encode packets and output them */
1660 if (start_time == 0 || ist->pts >= start_time)
1661 for(i=0;i<nb_ostreams;i++) {
1665 if (ost->source_index == ist_index) {
1667 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1668 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1669 while (frame_available) {
1670 AVRational ist_pts_tb;
1671 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1672 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1674 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1676 os = output_files[ost->file_index];
1678 /* set the input output pts pairs */
1679 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1681 if (ost->encoding_needed) {
1682 av_assert0(ist->decoding_needed);
1683 switch(ost->st->codec->codec_type) {
1684 case AVMEDIA_TYPE_AUDIO:
1685 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1687 case AVMEDIA_TYPE_VIDEO:
1689 if (ost->picref->video && !ost->frame_aspect_ratio)
1690 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1692 do_video_out(os, ost, ist, &picture, &frame_size,
1693 same_quality ? quality : ost->st->codec->global_quality);
1694 if (vstats_filename && frame_size)
1695 do_video_stats(os, ost, frame_size);
1697 case AVMEDIA_TYPE_SUBTITLE:
1698 do_subtitle_out(os, ost, ist, &subtitle,
1705 AVFrame avframe; //FIXME/XXX remove this
1707 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1709 av_init_packet(&opkt);
1711 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1712 #if !CONFIG_AVFILTER
1718 /* no reencoding needed : output the packet directly */
1719 /* force the input stream PTS */
1721 avcodec_get_frame_defaults(&avframe);
1722 ost->st->codec->coded_frame= &avframe;
1723 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1725 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1726 audio_size += data_size;
1727 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1728 video_size += data_size;
1732 opkt.stream_index= ost->index;
1733 if(pkt->pts != AV_NOPTS_VALUE)
1734 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1736 opkt.pts= AV_NOPTS_VALUE;
1738 if (pkt->dts == AV_NOPTS_VALUE)
1739 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1741 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1742 opkt.dts -= ost_tb_start_time;
1744 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1745 opkt.flags= pkt->flags;
1747 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1748 if( ost->st->codec->codec_id != CODEC_ID_H264
1749 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1750 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1752 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1753 opkt.destruct= av_destruct_packet;
1755 opkt.data = data_buf;
1756 opkt.size = data_size;
1759 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1760 ost->st->codec->frame_number++;
1761 ost->frame_number++;
1762 av_free_packet(&opkt);
1766 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1767 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1769 avfilter_unref_buffer(ost->picref);
1775 av_free(buffer_to_free);
1776 /* XXX: allocate the subtitles in the codec ? */
1777 if (subtitle_to_free) {
1778 avsubtitle_free(subtitle_to_free);
1779 subtitle_to_free = NULL;
1786 for(i=0;i<nb_ostreams;i++) {
1788 if (ost->source_index == ist_index) {
1789 AVCodecContext *enc= ost->st->codec;
1790 os = output_files[ost->file_index];
1792 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1794 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1797 if (ost->encoding_needed) {
1801 av_init_packet(&pkt);
1802 pkt.stream_index= ost->index;
1804 switch(ost->st->codec->codec_type) {
1805 case AVMEDIA_TYPE_AUDIO:
1806 fifo_bytes = av_fifo_size(ost->fifo);
1808 /* encode any samples remaining in fifo */
1809 if (fifo_bytes > 0) {
1810 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1811 int fs_tmp = enc->frame_size;
1813 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1814 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1815 enc->frame_size = fifo_bytes / (osize * enc->channels);
1817 int frame_bytes = enc->frame_size*osize*enc->channels;
1818 if (allocated_audio_buf_size < frame_bytes)
1820 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1823 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1824 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1825 ost->st->time_base.num, enc->sample_rate);
1826 enc->frame_size = fs_tmp;
1829 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1832 fprintf(stderr, "Audio encoding failed\n");
1836 pkt.flags |= AV_PKT_FLAG_KEY;
1838 case AVMEDIA_TYPE_VIDEO:
1839 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1841 fprintf(stderr, "Video encoding failed\n");
1845 if(enc->coded_frame && enc->coded_frame->key_frame)
1846 pkt.flags |= AV_PKT_FLAG_KEY;
1847 if (ost->logfile && enc->stats_out) {
1848 fprintf(ost->logfile, "%s", enc->stats_out);
1857 pkt.data= bit_buffer;
1859 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1860 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1861 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1871 static void print_sdp(AVFormatContext **avc, int n)
1875 av_sdp_create(avc, n, sdp, sizeof(sdp));
1876 printf("SDP:\n%s\n", sdp);
1880 static int copy_chapters(int infile, int outfile)
1882 AVFormatContext *is = input_files[infile].ctx;
1883 AVFormatContext *os = output_files[outfile];
1886 for (i = 0; i < is->nb_chapters; i++) {
1887 AVChapter *in_ch = is->chapters[i], *out_ch;
1888 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1889 AV_TIME_BASE_Q, in_ch->time_base);
1890 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1891 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1894 if (in_ch->end < ts_off)
1896 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1899 out_ch = av_mallocz(sizeof(AVChapter));
1901 return AVERROR(ENOMEM);
1903 out_ch->id = in_ch->id;
1904 out_ch->time_base = in_ch->time_base;
1905 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1906 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1908 if (metadata_chapters_autocopy)
1909 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1912 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1914 return AVERROR(ENOMEM);
1915 os->chapters[os->nb_chapters - 1] = out_ch;
1920 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1921 AVCodecContext *avctx)
1927 for (p = kf; *p; p++)
1930 ost->forced_kf_count = n;
1931 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1932 if (!ost->forced_kf_pts) {
1933 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1936 for (i = 0; i < n; i++) {
1937 p = i ? strchr(p, ',') + 1 : kf;
1938 t = parse_time_or_die("force_key_frames", p, 1);
1939 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1944 * The following code is the main loop of the file converter
1946 static int transcode(AVFormatContext **output_files,
1947 int nb_output_files,
1948 InputFile *input_files,
1950 StreamMap *stream_maps, int nb_stream_maps)
1952 int ret = 0, i, j, k, n, nb_ostreams = 0;
1953 AVFormatContext *is, *os;
1954 AVCodecContext *codec, *icodec;
1955 OutputStream *ost, **ost_table = NULL;
1959 uint8_t no_packet[MAX_FILES]={0};
1960 int no_packet_count=0;
1963 for (i = 0; i < nb_input_streams; i++)
1964 input_streams[i].start = av_gettime();
1966 /* output stream init */
1968 for(i=0;i<nb_output_files;i++) {
1969 os = output_files[i];
1970 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1971 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1972 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1973 ret = AVERROR(EINVAL);
1976 nb_ostreams += os->nb_streams;
1978 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1979 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1980 ret = AVERROR(EINVAL);
1984 /* Sanity check the mapping args -- do the input files & streams exist? */
1985 for(i=0;i<nb_stream_maps;i++) {
1986 int fi = stream_maps[i].file_index;
1987 int si = stream_maps[i].stream_index;
1989 if (fi < 0 || fi > nb_input_files - 1 ||
1990 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1991 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1992 ret = AVERROR(EINVAL);
1995 fi = stream_maps[i].sync_file_index;
1996 si = stream_maps[i].sync_stream_index;
1997 if (fi < 0 || fi > nb_input_files - 1 ||
1998 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1999 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2000 ret = AVERROR(EINVAL);
2005 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2009 for(k=0;k<nb_output_files;k++) {
2010 os = output_files[k];
2011 for(i=0;i<os->nb_streams;i++,n++) {
2013 ost = ost_table[n] = output_streams_for_file[k][i];
2014 if (nb_stream_maps > 0) {
2015 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2016 stream_maps[n].stream_index;
2018 /* Sanity check that the stream types match */
2019 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2020 int i= ost->file_index;
2021 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2022 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2023 stream_maps[n].file_index, stream_maps[n].stream_index,
2024 ost->file_index, ost->index);
2029 int best_nb_frames=-1;
2030 /* get corresponding input stream index : we select the first one with the right type */
2032 for (j = 0; j < nb_input_streams; j++) {
2034 ist = &input_streams[j];
2037 AVFormatContext *f = input_files[ist->file_index].ctx;
2039 for(pi=0; pi<f->nb_programs; pi++){
2040 AVProgram *p= f->programs[pi];
2041 if(p->id == opt_programid)
2042 for(si=0; si<p->nb_stream_indexes; si++){
2043 if(f->streams[ p->stream_index[si] ] == ist->st)
2048 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2049 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2050 if(best_nb_frames < ist->st->codec_info_nb_frames){
2051 best_nb_frames= ist->st->codec_info_nb_frames;
2052 ost->source_index = j;
2059 if(! opt_programid) {
2060 /* try again and reuse existing stream */
2061 for (j = 0; j < nb_input_streams; j++) {
2062 ist = &input_streams[j];
2063 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2064 && ist->st->discard != AVDISCARD_ALL) {
2065 ost->source_index = j;
2071 int i= ost->file_index;
2072 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2073 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2074 ost->file_index, ost->index);
2079 ist = &input_streams[ost->source_index];
2081 ost->sync_ist = (nb_stream_maps > 0) ?
2082 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2083 stream_maps[n].sync_stream_index] : ist;
2087 /* for each output stream, we compute the right encoding parameters */
2088 for(i=0;i<nb_ostreams;i++) {
2090 os = output_files[ost->file_index];
2091 ist = &input_streams[ost->source_index];
2093 codec = ost->st->codec;
2094 icodec = ist->st->codec;
2096 ost->st->disposition = ist->st->disposition;
2097 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2098 codec->chroma_sample_location = icodec->chroma_sample_location;
2100 if (ost->st->stream_copy) {
2101 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2103 if (extra_size > INT_MAX)
2106 /* if stream_copy is selected, no need to decode or encode */
2107 codec->codec_id = icodec->codec_id;
2108 codec->codec_type = icodec->codec_type;
2110 if(!codec->codec_tag){
2111 if( !os->oformat->codec_tag
2112 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2113 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2114 codec->codec_tag = icodec->codec_tag;
2117 codec->bit_rate = icodec->bit_rate;
2118 codec->rc_max_rate = icodec->rc_max_rate;
2119 codec->rc_buffer_size = icodec->rc_buffer_size;
2120 codec->extradata= av_mallocz(extra_size);
2121 if (!codec->extradata)
2123 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2124 codec->extradata_size= icodec->extradata_size;
2125 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){
2126 codec->time_base = icodec->time_base;
2127 codec->time_base.num *= icodec->ticks_per_frame;
2128 av_reduce(&codec->time_base.num, &codec->time_base.den,
2129 codec->time_base.num, codec->time_base.den, INT_MAX);
2131 codec->time_base = ist->st->time_base;
2132 switch(codec->codec_type) {
2133 case AVMEDIA_TYPE_AUDIO:
2134 if(audio_volume != 256) {
2135 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2138 codec->channel_layout = icodec->channel_layout;
2139 codec->sample_rate = icodec->sample_rate;
2140 codec->channels = icodec->channels;
2141 codec->frame_size = icodec->frame_size;
2142 codec->audio_service_type = icodec->audio_service_type;
2143 codec->block_align= icodec->block_align;
2144 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2145 codec->block_align= 0;
2146 if(codec->codec_id == CODEC_ID_AC3)
2147 codec->block_align= 0;
2149 case AVMEDIA_TYPE_VIDEO:
2150 codec->pix_fmt = icodec->pix_fmt;
2151 codec->width = icodec->width;
2152 codec->height = icodec->height;
2153 codec->has_b_frames = icodec->has_b_frames;
2154 if (!codec->sample_aspect_ratio.num) {
2155 codec->sample_aspect_ratio =
2156 ost->st->sample_aspect_ratio =
2157 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2158 ist->st->codec->sample_aspect_ratio.num ?
2159 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2162 case AVMEDIA_TYPE_SUBTITLE:
2163 codec->width = icodec->width;
2164 codec->height = icodec->height;
2166 case AVMEDIA_TYPE_DATA:
2173 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2174 switch(codec->codec_type) {
2175 case AVMEDIA_TYPE_AUDIO:
2176 ost->fifo= av_fifo_alloc(1024);
2179 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2180 if (!codec->sample_rate) {
2181 codec->sample_rate = icodec->sample_rate;
2183 codec->sample_rate >>= icodec->lowres;
2185 choose_sample_rate(ost->st, ost->enc);
2186 codec->time_base = (AVRational){1, codec->sample_rate};
2187 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2188 codec->sample_fmt = icodec->sample_fmt;
2189 choose_sample_fmt(ost->st, ost->enc);
2190 if (!codec->channels)
2191 codec->channels = icodec->channels;
2192 codec->channel_layout = icodec->channel_layout;
2193 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2194 codec->channel_layout = 0;
2195 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2196 icodec->request_channels = codec->channels;
2197 ist->decoding_needed = 1;
2198 ost->encoding_needed = 1;
2199 ost->resample_sample_fmt = icodec->sample_fmt;
2200 ost->resample_sample_rate = icodec->sample_rate;
2201 ost->resample_channels = icodec->channels;
2203 case AVMEDIA_TYPE_VIDEO:
2204 if (codec->pix_fmt == PIX_FMT_NONE)
2205 codec->pix_fmt = icodec->pix_fmt;
2206 choose_pixel_fmt(ost->st, ost->enc);
2208 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2209 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2213 if (!codec->width || !codec->height) {
2214 codec->width = icodec->width;
2215 codec->height = icodec->height;
2218 ost->video_resample = codec->width != icodec->width ||
2219 codec->height != icodec->height ||
2220 codec->pix_fmt != icodec->pix_fmt;
2221 if (ost->video_resample) {
2222 #if !CONFIG_AVFILTER
2223 avcodec_get_frame_defaults(&ost->pict_tmp);
2224 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2225 codec->width, codec->height)) {
2226 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2229 ost->img_resample_ctx = sws_getContext(
2236 ost->sws_flags, NULL, NULL, NULL);
2237 if (ost->img_resample_ctx == NULL) {
2238 fprintf(stderr, "Cannot get resampling context\n");
2242 codec->bits_per_raw_sample= 0;
2245 ost->resample_height = icodec->height;
2246 ost->resample_width = icodec->width;
2247 ost->resample_pix_fmt= icodec->pix_fmt;
2248 ost->encoding_needed = 1;
2249 ist->decoding_needed = 1;
2251 if (!ost->frame_rate.num)
2252 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2253 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2254 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2255 ost->frame_rate = ost->enc->supported_framerates[idx];
2257 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2260 if (configure_video_filters(ist, ost)) {
2261 fprintf(stderr, "Error opening filters!\n");
2266 case AVMEDIA_TYPE_SUBTITLE:
2267 ost->encoding_needed = 1;
2268 ist->decoding_needed = 1;
2275 if (ost->encoding_needed &&
2276 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2277 char logfilename[1024];
2280 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2281 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2283 if (codec->flags & CODEC_FLAG_PASS1) {
2284 f = fopen(logfilename, "wb");
2286 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2292 size_t logbuffer_size;
2293 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2294 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2297 codec->stats_in = logbuffer;
2301 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2302 int size= codec->width * codec->height;
2303 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2308 bit_buffer = av_malloc(bit_buffer_size);
2310 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2312 ret = AVERROR(ENOMEM);
2316 /* open each encoder */
2317 for(i=0;i<nb_ostreams;i++) {
2319 if (ost->encoding_needed) {
2320 AVCodec *codec = ost->enc;
2321 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2323 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2324 ost->st->codec->codec_id, ost->file_index, ost->index);
2325 ret = AVERROR(EINVAL);
2328 if (dec->subtitle_header) {
2329 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2330 if (!ost->st->codec->subtitle_header) {
2331 ret = AVERROR(ENOMEM);
2334 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2335 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2337 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2338 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2339 ost->file_index, ost->index);
2340 ret = AVERROR(EINVAL);
2343 assert_codec_experimental(ost->st->codec, 1);
2344 assert_avoptions(ost->opts);
2345 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2346 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2347 "It takes bits/s as argument, not kbits/s\n");
2348 extra_size += ost->st->codec->extradata_size;
2352 /* open each decoder */
2353 for (i = 0; i < nb_input_streams; i++) {
2354 ist = &input_streams[i];
2355 if (ist->decoding_needed) {
2356 AVCodec *codec = ist->dec;
2358 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2360 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2361 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2362 ret = AVERROR(EINVAL);
2366 /* update requested sample format for the decoder based on the
2367 corresponding encoder sample format */
2368 for (j = 0; j < nb_ostreams; j++) {
2370 if (ost->source_index == i) {
2371 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2376 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2377 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2378 ist->file_index, ist->st->index);
2379 ret = AVERROR(EINVAL);
2382 assert_codec_experimental(ist->st->codec, 0);
2383 assert_avoptions(ost->opts);
2384 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2385 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2390 for (i = 0; i < nb_input_streams; i++) {
2392 ist = &input_streams[i];
2394 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2395 ist->next_pts = AV_NOPTS_VALUE;
2396 init_pts_correction(&ist->pts_ctx);
2400 /* open files and write file headers */
2401 for(i=0;i<nb_output_files;i++) {
2402 os = output_files[i];
2403 if (avformat_write_header(os, &output_opts[i]) < 0) {
2404 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2405 ret = AVERROR(EINVAL);
2408 assert_avoptions(output_opts[i]);
2409 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2415 /* dump the file output parameters - cannot be done before in case
2417 for(i=0;i<nb_output_files;i++) {
2418 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2421 /* dump the stream mapping */
2423 fprintf(stderr, "Stream mapping:\n");
2424 for(i=0;i<nb_ostreams;i++) {
2426 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2427 input_streams[ost->source_index].file_index,
2428 input_streams[ost->source_index].st->index,
2431 if (ost->sync_ist != &input_streams[ost->source_index])
2432 fprintf(stderr, " [sync #%d.%d]",
2433 ost->sync_ist->file_index,
2434 ost->sync_ist->st->index);
2435 fprintf(stderr, "\n");
2440 fprintf(stderr, "%s\n", error);
2445 print_sdp(output_files, nb_output_files);
2449 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2452 timer_start = av_gettime();
2454 for(; received_sigterm == 0;) {
2455 int file_index, ist_index;
2464 /* select the stream that we must read now by looking at the
2465 smallest output pts */
2467 for(i=0;i<nb_ostreams;i++) {
2470 os = output_files[ost->file_index];
2471 ist = &input_streams[ost->source_index];
2472 if(ist->is_past_recording_time || no_packet[ist->file_index])
2474 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2475 ipts = (double)ist->pts;
2476 if (!input_files[ist->file_index].eof_reached){
2477 if(ipts < ipts_min) {
2479 if(input_sync ) file_index = ist->file_index;
2481 if(opts < opts_min) {
2483 if(!input_sync) file_index = ist->file_index;
2486 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2491 /* if none, if is finished */
2492 if (file_index < 0) {
2493 if(no_packet_count){
2495 memset(no_packet, 0, sizeof(no_packet));
2502 /* finish if limit size exhausted */
2503 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2506 /* read a frame from it and output it in the fifo */
2507 is = input_files[file_index].ctx;
2508 ret= av_read_frame(is, &pkt);
2509 if(ret == AVERROR(EAGAIN)){
2510 no_packet[file_index]=1;
2515 input_files[file_index].eof_reached = 1;
2523 memset(no_packet, 0, sizeof(no_packet));
2526 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2527 is->streams[pkt.stream_index]);
2529 /* the following test is needed in case new streams appear
2530 dynamically in stream : we ignore them */
2531 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2532 goto discard_packet;
2533 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2534 ist = &input_streams[ist_index];
2536 goto discard_packet;
2538 if (pkt.dts != AV_NOPTS_VALUE)
2539 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2540 if (pkt.pts != AV_NOPTS_VALUE)
2541 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2543 if (ist->ts_scale) {
2544 if(pkt.pts != AV_NOPTS_VALUE)
2545 pkt.pts *= ist->ts_scale;
2546 if(pkt.dts != AV_NOPTS_VALUE)
2547 pkt.dts *= ist->ts_scale;
2550 // 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);
2551 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2552 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2553 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2554 int64_t delta= pkt_dts - ist->next_pts;
2555 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2556 input_files[ist->file_index].ts_offset -= delta;
2558 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2559 delta, input_files[ist->file_index].ts_offset);
2560 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2561 if(pkt.pts != AV_NOPTS_VALUE)
2562 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2566 /* finish if recording time exhausted */
2567 if (recording_time != INT64_MAX &&
2568 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2569 ist->is_past_recording_time = 1;
2570 goto discard_packet;
2573 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2574 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2577 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2578 ist->file_index, ist->st->index);
2581 av_free_packet(&pkt);
2586 av_free_packet(&pkt);
2588 /* dump report by using the output first video and audio streams */
2589 print_report(output_files, ost_table, nb_ostreams, 0);
2592 /* at the end of stream, we must flush the decoder buffers */
2593 for (i = 0; i < nb_input_streams; i++) {
2594 ist = &input_streams[i];
2595 if (ist->decoding_needed) {
2596 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2602 /* write the trailer if needed and close file */
2603 for(i=0;i<nb_output_files;i++) {
2604 os = output_files[i];
2605 av_write_trailer(os);
2608 /* dump report by using the first video and audio streams */
2609 print_report(output_files, ost_table, nb_ostreams, 1);
2611 /* close each encoder */
2612 for(i=0;i<nb_ostreams;i++) {
2614 if (ost->encoding_needed) {
2615 av_freep(&ost->st->codec->stats_in);
2616 avcodec_close(ost->st->codec);
2619 avfilter_graph_free(&ost->graph);
2623 /* close each decoder */
2624 for (i = 0; i < nb_input_streams; i++) {
2625 ist = &input_streams[i];
2626 if (ist->decoding_needed) {
2627 avcodec_close(ist->st->codec);
2635 av_freep(&bit_buffer);
2638 for(i=0;i<nb_ostreams;i++) {
2641 if (ost->st->stream_copy)
2642 av_freep(&ost->st->codec->extradata);
2644 fclose(ost->logfile);
2645 ost->logfile = NULL;
2647 av_fifo_free(ost->fifo); /* works even if fifo is not
2648 initialized but set to zero */
2649 av_freep(&ost->st->codec->subtitle_header);
2650 av_free(ost->pict_tmp.data[0]);
2651 av_free(ost->forced_kf_pts);
2652 if (ost->video_resample)
2653 sws_freeContext(ost->img_resample_ctx);
2655 audio_resample_close(ost->resample);
2656 if (ost->reformat_ctx)
2657 av_audio_convert_free(ost->reformat_ctx);
2658 av_dict_free(&ost->opts);
2667 static int opt_format(const char *opt, const char *arg)
2669 last_asked_format = arg;
2673 static int opt_video_rc_override_string(const char *opt, const char *arg)
2675 video_rc_override_string = arg;
2679 static int opt_me_threshold(const char *opt, const char *arg)
2681 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2685 static int opt_verbose(const char *opt, const char *arg)
2687 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2691 static int opt_frame_rate(const char *opt, const char *arg)
2693 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2694 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2700 static int opt_frame_crop(const char *opt, const char *arg)
2702 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2703 return AVERROR(EINVAL);
2706 static int opt_frame_size(const char *opt, const char *arg)
2708 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2709 fprintf(stderr, "Incorrect frame size\n");
2710 return AVERROR(EINVAL);
2715 static int opt_pad(const char *opt, const char *arg) {
2716 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2720 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2722 if (strcmp(arg, "list")) {
2723 frame_pix_fmt = av_get_pix_fmt(arg);
2724 if (frame_pix_fmt == PIX_FMT_NONE) {
2725 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2726 return AVERROR(EINVAL);
2735 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2742 p = strchr(arg, ':');
2744 x = strtol(arg, &end, 10);
2746 y = strtol(end+1, &end, 10);
2748 ar = (double)x / (double)y;
2750 ar = strtod(arg, NULL);
2753 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2754 return AVERROR(EINVAL);
2756 frame_aspect_ratio = ar;
2760 static int opt_metadata(const char *opt, const char *arg)
2762 char *mid= strchr(arg, '=');
2765 fprintf(stderr, "Missing =\n");
2770 av_dict_set(&metadata, arg, mid, 0);
2775 static int opt_qscale(const char *opt, const char *arg)
2777 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2778 if (video_qscale == 0) {
2779 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2780 return AVERROR(EINVAL);
2785 static int opt_top_field_first(const char *opt, const char *arg)
2787 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2791 static int opt_thread_count(const char *opt, const char *arg)
2793 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2796 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2801 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2803 if (strcmp(arg, "list")) {
2804 audio_sample_fmt = av_get_sample_fmt(arg);
2805 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2806 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2807 return AVERROR(EINVAL);
2812 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2813 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2819 static int opt_audio_rate(const char *opt, const char *arg)
2821 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2825 static int opt_audio_channels(const char *opt, const char *arg)
2827 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2831 static int opt_codec(int *pstream_copy, char **pcodec_name,
2832 int codec_type, const char *arg)
2834 av_freep(pcodec_name);
2835 if (!strcmp(arg, "copy")) {
2838 *pcodec_name = av_strdup(arg);
2843 static int opt_audio_codec(const char *opt, const char *arg)
2845 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2848 static int opt_video_codec(const char *opt, const char *arg)
2850 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2853 static int opt_subtitle_codec(const char *opt, const char *arg)
2855 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2858 static int opt_data_codec(const char *opt, const char *arg)
2860 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2863 static int opt_codec_tag(const char *opt, const char *arg)
2866 uint32_t *codec_tag;
2868 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2869 !strcmp(opt, "vtag") ? &video_codec_tag :
2870 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2874 *codec_tag = strtol(arg, &tail, 0);
2876 *codec_tag = AV_RL32(arg);
2881 static int opt_map(const char *opt, const char *arg)
2886 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2887 m = &stream_maps[nb_stream_maps-1];
2889 m->file_index = strtol(arg, &p, 0);
2893 m->stream_index = strtol(p, &p, 0);
2896 m->sync_file_index = strtol(p, &p, 0);
2899 m->sync_stream_index = strtol(p, &p, 0);
2901 m->sync_file_index = m->file_index;
2902 m->sync_stream_index = m->stream_index;
2907 static void parse_meta_type(char *arg, char *type, int *index)
2917 if (*(++arg) == ':')
2918 *index = strtol(++arg, NULL, 0);
2921 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2928 static int opt_map_metadata(const char *opt, const char *arg)
2930 MetadataMap *m, *m1;
2933 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2934 &nb_meta_data_maps, nb_meta_data_maps + 1);
2936 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2937 m->file = strtol(arg, &p, 0);
2938 parse_meta_type(p, &m->type, &m->index);
2940 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2941 if (p = strchr(opt, ':'))
2942 parse_meta_type(p, &m1->type, &m1->index);
2946 if (m->type == 'g' || m1->type == 'g')
2947 metadata_global_autocopy = 0;
2948 if (m->type == 's' || m1->type == 's')
2949 metadata_streams_autocopy = 0;
2950 if (m->type == 'c' || m1->type == 'c')
2951 metadata_chapters_autocopy = 0;
2956 static int opt_input_ts_scale(const char *opt, const char *arg)
2958 unsigned int stream;
2962 stream = strtol(arg, &p, 0);
2965 scale= strtod(p, &p);
2967 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
2968 ts_scale[stream] = scale;
2972 static int opt_recording_time(const char *opt, const char *arg)
2974 recording_time = parse_time_or_die(opt, arg, 1);
2978 static int opt_start_time(const char *opt, const char *arg)
2980 start_time = parse_time_or_die(opt, arg, 1);
2984 static int opt_input_ts_offset(const char *opt, const char *arg)
2986 input_ts_offset = parse_time_or_die(opt, arg, 1);
2990 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2992 const char *codec_string = encoder ? "encoder" : "decoder";
2996 return CODEC_ID_NONE;
2998 avcodec_find_encoder_by_name(name) :
2999 avcodec_find_decoder_by_name(name);
3001 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3004 if(codec->type != type) {
3005 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3011 static int opt_input_file(const char *opt, const char *filename)
3013 AVFormatContext *ic;
3014 AVInputFormat *file_iformat = NULL;
3015 int err, i, ret, rfps, rfps_base;
3018 AVDictionary **opts;
3019 int orig_nb_streams; // number of streams before avformat_find_stream_info
3021 if (last_asked_format) {
3022 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3023 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3026 last_asked_format = NULL;
3029 if (!strcmp(filename, "-"))
3032 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3033 !strcmp(filename, "/dev/stdin");
3035 /* get default parameters from command line */
3036 ic = avformat_alloc_context();
3038 print_error(filename, AVERROR(ENOMEM));
3041 if (audio_sample_rate) {
3042 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3043 av_dict_set(&format_opts, "sample_rate", buf, 0);
3045 if (audio_channels) {
3046 snprintf(buf, sizeof(buf), "%d", audio_channels);
3047 av_dict_set(&format_opts, "channels", buf, 0);
3049 if (frame_rate.num) {
3050 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3051 av_dict_set(&format_opts, "framerate", buf, 0);
3053 if (frame_width && frame_height) {
3054 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3055 av_dict_set(&format_opts, "video_size", buf, 0);
3057 if (frame_pix_fmt != PIX_FMT_NONE)
3058 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3060 ic->video_codec_id =
3061 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3062 ic->audio_codec_id =
3063 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3064 ic->subtitle_codec_id=
3065 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3066 ic->flags |= AVFMT_FLAG_NONBLOCK;
3068 /* open the input file with generic libav function */
3069 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3071 print_error(filename, err);
3074 assert_avoptions(format_opts);
3079 for(i=0; i<ic->nb_streams; i++){
3080 ic->streams[i]->discard= AVDISCARD_ALL;
3082 for(i=0; i<ic->nb_programs; i++){
3083 AVProgram *p= ic->programs[i];
3084 if(p->id != opt_programid){
3085 p->discard = AVDISCARD_ALL;
3088 for(j=0; j<p->nb_stream_indexes; j++){
3089 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3094 fprintf(stderr, "Specified program id not found\n");
3100 /* Set AVCodecContext options for avformat_find_stream_info */
3101 opts = setup_find_stream_info_opts(ic, codec_opts);
3102 orig_nb_streams = ic->nb_streams;
3104 /* If not enough info to get the stream parameters, we decode the
3105 first frames to get it. (used in mpeg case for example) */
3106 ret = avformat_find_stream_info(ic, opts);
3107 if (ret < 0 && verbose >= 0) {
3108 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3109 av_close_input_file(ic);
3113 timestamp = start_time;
3114 /* add the stream start time */
3115 if (ic->start_time != AV_NOPTS_VALUE)
3116 timestamp += ic->start_time;
3118 /* if seeking requested, we execute it */
3119 if (start_time != 0) {
3120 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3122 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3123 filename, (double)timestamp / AV_TIME_BASE);
3125 /* reset seek info */
3129 /* update the current parameters so that they match the one of the input stream */
3130 for(i=0;i<ic->nb_streams;i++) {
3131 AVStream *st = ic->streams[i];
3132 AVCodecContext *dec = st->codec;
3135 dec->thread_count = thread_count;
3137 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3138 ist = &input_streams[nb_input_streams - 1];
3140 ist->file_index = nb_input_files;
3142 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3144 if (i < nb_ts_scale)
3145 ist->ts_scale = ts_scale[i];
3147 switch (dec->codec_type) {
3148 case AVMEDIA_TYPE_AUDIO:
3149 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3151 st->discard= AVDISCARD_ALL;
3153 case AVMEDIA_TYPE_VIDEO:
3154 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3155 rfps = ic->streams[i]->r_frame_rate.num;
3156 rfps_base = ic->streams[i]->r_frame_rate.den;
3158 dec->flags |= CODEC_FLAG_EMU_EDGE;
3159 dec->height >>= dec->lowres;
3160 dec->width >>= dec->lowres;
3163 dec->debug |= FF_DEBUG_MV;
3165 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3168 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3169 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3171 (float)rfps / rfps_base, rfps, rfps_base);
3175 st->discard= AVDISCARD_ALL;
3176 else if(video_discard)
3177 st->discard= video_discard;
3179 case AVMEDIA_TYPE_DATA:
3181 case AVMEDIA_TYPE_SUBTITLE:
3182 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3183 if(subtitle_disable)
3184 st->discard = AVDISCARD_ALL;
3186 case AVMEDIA_TYPE_ATTACHMENT:
3187 case AVMEDIA_TYPE_UNKNOWN:
3194 /* dump the file content */
3196 av_dump_format(ic, nb_input_files, filename, 0);
3198 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3199 input_files[nb_input_files - 1].ctx = ic;
3200 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3201 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3203 frame_rate = (AVRational){0, 0};
3204 frame_pix_fmt = PIX_FMT_NONE;
3207 audio_sample_rate = 0;
3209 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3210 av_freep(&ts_scale);
3213 for (i = 0; i < orig_nb_streams; i++)
3214 av_dict_free(&opts[i]);
3216 av_freep(&video_codec_name);
3217 av_freep(&audio_codec_name);
3218 av_freep(&subtitle_codec_name);
3224 static void check_inputs(int *has_video_ptr,
3226 int *has_subtitle_ptr,
3229 int has_video, has_audio, has_subtitle, has_data, i, j;
3230 AVFormatContext *ic;
3237 for(j=0;j<nb_input_files;j++) {
3238 ic = input_files[j].ctx;
3239 for(i=0;i<ic->nb_streams;i++) {
3240 AVCodecContext *enc = ic->streams[i]->codec;
3241 switch(enc->codec_type) {
3242 case AVMEDIA_TYPE_AUDIO:
3245 case AVMEDIA_TYPE_VIDEO:
3248 case AVMEDIA_TYPE_SUBTITLE:
3251 case AVMEDIA_TYPE_DATA:
3252 case AVMEDIA_TYPE_ATTACHMENT:
3253 case AVMEDIA_TYPE_UNKNOWN:
3261 *has_video_ptr = has_video;
3262 *has_audio_ptr = has_audio;
3263 *has_subtitle_ptr = has_subtitle;
3264 *has_data_ptr = has_data;
3267 static void new_video_stream(AVFormatContext *oc, int file_idx)
3271 AVCodecContext *video_enc;
3272 enum CodecID codec_id = CODEC_ID_NONE;
3273 AVCodec *codec= NULL;
3275 if(!video_stream_copy){
3276 if (video_codec_name) {
3277 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3278 codec = avcodec_find_encoder_by_name(video_codec_name);
3280 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3281 codec = avcodec_find_encoder(codec_id);
3285 ost = new_output_stream(oc, file_idx, codec);
3287 if (!video_stream_copy) {
3288 ost->frame_aspect_ratio = frame_aspect_ratio;
3289 frame_aspect_ratio = 0;
3291 ost->avfilter= vfilters;
3296 ost->bitstream_filters = video_bitstream_filters;
3297 video_bitstream_filters= NULL;
3299 st->codec->thread_count= thread_count;
3301 video_enc = st->codec;
3304 video_enc->codec_tag= video_codec_tag;
3306 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3307 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3310 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3311 if (video_stream_copy) {
3312 st->stream_copy = 1;
3313 video_enc->sample_aspect_ratio =
3314 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3320 ost->frame_rate = frame_rate;
3321 video_enc->codec_id = codec_id;
3323 video_enc->width = frame_width;
3324 video_enc->height = frame_height;
3325 video_enc->pix_fmt = frame_pix_fmt;
3326 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3329 video_enc->gop_size = 0;
3330 if (video_qscale || same_quality) {
3331 video_enc->flags |= CODEC_FLAG_QSCALE;
3332 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3336 video_enc->intra_matrix = intra_matrix;
3338 video_enc->inter_matrix = inter_matrix;
3340 p= video_rc_override_string;
3343 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3345 fprintf(stderr, "error parsing rc_override\n");
3348 video_enc->rc_override=
3349 av_realloc(video_enc->rc_override,
3350 sizeof(RcOverride)*(i+1));
3351 video_enc->rc_override[i].start_frame= start;
3352 video_enc->rc_override[i].end_frame = end;
3354 video_enc->rc_override[i].qscale= q;
3355 video_enc->rc_override[i].quality_factor= 1.0;
3358 video_enc->rc_override[i].qscale= 0;
3359 video_enc->rc_override[i].quality_factor= -q/100.0;
3364 video_enc->rc_override_count=i;
3365 if (!video_enc->rc_initial_buffer_occupancy)
3366 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3367 video_enc->me_threshold= me_threshold;
3368 video_enc->intra_dc_precision= intra_dc_precision - 8;
3371 video_enc->flags|= CODEC_FLAG_PSNR;
3376 video_enc->flags |= CODEC_FLAG_PASS1;
3378 video_enc->flags |= CODEC_FLAG_PASS2;
3382 if (forced_key_frames)
3383 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3385 if (video_language) {
3386 av_dict_set(&st->metadata, "language", video_language, 0);
3387 av_freep(&video_language);
3390 /* reset some key parameters */
3392 av_freep(&video_codec_name);
3393 av_freep(&forced_key_frames);
3394 video_stream_copy = 0;
3395 frame_pix_fmt = PIX_FMT_NONE;
3398 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3402 AVCodec *codec= NULL;
3403 AVCodecContext *audio_enc;
3404 enum CodecID codec_id = CODEC_ID_NONE;
3406 if(!audio_stream_copy){
3407 if (audio_codec_name) {
3408 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3409 codec = avcodec_find_encoder_by_name(audio_codec_name);
3411 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3412 codec = avcodec_find_encoder(codec_id);
3415 ost = new_output_stream(oc, file_idx, codec);
3418 ost->bitstream_filters = audio_bitstream_filters;
3419 audio_bitstream_filters= NULL;
3421 st->codec->thread_count= thread_count;
3423 audio_enc = st->codec;
3424 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3427 audio_enc->codec_tag= audio_codec_tag;
3429 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3430 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3432 if (audio_stream_copy) {
3433 st->stream_copy = 1;
3435 audio_enc->codec_id = codec_id;
3437 if (audio_qscale > QSCALE_NONE) {
3438 audio_enc->flags |= CODEC_FLAG_QSCALE;
3439 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3442 audio_enc->channels = audio_channels;
3443 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3444 audio_enc->sample_fmt = audio_sample_fmt;
3445 if (audio_sample_rate)
3446 audio_enc->sample_rate = audio_sample_rate;
3448 if (audio_language) {
3449 av_dict_set(&st->metadata, "language", audio_language, 0);
3450 av_freep(&audio_language);
3453 /* reset some key parameters */
3455 av_freep(&audio_codec_name);
3456 audio_stream_copy = 0;
3459 static void new_data_stream(AVFormatContext *oc, int file_idx)
3463 AVCodecContext *data_enc;
3465 ost = new_output_stream(oc, file_idx, NULL);
3467 data_enc = st->codec;
3468 if (!data_stream_copy) {
3469 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3473 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3476 data_enc->codec_tag= data_codec_tag;
3478 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3479 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3481 if (data_stream_copy) {
3482 st->stream_copy = 1;
3486 av_freep(&data_codec_name);
3487 data_stream_copy = 0;
3490 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3494 AVCodec *codec=NULL;
3495 AVCodecContext *subtitle_enc;
3496 enum CodecID codec_id = CODEC_ID_NONE;
3498 if(!subtitle_stream_copy){
3499 if (subtitle_codec_name) {
3500 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3501 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3503 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3504 codec = avcodec_find_encoder(codec_id);
3507 ost = new_output_stream(oc, file_idx, codec);
3509 subtitle_enc = st->codec;
3511 ost->bitstream_filters = subtitle_bitstream_filters;
3512 subtitle_bitstream_filters= NULL;
3514 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3516 if(subtitle_codec_tag)
3517 subtitle_enc->codec_tag= subtitle_codec_tag;
3519 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3520 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3522 if (subtitle_stream_copy) {
3523 st->stream_copy = 1;
3525 subtitle_enc->codec_id = codec_id;
3528 if (subtitle_language) {
3529 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3530 av_freep(&subtitle_language);
3533 subtitle_disable = 0;
3534 av_freep(&subtitle_codec_name);
3535 subtitle_stream_copy = 0;
3538 static int opt_new_stream(const char *opt, const char *arg)
3540 AVFormatContext *oc;
3541 int file_idx = nb_output_files - 1;
3542 if (nb_output_files <= 0) {
3543 fprintf(stderr, "At least one output file must be specified\n");
3546 oc = output_files[file_idx];
3548 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3549 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3550 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3551 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3556 /* arg format is "output-stream-index:streamid-value". */
3557 static int opt_streamid(const char *opt, const char *arg)
3563 av_strlcpy(idx_str, arg, sizeof(idx_str));
3564 p = strchr(idx_str, ':');
3567 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3572 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3573 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3574 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3578 static void opt_output_file(const char *filename)
3580 AVFormatContext *oc;
3581 int i, err, use_video, use_audio, use_subtitle, use_data;
3582 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3583 AVOutputFormat *file_oformat;
3585 if (!strcmp(filename, "-"))
3588 oc = avformat_alloc_context();
3590 print_error(filename, AVERROR(ENOMEM));
3594 if (last_asked_format) {
3595 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3596 if (!file_oformat) {
3597 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3600 last_asked_format = NULL;
3602 file_oformat = av_guess_format(NULL, filename, NULL);
3603 if (!file_oformat) {
3604 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3610 oc->oformat = file_oformat;
3611 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3613 if (!strcmp(file_oformat->name, "ffm") &&
3614 av_strstart(filename, "http:", NULL)) {
3615 /* special case for files sent to avserver: we get the stream
3616 parameters from avserver */
3617 int err = read_avserver_streams(oc, filename);
3619 print_error(filename, err);
3623 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3624 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3625 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3626 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 */
3628 /* disable if no corresponding type found */
3629 check_inputs(&input_has_video,
3631 &input_has_subtitle,
3634 if (!input_has_video)
3636 if (!input_has_audio)
3638 if (!input_has_subtitle)
3640 if (!input_has_data)
3643 /* manual disable */
3644 if (audio_disable) use_audio = 0;
3645 if (video_disable) use_video = 0;
3646 if (subtitle_disable) use_subtitle = 0;
3647 if (data_disable) use_data = 0;
3649 if (use_video) new_video_stream(oc, nb_output_files);
3650 if (use_audio) new_audio_stream(oc, nb_output_files);
3651 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3652 if (use_data) new_data_stream(oc, nb_output_files);
3654 av_dict_copy(&oc->metadata, metadata, 0);
3655 av_dict_free(&metadata);
3658 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3659 output_files[nb_output_files++] = oc;
3661 /* check filename in case of an image number is expected */
3662 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3663 if (!av_filename_number_test(oc->filename)) {
3664 print_error(oc->filename, AVERROR(EINVAL));
3669 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3670 /* test if it already exists to avoid loosing precious files */
3671 if (!file_overwrite &&
3672 (strchr(filename, ':') == NULL ||
3673 filename[1] == ':' ||
3674 av_strstart(filename, "file:", NULL))) {
3675 if (avio_check(filename, 0) == 0) {
3677 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3679 if (!read_yesno()) {
3680 fprintf(stderr, "Not overwriting - exiting\n");
3685 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3692 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3693 print_error(filename, err);
3698 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3699 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3700 oc->flags |= AVFMT_FLAG_NONBLOCK;
3703 if (chapters_input_file >= nb_input_files) {
3704 if (chapters_input_file == INT_MAX) {
3705 /* copy chapters from the first input file that has them*/
3706 chapters_input_file = -1;
3707 for (i = 0; i < nb_input_files; i++)
3708 if (input_files[i].ctx->nb_chapters) {
3709 chapters_input_file = i;
3713 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3714 chapters_input_file);
3718 if (chapters_input_file >= 0)
3719 copy_chapters(chapters_input_file, nb_output_files - 1);
3722 for (i = 0; i < nb_meta_data_maps; i++) {
3723 AVFormatContext *files[2];
3724 AVDictionary **meta[2];
3727 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3728 if ((index) < 0 || (index) >= (nb_elems)) {\
3729 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3734 int in_file_index = meta_data_maps[i][1].file;
3735 if (in_file_index < 0)
3737 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3740 files[1] = input_files[in_file_index].ctx;
3742 for (j = 0; j < 2; j++) {
3743 MetadataMap *map = &meta_data_maps[i][j];
3745 switch (map->type) {
3747 meta[j] = &files[j]->metadata;
3750 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3751 meta[j] = &files[j]->streams[map->index]->metadata;
3754 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3755 meta[j] = &files[j]->chapters[map->index]->metadata;
3758 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3759 meta[j] = &files[j]->programs[map->index]->metadata;
3764 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3767 /* copy global metadata by default */
3768 if (metadata_global_autocopy)
3769 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3770 AV_DICT_DONT_OVERWRITE);
3771 if (metadata_streams_autocopy)
3772 for (i = 0; i < oc->nb_streams; i++) {
3773 InputStream *ist = &input_streams[output_streams_for_file[nb_output_files-1][i]->source_index];
3774 av_dict_copy(&oc->streams[i]->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3777 frame_rate = (AVRational){0, 0};
3780 audio_sample_rate = 0;
3782 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3783 chapters_input_file = INT_MAX;
3785 av_freep(&meta_data_maps);
3786 nb_meta_data_maps = 0;
3787 metadata_global_autocopy = 1;
3788 metadata_streams_autocopy = 1;
3789 metadata_chapters_autocopy = 1;
3791 av_freep(&forced_key_frames);
3796 /* same option as mencoder */
3797 static int opt_pass(const char *opt, const char *arg)
3799 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3803 static int64_t getutime(void)
3806 struct rusage rusage;
3808 getrusage(RUSAGE_SELF, &rusage);
3809 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3810 #elif HAVE_GETPROCESSTIMES
3812 FILETIME c, e, k, u;
3813 proc = GetCurrentProcess();
3814 GetProcessTimes(proc, &c, &e, &k, &u);
3815 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3817 return av_gettime();
3821 static int64_t getmaxrss(void)
3823 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3824 struct rusage rusage;
3825 getrusage(RUSAGE_SELF, &rusage);
3826 return (int64_t)rusage.ru_maxrss * 1024;
3827 #elif HAVE_GETPROCESSMEMORYINFO
3829 PROCESS_MEMORY_COUNTERS memcounters;
3830 proc = GetCurrentProcess();
3831 memcounters.cb = sizeof(memcounters);
3832 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3833 return memcounters.PeakPagefileUsage;
3839 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3842 const char *p = str;
3849 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3856 static void opt_inter_matrix(const char *arg)
3858 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3859 parse_matrix_coeffs(inter_matrix, arg);
3862 static void opt_intra_matrix(const char *arg)
3864 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3865 parse_matrix_coeffs(intra_matrix, arg);
3868 static void show_usage(void)
3870 printf("Hyper fast Audio and Video encoder\n");
3871 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3875 static void show_help(void)
3878 AVOutputFormat *oformat = NULL;
3879 AVInputFormat *iformat = NULL;
3881 av_log_set_callback(log_callback_help);
3883 show_help_options(options, "Main options:\n",
3884 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3885 show_help_options(options, "\nAdvanced options:\n",
3886 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3888 show_help_options(options, "\nVideo options:\n",
3889 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3891 show_help_options(options, "\nAdvanced Video options:\n",
3892 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3893 OPT_VIDEO | OPT_EXPERT);
3894 show_help_options(options, "\nAudio options:\n",
3895 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897 show_help_options(options, "\nAdvanced Audio options:\n",
3898 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3899 OPT_AUDIO | OPT_EXPERT);
3900 show_help_options(options, "\nSubtitle options:\n",
3901 OPT_SUBTITLE | OPT_GRAB,
3903 show_help_options(options, "\nAudio/Video grab options:\n",
3907 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3910 /* individual codec options */
3912 while ((c = av_codec_next(c))) {
3913 if (c->priv_class) {
3914 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3919 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3922 /* individual muxer options */
3923 while ((oformat = av_oformat_next(oformat))) {
3924 if (oformat->priv_class) {
3925 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3930 /* individual demuxer options */
3931 while ((iformat = av_iformat_next(iformat))) {
3932 if (iformat->priv_class) {
3933 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3938 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3941 static int opt_target(const char *opt, const char *arg)
3943 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3944 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3946 if(!strncmp(arg, "pal-", 4)) {
3949 } else if(!strncmp(arg, "ntsc-", 5)) {
3952 } else if(!strncmp(arg, "film-", 5)) {
3957 /* Calculate FR via float to avoid int overflow */
3958 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3961 } else if((fr == 29970) || (fr == 23976)) {
3964 /* Try to determine PAL/NTSC by peeking in the input files */
3965 if(nb_input_files) {
3967 for (j = 0; j < nb_input_files; j++) {
3968 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3969 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3970 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3972 fr = c->time_base.den * 1000 / c->time_base.num;
3976 } else if((fr == 29970) || (fr == 23976)) {
3986 if(verbose > 0 && norm != UNKNOWN)
3987 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3990 if(norm == UNKNOWN) {
3991 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3992 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3993 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3997 if(!strcmp(arg, "vcd")) {
3998 opt_video_codec("vcodec", "mpeg1video");
3999 opt_audio_codec("vcodec", "mp2");
4000 opt_format("f", "vcd");
4002 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4003 opt_frame_rate("r", frame_rates[norm]);
4004 opt_default("g", norm == PAL ? "15" : "18");
4006 opt_default("b", "1150000");
4007 opt_default("maxrate", "1150000");
4008 opt_default("minrate", "1150000");
4009 opt_default("bufsize", "327680"); // 40*1024*8;
4011 opt_default("ab", "224000");
4012 audio_sample_rate = 44100;
4015 opt_default("packetsize", "2324");
4016 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4018 /* We have to offset the PTS, so that it is consistent with the SCR.
4019 SCR starts at 36000, but the first two packs contain only padding
4020 and the first pack from the other stream, respectively, may also have
4021 been written before.
4022 So the real data starts at SCR 36000+3*1200. */
4023 mux_preload= (36000+3*1200) / 90000.0; //0.44
4024 } else if(!strcmp(arg, "svcd")) {
4026 opt_video_codec("vcodec", "mpeg2video");
4027 opt_audio_codec("acodec", "mp2");
4028 opt_format("f", "svcd");
4030 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4031 opt_frame_rate("r", frame_rates[norm]);
4032 opt_default("g", norm == PAL ? "15" : "18");
4034 opt_default("b", "2040000");
4035 opt_default("maxrate", "2516000");
4036 opt_default("minrate", "0"); //1145000;
4037 opt_default("bufsize", "1835008"); //224*1024*8;
4038 opt_default("flags", "+scan_offset");
4041 opt_default("ab", "224000");
4042 audio_sample_rate = 44100;
4044 opt_default("packetsize", "2324");
4046 } else if(!strcmp(arg, "dvd")) {
4048 opt_video_codec("vcodec", "mpeg2video");
4049 opt_audio_codec("vcodec", "ac3");
4050 opt_format("f", "dvd");
4052 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4053 opt_frame_rate("r", frame_rates[norm]);
4054 opt_default("g", norm == PAL ? "15" : "18");
4056 opt_default("b", "6000000");
4057 opt_default("maxrate", "9000000");
4058 opt_default("minrate", "0"); //1500000;
4059 opt_default("bufsize", "1835008"); //224*1024*8;
4061 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4062 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4064 opt_default("ab", "448000");
4065 audio_sample_rate = 48000;
4067 } else if(!strncmp(arg, "dv", 2)) {
4069 opt_format("f", "dv");
4071 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4072 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4073 norm == PAL ? "yuv420p" : "yuv411p");
4074 opt_frame_rate("r", frame_rates[norm]);
4076 audio_sample_rate = 48000;
4080 fprintf(stderr, "Unknown target: %s\n", arg);
4081 return AVERROR(EINVAL);
4086 static int opt_vstats_file(const char *opt, const char *arg)
4088 av_free (vstats_filename);
4089 vstats_filename=av_strdup (arg);
4093 static int opt_vstats(const char *opt, const char *arg)
4096 time_t today2 = time(NULL);
4097 struct tm *today = localtime(&today2);
4099 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4101 return opt_vstats_file(opt, filename);
4104 static int opt_bsf(const char *opt, const char *arg)
4106 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4107 AVBitStreamFilterContext **bsfp;
4110 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4114 bsfp= *opt == 'v' ? &video_bitstream_filters :
4115 *opt == 'a' ? &audio_bitstream_filters :
4116 &subtitle_bitstream_filters;
4118 bsfp= &(*bsfp)->next;
4125 static int opt_preset(const char *opt, const char *arg)
4128 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4129 char *codec_name = *opt == 'v' ? video_codec_name :
4130 *opt == 'a' ? audio_codec_name :
4131 subtitle_codec_name;
4133 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4134 fprintf(stderr, "File for preset '%s' not found\n", arg);
4139 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4140 if(line[0] == '#' && !e)
4142 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4144 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4147 if(!strcmp(tmp, "acodec")){
4148 opt_audio_codec(tmp, tmp2);
4149 }else if(!strcmp(tmp, "vcodec")){
4150 opt_video_codec(tmp, tmp2);
4151 }else if(!strcmp(tmp, "scodec")){
4152 opt_subtitle_codec(tmp, tmp2);
4153 }else if(!strcmp(tmp, "dcodec")){
4154 opt_data_codec(tmp, tmp2);
4155 }else if(opt_default(tmp, tmp2) < 0){
4156 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4166 static const OptionDef options[] = {
4168 #include "cmdutils_common_opts.h"
4169 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4170 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4171 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4172 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4173 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4174 "outfile[,metadata]:infile[,metadata]" },
4175 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4176 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4177 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4178 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4179 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4180 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4181 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4182 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4183 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4184 "add timings for benchmarking" },
4185 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4186 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4187 "dump each input packet" },
4188 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4189 "when dumping packets, also dump the payload" },
4190 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4191 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4192 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4193 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4194 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4195 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4196 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4197 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4198 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4199 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4200 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4201 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4202 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4203 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4206 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4207 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4208 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4209 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4210 { "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" },
4211 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4212 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4213 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4214 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4215 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4216 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4217 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4218 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4219 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4220 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4221 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4222 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4223 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4224 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4225 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4226 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
4227 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4228 "use same quantizer as source (implies VBR)" },
4229 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4230 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4231 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4232 "deinterlace pictures" },
4233 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4234 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4235 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4237 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4239 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4240 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4241 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4242 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4243 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4244 { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4245 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4246 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4247 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4248 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4249 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4252 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4253 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4254 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4255 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4256 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4257 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4258 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4259 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4260 { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4261 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4262 { "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" },
4264 /* subtitle options */
4265 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4266 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4267 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4268 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },