comparison audioio/AudioGenerator.cpp @ 295:14b1768e5406 tonioni

Merge from default branch

     if (m_sampleDir != "") return;
 
     try {
         m_sampleDir = TempDirectory::getInstance()->getSubDirectoryPath("samples");
     } catch (DirectoryCreationFailed f) {
-        std::cerr << "WARNING: AudioGenerator::initialiseSampleDir:"
+        cerr << "WARNING: AudioGenerator::initialiseSampleDir:"
                   << " Failed to create temporary sample directory"
-                  << std::endl;
+                  << endl;
         m_sampleDir = "";
         return;
     }
 
     QDir sampleResourceDir(":/samples", "*.wav");

         QString fileName(sampleResourceDir[i]);
         QFile file(sampleResourceDir.filePath(fileName));
         QString target = QDir(m_sampleDir).filePath(fileName);
 
         if (!file.copy(target)) {
-            std::cerr << "WARNING: AudioGenerator::getSampleDir: "
-                      << "Unable to copy " << fileName.toStdString()
+            cerr << "WARNING: AudioGenerator::getSampleDir: "
+                      << "Unable to copy " << fileName
                       << " into temporary directory \""
-                      << m_sampleDir << "\"" << std::endl;
+                      << m_sampleDir << "\"" << endl;
         } else {
             QFile tf(target);
             tf.setPermissions(tf.permissions() |
                               QFile::WriteOwner |
                               QFile::WriteUser);

 void
 AudioGenerator::playPluginIdChanged(const Playable *playable, QString)
 {
     const Model *model = dynamic_cast<const Model *>(playable);
     if (!model) {
-        std::cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
+        cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
                   << playable << " is not a supported model type"
-                  << std::endl;
+                  << endl;
         return;
     }
 
     if (m_synthMap.find(model) == m_synthMap.end()) return;
     

 {
 //    SVDEBUG << "AudioGenerator::playPluginConfigurationChanged" << endl;
 
     const Model *model = dynamic_cast<const Model *>(playable);
     if (!model) {
-        std::cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
+        cerr << "WARNING: AudioGenerator::playPluginIdChanged: playable "
                   << playable << " is not a supported model type"
-                  << std::endl;
+                  << endl;
         return;
     }
 
     if (m_synthMap.find(model) == m_synthMap.end()) {
         SVDEBUG << "AudioGenerator::playPluginConfigurationChanged: We don't know about this plugin" << endl;

 {
     RealTimePluginFactory *factory =
 	RealTimePluginFactory::instanceFor(pluginId);
     
     if (!factory) {
-	std::cerr << "Failed to get plugin factory" << std::endl;
+	cerr << "Failed to get plugin factory" << endl;
 	return 0;
     }
 	
     RealTimePluginInstance *instance =
 	factory->instantiatePlugin
 	(pluginId, 0, 0, m_sourceSampleRate, m_pluginBlockSize, m_targetChannelCount);
 
     if (!instance) {
-	std::cerr << "Failed to instantiate plugin " << pluginId << std::endl;
+	cerr << "Failed to instantiate plugin " << pluginId << endl;
         return 0;
     }
 
     setSampleDir(instance);
 
     for (unsigned int i = 0; i < instance->getParameterCount(); ++i) {
         instance->setParameterValue(i, instance->getParameterDefault(i));
     }
     std::string defaultProgram = instance->getProgram(0, 0);
     if (defaultProgram != "") {
-        std::cerr << "first selecting default program " << defaultProgram << std::endl;
+        cerr << "first selecting default program " << defaultProgram << endl;
         instance->selectProgram(defaultProgram);
     }
     if (program != "") {
-        std::cerr << "now selecting desired program " << program << std::endl;
+        cerr << "now selecting desired program " << program << endl;
         instance->selectProgram(program.toStdString());
     }
     instance->setIdealChannelCount(m_targetChannelCount); // reset!
 
     return instance;

 size_t
 AudioGenerator::mixModel(Model *model, size_t startFrame, size_t frameCount,
 			 float **buffer, size_t fadeIn, size_t fadeOut)
 {
     if (m_sourceSampleRate == 0) {
-	std::cerr << "WARNING: AudioGenerator::mixModel: No base source sample rate available" << std::endl;
+	cerr << "WARNING: AudioGenerator::mixModel: No base source sample rate available" << endl;
 	return frameCount;
     }
 
     QMutexLocker locker(&m_mutex);
 

     if (!parameters) return frameCount;
 
     bool playing = !parameters->isPlayMuted();
     if (!playing) {
 #ifdef DEBUG_AUDIO_GENERATOR
-        std::cout << "AudioGenerator::mixModel(" << model << "): muted" << std::endl;
+        cout << "AudioGenerator::mixModel(" << model << "): muted" << endl;
 #endif
         return frameCount;
     }
 
     if (m_soloing) {
         if (m_soloModelSet.find(model) == m_soloModelSet.end()) {
 #ifdef DEBUG_AUDIO_GENERATOR
-            std::cout << "AudioGenerator::mixModel(" << model << "): not one of the solo'd models" << std::endl;
+            cout << "AudioGenerator::mixModel(" << model << "): not one of the solo'd models" << endl;
 #endif
             return frameCount;
         }
     }
 

     //calls to mixModel
 
     size_t got = blocks * m_pluginBlockSize;
 
 #ifdef DEBUG_AUDIO_GENERATOR
-    std::cout << "mixModel [synthetic note]: frames " << frames
-	      << ", blocks " << blocks << std::endl;
+    cout << "mixModel [synthetic note]: frames " << frames
+	      << ", blocks " << blocks << endl;
 #endif
 
     snd_seq_event_t onEv;
     onEv.type = SND_SEQ_EVENT_NOTEON;
     onEv.data.note.channel = 0;

 		    (noteOffs.begin()->frame, m_sourceSampleRate);
 
 		offEv.data.note.note = noteOffs.begin()->pitch;
 
 #ifdef DEBUG_AUDIO_GENERATOR
-		std::cerr << "mixModel [synthetic]: sending note-off event at time " << eventTime << " frame " << noteOffs.begin()->frame << " pitch " << noteOffs.begin()->pitch << std::endl;
+		cerr << "mixModel [synthetic]: sending note-off event at time " << eventTime << " frame " << noteOffs.begin()->frame << " pitch " << noteOffs.begin()->pitch << endl;
 #endif
 
 		plugin->sendEvent(eventTime, &offEv);
 		noteOffs.erase(noteOffs.begin());
 	    }

 	    
             if (ni->isMidiPitchQuantized) {
                 onEv.data.note.note = ni->midiPitch;
             } else {
 #ifdef DEBUG_AUDIO_GENERATOR
-                std::cerr << "mixModel [synthetic]: non-pitch-quantized notes are not supported [yet], quantizing" << std::endl;
+                cerr << "mixModel [synthetic]: non-pitch-quantized notes are not supported [yet], quantizing" << endl;
 #endif
                 onEv.data.note.note = Pitch::getPitchForFrequency(ni->frequency);
             }
 
             onEv.data.note.velocity = ni->velocity;
 
 	    plugin->sendEvent(eventTime, &onEv);
 
 #ifdef DEBUG_AUDIO_GENERATOR
-	    std::cout << "mixModel [synthetic]: note at frame " << noteFrame << ", block start " << (startFrame + i * m_pluginBlockSize) << ", resulting time " << eventTime << std::endl;
+	    cout << "mixModel [synthetic]: note at frame " << noteFrame << ", block start " << (startFrame + i * m_pluginBlockSize) << ", resulting time " << eventTime << endl;
 #endif
 	    
 	    noteOffs.insert
                 (NoteOff(onEv.data.note.note, noteFrame + ni->duration));
 	}

 		(noteOffs.begin()->frame, m_sourceSampleRate);
 
 	    offEv.data.note.note = noteOffs.begin()->pitch;
 
 #ifdef DEBUG_AUDIO_GENERATOR
-            std::cerr << "mixModel [synthetic]: sending leftover note-off event at time " << eventTime << " frame " << noteOffs.begin()->frame << " pitch " << noteOffs.begin()->pitch << std::endl;
+            cerr << "mixModel [synthetic]: sending leftover note-off event at time " << eventTime << " frame " << noteOffs.begin()->frame << " pitch " << noteOffs.begin()->pitch << endl;
 #endif
 
 	    plugin->sendEvent(eventTime, &offEv);
 	    noteOffs.erase(noteOffs.begin());
 	}

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