comparison vamp-sdk/hostext/PluginBufferingAdapter.cpp @ 134:c1dce0b033cb

* Permit '-' as well as the other characters in identifiers (existing plugins
  were already using this character, it's really the documentation that was
  at fault)
* Fix failure to return output descriptors properly from PluginBufferingAdapter
* Fix incorrect sample rate in output descriptors for certain sample types
  from PluginBufferingAdapter
* Fix incorrect timestamping on features returned from PluginBufferingAdapter
  (rounding error)

     size_t m_blockSize;
     size_t m_channels;
     vector<RingBuffer *> m_queue;
     float **m_buffers;
     float m_inputSampleRate;
-    RealTime m_timestamp;
+    long m_frame;
     bool m_unrun;
     mutable OutputList m_outputs;
     mutable std::map<int, bool> m_rewriteOutputTimes;
 		
-    void processBlock(FeatureSet& allFeatureSets, RealTime timestamp);
+    void processBlock(FeatureSet& allFeatureSets);
 };
 		
 PluginBufferingAdapter::PluginBufferingAdapter(Plugin *plugin) :
     PluginWrapper(plugin)
 {

     m_blockSize(0),
     m_channels(0), 
     m_queue(0),
     m_buffers(0),
     m_inputSampleRate(inputSampleRate),
-    m_timestamp(RealTime::zeroTime),
+    m_frame(0),
     m_unrun(true)
 {
     (void)getOutputDescriptors(); // set up m_outputs and m_rewriteOutputTimes
 }
 		

 {
     if (m_outputs.empty()) {
         m_outputs = m_plugin->getOutputDescriptors();
     }
 
-    PluginBufferingAdapter::OutputList outs;
+    PluginBufferingAdapter::OutputList outs = m_outputs;
 
     for (size_t i = 0; i < outs.size(); ++i) {
 
         switch (outs[i].sampleType) {
 
         case OutputDescriptor::OneSamplePerStep:
             outs[i].sampleType = OutputDescriptor::FixedSampleRate;
-            outs[i].sampleRate = 1.f / m_stepSize;
+            outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
             m_rewriteOutputTimes[i] = true;
             break;
             
         case OutputDescriptor::FixedSampleRate:
             if (outs[i].sampleRate == 0.f) {
-                outs[i].sampleRate = 1.f / m_stepSize;
+                outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
             }
             // We actually only need to rewrite output times for
             // features that don't have timestamps already, but we
             // can't tell from here whether our features will have
             // timestamps or not

 }
 
 void
 PluginBufferingAdapter::Impl::reset()
 {
-    m_timestamp = RealTime::zeroTime;
+    m_frame = 0;
     m_unrun = true;
 
     for (size_t i = 0; i < m_queue.size(); ++i) {
         m_queue[i]->reset();
     }

                                       RealTime timestamp)
 {
     FeatureSet allFeatureSets;
 
     if (m_unrun) {
-        m_timestamp = timestamp;
+        m_frame = RealTime::realTime2Frame(timestamp,
+                                           int(m_inputSampleRate + 0.5));
         m_unrun = false;
     }
 			
     // queue the new input
     

     }    
     
     // process as much as we can
 
     while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
-        processBlock(allFeatureSets, timestamp);
+        processBlock(allFeatureSets);
     }	
     
     return allFeatureSets;
 }
     

 {
     FeatureSet allFeatureSets;
     
     // process remaining samples in queue
     while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
-        processBlock(allFeatureSets, m_timestamp);
+        processBlock(allFeatureSets);
     }
     
     // pad any last samples remaining and process
     if (m_queue[0]->getReadSpace() > 0) {
         for (size_t i = 0; i < m_channels; ++i) {
             m_queue[i]->zero(m_blockSize - m_queue[i]->getReadSpace());
         }
-        processBlock(allFeatureSets, m_timestamp);
+        processBlock(allFeatureSets);
     }			
     
     // get remaining features			
 
     FeatureSet featureSet = m_plugin->getRemainingFeatures();

     
     return allFeatureSets;
 }
     
 void
-PluginBufferingAdapter::Impl::processBlock(FeatureSet& allFeatureSets,
-                                           RealTime timestamp)
+PluginBufferingAdapter::Impl::processBlock(FeatureSet& allFeatureSets)
 {
     for (size_t i = 0; i < m_channels; ++i) {
         m_queue[i]->peek(m_buffers[i], m_blockSize);
     }
 
-    FeatureSet featureSet = m_plugin->process(m_buffers, m_timestamp);
+    long frame = m_frame;
+    RealTime timestamp = RealTime::frame2RealTime
+        (frame, int(m_inputSampleRate + 0.5));
+
+    FeatureSet featureSet = m_plugin->process(m_buffers, timestamp);
     
     for (FeatureSet::iterator iter = featureSet.begin();
          iter != featureSet.end(); ++iter) {
 
         int outputNo = iter->first;
 
         if (m_rewriteOutputTimes[outputNo]) {
             
-            // Make sure the timestamp is always set
-	
             FeatureList featureList = iter->second;
 	
             for (size_t i = 0; i < featureList.size(); ++i) {
 
                 switch (m_outputs[outputNo].sampleType) {
 
                 case OutputDescriptor::OneSamplePerStep:
                     // use our internal timestamp, always
-                    featureList[i].timestamp = m_timestamp;
+                    featureList[i].timestamp = timestamp;
                     featureList[i].hasTimestamp = true;
                     break;
 
                 case OutputDescriptor::FixedSampleRate:
                     // use our internal timestamp if feature lacks one
                     if (!featureList[i].hasTimestamp) {
-                        featureList[i].timestamp = m_timestamp;
+                        featureList[i].timestamp = timestamp;
                         featureList[i].hasTimestamp = true;
                     }
                     break;
 
                 case OutputDescriptor::VariableSampleRate:

 
     for (size_t i = 0; i < m_channels; ++i) {
         m_queue[i]->skip(m_stepSize);
     }
     
-    // fake up the timestamp each time we step forward
-
-    long frame = RealTime::realTime2Frame(m_timestamp,
-                                          int(m_inputSampleRate + 0.5));
-    m_timestamp = RealTime::frame2RealTime(frame + m_stepSize,
-                                           int(m_inputSampleRate + 0.5));
+    // increment internal frame counter each time we step forward
+    m_frame += m_stepSize;
 }
 
 }
 	
 }