comparison audioio/AudioCallbackPlaySource.cpp @ 32:e3b32dc5180b

* Make resampler quality configurable
* Fall back to linear resampling when playing very fast
* Switch off transient detection in time stretcher when playing very very fast

 #include "AudioGenerator.h"
 
 #include "data/model/Model.h"
 #include "view/ViewManager.h"
 #include "base/PlayParameterRepository.h"
+#include "base/Preferences.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "PhaseVocoderTimeStretcher.h"
 
 #include <iostream>

     m_lastModelEndFrame(0),
     m_outputLeft(0.0),
     m_outputRight(0.0),
     m_timeStretcher(0),
     m_fillThread(0),
-    m_converter(0)
+    m_converter(0),
+    m_crapConverter(0),
+    m_resampleQuality(Preferences::getInstance()->getResampleQuality())
 {
     m_viewManager->setAudioPlaySource(this);
 
     connect(m_viewManager, SIGNAL(selectionChanged()),
 	    this, SLOT(selectionChanged()));

 	    this, SLOT(playSelectionModeChanged()));
 
     connect(PlayParameterRepository::getInstance(),
 	    SIGNAL(playParametersChanged(PlayParameters *)),
 	    this, SLOT(playParametersChanged(PlayParameters *)));
+
+    connect(Preferences::getInstance(),
+            SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
+            this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 }
 
 AudioCallbackPlaySource::~AudioCallbackPlaySource()
 {
     m_exiting = true;

     }
 
     if (buffersChanged || srChanged) {
 	if (m_converter) {
 	    src_delete(m_converter);
+            src_delete(m_crapConverter);
 	    m_converter = 0;
+            m_crapConverter = 0;
 	}
     }
 
     m_mutex.unlock();
 

     m_models.erase(model);
 
     if (m_models.empty()) {
 	if (m_converter) {
 	    src_delete(m_converter);
+            src_delete(m_crapConverter);
 	    m_converter = 0;
+            m_crapConverter = 0;
 	}
 	m_sourceSampleRate = 0;
     }
 
     size_t lastEnd = 0;

 
     m_models.clear();
 
     if (m_converter) {
 	src_delete(m_converter);
+        src_delete(m_crapConverter);
 	m_converter = 0;
+        m_crapConverter = 0;
     }
 
     m_lastModelEndFrame = 0;
 
     m_sourceSampleRate = 0;

 		RingBuffer<float> *rb = getReadRingBuffer(c);
 		if (rb) rb->reset();
 	    }
 	}
 	if (m_converter) src_reset(m_converter);
+        if (m_crapConverter) src_reset(m_crapConverter);
     } else {
 	if (m_converter) src_reset(m_converter);
+        if (m_crapConverter) src_reset(m_crapConverter);
 	m_readBufferFill = m_writeBufferFill = startFrame;
     }
     m_mutex.unlock();
 
     m_audioGenerator->reset();

 
 void
 AudioCallbackPlaySource::playParametersChanged(PlayParameters *params)
 {
     clearRingBuffers();
+}
+
+void
+AudioCallbackPlaySource::preferenceChanged(PropertyContainer::PropertyName n)
+{
+    if (n == "Resample Quality") {
+        setResampleQuality(Preferences::getInstance()->getResampleQuality());
+    }
 }
 
 void
 AudioCallbackPlaySource::setTargetBlockSize(size_t size)
 {

 
 void
 AudioCallbackPlaySource::setTargetSampleRate(size_t sr)
 {
     m_targetSampleRate = sr;
+    initialiseConverter();
+}
+
+void
+AudioCallbackPlaySource::initialiseConverter()
+{
+    m_mutex.lock();
+
+    if (m_converter) {
+        src_delete(m_converter);
+        src_delete(m_crapConverter);
+        m_converter = 0;
+        m_crapConverter = 0;
+    }
 
     if (getSourceSampleRate() != getTargetSampleRate()) {
 
 	int err = 0;
-	m_converter = src_new(SRC_SINC_BEST_QUALITY,
+
+	m_converter = src_new(m_resampleQuality == 2 ? SRC_SINC_BEST_QUALITY :
+                              m_resampleQuality == 1 ? SRC_SINC_MEDIUM_QUALITY :
+                              m_resampleQuality == 0 ? SRC_SINC_FASTEST :
+                                                       SRC_SINC_MEDIUM_QUALITY,
 			      getTargetChannelCount(), &err);
-	if (!m_converter) {
+
+        if (m_converter) {
+            m_crapConverter = src_new(SRC_LINEAR,
+                                      getTargetChannelCount(),
+                                      &err);
+        }
+
+	if (!m_converter || !m_crapConverter) {
 	    std::cerr
 		<< "AudioCallbackPlaySource::setModel: ERROR in creating samplerate converter: "
 		<< src_strerror(err) << std::endl;
+
+            if (m_converter) {
+                src_delete(m_converter);
+                m_converter = 0;
+            } 
+
+            if (m_crapConverter) {
+                src_delete(m_crapConverter);
+                m_crapConverter = 0;
+            }
+
+            m_mutex.unlock();
 
             emit sampleRateMismatch(getSourceSampleRate(),
                                     getTargetSampleRate(),
                                     false);
 	} else {
 
+            m_mutex.unlock();
+
             emit sampleRateMismatch(getSourceSampleRate(),
                                     getTargetSampleRate(),
                                     true);
         }
-    }
+    } else {
+        m_mutex.unlock();
+    }
+}
+
+void
+AudioCallbackPlaySource::setResampleQuality(int q)
+{
+    if (q == m_resampleQuality) return;
+    m_resampleQuality = q;
+
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+    std::cerr << "AudioCallbackPlaySource::setResampleQuality: setting to "
+              << m_resampleQuality << std::endl;
+#endif
+
+    initialiseConverter();
 }
 
 size_t
 AudioCallbackPlaySource::getTargetSampleRate() const
 {

 	data.input_frames = got;
 	data.output_frames = work;
 	data.src_ratio = ratio;
 	data.end_of_input = 0;
 	
-	int err = src_process(m_converter, &data);
-//	size_t toCopy = size_t(work * ratio + 0.1);
+	int err = 0;
+
+        if (m_timeStretcher && m_timeStretcher->getRatio() < 0.4) {
+#ifdef DEBUG_AUDIO_PLAY_SOURCE
+            std::cerr << "Using crappy converter" << std::endl;
+#endif
+            src_process(m_crapConverter, &data);
+        } else {
+            src_process(m_converter, &data);
+        }
+
 	size_t toCopy = size_t(got * ratio + 0.1);
 
 	if (err) {
 	    std::cerr
 		<< "AudioCallbackPlaySourceFillThread: ERROR in samplerate conversion: "