libs/ardour/export_graph_builder.cc

   1 #include "ardour/export_graph_builder.h"
   2
   3 #include "audiographer/process_context.h"
   4 #include "audiographer/general/interleaver.h"
   5 #include "audiographer/general/normalizer.h"
   6 #include "audiographer/general/peak_reader.h"
   7 #include "audiographer/general/sample_format_converter.h"
   8 #include "audiographer/general/sr_converter.h"
   9 #include "audiographer/general/silence_trimmer.h"
  10 #include "audiographer/general/threader.h"
  11 #include "audiographer/sndfile/tmp_file.h"
  12 #include "audiographer/sndfile/sndfile_writer.h"
  13
  14 #include "ardour/audioengine.h"
  15 #include "ardour/export_channel_configuration.h"
  16 #include "ardour/export_filename.h"
  17 #include "ardour/export_format_specification.h"
  18 #include "ardour/sndfile_helpers.h"
  19
  20 #include "pbd/filesystem.h"
  21
  22 using namespace AudioGrapher;
  23 using std::string;
  24
  25 namespace ARDOUR {
  26
  27 ExportGraphBuilder::ExportGraphBuilder (Session const & session)
  28   : session (session)
  29   , thread_pool (4) // FIXME thread amount to cores amount
  30 {
  31         process_buffer_frames = session.engine().frames_per_cycle();
  32         process_buffer = new Sample[process_buffer_frames];
  33 }
  34
  35 ExportGraphBuilder::~ExportGraphBuilder ()
  36 {
  37         delete [] process_buffer;
  38 }
  39
  40 int
  41 ExportGraphBuilder::process (nframes_t /* frames */, bool last_cycle)
  42 {
  43         for (ChannelMap::iterator it = channels.begin(); it != channels.end(); ++it) {
  44                 it->first->read (process_buffer, process_buffer_frames);
  45                 ProcessContext<Sample> context(process_buffer, process_buffer_frames, 1);
  46                 if (last_cycle) { context.set_flag (ProcessContext<Sample>::EndOfInput); }
  47                 it->second->process (context);
  48         }
  49
  50         return 0;
  51 }
  52
  53 bool
  54 ExportGraphBuilder::process_normalize ()
  55 {
  56         for (std::list<Normalizer *>::iterator it = normalizers.begin(); it != normalizers.end(); /* ++ in loop */) {
  57                 if ((*it)->process()) {
  58                         it = normalizers.erase (it);
  59                 } else {
  60                         ++it;
  61                 }
  62         }
  63
  64         return normalizers.empty();
  65 }
  66
  67 void
  68 ExportGraphBuilder::reset ()
  69 {
  70         channel_configs.clear ();
  71         channels.clear ();
  72         normalizers.clear ();
  73 }
  74
  75 void
  76 ExportGraphBuilder::add_config (FileSpec const & config)
  77 {
  78         if (!config.channel_config->get_split ()) {
  79                 add_split_config (config);
  80                 return;
  81         }
  82
  83         // Split channel configurations are split into several channel configurations,
  84         // each corresponding to a file, at this stage
  85         typedef std::list<boost::shared_ptr<ExportChannelConfiguration> > ConfigList;
  86         ConfigList file_configs;
  87         config.channel_config->configurations_for_files (file_configs);
  88
  89         unsigned chan = 1;
  90         for (ConfigList::iterator it = file_configs.begin(); it != file_configs.end(); ++it, ++chan) {
  91                 FileSpec copy = config;
  92                 copy.channel_config = *it;
  93
  94                 copy.filename.reset (new ExportFilename (*copy.filename));
  95                 copy.filename->include_channel = true;
  96                 copy.filename->set_channel (chan);
  97
  98                 add_split_config (copy);
  99         }
 100 }
 101
 102 void
 103 ExportGraphBuilder::add_split_config (FileSpec const & config)
 104 {
 105         for (ChannelConfigList::iterator it = channel_configs.begin(); it != channel_configs.end(); ++it) {
 106                 if (*it == config) {
 107                         it->add_child (config);
 108                         return;
 109                 }
 110         }
 111
 112         // No duplicate channel config found, create new one
 113         channel_configs.push_back (new ChannelConfig (*this, config, channels));
 114 }
 115
 116 /* Encoder */
 117
 118 template <>
 119 boost::shared_ptr<AudioGrapher::Sink<Sample> >
 120 ExportGraphBuilder::Encoder::init (FileSpec const & new_config)
 121 {
 122         config = new_config;
 123         init_writer (float_writer);
 124         return float_writer;
 125 }
 126
 127 template <>
 128 boost::shared_ptr<AudioGrapher::Sink<int> >
 129 ExportGraphBuilder::Encoder::init (FileSpec const & new_config)
 130 {
 131         config = new_config;
 132         init_writer (int_writer);
 133         return int_writer;
 134 }
 135
 136 template <>
 137 boost::shared_ptr<AudioGrapher::Sink<short> >
 138 ExportGraphBuilder::Encoder::init (FileSpec const & new_config)
 139 {
 140         config = new_config;
 141         init_writer (short_writer);
 142         return short_writer;
 143 }
 144
 145 void
 146 ExportGraphBuilder::Encoder::add_child (FileSpec const & new_config)
 147 {
 148         filenames.push_back (new_config.filename);
 149 }
 150
 151 bool
 152 ExportGraphBuilder::Encoder::operator== (FileSpec const & other_config) const
 153 {
 154         return get_real_format (config) == get_real_format (other_config);
 155 }
 156
 157 int
 158 ExportGraphBuilder::Encoder::get_real_format (FileSpec const & config)
 159 {
 160         ExportFormatSpecification & format = *config.format;
 161         return format.format_id() | format.sample_format() | format.endianness();
 162 }
 163
 164 template<typename T>
 165 void
 166 ExportGraphBuilder::Encoder::init_writer (boost::shared_ptr<AudioGrapher::SndfileWriter<T> > & writer)
 167 {
 168         unsigned channels = config.channel_config->get_n_chans();
 169         int format = get_real_format (config);
 170         string filename = config.filename->get_path (config.format);
 171
 172         writer.reset (new AudioGrapher::SndfileWriter<T> (filename, format, channels, config.format->sample_rate(), config.broadcast_info));
 173         writer->FileWritten.connect_same_thread (copy_files_connection, boost::bind (&ExportGraphBuilder::Encoder::copy_files, this, _1));
 174 }
 175
 176 void
 177 ExportGraphBuilder::Encoder::copy_files (std::string orig_path)
 178 {
 179         while (filenames.size()) {
 180                 FilenamePtr & filename = filenames.front();
 181                 PBD::sys::copy_file (orig_path, filename->get_path (config.format).c_str());
 182                 filenames.pop_front();
 183         }
 184 }
 185
 186 /* SFC */
 187
 188 ExportGraphBuilder::SFC::SFC (ExportGraphBuilder &, FileSpec const & new_config, nframes_t max_frames)
 189   : data_width(0)
 190 {
 191         config = new_config;
 192         data_width = sndfile_data_width (Encoder::get_real_format (config));
 193         unsigned channels = new_config.channel_config->get_n_chans();
 194
 195         if (data_width == 8 || data_width == 16) {
 196                 short_converter = ShortConverterPtr (new SampleFormatConverter<short> (channels));
 197                 short_converter->init (max_frames, config.format->dither_type(), data_width);
 198                 add_child (config);
 199         } else if (data_width == 24 || data_width == 32) {
 200                 int_converter = IntConverterPtr (new SampleFormatConverter<int> (channels));
 201                 int_converter->init (max_frames, config.format->dither_type(), data_width);
 202                 add_child (config);
 203         } else {
 204                 float_converter = FloatConverterPtr (new SampleFormatConverter<Sample> (channels));
 205                 float_converter->init (max_frames, config.format->dither_type(), data_width);
 206                 add_child (config);
 207         }
 208 }
 209
 210 ExportGraphBuilder::FloatSinkPtr
 211 ExportGraphBuilder::SFC::sink ()
 212 {
 213         if (data_width == 8 || data_width == 16) {
 214                 return short_converter;
 215         } else if (data_width == 24 || data_width == 32) {
 216                 return int_converter;
 217         } else {
 218                 return float_converter;
 219         }
 220 }
 221
 222 void
 223 ExportGraphBuilder::SFC::add_child (FileSpec const & new_config)
 224 {
 225         for (boost::ptr_list<Encoder>::iterator it = children.begin(); it != children.end(); ++it) {
 226                 if (*it == new_config) {
 227                         it->add_child (new_config);
 228                         return;
 229                 }
 230         }
 231
 232         children.push_back (new Encoder());
 233         Encoder & encoder = children.back();
 234
 235         if (data_width == 8 || data_width == 16) {
 236                 short_converter->add_output (encoder.init<short> (new_config));
 237         } else if (data_width == 24 || data_width == 32) {
 238                 int_converter->add_output (encoder.init<int> (new_config));
 239         } else {
 240                 float_converter->add_output (encoder.init<Sample> (new_config));
 241         }
 242 }
 243
 244 bool
 245 ExportGraphBuilder::SFC::operator== (FileSpec const & other_config) const
 246 {
 247         return config.format->sample_format() == other_config.format->sample_format();
 248 }
 249
 250 /* Normalizer */
 251
 252 ExportGraphBuilder::Normalizer::Normalizer (ExportGraphBuilder & parent, FileSpec const & new_config, nframes_t /*max_frames*/)
 253   : parent (parent)
 254 {
 255         config = new_config;
 256         max_frames_out = 4086; // TODO good chunk size
 257
 258         buffer.reset (new AllocatingProcessContext<Sample> (max_frames_out, config.channel_config->get_n_chans()));
 259         peak_reader.reset (new PeakReader ());
 260         normalizer.reset (new AudioGrapher::Normalizer (config.format->normalize_target()));
 261         threader.reset (new Threader<Sample> (parent.thread_pool));
 262
 263         normalizer->alloc_buffer (max_frames_out);
 264         normalizer->add_output (threader);
 265
 266         int format = ExportFormatBase::F_RAW | ExportFormatBase::SF_Float;
 267         tmp_file.reset (new TmpFile<float> (format, config.channel_config->get_n_chans(),
 268                                             config.format->sample_rate()));
 269         tmp_file->FileWritten.connect_same_thread (post_processing_connection, boost::bind (&Normalizer::start_post_processing, this));
 270
 271         add_child (new_config);
 272
 273         peak_reader->add_output (tmp_file);
 274 }
 275
 276 ExportGraphBuilder::FloatSinkPtr
 277 ExportGraphBuilder::Normalizer::sink ()
 278 {
 279         return peak_reader;
 280 }
 281
 282 void
 283 ExportGraphBuilder::Normalizer::add_child (FileSpec const & new_config)
 284 {
 285         for (boost::ptr_list<SFC>::iterator it = children.begin(); it != children.end(); ++it) {
 286                 if (*it == new_config) {
 287                         it->add_child (new_config);
 288                         return;
 289                 }
 290         }
 291
 292         children.push_back (new SFC (parent, new_config, max_frames_out));
 293         threader->add_output (children.back().sink());
 294 }
 295
 296 bool
 297 ExportGraphBuilder::Normalizer::operator== (FileSpec const & other_config) const
 298 {
 299         return config.format->normalize() == other_config.format->normalize() &&
 300                config.format->normalize_target() == other_config.format->normalize_target();
 301 }
 302
 303 bool
 304 ExportGraphBuilder::Normalizer::process()
 305 {
 306         nframes_t frames_read = tmp_file->read (*buffer);
 307         return frames_read != buffer->frames();
 308 }
 309
 310 void
 311 ExportGraphBuilder::Normalizer::start_post_processing()
 312 {
 313         normalizer->set_peak (peak_reader->get_peak());
 314         tmp_file->seek (0, SEEK_SET);
 315         tmp_file->add_output (normalizer);
 316         parent.normalizers.push_back (this);
 317 }
 318
 319 /* SRC */
 320
 321 ExportGraphBuilder::SRC::SRC (ExportGraphBuilder & parent, FileSpec const & new_config, nframes_t max_frames)
 322   : parent (parent)
 323 {
 324         config = new_config;
 325         converter.reset (new SampleRateConverter (new_config.channel_config->get_n_chans()));
 326         ExportFormatSpecification & format = *new_config.format;
 327         converter->init (parent.session.nominal_frame_rate(), format.sample_rate(), format.src_quality());
 328         max_frames_out = converter->allocate_buffers (max_frames);
 329
 330         add_child (new_config);
 331 }
 332
 333 ExportGraphBuilder::FloatSinkPtr
 334 ExportGraphBuilder::SRC::sink ()
 335 {
 336         return converter;
 337 }
 338
 339 void
 340 ExportGraphBuilder::SRC::add_child (FileSpec const & new_config)
 341 {
 342         if (new_config.format->normalize()) {
 343                 add_child_to_list (new_config, normalized_children);
 344         } else {
 345                 add_child_to_list (new_config, children);
 346         }
 347 }
 348
 349 template<typename T>
 350 void
 351 ExportGraphBuilder::SRC::add_child_to_list (FileSpec const & new_config, boost::ptr_list<T> & list)
 352 {
 353         for (typename boost::ptr_list<T>::iterator it = list.begin(); it != list.end(); ++it) {
 354                 if (*it == new_config) {
 355                         it->add_child (new_config);
 356                         return;
 357                 }
 358         }
 359
 360         list.push_back (new T (parent, new_config, max_frames_out));
 361         converter->add_output (list.back().sink ());
 362 }
 363
 364 bool
 365 ExportGraphBuilder::SRC::operator== (FileSpec const & other_config) const
 366 {
 367         return config.format->sample_rate() == other_config.format->sample_rate();
 368 }
 369
 370 /* SilenceHandler */
 371 ExportGraphBuilder::SilenceHandler::SilenceHandler (ExportGraphBuilder & parent, FileSpec const & new_config, nframes_t max_frames)
 372   : parent (parent)
 373 {
 374         config = new_config;
 375         max_frames_in = max_frames;
 376         nframes_t sample_rate = parent.session.nominal_frame_rate();
 377
 378         silence_trimmer.reset (new SilenceTrimmer<Sample>(max_frames_in));
 379         silence_trimmer->set_trim_beginning (config.format->trim_beginning());
 380         silence_trimmer->set_trim_end (config.format->trim_end());
 381         silence_trimmer->add_silence_to_beginning (config.format->silence_beginning(sample_rate));
 382         silence_trimmer->add_silence_to_end (config.format->silence_end(sample_rate));
 383
 384         add_child (new_config);
 385 }
 386
 387 ExportGraphBuilder::FloatSinkPtr
 388 ExportGraphBuilder::SilenceHandler::sink ()
 389 {
 390         return silence_trimmer;
 391 }
 392
 393 void
 394 ExportGraphBuilder::SilenceHandler::add_child (FileSpec const & new_config)
 395 {
 396         for (boost::ptr_list<SRC>::iterator it = children.begin(); it != children.end(); ++it) {
 397                 if (*it == new_config) {
 398                         it->add_child (new_config);
 399                         return;
 400                 }
 401         }
 402
 403         children.push_back (new SRC (parent, new_config, max_frames_in));
 404         silence_trimmer->add_output (children.back().sink());
 405 }
 406
 407 bool
 408 ExportGraphBuilder::SilenceHandler::operator== (FileSpec const & other_config) const
 409 {
 410         ExportFormatSpecification & format = *config.format;
 411         ExportFormatSpecification & other_format = *other_config.format;
 412         return (format.trim_beginning() == other_format.trim_beginning()) &&
 413                (format.trim_end() == other_format.trim_end()) &&
 414                (format.silence_beginning() == other_format.silence_beginning()) &&
 415                (format.silence_end() == other_format.silence_end());
 416 }
 417
 418 /* ChannelConfig */
 419
 420 ExportGraphBuilder::ChannelConfig::ChannelConfig (ExportGraphBuilder & parent, FileSpec const & new_config, ChannelMap & channel_map)
 421   : parent (parent)
 422 {
 423         typedef ExportChannelConfiguration::ChannelList ChannelList;
 424
 425         config = new_config;
 426         max_frames = parent.session.engine().frames_per_cycle();
 427
 428         interleaver.reset (new Interleaver<Sample> ());
 429         interleaver->init (new_config.channel_config->get_n_chans(), max_frames);
 430
 431         ChannelList const & channel_list = config.channel_config->get_channels();
 432         unsigned chan = 0;
 433         for (ChannelList::const_iterator it = channel_list.begin(); it != channel_list.end(); ++it, ++chan) {
 434                 ChannelMap::iterator map_it = channel_map.find (*it);
 435                 if (map_it == channel_map.end()) {
 436                         std::pair<ChannelMap::iterator, bool> result_pair =
 437                                 channel_map.insert (std::make_pair (*it, IdentityVertexPtr (new IdentityVertex<Sample> ())));
 438                         assert (result_pair.second);
 439                         map_it = result_pair.first;
 440                 }
 441                 map_it->second->add_output (interleaver->input (chan));
 442         }
 443
 444         add_child (new_config);
 445 }
 446
 447 void
 448 ExportGraphBuilder::ChannelConfig::add_child (FileSpec const & new_config)
 449 {
 450         for (boost::ptr_list<SilenceHandler>::iterator it = children.begin(); it != children.end(); ++it) {
 451                 if (*it == new_config) {
 452                         it->add_child (new_config);
 453                         return;
 454                 }
 455         }
 456
 457         nframes_t max_frames_out = new_config.channel_config->get_n_chans() * max_frames;
 458         children.push_back (new SilenceHandler (parent, new_config, max_frames_out));
 459         interleaver->add_output (children.back().sink ());
 460 }
 461
 462 bool
 463 ExportGraphBuilder::ChannelConfig::operator== (FileSpec const & other_config) const
 464 {
 465         return config.channel_config == other_config.channel_config;
 466 }
 467
 468 } // namespace ARDOUR