comparison audioio/AudioGenerator.cpp @ 305:9716c75499ef tonioni

Toward using a sample mixer (with arbitrary frequency target) instead of dssi player plugin

 #include "data/model/FlexiNoteModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/NoteData.h"
 
-#include "plugin/RealTimePluginFactory.h"
-#include "plugin/RealTimePluginInstance.h"
-#include "plugin/PluginIdentifier.h"
-#include "plugin/PluginXml.h"
-#include "plugin/api/alsa/seq_event.h"
-
 #include <iostream>
 #include <cmath>
 
 #include <QDir>
 #include <QFile>
 
 const size_t
-AudioGenerator::m_pluginBlockSize = 2048;
+AudioGenerator::m_processingBlockSize = 2048;
 
 QString
 AudioGenerator::m_sampleDir = "";
 
 //#define DEBUG_AUDIO_GENERATOR 1

     m_soloing(false)
 {
     initialiseSampleDir();
 
     connect(PlayParameterRepository::getInstance(),
-            SIGNAL(playPluginIdChanged(const Playable *, QString)),
+            SIGNAL(playSampleIdChanged(const Playable *, QString)),
             this,
-            SLOT(playPluginIdChanged(const Playable *, QString)));
-
-    connect(PlayParameterRepository::getInstance(),
-            SIGNAL(playPluginConfigurationChanged(const Playable *, QString)),
-            this,
-            SLOT(playPluginConfigurationChanged(const Playable *, QString)));
+            SLOT(playSampleIdChanged(const Playable *, QString)));
 }
 
 AudioGenerator::~AudioGenerator()
 {
 #ifdef DEBUG_AUDIO_GENERATOR

 	if (dtvm) {
 	    m_sourceSampleRate = model->getSampleRate();
 	    return true;
 	}
     }
-
+/*!!!
     RealTimePluginInstance *plugin = loadPluginFor(model);
     if (plugin) {
         QMutexLocker locker(&m_mutex);
         m_synthMap[model] = plugin;
         return true;
     }
-
+*/
     return false;
 }
 
 void
-AudioGenerator::playPluginIdChanged(const Playable *playable, QString)
+AudioGenerator::playSampleIdChanged(const Playable *playable, QString)
 {
     const Model *model = dynamic_cast<const Model *>(playable);
     if (!model) {
-        cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
+        cerr << "WARNING: AudioGenerator::playSampleIdChanged: playable "
                   << playable << " is not a supported model type"
                   << endl;
         return;
     }
 
     if (m_synthMap.find(model) == m_synthMap.end()) return;
-    
+/*!!!    
     RealTimePluginInstance *plugin = loadPluginFor(model);
     if (plugin) {
         QMutexLocker locker(&m_mutex);
         delete m_synthMap[model];
         m_synthMap[model] = plugin;
     }
-}
-
+*/
+}
+/*!!!
 void
 AudioGenerator::playPluginConfigurationChanged(const Playable *playable,
                                                QString configurationXml)
 {
 //    SVDEBUG << "AudioGenerator::playPluginConfigurationChanged" << endl;
 
     const Model *model = dynamic_cast<const Model *>(playable);
     if (!model) {
-        cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
+        cerr << "WARNING: AudioGenerator::playSampleIdChanged: playable "
                   << playable << " is not a supported model type"
                   << endl;
         return;
     }
 

     if (!playable || !playable->canPlay()) return 0;
 
     PlayParameters *parameters =
 	PlayParameterRepository::getInstance()->getPlayParameters(playable);
     if (parameters) {
-        pluginId = parameters->getPlayPluginId();
+        pluginId = parameters->getPlaySampleId();
         configurationXml = parameters->getPlayPluginConfiguration();
     }
 
     std::cerr << "AudioGenerator::loadPluginFor(" << model << "): id = " << pluginId << std::endl;
 

     }
 
     configurationXml = PluginXml(plugin).toXmlString();
 
     if (parameters) {
-        parameters->setPlayPluginId(pluginId);
+        parameters->setPlaySampleId(pluginId);
         parameters->setPlayPluginConfiguration(configurationXml);
     }
 
     return plugin;
 }

 	return 0;
     }
 	
     RealTimePluginInstance *instance =
 	factory->instantiatePlugin
-	(pluginId, 0, 0, m_sourceSampleRate, m_pluginBlockSize, m_targetChannelCount);
+	(pluginId, 0, 0, m_sourceSampleRate, m_processingBlockSize, m_targetChannelCount);
 
     if (!instance) {
 	cerr << "Failed to instantiate plugin " << pluginId << endl;
         return 0;
     }

     }
     instance->setIdealChannelCount(m_targetChannelCount); // reset!
 
     return instance;
 }
-
+*/
 void
 AudioGenerator::removeModel(Model *model)
 {
     SparseOneDimensionalModel *sodm =
 	dynamic_cast<SparseOneDimensionalModel *>(model);

 
     QMutexLocker locker(&m_mutex);
 
     if (m_synthMap.find(sodm) == m_synthMap.end()) return;
 
-    RealTimePluginInstance *instance = m_synthMap[sodm];
-    m_synthMap.erase(sodm);
+//!!!    RealTimePluginInstance *instance = m_synthMap[sodm];
+//    m_synthMap.erase(sodm);
     delete instance;
 }
 
 void
 AudioGenerator::clearModels()
 {
     QMutexLocker locker(&m_mutex);
+/*!!!
     while (!m_synthMap.empty()) {
 	RealTimePluginInstance *instance = m_synthMap.begin()->second;
 	m_synthMap.erase(m_synthMap.begin());
 	delete instance;
     }
+*/
 }    
 
 void
 AudioGenerator::reset()
 {
     QMutexLocker locker(&m_mutex);
+/*!!!
     for (PluginMap::iterator i = m_synthMap.begin(); i != m_synthMap.end(); ++i) {
 	if (i->second) {
 	    i->second->silence();
 	    i->second->discardEvents();
 	}
     }
+*/
 
     m_noteOffs.clear();
 }
 
 void

 //    SVDEBUG << "AudioGenerator::setTargetChannelCount(" << targetChannelCount << ")" << endl;
 
     QMutexLocker locker(&m_mutex);
     m_targetChannelCount = targetChannelCount;
 
