comparison transform/RealTimeEffectModelTransformer.cpp @ 1740:fe3f7f8df3a3 by-id

More work on transformers

         SVCERR << "RealTimeEffectModelTransformer: No factory available for plugin id \""
                << pluginId << "\"" << endl;
         return;
     }
 
-    DenseTimeValueModel *input = getConformingInput();
-    if (!input) return;
+    auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+    if (!input) {
+        SVCERR << "RealTimeEffectModelTransformer: Input is absent or of wrong type" << endl;
+        return;
+    }
 
     m_plugin = factory->instantiatePlugin(pluginId, 0, 0,
                                           input->getSampleRate(),
                                           transform.getBlockSize(),
                                           input->getChannelCount());

         int outputChannels = (int)m_plugin->getAudioOutputCount();
         if (outputChannels > input->getChannelCount()) {
             outputChannels = input->getChannelCount();
         }
 
-        WritableWaveFileModel *model = new WritableWaveFileModel
+        auto model = std::make_shared<WritableWaveFileModel>
             (input->getSampleRate(), outputChannels);
 
-        m_outputs.push_back(model);
+        ModelById::add(model);
+        m_outputs.push_back(model->getId());
 
     } else {
         
-        SparseTimeValueModel *model = new SparseTimeValueModel
-            (input->getSampleRate(), transform.getBlockSize(), 0.0, 0.0, false);
-
+        auto model = std::make_shared<SparseTimeValueModel>
+            (input->getSampleRate(), transform.getBlockSize(),
+             0.0, 0.0, false);
         if (m_units != "") model->setScaleUnits(m_units);
 
-        m_outputs.push_back(model);
+        ModelById::add(model);
+        m_outputs.push_back(model->getId());
     }
 }
 
 RealTimeEffectModelTransformer::~RealTimeEffectModelTransformer()
 {
     delete m_plugin;
 }
 
-DenseTimeValueModel *
-RealTimeEffectModelTransformer::getConformingInput()
-{
-    DenseTimeValueModel *dtvm =
-        dynamic_cast<DenseTimeValueModel *>(getInputModel());
-    if (!dtvm) {
-        SVDEBUG << "RealTimeEffectModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
-    }
-    return dtvm;
-}
-
 void
 RealTimeEffectModelTransformer::run()
 {
-    DenseTimeValueModel *input = getConformingInput();
-    if (!input) return;
-
-    while (!input->isReady() && !m_abandoned) {
-        SVDEBUG << "RealTimeEffectModelTransformer::run: Waiting for input model to be ready..." << endl;
-        usleep(500000);
-    }
-    if (m_abandoned) {
-        return;
-    }
     if (m_outputs.empty()) {
-        return;
-    }
-    
-    SparseTimeValueModel *stvm =
-        dynamic_cast<SparseTimeValueModel *>(m_outputs[0]);
-    WritableWaveFileModel *wwfm =
-        dynamic_cast<WritableWaveFileModel *>(m_outputs[0]);
+        abandon();
+        return;
+    }
+
+    bool ready = false;
+    while (!ready && !m_abandoned) {
+        { // scope so as to release input shared_ptr before sleeping
+            auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+            if (!input) {
+                abandon();
+                return;
+            }
+            ready = input->isReady();
+        }
+        if (!ready) {
+            SVDEBUG << "RealTimeEffectModelTransformer::run: Waiting for input model to be ready..." << endl;
+            usleep(500000);
+        }
+    }
+    if (m_abandoned) return;
+
+    auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+    if (!input) {
+        abandon();
+        return;
+    }
+
+    auto stvm = ModelById::getAs<SparseTimeValueModel>(m_outputs[0]);
+    auto wwfm = ModelById::getAs<WritableWaveFileModel>(m_outputs[0]);
 
     if (!stvm && !wwfm) {
         return;
     }
 

 
     sv_frame_t blockSize = m_plugin->getBufferSize();
 
     float **inbufs = m_plugin->getAudioInputBuffers();
 
-    sv_frame_t startFrame = m_input.getModel()->getStartFrame();
-    sv_frame_t endFrame = m_input.getModel()->getEndFrame();
+    sv_frame_t startFrame = input->getStartFrame();
+    sv_frame_t endFrame = input->getEndFrame();
 
     Transform transform = m_transforms[0];
     
     RealTime contextStartRT = transform.getStartTime();
     RealTime contextDurationRT = transform.getDuration();

                         inbufs[ch][i] = inbufs[ch % channelCount][i];
                     }
                 }
             }
         }
-
-/*
-        cerr << "Input for plugin: " << m_plugin->getAudioInputCount() << " channels "<< endl;
-
-        for (int ch = 0; ch < m_plugin->getAudioInputCount(); ++ch) {
-            cerr << "Input channel " << ch << endl;
-            for (int i = 0; i < 100; ++i) {
-                cerr << inbufs[ch][i] << " ";
-                if (isnan(inbufs[ch][i])) {
-                    cerr << "\n\nWARNING: NaN in audio input" << endl;
-                }
-            }
-        }
-*/
 
         m_plugin->run(RealTime::frame2RealTime(blockFrame, sampleRate));
 
         if (stvm) {