X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_graph_builder.cc;h=b89e73d0eda270a28c8303bef1954f45e0d10888;hb=9bf40bde3aed831791108bfccc4b1e10b071afdc;hp=9065aea1303ef3d62e18a5cd37cde6d1e9e8b116;hpb=77687519b69f39aaa2354f4c9945958fc1c630fe;p=ardour.git diff --git a/libs/ardour/export_graph_builder.cc b/libs/ardour/export_graph_builder.cc index 9065aea130..b89e73d0ed 100644 --- a/libs/ardour/export_graph_builder.cc +++ b/libs/ardour/export_graph_builder.cc @@ -60,7 +60,7 @@ ExportGraphBuilder::ExportGraphBuilder (Session const & session) : session (session) , thread_pool (hardware_concurrency()) { - process_buffer_frames = session.engine().samples_per_cycle(); + process_buffer_samples = session.engine().samples_per_cycle(); } ExportGraphBuilder::~ExportGraphBuilder () @@ -68,14 +68,14 @@ ExportGraphBuilder::~ExportGraphBuilder () } int -ExportGraphBuilder::process (framecnt_t frames, bool last_cycle) +ExportGraphBuilder::process (samplecnt_t samples, bool last_cycle) { - assert(frames <= process_buffer_frames); + assert(samples <= process_buffer_samples); for (ChannelMap::iterator it = channels.begin(); it != channels.end(); ++it) { Sample const * process_buffer = 0; - it->first->read (process_buffer, frames); - ConstProcessContext context(process_buffer, frames, 1); + it->first->read (process_buffer, samples); + ConstProcessContext context(process_buffer, samples, 1); if (last_cycle) { context().set_flag (ProcessContext::EndOfInput); } it->second->process (context); } @@ -84,25 +84,25 @@ ExportGraphBuilder::process (framecnt_t frames, bool last_cycle) } bool -ExportGraphBuilder::process_normalize () +ExportGraphBuilder::post_process () { - for (std::list::iterator it = normalizers.begin(); it != normalizers.end(); /* ++ in loop */) { + for (std::list::iterator it = intermediates.begin(); it != intermediates.end(); /* ++ in loop */) { if ((*it)->process()) { - it = normalizers.erase (it); + it = intermediates.erase (it); } else { ++it; } } - return normalizers.empty(); + return intermediates.empty(); } unsigned -ExportGraphBuilder::get_normalize_cycle_count() const +ExportGraphBuilder::get_postprocessing_cycle_count() const { unsigned max = 0; - for (std::list::const_iterator it = normalizers.begin(); it != normalizers.end(); ++it) { - max = std::max(max, (*it)->get_normalize_cycle_count()); + for (std::list::const_iterator it = intermediates.begin(); it != intermediates.end(); ++it) { + max = std::max(max, (*it)->get_postprocessing_cycle_count()); } return max; } @@ -113,8 +113,9 @@ ExportGraphBuilder::reset () timespan.reset(); channel_configs.clear (); channels.clear (); - normalizers.clear (); + intermediates.clear (); analysis_map.clear(); + _realtime = false; } void @@ -135,21 +136,23 @@ ExportGraphBuilder::set_current_timespan (boost::shared_ptr span } void -ExportGraphBuilder::add_config (FileSpec const & config) +ExportGraphBuilder::add_config (FileSpec const & config, bool rt) { ExportChannelConfiguration::ChannelList const & channels = config.channel_config->get_channels(); for(ExportChannelConfiguration::ChannelList::const_iterator it = channels.begin(); it != channels.end(); ++it) { - (*it)->set_max_buffer_size(process_buffer_frames); + (*it)->set_max_buffer_size(process_buffer_samples); } + _realtime = rt; + // If the sample rate is "session rate", change it to the real value. // However, we need to copy it to not change the config which is saved... FileSpec new_config (config); new_config.format.reset(new ExportFormatSpecification(*new_config.format, false)); if(new_config.format->sample_rate() == ExportFormatBase::SR_Session) { - framecnt_t session_rate = session.nominal_frame_rate(); + samplecnt_t session_rate = session.nominal_sample_rate(); new_config.format->set_sample_rate(ExportFormatBase::nearest_sample_rate(session_rate)); } @@ -302,7 +305,7 @@ ExportGraphBuilder::Encoder::copy_files (std::string orig_path) /* SFC */ -ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &parent, FileSpec const & new_config, framecnt_t max_frames) +ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &parent, FileSpec const & new_config, samplecnt_t max_samples) : data_width(0) { config = new_config; @@ -310,14 +313,14 @@ ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &parent, FileSpec const & new_c 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 (max_frames)); - analyser.reset (new Analyser (config.format->sample_rate(), channels, max_frames, - (framecnt_t) ceil (duration * config.format->sample_rate () / (double) sample_rate))); + samplecnt_t sample_rate = parent.session.nominal_sample_rate(); + samplecnt_t sb = config.format->silence_beginning_at (parent.timespan->get_start(), sample_rate); + samplecnt_t se = config.format->silence_end_at (parent.timespan->get_end(), sample_rate); + samplecnt_t duration = parent.timespan->get_length () + sb + se; + max_samples = min ((samplecnt_t) 8192 * channels, max ((samplecnt_t) 4096 * channels, max_samples)); + chunker.reset (new Chunker (max_samples)); + analyser.reset (new Analyser (config.format->sample_rate(), channels, max_samples, + (samplecnt_t) ceil (duration * config.format->sample_rate () / (double) sample_rate))); chunker->add_output (analyser); config.filename->set_channel_config (config.channel_config); @@ -326,19 +329,19 @@ ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &parent, FileSpec const & new_c if (data_width == 8 || data_width == 16) { short_converter = ShortConverterPtr (new SampleFormatConverter (channels)); - short_converter->init (max_frames, config.format->dither_type(), data_width); + short_converter->init (max_samples, 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 (channels)); - int_converter->init (max_frames, config.format->dither_type(), data_width); + int_converter->init (max_samples, 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 (channels)); - float_converter->init (max_frames, config.format->dither_type(), actual_data_width); + float_converter->init (max_samples, config.format->dither_type(), actual_data_width); add_child (config); if (_analyse) { analyser->add_output (float_converter); } } @@ -408,11 +411,12 @@ ExportGraphBuilder::SFC::operator== (FileSpec const & other_config) const return config.format->sample_format() == other_config.format->sample_format(); } -/* Normalizer */ +/* Intermediate (Normalizer, TmpFile) */ -ExportGraphBuilder::Normalizer::Normalizer (ExportGraphBuilder & parent, FileSpec const & new_config, framecnt_t max_frames) +ExportGraphBuilder::Intermediate::Intermediate (ExportGraphBuilder & parent, FileSpec const & new_config, samplecnt_t max_samples) : parent (parent) , use_loudness (false) + , use_peak (false) { std::string tmpfile_path = parent.session.session_directory().export_path(); tmpfile_path = Glib::build_filename(tmpfile_path, "XXXXXX"); @@ -422,45 +426,59 @@ ExportGraphBuilder::Normalizer::Normalizer (ExportGraphBuilder & parent, FileSpe config = new_config; uint32_t const channels = config.channel_config->get_n_chans(); - max_frames_out = 4086 - (4086 % channels); // TODO good chunk size + max_samples_out = 4086 - (4086 % channels); // TODO good chunk size use_loudness = config.format->normalize_loudness (); + use_peak = config.format->normalize (); + + buffer.reset (new AllocatingProcessContext (max_samples_out, channels)); + + if (use_peak) { + peak_reader.reset (new PeakReader ()); + } + if (use_loudness) { + loudness_reader.reset (new LoudnessReader (config.format->sample_rate(), channels, max_samples)); + } - buffer.reset (new AllocatingProcessContext (max_frames_out, channels)); - peak_reader.reset (new PeakReader ()); - loudness_reader.reset (new LoudnessReader (config.format->sample_rate(), channels, max_frames)); normalizer.reset (new AudioGrapher::Normalizer (use_loudness ? 0.0 : config.format->normalize_dbfs())); threader.reset (new Threader (parent.thread_pool)); - - normalizer->alloc_buffer (max_frames_out); + normalizer->alloc_buffer (max_samples_out); normalizer->add_output (threader); int format = ExportFormatBase::F_RAW | ExportFormatBase::SF_Float; - tmp_file.reset (new TmpFileSync (&tmpfile_path_buf[0], format, channels, config.format->sample_rate())); + + if (parent._realtime) { + tmp_file.reset (new TmpFileRt (&tmpfile_path_buf[0], format, channels, config.format->sample_rate())); + } else { + tmp_file.reset (new TmpFileSync (&tmpfile_path_buf[0], format, channels, config.format->sample_rate())); + } + tmp_file->FileWritten.connect_same_thread (post_processing_connection, - boost::bind (&Normalizer::prepare_post_processing, this)); + boost::bind (&Intermediate::prepare_post_processing, this)); tmp_file->FileFlushed.connect_same_thread (post_processing_connection, - boost::bind (&Normalizer::start_post_processing, this)); + boost::bind (&Intermediate::start_post_processing, this)); add_child (new_config); if (use_loudness) { loudness_reader->add_output (tmp_file); - } else { + } else if (use_peak) { peak_reader->add_output (tmp_file); } } ExportGraphBuilder::FloatSinkPtr -ExportGraphBuilder::Normalizer::sink () +ExportGraphBuilder::Intermediate::sink () { if (use_loudness) { return loudness_reader; + } else if (use_peak) { + return peak_reader; } - return peak_reader; + return tmp_file; } void -ExportGraphBuilder::Normalizer::add_child (FileSpec const & new_config) +ExportGraphBuilder::Intermediate::add_child (FileSpec const & new_config) { for (boost::ptr_list::iterator it = children.begin(); it != children.end(); ++it) { if (*it == new_config) { @@ -469,12 +487,12 @@ ExportGraphBuilder::Normalizer::add_child (FileSpec const & new_config) } } - children.push_back (new SFC (parent, new_config, max_frames_out)); + children.push_back (new SFC (parent, new_config, max_samples_out)); threader->add_output (children.back().sink()); } void -ExportGraphBuilder::Normalizer::remove_children (bool remove_out_files) +ExportGraphBuilder::Intermediate::remove_children (bool remove_out_files) { boost::ptr_list::iterator iter = children.begin (); @@ -485,7 +503,7 @@ ExportGraphBuilder::Normalizer::remove_children (bool remove_out_files) } bool -ExportGraphBuilder::Normalizer::operator== (FileSpec const & other_config) const +ExportGraphBuilder::Intermediate::operator== (FileSpec const & other_config) const { return config.format->normalize() == other_config.format->normalize() && config.format->normalize_loudness () == other_config.format->normalize_loudness() && @@ -498,38 +516,43 @@ ExportGraphBuilder::Normalizer::operator== (FileSpec const & other_config) const } unsigned -ExportGraphBuilder::Normalizer::get_normalize_cycle_count() const +ExportGraphBuilder::Intermediate::get_postprocessing_cycle_count() const { - return static_cast(std::ceil(static_cast(tmp_file->get_frames_written()) / - max_frames_out)); + return static_cast(std::ceil(static_cast(tmp_file->get_samples_written()) / + max_samples_out)); } bool -ExportGraphBuilder::Normalizer::process() +ExportGraphBuilder::Intermediate::process() { - framecnt_t frames_read = tmp_file->read (*buffer); - return frames_read != buffer->frames(); + samplecnt_t samples_read = tmp_file->read (*buffer); + return samples_read != buffer->samples(); } void -ExportGraphBuilder::Normalizer::prepare_post_processing() +ExportGraphBuilder::Intermediate::prepare_post_processing() { // called in sync rt-context float gain; if (use_loudness) { gain = normalizer->set_peak (loudness_reader->get_peak (config.format->normalize_lufs (), config.format->normalize_dbtp ())); - } else { + } else if (use_peak) { gain = normalizer->set_peak (peak_reader->get_peak()); + } else { + gain = normalizer->set_peak (0.0); } - for (boost::ptr_list::iterator i = children.begin(); i != children.end(); ++i) { - (*i).set_peak (gain); + if (use_loudness || use_peak) { + // push info to analyzers + for (boost::ptr_list::iterator i = children.begin(); i != children.end(); ++i) { + (*i).set_peak (gain); + } } tmp_file->add_output (normalizer); - parent.normalizers.push_back (this); + parent.intermediates.push_back (this); } void -ExportGraphBuilder::Normalizer::start_post_processing() +ExportGraphBuilder::Intermediate::start_post_processing() { // called in disk-thread (when exporting in realtime) tmp_file->seek (0, SEEK_SET); @@ -540,14 +563,14 @@ ExportGraphBuilder::Normalizer::start_post_processing() /* SRC */ -ExportGraphBuilder::SRC::SRC (ExportGraphBuilder & parent, FileSpec const & new_config, framecnt_t max_frames) +ExportGraphBuilder::SRC::SRC (ExportGraphBuilder & parent, FileSpec const & new_config, samplecnt_t max_samples) : parent (parent) { config = new_config; converter.reset (new SampleRateConverter (new_config.channel_config->get_n_chans())); ExportFormatSpecification & format = *new_config.format; - converter->init (parent.session.nominal_frame_rate(), format.sample_rate(), format.src_quality()); - max_frames_out = converter->allocate_buffers (max_frames); + converter->init (parent.session.nominal_sample_rate(), format.sample_rate(), format.src_quality()); + max_samples_out = converter->allocate_buffers (max_samples); add_child (new_config); } @@ -561,8 +584,8 @@ ExportGraphBuilder::SRC::sink () void ExportGraphBuilder::SRC::add_child (FileSpec const & new_config) { - if (new_config.format->normalize()) { - add_child_to_list (new_config, normalized_children); + if (new_config.format->normalize() || parent._realtime) { + add_child_to_list (new_config, intermediate_children); } else { add_child_to_list (new_config, children); } @@ -579,12 +602,12 @@ ExportGraphBuilder::SRC::remove_children (bool remove_out_files) sfc_iter = children.erase (sfc_iter); } - boost::ptr_list::iterator norm_iter = normalized_children.begin(); + boost::ptr_list::iterator norm_iter = intermediate_children.begin(); - while (norm_iter != normalized_children.end() ) { + while (norm_iter != intermediate_children.end() ) { converter->remove_output (norm_iter->sink() ); norm_iter->remove_children (remove_out_files); - norm_iter = normalized_children.erase (norm_iter); + norm_iter = intermediate_children.erase (norm_iter); } } @@ -600,7 +623,7 @@ ExportGraphBuilder::SRC::add_child_to_list (FileSpec const & new_config, boost:: } } - list.push_back (new T (parent, new_config, max_frames_out)); + list.push_back (new T (parent, new_config, max_samples_out)); converter->add_output (list.back().sink ()); } @@ -611,24 +634,30 @@ ExportGraphBuilder::SRC::operator== (FileSpec const & other_config) const } /* SilenceHandler */ -ExportGraphBuilder::SilenceHandler::SilenceHandler (ExportGraphBuilder & parent, FileSpec const & new_config, framecnt_t max_frames) +ExportGraphBuilder::SilenceHandler::SilenceHandler (ExportGraphBuilder & parent, FileSpec const & new_config, samplecnt_t max_samples) : parent (parent) { config = new_config; - max_frames_in = max_frames; - framecnt_t sample_rate = parent.session.nominal_frame_rate(); - + max_samples_in = max_samples; + samplecnt_t sample_rate = parent.session.nominal_sample_rate(); + + /* work around partsing "-inf" config to "0" -- 7b1f97b + * silence trim 0dBFS makes no sense, anyway. + */ + float est = Config->get_export_silence_threshold (); + if (est >= 0.f) est = -INFINITY; #ifdef MIXBUS - silence_trimmer.reset (new SilenceTrimmer(max_frames_in, -90)); + // Mixbus channelstrip always dithers the signal, cut above dither level + silence_trimmer.reset (new SilenceTrimmer(max_samples_in, std::max (-90.f, est))); #else // TODO silence-threshold should be per export-preset, with Config->get_silence_threshold being the default - silence_trimmer.reset (new SilenceTrimmer(max_frames_in, Config->get_export_silence_threshold ())); + silence_trimmer.reset (new SilenceTrimmer(max_samples_in, est)); #endif silence_trimmer->set_trim_beginning (config.format->trim_beginning()); silence_trimmer->set_trim_end (config.format->trim_end()); - 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); + samplecnt_t sb = config.format->silence_beginning_at (parent.timespan->get_start(), sample_rate); + samplecnt_t se = config.format->silence_end_at (parent.timespan->get_end(), sample_rate); silence_trimmer->add_silence_to_beginning (sb); silence_trimmer->add_silence_to_end (se); @@ -652,7 +681,7 @@ ExportGraphBuilder::SilenceHandler::add_child (FileSpec const & new_config) } } - children.push_back (new SRC (parent, new_config, max_frames_in)); + children.push_back (new SRC (parent, new_config, max_samples_in)); silence_trimmer->add_output (children.back().sink()); } @@ -688,17 +717,17 @@ ExportGraphBuilder::ChannelConfig::ChannelConfig (ExportGraphBuilder & parent, F config = new_config; - framecnt_t max_frames = parent.session.engine().samples_per_cycle(); + samplecnt_t max_samples = parent.session.engine().samples_per_cycle(); interleaver.reset (new Interleaver ()); - interleaver->init (new_config.channel_config->get_n_chans(), max_frames); + interleaver->init (new_config.channel_config->get_n_chans(), max_samples); // Make the chunk size divisible by the channel count int chan_count = new_config.channel_config->get_n_chans(); - max_frames_out = 8192; + max_samples_out = 8192; if (chan_count > 0) { - max_frames_out -= max_frames_out % chan_count; + max_samples_out -= max_samples_out % chan_count; } - chunker.reset (new Chunker (max_frames_out)); + chunker.reset (new Chunker (max_samples_out)); interleaver->add_output(chunker); ChannelList const & channel_list = config.channel_config->get_channels(); @@ -729,7 +758,7 @@ ExportGraphBuilder::ChannelConfig::add_child (FileSpec const & new_config) } } - children.push_back (new SilenceHandler (parent, new_config, max_frames_out)); + children.push_back (new SilenceHandler (parent, new_config, max_samples_out)); chunker->add_output (children.back().sink ()); }