comparison data/model/FFTModel.cpp @ 1744:b92bdcd4954b by-id

Update FFT model to ById

 using namespace std;
 
 static HitCount inSmallCache("FFTModel: Small FFT cache");
 static HitCount inSourceCache("FFTModel: Source data cache");
 
-FFTModel::FFTModel(const DenseTimeValueModel *model,
+FFTModel::FFTModel(ModelId modelId,
                    int channel,
                    WindowType windowType,
                    int windowSize,
                    int windowIncrement,
                    int fftSize) :
-    m_model(model),
+    m_model(modelId),
     m_channel(channel),
     m_windowType(windowType),
     m_windowSize(windowSize),
     m_windowIncrement(windowIncrement),
     m_fftSize(fftSize),

         throw invalid_argument("FFTModel window size may not exceed FFT size");
     }
 
     m_fft.initFloat();
 
-    connect(model, SIGNAL(modelChanged()),
-            this, SIGNAL(modelChanged()));
-    connect(model, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
-            this, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)));
-    connect(model, SIGNAL(aboutToBeDeleted()),
-            this, SLOT(sourceModelAboutToBeDeleted()));
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    if (model) {
+        connect(model.get(), SIGNAL(modelChanged()),
+                this, SIGNAL(modelChanged()));
+        connect(model.get(), SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
+                this, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)));
+    }
 }
 
 FFTModel::~FFTModel()
 {
 }
 
-void
-FFTModel::sourceModelAboutToBeDeleted()
-{
-    if (m_model) {
-        SVDEBUG << "FFTModel[" << this << "]::sourceModelAboutToBeDeleted(" << m_model << ")" << endl;
-        m_model = nullptr;
-    }
+bool
+FFTModel::isOK() const
+{
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    return (model && model->isOK());
+}
+
+int
+FFTModel::getCompletion() const
+{
+    int c = 100;
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    if (model) {
+        if (model->isReady(&c)) return 100;
+    }
+    return c;
+}
+
+sv_samplerate_t
+FFTModel::getSampleRate() const
+{
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    if (model) return model->getSampleRate();
+    else return 0;
 }
 
 int
 FFTModel::getWidth() const
 {
-    if (!m_model) return 0;
-    return int((m_model->getEndFrame() - m_model->getStartFrame())
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    if (!model) return 0;
+    return int((model->getEndFrame() - model->getStartFrame())
                / m_windowIncrement) + 1;
 }
 
 int
 FFTModel::getHeight() const

 FFTModel::fvec
 FFTModel::getSourceDataUncached(pair<sv_frame_t, sv_frame_t> range) const
 {
     Profiler profiler("FFTModel::getSourceDataUncached");
 
-    if (!m_model) return {};
+    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
+    if (!model) return {};
     
     decltype(range.first) pfx = 0;
     if (range.first < 0) {
         pfx = -range.first;
         range = { 0, range.second };
     }
 
-    auto data = m_model->getData(m_channel,
-                                 range.first,
-                                 range.second - range.first);
+    auto data = model->getData(m_channel,
+                               range.first,
+                               range.second - range.first);
 
     if (data.empty()) {
         SVDEBUG << "NOTE: empty source data for range (" << range.first << ","
                 << range.second << ") (model end frame "
-                << m_model->getEndFrame() << ")" << endl;
+                << model->getEndFrame() << ")" << endl;
     }
     
     // don't return a partial frame
     data.resize(range.second - range.first, 0.f);
 

         vector<float> pad(pfx, 0.f);
         data.insert(data.begin(), pad.begin(), pad.end());
     }
     
     if (m_channel == -1) {
-        int channels = m_model->getChannelCount();
+        int channels = model->getChannelCount();
         if (channels > 1) {
             int n = int(data.size());
             float factor = 1.f / float(channels);
             // use mean instead of sum for fft model input
             for (int i = 0; i < n; ++i) {