comparison audio/AudioCallbackPlaySource.h @ 554:4be200469a9c 3.0-integration

Merge from branch bqresample

 #include <set>
 #include <map>
 
 namespace RubberBand {
     class RubberBandStretcher;
+}
+
+namespace breakfastquay {
+    class ResamplerWrapper;
 }
 
 class Model;
 class ViewManagerBase;
 class AudioGenerator;

      * Set the playback target.
      */
     virtual void setSystemPlaybackTarget(breakfastquay::SystemPlaybackTarget *);
 
     /**
+     * Set the resampler wrapper, if one is in use.
+     */
+    virtual void setResamplerWrapper(breakfastquay::ResamplerWrapper *);
+    
+    /**
      * Set the block size of the target audio device.  This should be
      * called by the target class.
      */
     virtual void setSystemPlaybackBlockSize(int blockSize);
 

      */
     int getTargetBlockSize() const;
 
     /**
      * Set the playback latency of the target audio device, in frames
-     * at the target sample rate.  This is the difference between the
+     * at the device sample rate.  This is the difference between the
      * frame currently "leaving the speakers" and the last frame (or
      * highest last frame across all channels) requested via
      * getSamples().  The default is zero.
      */
     void setSystemPlaybackLatency(int);

 
     /**
      * Return the sample rate set by the target audio device (or the
      * source sample rate if the target hasn't set one).
      */
-    virtual sv_samplerate_t getTargetSampleRate() const;
+    sv_samplerate_t getDeviceSampleRate() const;
 
     /**
      * Indicate how many channels the target audio device was opened
      * with. Note that the target device does channel mixing in the
      * case where our requested channel count does not match its.

     /**
      * Get the number of channels of audio that will be provided
      * to the play target.  This may be more than the source channel
      * count: for example, a mono source will provide 2 channels
      * after pan.
+     *
      * This may safely be called from a realtime thread.  Returns 0 if
      * there is no source yet available.
-     */
-    int getTargetChannelCount() const;
+     *
+     * override from AudioPlaySource
+     */
+    virtual int getTargetChannelCount() const override;
 
     /**
      * ApplicationPlaybackSource equivalent of the above.
-     */
-    virtual int getApplicationChannelCount() const {
+     *
+     * override from breakfastquay::ApplicationPlaybackSource
+     */
+    virtual int getApplicationChannelCount() const override {
         return getTargetChannelCount();
     }
     
     /**
-     * Get the actual sample rate of the source material.  This may
-     * safely be called from a realtime thread.  Returns 0 if there is
-     * no source yet available.
-     */
-    virtual sv_samplerate_t getSourceSampleRate() const;
-
-    /**
-     * ApplicationPlaybackSource equivalent of the above.
-     */
-    virtual int getApplicationSampleRate() const {
-        return int(round(getSourceSampleRate()));
+     * Get the actual sample rate of the source material (the main
+     * model).  This may safely be called from a realtime thread.
+     * Returns 0 if there is no source yet available.
+     *
+     * When this changes, the AudioCallbackPlaySource notifies its
+     * ResamplerWrapper of the new sample rate so that it can resample
+     * correctly on the way to the device (which is opened at a fixed
+     * rate, see getApplicationSampleRate).
+     */
+    virtual sv_samplerate_t getSourceSampleRate() const override;
+
+    /**
+     * ApplicationPlaybackSource interface method: get the sample rate
+     * at which the application wants the device to be opened. We
+     * always allow the device to open at its default rate, and then
+     * we resample if the audio is at a different rate. This avoids
+     * having to close and re-open the device to obtain consistent
+     * behaviour for consecutive sessions with different source rates.
+     */
+    virtual int getApplicationSampleRate() const override {
+        return 0;
     }
 
     /**
      * Get "count" samples (at the target sample rate) of the mixed
      * audio data, in all channels.  This may safely be called from a

     sv_frame_t                        m_writeBufferFill;
     Scavenger<RingBufferVector>       m_bufferScavenger;
     int                               m_sourceChannelCount;
     sv_frame_t                        m_blockSize;
     sv_samplerate_t                   m_sourceSampleRate;
-    sv_samplerate_t                   m_targetSampleRate;
+    sv_samplerate_t                   m_deviceSampleRate;
     sv_frame_t                        m_playLatency;
     breakfastquay::SystemPlaybackTarget *m_target;
     double                            m_lastRetrievalTimestamp;
     sv_frame_t                        m_lastRetrievedBlockSize;
     bool                              m_trustworthyTimestamps;

     };
 
     QMutex m_mutex;
     QWaitCondition m_condition;
     FillThread *m_fillThread;
+    breakfastquay::ResamplerWrapper *m_resamplerWrapper; // I don't own this
 };
 
 #endif