+/*!!!
     for (PluginMap::iterator i = m_synthMap.begin(); i != m_synthMap.end(); ++i) {
 	if (i->second) i->second->setIdealChannelCount(targetChannelCount);
     }
+*/
 }
 
 size_t
 AudioGenerator::getBlockSize() const
 {
-    return m_pluginBlockSize;
+    return m_processingBlockSize;
 }
 
 void
 AudioGenerator::setSoloModelSet(std::set<Model *> s)
 {

 {
     RealTimePluginInstance *plugin = m_synthMap[model];
     if (!plugin) return 0;
 
     size_t latency = plugin->getLatency();
-    size_t blocks = frames / m_pluginBlockSize;
+    size_t blocks = frames / m_processingBlockSize;
     
     //!!! hang on -- the fact that the audio callback play source's
     //buffer is a multiple of the plugin's buffer size doesn't mean
     //that we always get called for a multiple of it here (because it
     //also depends on the JACK block size).  how should we ensure that

     //always have a multiple of the plugin buffer size?  I guess this
     //class has to be queryable for the plugin buffer size & the
     //callback play source has to use that as a multiple for all the
     //calls to mixModel
 
-    size_t got = blocks * m_pluginBlockSize;
+    size_t got = blocks * m_processingBlockSize;
 
 #ifdef DEBUG_AUDIO_GENERATOR
     cout << "mixModel [synthetic note]: frames " << frames
 	      << ", blocks " << blocks << endl;
 #endif

     
     NoteOffSet &noteOffs = m_noteOffs[model];
 
     for (size_t i = 0; i < blocks; ++i) {
 
-	size_t reqStart = startFrame + i * m_pluginBlockSize;
+	size_t reqStart = startFrame + i * m_processingBlockSize;
 
         NoteList notes;
         NoteExportable *exportable = dynamic_cast<NoteExportable *>(model);
         if (exportable) {
             notes = exportable->getNotes(reqStart + latency,
-                                         reqStart + latency + m_pluginBlockSize);
+                                         reqStart + latency + m_processingBlockSize);
         }
 
         Vamp::RealTime blockTime = Vamp::RealTime::frame2RealTime
-	    (startFrame + i * m_pluginBlockSize, m_sourceSampleRate);
+	    (startFrame + i * m_processingBlockSize, m_sourceSampleRate);
 
 	for (NoteList::const_iterator ni = notes.begin();
              ni != notes.end(); ++ni) {
 
 	    size_t noteFrame = ni->start;
 
 	    if (noteFrame >= latency) noteFrame -= latency;
 
 	    if (noteFrame < reqStart ||
-		noteFrame >= reqStart + m_pluginBlockSize) continue;
+		noteFrame >= reqStart + m_processingBlockSize) continue;
 
 	    while (noteOffs.begin() != noteOffs.end() &&
 		   noteOffs.begin()->frame <= noteFrame) {
 
                 Vamp::RealTime eventTime = Vamp::RealTime::frame2RealTime

             onEv.data.note.velocity = ni->velocity;
 
 	    plugin->sendEvent(eventTime, &onEv);
 
 #ifdef DEBUG_AUDIO_GENERATOR
-	    cout << "mixModel [synthetic]: note at frame " << noteFrame << ", block start " << (startFrame + i * m_pluginBlockSize) << ", resulting time " << eventTime << endl;
+	    cout << "mixModel [synthetic]: note at frame " << noteFrame << ", block start " << (startFrame + i * m_processingBlockSize) << ", resulting time " << eventTime << endl;
 #endif
 	    
 	    noteOffs.insert
                 (NoteOff(onEv.data.note.note, noteFrame + ni->duration));
 	}
 
 	while (noteOffs.begin() != noteOffs.end() &&
 	       noteOffs.begin()->frame <=
-	       startFrame + i * m_pluginBlockSize + m_pluginBlockSize) {
+	       startFrame + i * m_processingBlockSize + m_processingBlockSize) {
 
             Vamp::RealTime eventTime = Vamp::RealTime::frame2RealTime
 		(noteOffs.begin()->frame, m_sourceSampleRate);
 
 	    offEv.data.note.note = noteOffs.begin()->pitch;

 	plugin->run(blockTime);
 	float **outs = plugin->getAudioOutputBuffers();
 
 	for (size_t c = 0; c < m_targetChannelCount; ++c) {
 #ifdef DEBUG_AUDIO_GENERATOR
-	    cout << "mixModel [synthetic]: adding " << m_pluginBlockSize << " samples from plugin output " << c << endl;
+	    cout << "mixModel [synthetic]: adding " << m_processingBlockSize << " samples from plugin output " << c << endl;
 #endif
 
 	    size_t sourceChannel = (c % plugin->getAudioOutputCount());
 
 	    float channelGain = gain;

 		} else {
 		    if (pan < 0.0) channelGain *= pan + 1.0;
 		}
 	    }
 
-	    for (size_t j = 0; j < m_pluginBlockSize; ++j) {
-		buffer[c][i * m_pluginBlockSize + j] +=
+	    for (size_t j = 0; j < m_processingBlockSize; ++j) {
+		buffer[c][i * m_processingBlockSize + j] +=
 		    channelGain * outs[sourceChannel][j];
 	    }
 	}
     }