comparison audioio/AudioGenerator.cpp @ 366:0876ea394902 warnfix_no_size_t

Remove size_t's, fix compiler warnings

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

 
     m_noteOffs.clear();
 }
 
 void
-AudioGenerator::setTargetChannelCount(size_t targetChannelCount)
+AudioGenerator::setTargetChannelCount(int targetChannelCount)
 {
     if (m_targetChannelCount == targetChannelCount) return;
 
 //    SVDEBUG << "AudioGenerator::setTargetChannelCount(" << targetChannelCount << ")" << endl;
 

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

 
     m_soloModelSet.clear();
     m_soloing = false;
 }
 
-size_t
-AudioGenerator::mixModel(Model *model, size_t startFrame, size_t frameCount,
-			 float **buffer, size_t fadeIn, size_t fadeOut)
+int
+AudioGenerator::mixModel(Model *model, int startFrame, int frameCount,
+			 float **buffer, int fadeIn, int 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;
 }
 
-size_t
+int
 AudioGenerator::mixDenseTimeValueModel(DenseTimeValueModel *dtvm,
-				       size_t startFrame, size_t frames,
+				       int startFrame, int frames,
 				       float **buffer, float gain, float pan,
-				       size_t fadeIn, size_t fadeOut)
+				       int fadeIn, int fadeOut)
 {
     static float **channelBuffer = 0;
-    static size_t  channelBufSiz = 0;
-    static size_t  channelBufCount = 0;
-
-    size_t totalFrames = frames + fadeIn/2 + fadeOut/2;
-
-    size_t modelChannels = dtvm->getChannelCount();
+    static int  channelBufSiz = 0;
+    static int  channelBufCount = 0;
+
+    int totalFrames = frames + fadeIn/2 + fadeOut/2;
+
+    int modelChannels = dtvm->getChannelCount();
 
     if (channelBufSiz < totalFrames || channelBufCount < modelChannels) {
 
-        for (size_t c = 0; c < channelBufCount; ++c) {
+        for (int c = 0; c < channelBufCount; ++c) {
             delete[] channelBuffer[c];
         }
 
 	delete[] channelBuffer;
         channelBuffer = new float *[modelChannels];
 
-        for (size_t c = 0; c < modelChannels; ++c) {
+        for (int c = 0; c < modelChannels; ++c) {
             channelBuffer[c] = new float[totalFrames];
         }
 
         channelBufCount = modelChannels;
 	channelBufSiz = totalFrames;
     }
 
-    size_t got = 0;
+    int got = 0;
 
     if (startFrame >= fadeIn/2) {
         got = dtvm->getData(0, modelChannels - 1,
                             startFrame - fadeIn/2,
                             frames + fadeOut/2 + fadeIn/2,
                             channelBuffer);
     } else {
-        size_t missing = fadeIn/2 - startFrame;
-
-        for (size_t c = 0; c < modelChannels; ++c) {
+        int missing = fadeIn/2 - startFrame;
+
+        for (int c = 0; c < modelChannels; ++c) {
             channelBuffer[c] += missing;
         }
 
         got = dtvm->getData(0, modelChannels - 1,
                             startFrame,
                             frames + fadeOut/2,
                             channelBuffer);
 
-        for (size_t c = 0; c < modelChannels; ++c) {
+        for (int c = 0; c < modelChannels; ++c) {
             channelBuffer[c] -= missing;
         }
 
         got += missing;
     }	    
 
-    for (size_t c = 0; c < m_targetChannelCount; ++c) {
-
-	size_t sourceChannel = (c % modelChannels);
+    for (int c = 0; c < m_targetChannelCount; ++c) {
+
+	int sourceChannel = (c % modelChannels);
 
 //	SVDEBUG << "mixing channel " << c << " from source channel " << sourceChannel << endl;
 
 	float channelGain = gain;
 	if (pan != 0.0) {

 	    } else {
 		if (pan < 0.0) channelGain *= pan + 1.0;
 	    }
 	}
 
-	for (size_t i = 0; i < fadeIn/2; ++i) {
+	for (int i = 0; i < fadeIn/2; ++i) {
 	    float *back = buffer[c];
 	    back -= fadeIn/2;
 	    back[i] += (channelGain * channelBuffer[sourceChannel][i] * i) / fadeIn;
 	}
 
-	for (size_t i = 0; i < frames + fadeOut/2; ++i) {
+	for (int i = 0; i < frames + fadeOut/2; ++i) {
 	    float mult = channelGain;
 	    if (i < fadeIn/2) {
 		mult = (mult * i) / fadeIn;
 	    }
 	    if (i > frames - fadeOut/2) {

     }
 
     return got;
 }
   
-size_t
+int
 AudioGenerator::mixClipModel(Model *model,
-                             size_t startFrame, size_t frames,
+                             int startFrame, int frames,
                              float **buffer, float gain, float pan)
 {
     ClipMixer *clipMixer = m_clipMixerMap[model];
     if (!clipMixer) return 0;
 
-    size_t blocks = frames / m_processingBlockSize;
+    int blocks = 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
 
-    size_t got = blocks * m_processingBlockSize;
+    int got = blocks * m_processingBlockSize;
 
 #ifdef DEBUG_AUDIO_GENERATOR
     cout << "mixModel [clip]: frames " << frames
 	      << ", blocks " << blocks << endl;
 #endif

 
     NoteOffSet &noteOffs = m_noteOffs[model];
 
     float **bufferIndexes = new float *[m_targetChannelCount];
 
-    for (size_t i = 0; i < blocks; ++i) {
-
-	size_t reqStart = startFrame + i * m_processingBlockSize;
+    for (int i = 0; i < blocks; ++i) {
+
+	int reqStart = startFrame + i * m_processingBlockSize;
 
         NoteList notes;
         NoteExportable *exportable = dynamic_cast<NoteExportable *>(model);
         if (exportable) {
-            notes = exportable->getNotes(reqStart,
-                                         reqStart + m_processingBlockSize);
+            notes = exportable->getNotesWithin(reqStart,
+                                               reqStart + m_processingBlockSize);
         }
 
         std::vector<ClipMixer::NoteStart> starts;
         std::vector<ClipMixer::NoteEnd> ends;
 
 	for (NoteList::const_iterator ni = notes.begin();
              ni != notes.end(); ++ni) {
 
-	    size_t noteFrame = ni->start;
+	    int noteFrame = ni->start;
 
 	    if (noteFrame < reqStart ||
 		noteFrame >= reqStart + m_processingBlockSize) continue;
 
 	    while (noteOffs.begin() != noteOffs.end() &&
 		   noteOffs.begin()->frame <= noteFrame) {
 
-                size_t eventFrame = noteOffs.begin()->frame;
+                int eventFrame = noteOffs.begin()->frame;
                 if (eventFrame < reqStart) eventFrame = reqStart;
 
                 off.frameOffset = eventFrame - reqStart;
                 off.frequency = noteOffs.begin()->frequency;
 

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

 
             ends.push_back(off);
             noteOffs.erase(noteOffs.begin());
 	}
 
-	for (size_t c = 0; c < m_targetChannelCount; ++c) {
+	for (int c = 0; c < m_targetChannelCount; ++c) {
             bufferIndexes[c] = buffer[c] + i * m_processingBlockSize;
         }
 
         clipMixer->mix(bufferIndexes, gain, starts, ends);
     }

     delete[] bufferIndexes;
 
     return got;
 }
 
-size_t
+int
 AudioGenerator::mixContinuousSynthModel(Model *model,
-                                        size_t startFrame,
-                                        size_t frames,
+                                        int startFrame,
+                                        int 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;
 
-    size_t blocks = frames / m_processingBlockSize;
+    int blocks = frames / m_processingBlockSize;
 
     //!!! todo: see comment in mixClipModel
 
-    size_t got = blocks * m_processingBlockSize;
+    int got = blocks * m_processingBlockSize;
 
 #ifdef DEBUG_AUDIO_GENERATOR
     cout << "mixModel [synth]: frames " << frames
 	      << ", blocks " << blocks << endl;
 #endif
     
     float **bufferIndexes = new float *[m_targetChannelCount];
 
-    for (size_t i = 0; i < blocks; ++i) {
-
-	size_t reqStart = startFrame + i * m_processingBlockSize;
-
-	for (size_t c = 0; c < m_targetChannelCount; ++c) {
+    for (int i = 0; i < blocks; ++i) {
+
+	int reqStart = startFrame + i * m_processingBlockSize;
+
+	for (int c = 0; c < m_targetChannelCount; ++c) {
             bufferIndexes[c] = buffer[c] + i * m_processingBlockSize;
         }
 
         SparseTimeValueModel::PointList points = 
             stvm->getPoints(reqStart, reqStart + m_processingBlockSize);