2008-07-30 06:50:14 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2012-11-14 19:46:40 +00:00
|
|
|
#if !defined(AudioStream_h_)
|
|
|
|
#define AudioStream_h_
|
2008-11-06 20:53:20 +00:00
|
|
|
|
2012-10-25 10:09:40 +00:00
|
|
|
#include "AudioSampleFormat.h"
|
2012-11-28 16:25:57 +00:00
|
|
|
#include "nsAutoPtr.h"
|
2013-09-25 02:10:24 +00:00
|
|
|
#include "nsCOMPtr.h"
|
2014-04-09 19:59:07 +00:00
|
|
|
#include "nsThreadUtils.h"
|
2014-04-10 17:39:20 +00:00
|
|
|
#include "mozilla/dom/AudioChannelBinding.h"
|
2015-08-27 02:49:17 +00:00
|
|
|
#include "mozilla/Monitor.h"
|
2015-10-18 05:24:48 +00:00
|
|
|
#include "mozilla/RefPtr.h"
|
2015-08-27 02:49:17 +00:00
|
|
|
#include "mozilla/TimeStamp.h"
|
2014-08-18 17:12:08 +00:00
|
|
|
#include "mozilla/UniquePtr.h"
|
2014-08-25 13:26:09 +00:00
|
|
|
#include "CubebUtils.h"
|
2015-07-06 19:08:56 +00:00
|
|
|
#include "soundtouch/SoundTouchFactory.h"
|
2013-09-05 20:25:17 +00:00
|
|
|
|
2012-11-14 19:45:33 +00:00
|
|
|
namespace mozilla {
|
|
|
|
|
2015-03-08 01:07:17 +00:00
|
|
|
struct CubebDestroyPolicy
|
2014-08-18 17:12:08 +00:00
|
|
|
{
|
2015-01-15 07:47:00 +00:00
|
|
|
void operator()(cubeb_stream* aStream) const {
|
2014-08-18 17:12:08 +00:00
|
|
|
cubeb_stream_destroy(aStream);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-11-22 10:38:28 +00:00
|
|
|
class AudioStream;
|
2014-06-26 02:56:23 +00:00
|
|
|
class FrameHistory;
|
2016-04-08 07:37:31 +00:00
|
|
|
class AudioConfig;
|
|
|
|
class AudioConverter;
|
2012-11-22 10:38:28 +00:00
|
|
|
|
|
|
|
class AudioClock
|
|
|
|
{
|
2013-11-28 05:09:08 +00:00
|
|
|
public:
|
2016-06-01 08:36:10 +00:00
|
|
|
AudioClock();
|
|
|
|
|
|
|
|
// Initialize the clock with the current sampling rate.
|
|
|
|
// Need to be called before querying the clock.
|
|
|
|
void Init(uint32_t aRate);
|
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
// Update the number of samples that has been written in the audio backend.
|
|
|
|
// Called on the state machine thread.
|
2014-06-26 02:56:23 +00:00
|
|
|
void UpdateFrameHistory(uint32_t aServiced, uint32_t aUnderrun);
|
2016-06-01 08:18:56 +00:00
|
|
|
|
|
|
|
/**
|
2016-06-06 03:13:34 +00:00
|
|
|
* @param aFrames The playback position in frames of the audio engine.
|
2016-06-01 08:18:56 +00:00
|
|
|
* @return The playback position in frames of the stream,
|
|
|
|
* adjusted by playback rate changes and underrun frames.
|
|
|
|
*/
|
2016-06-06 03:13:34 +00:00
|
|
|
int64_t GetPositionInFrames(int64_t aFrames) const;
|
2016-06-01 08:19:35 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param frames The playback position in frames of the audio engine.
|
|
|
|
* @return The playback position in microseconds of the stream,
|
|
|
|
* adjusted by playback rate changes and underrun frames.
|
|
|
|
*/
|
|
|
|
int64_t GetPosition(int64_t frames) const;
|
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
// Set the playback rate.
|
|
|
|
// Called on the audio thread.
|
2016-06-01 08:45:32 +00:00
|
|
|
void SetPlaybackRate(double aPlaybackRate);
|
2013-11-28 05:09:08 +00:00
|
|
|
// Get the current playback rate.
|
|
|
|
// Called on the audio thread.
|
2014-06-26 02:56:23 +00:00
|
|
|
double GetPlaybackRate() const;
|
2013-11-28 05:09:08 +00:00
|
|
|
// Set if we are preserving the pitch.
|
|
|
|
// Called on the audio thread.
|
|
|
|
void SetPreservesPitch(bool aPreservesPitch);
|
|
|
|
// Get the current pitch preservation state.
|
|
|
|
// Called on the audio thread.
|
2014-06-26 02:56:23 +00:00
|
|
|
bool GetPreservesPitch() const;
|
2016-06-01 08:36:10 +00:00
|
|
|
|
2016-06-01 09:38:47 +00:00
|
|
|
uint32_t GetInputRate() const { return mInRate; }
|
|
|
|
uint32_t GetOutputRate() const { return mOutRate; }
|
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
private:
|
|
|
|
// Output rate in Hz (characteristic of the playback rate)
|
2016-01-21 13:11:14 +00:00
|
|
|
uint32_t mOutRate;
|
2013-11-28 05:09:08 +00:00
|
|
|
// Input rate in Hz (characteristic of the media being played)
|
2016-01-21 13:11:14 +00:00
|
|
|
uint32_t mInRate;
|
2013-11-28 05:09:08 +00:00
|
|
|
// True if the we are timestretching, false if we are resampling.
|
|
|
|
bool mPreservesPitch;
|
2015-08-27 02:49:17 +00:00
|
|
|
// The history of frames sent to the audio engine in each DataCallback.
|
2014-06-26 02:56:23 +00:00
|
|
|
const nsAutoPtr<FrameHistory> mFrameHistory;
|
2013-11-28 05:09:08 +00:00
|
|
|
};
|
|
|
|
|
2016-01-18 03:24:06 +00:00
|
|
|
/*
|
|
|
|
* A bookkeeping class to track the read/write position of an audio buffer.
|
|
|
|
*/
|
|
|
|
class AudioBufferCursor {
|
|
|
|
public:
|
|
|
|
AudioBufferCursor(AudioDataValue* aPtr, uint32_t aChannels, uint32_t aFrames)
|
|
|
|
: mPtr(aPtr), mChannels(aChannels), mFrames(aFrames) {}
|
|
|
|
|
|
|
|
// Advance the cursor to account for frames that are consumed.
|
|
|
|
uint32_t Advance(uint32_t aFrames) {
|
|
|
|
MOZ_ASSERT(mFrames >= aFrames);
|
|
|
|
mFrames -= aFrames;
|
|
|
|
mPtr += mChannels * aFrames;
|
|
|
|
return aFrames;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The number of frames available for read/write in this buffer.
|
|
|
|
uint32_t Available() const { return mFrames; }
|
|
|
|
|
|
|
|
// Return a pointer where read/write should begin.
|
|
|
|
AudioDataValue* Ptr() const { return mPtr; }
|
|
|
|
|
|
|
|
protected:
|
|
|
|
AudioDataValue* mPtr;
|
|
|
|
const uint32_t mChannels;
|
|
|
|
uint32_t mFrames;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A helper class to encapsulate pointer arithmetic and provide means to modify
|
|
|
|
* the underlying audio buffer.
|
|
|
|
*/
|
|
|
|
class AudioBufferWriter : private AudioBufferCursor {
|
|
|
|
public:
|
|
|
|
AudioBufferWriter(AudioDataValue* aPtr, uint32_t aChannels, uint32_t aFrames)
|
|
|
|
: AudioBufferCursor(aPtr, aChannels, aFrames) {}
|
|
|
|
|
|
|
|
uint32_t WriteZeros(uint32_t aFrames) {
|
|
|
|
memset(mPtr, 0, sizeof(AudioDataValue) * mChannels * aFrames);
|
|
|
|
return Advance(aFrames);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t Write(const AudioDataValue* aPtr, uint32_t aFrames) {
|
|
|
|
memcpy(mPtr, aPtr, sizeof(AudioDataValue) * mChannels * aFrames);
|
|
|
|
return Advance(aFrames);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Provide a write fuction to update the audio buffer with the following
|
|
|
|
// signature: uint32_t(const AudioDataValue* aPtr, uint32_t aFrames)
|
|
|
|
// aPtr: Pointer to the audio buffer.
|
|
|
|
// aFrames: The number of frames available in the buffer.
|
|
|
|
// return: The number of frames actually written by the function.
|
|
|
|
template <typename Function>
|
|
|
|
uint32_t Write(const Function& aFunction, uint32_t aFrames) {
|
|
|
|
return Advance(aFunction(mPtr, aFrames));
|
|
|
|
}
|
|
|
|
|
|
|
|
using AudioBufferCursor::Available;
|
|
|
|
};
|
|
|
|
|
2012-06-01 04:45:01 +00:00
|
|
|
// Access to a single instance of this class must be synchronized by
|
|
|
|
// callers, or made from a single thread. One exception is that access to
|
2014-07-29 16:45:03 +00:00
|
|
|
// GetPosition, GetPositionInFrames, SetVolume, and Get{Rate,Channels},
|
|
|
|
// SetMicrophoneActive is thread-safe without external synchronization.
|
2015-03-21 16:28:04 +00:00
|
|
|
class AudioStream final
|
2008-07-30 06:50:14 +00:00
|
|
|
{
|
2014-06-20 11:08:24 +00:00
|
|
|
virtual ~AudioStream();
|
|
|
|
|
2010-11-17 04:14:19 +00:00
|
|
|
public:
|
2014-04-09 19:59:07 +00:00
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AudioStream)
|
2016-01-12 13:48:25 +00:00
|
|
|
|
|
|
|
class Chunk {
|
|
|
|
public:
|
|
|
|
// Return a pointer to the audio data.
|
|
|
|
virtual const AudioDataValue* Data() const = 0;
|
|
|
|
// Return the number of frames in this chunk.
|
|
|
|
virtual uint32_t Frames() const = 0;
|
2016-01-21 13:11:14 +00:00
|
|
|
// Return the number of audio channels.
|
|
|
|
virtual uint32_t Channels() const = 0;
|
|
|
|
// Return the sample rate of this chunk.
|
|
|
|
virtual uint32_t Rate() const = 0;
|
2016-01-12 13:48:25 +00:00
|
|
|
// Return a writable pointer for downmixing.
|
|
|
|
virtual AudioDataValue* GetWritable() const = 0;
|
|
|
|
virtual ~Chunk() {}
|
|
|
|
};
|
|
|
|
|
|
|
|
class DataSource {
|
|
|
|
public:
|
|
|
|
// Return a chunk which contains at most aFrames frames or zero if no
|
|
|
|
// frames in the source at all.
|
|
|
|
virtual UniquePtr<Chunk> PopFrames(uint32_t aFrames) = 0;
|
|
|
|
// Return true if no more data will be added to the source.
|
|
|
|
virtual bool Ended() const = 0;
|
|
|
|
// Notify that all data is drained by the AudioStream.
|
|
|
|
virtual void Drained() = 0;
|
|
|
|
protected:
|
|
|
|
virtual ~DataSource() {}
|
|
|
|
};
|
|
|
|
|
|
|
|
explicit AudioStream(DataSource& aSource);
|
2013-11-28 05:09:08 +00:00
|
|
|
|
2011-09-27 03:31:18 +00:00
|
|
|
// Initialize the audio stream. aNumChannels is the number of audio
|
|
|
|
// channels (1 for mono, 2 for stereo, etc) and aRate is the sample rate
|
|
|
|
// (22050Hz, 44100Hz, etc).
|
2016-01-21 13:11:14 +00:00
|
|
|
nsresult Init(uint32_t aNumChannels, uint32_t aRate,
|
2015-08-27 02:49:17 +00:00
|
|
|
const dom::AudioChannel aAudioStreamChannel);
|
2008-07-30 06:50:14 +00:00
|
|
|
|
|
|
|
// Closes the stream. All future use of the stream is an error.
|
2013-11-28 05:09:08 +00:00
|
|
|
void Shutdown();
|
2008-07-30 06:50:14 +00:00
|
|
|
|
2014-07-18 17:22:03 +00:00
|
|
|
void Reset();
|
|
|
|
|
2008-07-30 06:50:14 +00:00
|
|
|
// Set the current volume of the audio playback. This is a value from
|
2012-06-01 04:45:01 +00:00
|
|
|
// 0 (meaning muted) to 1 (meaning full volume). Thread-safe.
|
2013-11-28 05:09:08 +00:00
|
|
|
void SetVolume(double aVolume);
|
2008-07-30 06:50:14 +00:00
|
|
|
|
2012-11-26 14:13:08 +00:00
|
|
|
// Start the stream.
|
2013-11-28 05:09:08 +00:00
|
|
|
void Start();
|
2012-11-26 14:13:08 +00:00
|
|
|
|
|
|
|
// Pause audio playback.
|
2013-11-28 05:09:08 +00:00
|
|
|
void Pause();
|
2009-05-15 01:29:05 +00:00
|
|
|
|
2012-11-26 14:13:08 +00:00
|
|
|
// Resume audio playback.
|
2013-11-28 05:09:08 +00:00
|
|
|
void Resume();
|
2009-05-15 01:29:05 +00:00
|
|
|
|
2011-09-27 03:31:18 +00:00
|
|
|
// Return the position in microseconds of the audio frame being played by
|
2012-11-22 10:38:28 +00:00
|
|
|
// the audio hardware, compensated for playback rate change. Thread-safe.
|
2013-11-28 05:09:08 +00:00
|
|
|
int64_t GetPosition();
|
2010-04-02 03:03:07 +00:00
|
|
|
|
2011-09-27 03:31:18 +00:00
|
|
|
// Return the position, measured in audio frames played since the stream
|
2012-06-01 04:45:01 +00:00
|
|
|
// was opened, of the audio hardware. Thread-safe.
|
2013-11-28 05:09:08 +00:00
|
|
|
int64_t GetPositionInFrames();
|
2010-08-25 13:10:00 +00:00
|
|
|
|
2016-04-13 07:55:48 +00:00
|
|
|
static uint32_t GetPreferredRate()
|
|
|
|
{
|
|
|
|
return CubebUtils::PreferredSampleRate();
|
|
|
|
}
|
2016-06-01 09:54:37 +00:00
|
|
|
|
2016-01-21 13:11:14 +00:00
|
|
|
uint32_t GetOutChannels() { return mOutChannels; }
|
2012-10-25 10:09:38 +00:00
|
|
|
|
2012-11-22 10:38:28 +00:00
|
|
|
// Set playback rate as a multiple of the intrinsic playback rate. This is to
|
|
|
|
// be called only with aPlaybackRate > 0.0.
|
2013-11-28 05:09:08 +00:00
|
|
|
nsresult SetPlaybackRate(double aPlaybackRate);
|
2012-11-22 10:38:28 +00:00
|
|
|
// Switch between resampling (if false) and time stretching (if true, default).
|
2013-11-28 05:09:08 +00:00
|
|
|
nsresult SetPreservesPitch(bool aPreservesPitch);
|
|
|
|
|
2014-04-13 18:08:10 +00:00
|
|
|
size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
|
|
|
|
|
2014-05-21 07:28:22 +00:00
|
|
|
protected:
|
|
|
|
friend class AudioClock;
|
|
|
|
|
2014-06-26 02:56:23 +00:00
|
|
|
// Return the position, measured in audio frames played since the stream was
|
|
|
|
// opened, of the audio hardware, not adjusted for the changes of playback
|
|
|
|
// rate or underrun frames.
|
2014-05-21 07:28:22 +00:00
|
|
|
// Caller must own the monitor.
|
|
|
|
int64_t GetPositionInFramesUnlocked();
|
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
private:
|
2016-09-16 00:54:24 +00:00
|
|
|
nsresult OpenCubeb(cubeb* aContext, cubeb_stream_params& aParams,
|
2016-05-31 06:18:58 +00:00
|
|
|
TimeStamp aStartTime, bool aIsFirst);
|
2014-04-09 19:59:07 +00:00
|
|
|
|
2016-01-21 16:51:36 +00:00
|
|
|
static long DataCallback_S(cubeb_stream*, void* aThis,
|
|
|
|
const void* /* aInputBuffer */, void* aOutputBuffer,
|
|
|
|
long aFrames)
|
2013-11-28 05:09:08 +00:00
|
|
|
{
|
2016-01-21 16:51:36 +00:00
|
|
|
return static_cast<AudioStream*>(aThis)->DataCallback(aOutputBuffer, aFrames);
|
2013-11-28 05:09:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void StateCallback_S(cubeb_stream*, void* aThis, cubeb_state aState)
|
|
|
|
{
|
|
|
|
static_cast<AudioStream*>(aThis)->StateCallback(aState);
|
|
|
|
}
|
|
|
|
|
2014-07-29 16:45:03 +00:00
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
long DataCallback(void* aBuffer, long aFrames);
|
|
|
|
void StateCallback(cubeb_state aState);
|
|
|
|
|
|
|
|
nsresult EnsureTimeStretcherInitializedUnlocked();
|
|
|
|
|
2016-04-13 10:25:50 +00:00
|
|
|
// Return true if audio frames are valid (correct sampling rate and valid
|
|
|
|
// channel count) otherwise false.
|
|
|
|
bool IsValidAudioFormat(Chunk* aChunk);
|
2016-01-12 13:48:25 +00:00
|
|
|
|
2016-01-18 03:24:06 +00:00
|
|
|
void GetUnprocessed(AudioBufferWriter& aWriter);
|
|
|
|
void GetTimeStretched(AudioBufferWriter& aWriter);
|
2013-11-28 05:09:08 +00:00
|
|
|
|
2016-05-30 13:12:35 +00:00
|
|
|
template <typename Function, typename... Args>
|
|
|
|
int InvokeCubeb(Function aFunction, Args&&... aArgs);
|
|
|
|
|
2016-01-12 13:48:25 +00:00
|
|
|
// The monitor is held to protect all access to member variables.
|
2013-11-28 05:09:08 +00:00
|
|
|
Monitor mMonitor;
|
2012-11-22 10:38:28 +00:00
|
|
|
|
2016-01-21 13:11:14 +00:00
|
|
|
uint32_t mChannels;
|
|
|
|
uint32_t mOutChannels;
|
2012-11-22 10:38:28 +00:00
|
|
|
AudioClock mAudioClock;
|
2015-07-06 19:08:56 +00:00
|
|
|
soundtouch::SoundTouch* mTimeStretcher;
|
2013-10-25 22:13:42 +00:00
|
|
|
|
2013-11-28 05:09:08 +00:00
|
|
|
// Output file for dumping audio
|
|
|
|
FILE* mDumpFile;
|
|
|
|
|
2014-08-18 17:12:08 +00:00
|
|
|
// Owning reference to a cubeb_stream.
|
2015-03-08 01:07:17 +00:00
|
|
|
UniquePtr<cubeb_stream, CubebDestroyPolicy> mCubebStream;
|
2013-11-28 05:09:08 +00:00
|
|
|
|
|
|
|
enum StreamState {
|
|
|
|
INITIALIZED, // Initialized, playback has not begun.
|
2016-05-31 03:54:30 +00:00
|
|
|
STARTED, // cubeb started.
|
2013-11-28 05:09:08 +00:00
|
|
|
STOPPED, // Stopped by a call to Pause().
|
|
|
|
DRAINED, // StateCallback has indicated that the drain is complete.
|
2014-04-09 19:59:07 +00:00
|
|
|
ERRORED, // Stream disabled due to an internal error.
|
|
|
|
SHUTDOWN // Shutdown has been called
|
2013-11-28 05:09:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
StreamState mState;
|
2016-01-12 13:48:25 +00:00
|
|
|
|
|
|
|
DataSource& mDataSource;
|
2008-07-30 06:50:14 +00:00
|
|
|
};
|
2010-11-17 04:14:19 +00:00
|
|
|
|
2012-11-14 19:45:33 +00:00
|
|
|
} // namespace mozilla
|
|
|
|
|
2008-11-06 20:53:20 +00:00
|
|
|
#endif
|