comparison audioio/AudioGenerator.cpp @ 450:d9d132c0e240 alignment_view

Merge from default branch

 #include <cmath>
 
 #include <QDir>
 #include <QFile>
 
-const int
+const sv_frame_t
 AudioGenerator::m_processingBlockSize = 1024;
 
 QString
 AudioGenerator::m_sampleDir = "";
 

 	    m_sourceSampleRate = model->getSampleRate();
 	    return true;
 	}
     }
 
+    const Playable *playable = model;
+    if (!playable || !playable->canPlay()) return 0;
+
+    PlayParameters *parameters =
+	PlayParameterRepository::getInstance()->getPlayParameters(playable);
+
+    bool willPlay = !parameters->isPlayMuted();
+    
     if (usesClipMixer(model)) {
         ClipMixer *mixer = makeClipMixerFor(model);
         if (mixer) {
             QMutexLocker locker(&m_mutex);
             m_clipMixerMap[model] = mixer;
-            return true;
+            return willPlay;
         }
     }
 
     if (usesContinuousSynth(model)) {
         ContinuousSynth *synth = makeSynthFor(model);
         if (synth) {
             QMutexLocker locker(&m_mutex);
             m_continuousSynthMap[model] = synth;
-            return true;
+            return willPlay;
         }
     }
 
     return false;
 }

 	PlayParameterRepository::getInstance()->getPlayParameters(playable);
     if (parameters) {
         clipId = parameters->getPlayClipId();
     }
 
+#ifdef DEBUG_AUDIO_GENERATOR
     std::cerr << "AudioGenerator::makeClipMixerFor(" << model << "): sample id = " << clipId << std::endl;
+#endif
 
     if (clipId == "") {
         SVDEBUG << "AudioGenerator::makeClipMixerFor(" << model << "): no sample, skipping" << endl;
         return 0;
     }
 
     ClipMixer *mixer = new ClipMixer(m_targetChannelCount,
                                      m_sourceSampleRate,
                                      m_processingBlockSize);
 
-    float clipF0 = Pitch::getFrequencyForPitch(60, 0, 440.0f); // required
+    double clipF0 = Pitch::getFrequencyForPitch(60, 0, 440.0); // required
 
     QString clipPath = QString("%1/%2.wav").arg(m_sampleDir).arg(clipId);
 
-    float level = wantsQuieterClips(model) ? 0.5 : 1.0;
+    double level = wantsQuieterClips(model) ? 0.5 : 1.0;
     if (!mixer->loadClipData(clipPath, clipF0, level)) {
         delete mixer;
         return 0;
     }
 
+#ifdef DEBUG_AUDIO_GENERATOR
     std::cerr << "AudioGenerator::makeClipMixerFor(" << model << "): loaded clip " << clipId << std::endl;
+#endif
 
     return mixer;
 }
 
 ContinuousSynth *

     ContinuousSynth *synth = new ContinuousSynth(m_targetChannelCount,
                                                  m_sourceSampleRate,
                                                  m_processingBlockSize,
                                                  m_waveType);
 
+#ifdef DEBUG_AUDIO_GENERATOR
     std::cerr << "AudioGenerator::makeSynthFor(" << model << "): created synth" << std::endl;
+#endif
 
     return synth;
 }
 
 void

 void
 AudioGenerator::reset()
 {
     QMutexLocker locker(&m_mutex);
 
+#ifdef DEBUG_AUDIO_GENERATOR
     cerr << "AudioGenerator::reset()" << endl;
+#endif
 
     for (ClipMixerMap::iterator i = m_clipMixerMap.begin(); i != m_clipMixerMap.end(); ++i) {
 	if (i->second) {
 	    i->second->reset();
 	}

     for (ClipMixerMap::iterator i = m_clipMixerMap.begin(); i != m_clipMixerMap.end(); ++i) {
 	if (i->second) i->second->setChannelCount(targetChannelCount);
     }
 }
 
-int
+sv_frame_t
 AudioGenerator::getBlockSize() const
 {
     return m_processingBlockSize;
 }
 

 
     m_soloModelSet.clear();
     m_soloing = false;
 }
 
-int
-AudioGenerator::mixModel(Model *model, int startFrame, int frameCount,
-			 float **buffer, int fadeIn, int fadeOut)
+sv_frame_t
+AudioGenerator::mixModel(Model *model, sv_frame_t startFrame, sv_frame_t frameCount,
+			 float **buffer, sv_frame_t fadeIn, sv_frame_t fadeOut)
 {
     if (m_sourceSampleRate == 0) {
 	cerr << "WARNING: AudioGenerator::mixModel: No base source sample rate available" << endl;
 	return frameCount;
     }

     std::cerr << "AudioGenerator::mixModel: WARNING: Model " << model << " of type " << model->getTypeName() << " is marked as playable, but I have no mechanism to play it" << std::endl;
 
     return frameCount;
 }
 
-int
+sv_frame_t
 AudioGenerator::mixDenseTimeValueModel(DenseTimeValueModel *dtvm,
-				       int startFrame, int frames,
+				       sv_frame_t startFrame, sv_frame_t frames,
 				       float **buffer, float gain, float pan,
-				       int fadeIn, int fadeOut)
-{
-    int maxFrames = frames + std::max(fadeIn, fadeOut);
+				       sv_frame_t fadeIn, sv_frame_t fadeOut)
+{
+    sv_frame_t maxFrames = frames + std::max(fadeIn, fadeOut);
 
     int modelChannels = dtvm->getChannelCount();
 
     if (m_channelBufSiz < maxFrames || m_channelBufCount < modelChannels) {
 

 
         m_channelBufCount = modelChannels;
 	m_channelBufSiz = maxFrames;
     }
 
-    int got = 0;
+    sv_frame_t got = 0;
 
     if (startFrame >= fadeIn/2) {
         got = dtvm->getData(0, modelChannels - 1,
                             startFrame - fadeIn/2,
                             frames + fadeOut/2 + fadeIn/2,
                             m_channelBuffer);
     } else {
-        int missing = fadeIn/2 - startFrame;
+        sv_frame_t missing = fadeIn/2 - startFrame;
 
         for (int c = 0; c < modelChannels; ++c) {
             m_channelBuffer[c] += missing;
         }
 

 //	SVDEBUG << "mixing channel " << c << " from source channel " << sourceChannel << endl;
 
 	float channelGain = gain;
 	if (pan != 0.0) {
 	    if (c == 0) {
-		if (pan > 0.0) channelGain *= 1.0 - pan;
+		if (pan > 0.0) channelGain *= 1.0f - pan;
 	    } else {
-		if (pan < 0.0) channelGain *= pan + 1.0;
+		if (pan < 0.0) channelGain *= pan + 1.0f;
 	    }
 	}
 
-	for (int i = 0; i < fadeIn/2; ++i) {
+	for (sv_frame_t i = 0; i < fadeIn/2; ++i) {
 	    float *back = buffer[c];
 	    back -= fadeIn/2;
-	    back[i] += (channelGain * m_channelBuffer[sourceChannel][i] * i) / fadeIn;
+	    back[i] +=
+                (channelGain * m_channelBuffer[sourceChannel][i] * float(i))
+                / float(fadeIn);
 	}
 
-	for (int i = 0; i < frames + fadeOut/2; ++i) {
+	for (sv_frame_t i = 0; i < frames + fadeOut/2; ++i) {
 	    float mult = channelGain;
 	    if (i < fadeIn/2) {
-		mult = (mult * i) / fadeIn;
+		mult = (mult * float(i)) / float(fadeIn);
 	    }
 	    if (i > frames - fadeOut/2) {
-		mult = (mult * ((frames + fadeOut/2) - i)) / fadeOut;
+		mult = (mult * float((frames + fadeOut/2) - i)) / float(fadeOut);
 	    }
             float val = m_channelBuffer[sourceChannel][i];
             if (i >= got) val = 0.f;
 	    buffer[c][i] += mult * val;
 	}
     }
 
     return got;
 }
   
-int
+sv_frame_t
 AudioGenerator::mixClipModel(Model *model,
-                             int startFrame, int frames,
+                             sv_frame_t startFrame, sv_frame_t frames,
                              float **buffer, float gain, float pan)
 {
     ClipMixer *clipMixer = m_clipMixerMap[model];
     if (!clipMixer) return 0;
 
-    int blocks = frames / m_processingBlockSize;
+    int blocks = int(frames / m_processingBlockSize);
     
     //!!! todo: the below -- it matters
 
     //!!! hang on -- the fact that the audio callback play source's
     //buffer is a multiple of the plugin's buffer size doesn't mean

     //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
 
-    int got = blocks * m_processingBlockSize;
-
-#ifdef DEBUG_AUDIO_GENERATOR
-    cout << "mixModel [clip]: frames " << frames
-	      << ", blocks " << blocks << endl;
+    sv_frame_t got = blocks * m_processingBlockSize;
+
+#ifdef DEBUG_AUDIO_GENERATOR
+    cout << "mixModel [clip]: start " << startFrame << ", frames " << frames
+         << ", blocks " << blocks << ", have " << m_noteOffs.size()
+         << " note-offs" << endl;
 #endif
 
     ClipMixer::NoteStart on;
     ClipMixer::NoteEnd off;
 

 
     float **bufferIndexes = new float *[m_targetChannelCount];
 
     for (int i = 0; i < blocks; ++i) {
 
-	int reqStart = startFrame + i * m_processingBlockSize;
+	sv_frame_t reqStart = startFrame + i * m_processingBlockSize;
 
         NoteList notes;
         NoteExportable *exportable = dynamic_cast<NoteExportable *>(model);
         if (exportable) {
             notes = exportable->getNotesWithin(reqStart,

         std::vector<ClipMixer::NoteEnd> ends;
 
 	for (NoteList::const_iterator ni = notes.begin();
              ni != notes.end(); ++ni) {
 
-	    int noteFrame = ni->start;
+	    sv_frame_t noteFrame = ni->start;
 
 	    if (noteFrame < reqStart ||
 		noteFrame >= reqStart + m_processingBlockSize) continue;
 
 	    while (noteOffs.begin() != noteOffs.end() &&
 		   noteOffs.begin()->frame <= noteFrame) {
 
-                int eventFrame = noteOffs.begin()->frame;
+                sv_frame_t eventFrame = noteOffs.begin()->frame;
                 if (eventFrame < reqStart) eventFrame = reqStart;
 
                 off.frameOffset = eventFrame - reqStart;
                 off.frequency = noteOffs.begin()->frequency;
 

 		noteOffs.erase(noteOffs.begin());
 	    }
 
             on.frameOffset = noteFrame - reqStart;
             on.frequency = ni->getFrequency();
-            on.level = float(ni->velocity) / 127.0;
+            on.level = float(ni->velocity) / 127.0f;
             on.pan = pan;
 
 #ifdef DEBUG_AUDIO_GENERATOR
 	    cout << "mixModel [clip]: adding note at frame " << noteFrame << ", frame offset " << on.frameOffset << " frequency " << on.frequency << ", level " << on.level << endl;
 #endif

 	}
 
 	while (noteOffs.begin() != noteOffs.end() &&
 	       noteOffs.begin()->frame <= reqStart + m_processingBlockSize) {
 
-            int eventFrame = noteOffs.begin()->frame;
+            sv_frame_t eventFrame = noteOffs.begin()->frame;
             if (eventFrame < reqStart) eventFrame = reqStart;
 
             off.frameOffset = eventFrame - reqStart;
             off.frequency = noteOffs.begin()->frequency;
 

     delete[] bufferIndexes;
 
     return got;
 }
 
-int
+sv_frame_t
 AudioGenerator::mixContinuousSynthModel(Model *model,
-                                        int startFrame,
-                                        int frames,
+                                        sv_frame_t startFrame,
+                                        sv_frame_t frames,
                                         float **buffer,
                                         float gain, 
                                         float pan)
 {
     ContinuousSynth *synth = m_continuousSynthMap[model];

 
     // only type we support here at the moment
     SparseTimeValueModel *stvm = qobject_cast<SparseTimeValueModel *>(model);
     if (stvm->getScaleUnits() != "Hz") return 0;
 
-    int blocks = frames / m_processingBlockSize;
+    int blocks = int(frames / m_processingBlockSize);
 
     //!!! todo: see comment in mixClipModel
 
-    int got = blocks * m_processingBlockSize;
+    sv_frame_t got = blocks * m_processingBlockSize;
 
 #ifdef DEBUG_AUDIO_GENERATOR
     cout << "mixModel [synth]: frames " << frames
 	      << ", blocks " << blocks << endl;
 #endif
     
     float **bufferIndexes = new float *[m_targetChannelCount];
 
     for (int i = 0; i < blocks; ++i) {
 
-	int reqStart = startFrame + i * m_processingBlockSize;
+	sv_frame_t reqStart = startFrame + i * m_processingBlockSize;
 
 	for (int c = 0; c < m_targetChannelCount; ++c) {
             bufferIndexes[c] = buffer[c] + i * m_processingBlockSize;
         }