#include "libavcodec/opt.h"
#include "libavcodec/audioconvert.h"
#include "libavcore/parseutils.h"
+#include "libavcore/samplefmt.h"
#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/intreadwrite.h"
#if CONFIG_AVFILTER
# include "libavfilter/avfilter.h"
# include "libavfilter/avfiltergraph.h"
-# include "libavfilter/graphparser.h"
# include "libavfilter/vsrc_buffer.h"
#endif
int index; //< stream/chapter/program number
} AVMetaDataMap;
+typedef struct AVChapterMap {
+ int in_file;
+ int out_file;
+} AVChapterMap;
+
static const OptionDef options[];
#define MAX_FILES 100
static int metadata_streams_autocopy = 1;
static int metadata_chapters_autocopy = 1;
+static AVChapterMap *chapter_maps = NULL;
+static int nb_chapter_maps;
+
/* indexed by output file stream index */
static int *streamid_map = NULL;
static int nb_streamid_map = 0;
static int frame_height = 0;
static float frame_aspect_ratio = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
-static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
+static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
static AVRational frame_rate;
static float video_qscale = 0;
char args[255];
int ret;
- graph = av_mallocz(sizeof(AVFilterGraph));
+ graph = avfilter_graph_alloc();
if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
return ret;
AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
outputs->name = av_strdup("in");
- outputs->filter = last_filter;
+ outputs->filter_ctx = last_filter;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
- inputs->filter = ist->output_video_filter;
+ inputs->filter_ctx = ist->output_video_filter;
inputs->pad_idx = 0;
inputs->next = NULL;
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
{
if(codec && codec->sample_fmts){
- const enum SampleFormat *p= codec->sample_fmts;
+ const enum AVSampleFormat *p= codec->sample_fmts;
for(; *p!=-1; p++){
if(*p == st->codec->sample_fmt)
break;
int size_out, frame_bytes, ret;
AVCodecContext *enc= ost->st->codec;
AVCodecContext *dec= ist->st->codec;
- int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
- int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
+ int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
+ int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
const int coded_bps = av_get_bits_per_sample(enc->codec->id);
need_realloc:
ost->audio_resample = 1;
if (ost->audio_resample && !ost->resample) {
- if (dec->sample_fmt != SAMPLE_FMT_S16)
+ if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
ost->resample = av_audio_resample_init(enc->channels, dec->channels,
enc->sample_rate, dec->sample_rate,
}
}
-#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
+#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
if (ost->reformat_ctx)
dec->sample_fmt, 1, NULL, 0);
if (!ost->reformat_ctx) {
fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
- avcodec_get_sample_fmt_name(dec->sample_fmt),
- avcodec_get_sample_fmt_name(enc->sample_fmt));
+ av_get_sample_fmt_name(dec->sample_fmt),
+ av_get_sample_fmt_name(enc->sample_fmt));
ffmpeg_exit(1);
}
ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
if(vdelta<=-0.6){
nb_frames=0;
}else if(vdelta>0.6)
- ost->sync_opts= lrintf(sync_ipts);
+ ost->sync_opts= lrintf(sync_ipts);
}else if (vdelta > 1.1)
nb_frames = lrintf(vdelta);
//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);
#endif
AVPacket avpkt;
- int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
+ int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts= ist->pts;
ret = 0;
/* encode any samples remaining in fifo */
if (fifo_bytes > 0) {
- int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
+ int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
int fs_tmp = enc->frame_size;
av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
ost->fifo= av_fifo_alloc(1024);
if(!ost->fifo)
goto fail;
- ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
+ ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
icodec->request_channels = codec->channels;
ist->decoding_needed = 1;
ost = ost_table[i];
if (ost->encoding_needed) {
AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
+ AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
if (!codec)
codec = avcodec_find_encoder(ost->st->codec->codec_id);
if (!codec) {
ret = AVERROR(EINVAL);
goto dump_format;
}
+ if (dec->subtitle_header) {
+ ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
+ if (!ost->st->codec->subtitle_header) {
+ ret = AVERROR(ENOMEM);
+ goto dump_format;
+ }
+ memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
+ ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
+ }
if (avcodec_open(ost->st->codec, codec) < 0) {
snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
ost->file_index, ost->index);
int out_file_index = meta_data_maps[i][0].file;
int in_file_index = meta_data_maps[i][1].file;
+ if (in_file_index < 0 || out_file_index < 0)
+ continue;
METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
}
- /* copy chapters from the first input file that has them*/
- for (i = 0; i < nb_input_files; i++) {
- if (!input_files[i]->nb_chapters)
- continue;
+ /* copy chapters according to chapter maps */
+ for (i = 0; i < nb_chapter_maps; i++) {
+ int infile = chapter_maps[i].in_file;
+ int outfile = chapter_maps[i].out_file;
- for (j = 0; j < nb_output_files; j++)
- if ((ret = copy_chapters(i, j)) < 0)
- goto dump_format;
+ if (infile < 0 || outfile < 0)
+ continue;
+ if (infile >= nb_input_files) {
+ snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
+ ret = AVERROR(EINVAL);
+ goto dump_format;
+ }
+ if (outfile >= nb_output_files) {
+ snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
+ ret = AVERROR(EINVAL);
+ goto dump_format;
+ }
+ copy_chapters(infile, outfile);
}
+ /* copy chapters from the first input file that has them*/
+ if (!nb_chapter_maps)
+ for (i = 0; i < nb_input_files; i++) {
+ if (!input_files[i]->nb_chapters)
+ continue;
+
+ for (j = 0; j < nb_output_files; j++)
+ if ((ret = copy_chapters(i, j)) < 0)
+ goto dump_format;
+ break;
+ }
+
/* open files and write file headers */
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
}
#if CONFIG_AVFILTER
if (graph) {
- avfilter_graph_destroy(graph);
+ avfilter_graph_free(graph);
av_freep(&graph);
}
#endif
}
av_fifo_free(ost->fifo); /* works even if fifo is not
initialized but set to zero */
+ av_freep(&ost->st->codec->subtitle_header);
av_free(ost->pict_tmp.data[0]);
av_free(ost->forced_kf_pts);
if (ost->video_resample)
static void opt_audio_sample_fmt(const char *arg)
{
if (strcmp(arg, "list"))
- audio_sample_fmt = avcodec_get_sample_fmt(arg);
+ audio_sample_fmt = av_get_sample_fmt(arg);
else {
- list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
+ list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
ffmpeg_exit(0);
}
}
metadata_chapters_autocopy = 0;
}
+static void opt_map_chapters(const char *arg)
+{
+ AVChapterMap *c;
+ char *p;
+
+ chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
+ nb_chapter_maps + 1);
+ c = &chapter_maps[nb_chapter_maps - 1];
+ c->out_file = strtol(arg, &p, 0);
+ if (*p)
+ p++;
+
+ c->in_file = strtol(p, &p, 0);
+}
+
static void opt_input_ts_scale(const char *arg)
{
unsigned int stream;
if(subtitle_codec_tag)
subtitle_enc->codec_tag= subtitle_codec_tag;
+ if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
+ subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
+ avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
+ }
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
{
FILE *f=NULL;
char filename[1000], tmp[1000], tmp2[1000], line[1000];
- int i;
- const char *base[3]= { getenv("FFMPEG_DATADIR"),
- getenv("HOME"),
- FFMPEG_DATADIR,
- };
-
- if (*opt != 'f') {
- for(i=0; i<3 && !f; i++){
- if(!base[i])
- continue;
- snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
- f= fopen(filename, "r");
- if(!f){
- char *codec_name= *opt == 'v' ? video_codec_name :
- *opt == 'a' ? audio_codec_name :
- subtitle_codec_name;
- snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg);
- f= fopen(filename, "r");
- }
- }
- } else {
- av_strlcpy(filename, arg, sizeof(filename));
- f= fopen(filename, "r");
- }
+ char *codec_name = *opt == 'v' ? video_codec_name :
+ *opt == 'a' ? audio_codec_name :
+ subtitle_codec_name;
- if(!f){
+ if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
fprintf(stderr, "File for preset '%s' not found\n", arg);
ffmpeg_exit(1);
}
{ "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
{ "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
{ "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
+ { "map_chapters", HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters}, "set chapters mapping", "outfile:infile" },
{ "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
{ "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
{ "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },