comparison audio/AudioCallbackPlaySource.h @ 559:7b115a6505b8 3.0-integration

Handle increases in the overall channel count by closing and reopening the audio device.

     /**
      * Start making data available in the ring buffers for playback,
      * from the given frame.  If playback is already under way, reseek
      * to the given frame and continue.
      */
-    virtual void play(sv_frame_t startFrame);
+    virtual void play(sv_frame_t startFrame) override;
 
     /**
      * Stop playback and ensure that no more data is returned.
      */
-    virtual void stop();
+    virtual void stop() override;
 
     /**
      * Return whether playback is currently supposed to be happening.
      */
-    virtual bool isPlaying() const { return m_playing; }
+    virtual bool isPlaying() const override { return m_playing; }
 
     /**
      * Return the frame number that is currently expected to be coming
      * out of the speakers.  (i.e. compensating for playback latency.)
      */
-    virtual sv_frame_t getCurrentPlayingFrame();
+    virtual sv_frame_t getCurrentPlayingFrame() override;
     
     /** 
      * Return the last frame that would come out of the speakers if we
      * stopped playback right now.
      */

     
     /**
      * Set the block size of the target audio device.  This should be
      * called by the target class.
      */
-    virtual void setSystemPlaybackBlockSize(int blockSize);
+    virtual void setSystemPlaybackBlockSize(int blockSize) override;
 
     /**
      * Get the block size of the target audio device.  This may be an
      * estimate or upper bound, if the target has a variable block
      * size; the source should behave itself even if this value turns

      * 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);
+    virtual void setSystemPlaybackLatency(int) override;
 
     /**
      * Get the playback latency of the target audio device.
      */
     sv_frame_t getTargetPlayLatency() const;

      * (i.e. cannot accommodate arbitrary sample rates based on the
      * source).  If the target sets this to something other than the
      * source sample rate, this class will resample automatically to
      * fit.
      */
-    void setSystemPlaybackSampleRate(int);
+    virtual void setSystemPlaybackSampleRate(int) override;
 
     /**
      * Return the sample rate set by the target audio device (or the
      * source sample rate if the target hasn't set one).
      */
     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.
-     */
-    void setSystemPlaybackChannelCount(int);
+     * case where our requested channel count does not match its, so
+     * long as we provide the number of channels we specified when the
+     * target was started in getApplicationChannelCount().
+     */
+    virtual void setSystemPlaybackChannelCount(int) override;
     
     /**
      * Set the current output levels for metering (for call from the
      * target)
      */

      *
      * override from AudioPlaySource
      */
     virtual int getTargetChannelCount() const override;
 
+    /**
+     * Get the number of channels of audio the device is
+     * expecting. Equal to whatever getTargetChannelCount() was
+     * returning at the time the device was initialised.
+     */
+    int getDeviceChannelCount() const;
+    
     /**
      * ApplicationPlaybackSource equivalent of the above.
      *
      * override from breakfastquay::ApplicationPlaybackSource
      */

     /**
      * Get "count" samples (at the target sample rate) of the mixed
      * audio data, in all channels.  This may safely be called from a
      * realtime thread.
      */
-    virtual int getSourceSamples(int count, float **buffer);
+    virtual int getSourceSamples(float *const *buffer, int nchannels, int count) override;
 
     /**
      * Set the time stretcher factor (i.e. playback speed).
      */
     void setTimeStretch(double factor);

     void playStatusChanged(bool isPlaying);
 
     void sampleRateMismatch(sv_samplerate_t requested,
                             sv_samplerate_t available,
                             bool willResample);
+
+    void channelCountIncreased();
 
     void audioOverloadPluginDisabled();
     void audioTimeStretchMultiChannelDisabled();
 
     void activity(QString);

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

     // new buffered frame position (which may be earlier than the
     // frame argument passed in, in the case of looping).
     sv_frame_t mixModels(sv_frame_t &frame, sv_frame_t count, float **buffers);
 
     // Called from getSourceSamples.
-    void applyAuditioningEffect(sv_frame_t count, float **buffers);
+    void applyAuditioningEffect(sv_frame_t count, float *const *buffers);
 
     // Ranges of current selections, if play selection is active
     std::vector<RealTime> m_rangeStarts;
     std::vector<RealTime> m_rangeDurations;
     void rebuildRangeLists();