/*
- Copyright (C) 2008-2012 Paul Davis
+ Copyright (C) 2008-2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
#include "audiographer/general/chunker.h"
#include "audiographer/general/interleaver.h"
#include "audiographer/general/normalizer.h"
+#include "audiographer/general/analyser.h"
#include "audiographer/general/peak_reader.h"
#include "audiographer/general/sample_format_converter.h"
#include "audiographer/general/sr_converter.h"
channel_configs.clear ();
channels.clear ();
normalizers.clear ();
+ analysis_map.clear();
}
void
ExportGraphBuilder::cleanup (bool remove_out_files/*=false*/)
{
ChannelConfigList::iterator iter = channel_configs.begin();
-
+
while (iter != channel_configs.end() ) {
iter->remove_children(remove_out_files);
iter = channel_configs.erase(iter);
}
}
-
+
void
ExportGraphBuilder::set_current_timespan (boost::shared_ptr<ExportTimespan> span)
{
}
}
+void
+ExportGraphBuilder::get_analysis_results (AnalysisResults& results) {
+ for (AnalysisMap::iterator i = analysis_map.begin(); i != analysis_map.end(); ++i) {
+ ExportAnalysisPtr p = i->second->result ();
+ if (p) {
+ results.insert (std::make_pair (i->first, p));
+ }
+ }
+}
+
void
ExportGraphBuilder::add_split_config (FileSpec const & config)
{
// No duplicate channel config found, create new one
channel_configs.push_back (new ChannelConfig (*this, config, channels));
}
-
+
/* Encoder */
template <>
{
filenames.push_back (new_config.filename);
}
-
+
void
ExportGraphBuilder::Encoder::destroy_writer (bool delete_out_file)
{
if (delete_out_file ) {
-
+
if (float_writer) {
float_writer->close ();
}
-
+
if (int_writer) {
int_writer->close ();
}
-
+
if (short_writer) {
short_writer->close ();
}
std::cout << "Encoder::destroy_writer () : Error removing file: " << strerror(errno) << std::endl;
}
}
-
+
float_writer.reset ();
int_writer.reset ();
short_writer.reset ();
/* SFC */
-ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &, FileSpec const & new_config, framecnt_t max_frames)
+ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &parent, FileSpec const & new_config, framecnt_t max_frames)
: data_width(0)
{
config = new_config;
data_width = sndfile_data_width (Encoder::get_real_format (config));
unsigned channels = new_config.channel_config->get_n_chans();
+ _analyse = config.format->analyse();
+ if (_analyse) {
+ framecnt_t sample_rate = parent.session.nominal_frame_rate();
+ framecnt_t sb = config.format->silence_beginning_at (parent.timespan->get_start(), sample_rate);
+ framecnt_t se = config.format->silence_end_at (parent.timespan->get_end(), sample_rate);
+ framecnt_t duration = parent.timespan->get_length () + sb + se;
+ max_frames = min ((framecnt_t) 8192 * channels, max ((framecnt_t) 4096 * channels, max_frames));
+ chunker.reset (new Chunker<Sample> (max_frames));
+ analyser.reset (new Analyser (config.format->sample_rate(), channels, max_frames,
+ (framecnt_t) ceil (duration * config.format->sample_rate () / (double) sample_rate)));
+ chunker->add_output (analyser);
+ parent.add_analyser (config.filename->get_path (config.format), analyser);
+ }
if (data_width == 8 || data_width == 16) {
short_converter = ShortConverterPtr (new SampleFormatConverter<short> (channels));
short_converter->init (max_frames, config.format->dither_type(), data_width);
add_child (config);
+ if (_analyse) { analyser->add_output (short_converter); }
+
} else if (data_width == 24 || data_width == 32) {
int_converter = IntConverterPtr (new SampleFormatConverter<int> (channels));
int_converter->init (max_frames, config.format->dither_type(), data_width);
add_child (config);
+ if (_analyse) { analyser->add_output (int_converter); }
} else {
int actual_data_width = 8 * sizeof(Sample);
float_converter = FloatConverterPtr (new SampleFormatConverter<Sample> (channels));
float_converter->init (max_frames, config.format->dither_type(), actual_data_width);
add_child (config);
+ if (_analyse) { analyser->add_output (float_converter); }
+ }
+}
+
+void
+ExportGraphBuilder::SFC::set_peak (float gain)
+{
+ if (_analyse) {
+ analyser->set_normalization_gain (gain);
}
}
ExportGraphBuilder::FloatSinkPtr
ExportGraphBuilder::SFC::sink ()
{
- if (data_width == 8 || data_width == 16) {
+ if (_analyse) {
+ return chunker;
+ } else if (data_width == 8 || data_width == 16) {
return short_converter;
} else if (data_width == 24 || data_width == 32) {
return int_converter;
ExportGraphBuilder::SFC::remove_children (bool remove_out_files)
{
boost::ptr_list<Encoder>::iterator iter = children.begin ();
-
+
while (iter != children.end() ) {
-
+
if (remove_out_files) {
iter->destroy_writer(remove_out_files);
}
iter = children.erase (iter);
}
}
-
+
bool
ExportGraphBuilder::SFC::operator== (FileSpec const & other_config) const
{
config = new_config;
uint32_t const channels = config.channel_config->get_n_chans();
max_frames_out = 4086 - (4086 % channels); // TODO good chunk size
-
+
buffer.reset (new AllocatingProcessContext<Sample> (max_frames_out, channels));
peak_reader.reset (new PeakReader ());
normalizer.reset (new AudioGrapher::Normalizer (config.format->normalize_target()));
ExportGraphBuilder::Normalizer::remove_children (bool remove_out_files)
{
boost::ptr_list<SFC>::iterator iter = children.begin ();
-
+
while (iter != children.end() ) {
iter->remove_children (remove_out_files);
iter = children.erase (iter);
}
}
-
+
bool
ExportGraphBuilder::Normalizer::operator== (FileSpec const & other_config) const
{
void
ExportGraphBuilder::Normalizer::start_post_processing()
{
- normalizer->set_peak (peak_reader->get_peak());
+ const float gain = normalizer->set_peak (peak_reader->get_peak());
+ for (boost::ptr_list<SFC>::iterator i = children.begin(); i != children.end(); ++i) {
+ (*i).set_peak (gain);
+ }
tmp_file->seek (0, SEEK_SET);
tmp_file->add_output (normalizer);
parent.normalizers.push_back (this);
add_child_to_list (new_config, children);
}
}
-
+
void
ExportGraphBuilder::SRC::remove_children (bool remove_out_files)
{
boost::ptr_list<SFC>::iterator sfc_iter = children.begin();
-
+
while (sfc_iter != children.end() ) {
converter->remove_output (sfc_iter->sink() );
sfc_iter->remove_children (remove_out_files);
sfc_iter = children.erase (sfc_iter);
}
-
+
boost::ptr_list<Normalizer>::iterator norm_iter = normalized_children.begin();
-
+
while (norm_iter != normalized_children.end() ) {
converter->remove_output (norm_iter->sink() );
norm_iter->remove_children (remove_out_files);
max_frames_in = max_frames;
framecnt_t sample_rate = parent.session.nominal_frame_rate();
- silence_trimmer.reset (new SilenceTrimmer<Sample>(max_frames_in));
+ // TODO silence-threshold should be per export-preset, with Config->get_silence_threshold being the default
+ silence_trimmer.reset (new SilenceTrimmer<Sample>(max_frames_in, Config->get_export_silence_threshold ()));
silence_trimmer->set_trim_beginning (config.format->trim_beginning());
silence_trimmer->set_trim_end (config.format->trim_end());
children.push_back (new SRC (parent, new_config, max_frames_in));
silence_trimmer->add_output (children.back().sink());
}
-
+
void
ExportGraphBuilder::SilenceHandler::remove_children (bool remove_out_files)
{
boost::ptr_list<SRC>::iterator iter = children.begin();
-
+
while (iter != children.end() ) {
silence_trimmer->remove_output (iter->sink() );
iter->remove_children (remove_out_files);
children.push_back (new SilenceHandler (parent, new_config, max_frames_out));
chunker->add_output (children.back().sink ());
}
-
+
void
ExportGraphBuilder::ChannelConfig::remove_children (bool remove_out_files)
{
boost::ptr_list<SilenceHandler>::iterator iter = children.begin();
-
+
while(iter != children.end() ) {
-
+
chunker->remove_output (iter->sink ());
iter->remove_children (remove_out_files);
iter = children.erase(iter);
projects / ardour.git / blobdiff