mirror of
https://git.eden-emu.dev/eden-emu/eden.git
synced 2025-07-20 19:55:46 +00:00
374 lines
13 KiB
C++
374 lines
13 KiB
C++
/*
|
|
* Copyright 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef OBOE_STREAM_BASE_H_
|
|
#define OBOE_STREAM_BASE_H_
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
#include "oboe/AudioStreamCallback.h"
|
|
#include "oboe/Definitions.h"
|
|
|
|
namespace oboe {
|
|
|
|
/**
|
|
* Base class containing parameters for audio streams and builders.
|
|
**/
|
|
class AudioStreamBase {
|
|
|
|
public:
|
|
|
|
AudioStreamBase() {}
|
|
|
|
virtual ~AudioStreamBase() = default;
|
|
|
|
// This class only contains primitives so we can use default constructor and copy methods.
|
|
|
|
/**
|
|
* Default copy constructor
|
|
*/
|
|
AudioStreamBase(const AudioStreamBase&) = default;
|
|
|
|
/**
|
|
* Default assignment operator
|
|
*/
|
|
AudioStreamBase& operator=(const AudioStreamBase&) = default;
|
|
|
|
/**
|
|
* @return number of channels, for example 2 for stereo, or kUnspecified
|
|
*/
|
|
int32_t getChannelCount() const { return mChannelCount; }
|
|
|
|
/**
|
|
* @return Direction::Input or Direction::Output
|
|
*/
|
|
Direction getDirection() const { return mDirection; }
|
|
|
|
/**
|
|
* @return sample rate for the stream or kUnspecified
|
|
*/
|
|
int32_t getSampleRate() const { return mSampleRate; }
|
|
|
|
/**
|
|
* @deprecated use `getFramesPerDataCallback` instead.
|
|
*/
|
|
int32_t getFramesPerCallback() const { return getFramesPerDataCallback(); }
|
|
|
|
/**
|
|
* @return the number of frames in each data callback or kUnspecified.
|
|
*/
|
|
int32_t getFramesPerDataCallback() const { return mFramesPerCallback; }
|
|
|
|
/**
|
|
* @return the audio sample format (e.g. Float or I16)
|
|
*/
|
|
AudioFormat getFormat() const { return mFormat; }
|
|
|
|
/**
|
|
* Query the maximum number of frames that can be filled without blocking.
|
|
* If the stream has been closed the last known value will be returned.
|
|
*
|
|
* @return buffer size
|
|
*/
|
|
virtual int32_t getBufferSizeInFrames() { return mBufferSizeInFrames; }
|
|
|
|
/**
|
|
* @return capacityInFrames or kUnspecified
|
|
*/
|
|
virtual int32_t getBufferCapacityInFrames() const { return mBufferCapacityInFrames; }
|
|
|
|
/**
|
|
* @return the sharing mode of the stream.
|
|
*/
|
|
SharingMode getSharingMode() const { return mSharingMode; }
|
|
|
|
/**
|
|
* @return the performance mode of the stream.
|
|
*/
|
|
PerformanceMode getPerformanceMode() const { return mPerformanceMode; }
|
|
|
|
/**
|
|
* @return the device ID of the stream.
|
|
*/
|
|
int32_t getDeviceId() const {
|
|
return mDeviceIds.empty() ? kUnspecified : mDeviceIds[0];
|
|
}
|
|
|
|
std::vector<int32_t> getDeviceIds() const {
|
|
return mDeviceIds;
|
|
}
|
|
|
|
/**
|
|
* For internal use only.
|
|
* @return the data callback object for this stream, if set.
|
|
*/
|
|
AudioStreamDataCallback *getDataCallback() const {
|
|
return mDataCallback;
|
|
}
|
|
|
|
/**
|
|
* For internal use only.
|
|
* @return the error callback object for this stream, if set.
|
|
*/
|
|
AudioStreamErrorCallback *getErrorCallback() const {
|
|
return mErrorCallback;
|
|
}
|
|
|
|
/**
|
|
* For internal use only.
|
|
* @return the presentation callback object for this stream, if set.
|
|
*/
|
|
std::shared_ptr<AudioStreamPresentationCallback> getPresentationCallback() const {
|
|
return mSharedPresentationCallback;
|
|
}
|
|
|
|
/**
|
|
* @return true if a data callback was set for this stream
|
|
*/
|
|
bool isDataCallbackSpecified() const {
|
|
return mDataCallback != nullptr;
|
|
}
|
|
|
|
/**
|
|
* Note that if the app does not set an error callback then a
|
|
* default one may be provided.
|
|
* @return true if an error callback was set for this stream
|
|
*/
|
|
bool isErrorCallbackSpecified() const {
|
|
return mErrorCallback != nullptr;
|
|
}
|
|
|
|
/**
|
|
* @return true if a presentation callback was set for this stream
|
|
*/
|
|
bool isPresentationCallbackSpecified() const {
|
|
return mSharedPresentationCallback != nullptr;
|
|
}
|
|
|
|
/**
|
|
* @return the usage for this stream.
|
|
*/
|
|
Usage getUsage() const { return mUsage; }
|
|
|
|
/**
|
|
* @return the stream's content type.
|
|
*/
|
|
ContentType getContentType() const { return mContentType; }
|
|
|
|
/**
|
|
* @return the stream's input preset.
|
|
*/
|
|
InputPreset getInputPreset() const { return mInputPreset; }
|
|
|
|
/**
|
|
* @return the stream's session ID allocation strategy (None or Allocate).
|
|
*/
|
|
SessionId getSessionId() const { return mSessionId; }
|
|
|
|
/**
|
|
* @return whether the content of the stream is spatialized.
|
|
*/
|
|
bool isContentSpatialized() const { return mIsContentSpatialized; }
|
|
|
|
/**
|
|
* @return the spatialization behavior for the stream.
|
|
*/
|
|
SpatializationBehavior getSpatializationBehavior() const { return mSpatializationBehavior; }
|
|
|
|
/**
|
|
* Return the policy that determines whether the audio may or may not be captured
|
|
* by other apps or the system.
|
|
*
|
|
* See AudioStreamBuilder_setAllowedCapturePolicy().
|
|
*
|
|
* Added in API level 29 to AAudio.
|
|
*
|
|
* @return the allowed capture policy, for example AllowedCapturePolicy::All
|
|
*/
|
|
AllowedCapturePolicy getAllowedCapturePolicy() const { return mAllowedCapturePolicy; }
|
|
|
|
/**
|
|
* Return whether this input stream is marked as privacy sensitive.
|
|
*
|
|
* See AudioStreamBuilder_setPrivacySensitiveMode().
|
|
*
|
|
* Added in API level 30 to AAudio.
|
|
*
|
|
* @return PrivacySensitiveMode::Enabled if privacy sensitive,
|
|
* PrivacySensitiveMode::Disabled if not privacy sensitive, and
|
|
* PrivacySensitiveMode::Unspecified if API is not supported.
|
|
*/
|
|
PrivacySensitiveMode getPrivacySensitiveMode() const { return mPrivacySensitiveMode; }
|
|
|
|
/**
|
|
* @return true if Oboe can convert channel counts to achieve optimal results.
|
|
*/
|
|
bool isChannelConversionAllowed() const {
|
|
return mChannelConversionAllowed;
|
|
}
|
|
|
|
/**
|
|
* @return true if Oboe can convert data formats to achieve optimal results.
|
|
*/
|
|
bool isFormatConversionAllowed() const {
|
|
return mFormatConversionAllowed;
|
|
}
|
|
|
|
/**
|
|
* @return whether and how Oboe can convert sample rates to achieve optimal results.
|
|
*/
|
|
SampleRateConversionQuality getSampleRateConversionQuality() const {
|
|
return mSampleRateConversionQuality;
|
|
}
|
|
|
|
/**
|
|
* @return the stream's channel mask.
|
|
*/
|
|
ChannelMask getChannelMask() const {
|
|
return mChannelMask;
|
|
}
|
|
|
|
/**
|
|
* @return number of channels for the hardware, for example 2 for stereo, or kUnspecified.
|
|
*/
|
|
int32_t getHardwareChannelCount() const { return mHardwareChannelCount; }
|
|
|
|
/**
|
|
* @return hardware sample rate for the stream or kUnspecified
|
|
*/
|
|
int32_t getHardwareSampleRate() const { return mHardwareSampleRate; }
|
|
|
|
/**
|
|
* @return the audio sample format of the hardware (e.g. Float or I16)
|
|
*/
|
|
AudioFormat getHardwareFormat() const { return mHardwareFormat; }
|
|
|
|
protected:
|
|
/** The callback which will be fired when new data is ready to be read/written. **/
|
|
AudioStreamDataCallback *mDataCallback = nullptr;
|
|
std::shared_ptr<AudioStreamDataCallback> mSharedDataCallback;
|
|
|
|
/** The callback which will be fired when an error or a disconnect occurs. **/
|
|
AudioStreamErrorCallback *mErrorCallback = nullptr;
|
|
std::shared_ptr<AudioStreamErrorCallback> mSharedErrorCallback;
|
|
|
|
std::shared_ptr<AudioStreamPresentationCallback> mSharedPresentationCallback;
|
|
|
|
/** Number of audio frames which will be requested in each callback */
|
|
int32_t mFramesPerCallback = kUnspecified;
|
|
/** Stream channel count */
|
|
int32_t mChannelCount = kUnspecified;
|
|
/** Stream sample rate */
|
|
int32_t mSampleRate = kUnspecified;
|
|
/** Stream buffer capacity specified as a number of audio frames */
|
|
int32_t mBufferCapacityInFrames = kUnspecified;
|
|
/** Stream buffer size specified as a number of audio frames */
|
|
int32_t mBufferSizeInFrames = kUnspecified;
|
|
/** Stream channel mask. Only active on Android 32+ */
|
|
ChannelMask mChannelMask = ChannelMask::Unspecified;
|
|
|
|
/** Stream sharing mode */
|
|
SharingMode mSharingMode = SharingMode::Shared;
|
|
/** Format of audio frames */
|
|
AudioFormat mFormat = AudioFormat::Unspecified;
|
|
/** Stream direction */
|
|
Direction mDirection = Direction::Output;
|
|
/** Stream performance mode */
|
|
PerformanceMode mPerformanceMode = PerformanceMode::None;
|
|
|
|
/** Stream usage. Only active on Android 28+ */
|
|
Usage mUsage = Usage::Media;
|
|
/** Stream content type. Only active on Android 28+ */
|
|
ContentType mContentType = ContentType::Music;
|
|
/** Stream input preset. Only active on Android 28+
|
|
* TODO InputPreset::Unspecified should be considered as a possible default alternative.
|
|
*/
|
|
InputPreset mInputPreset = InputPreset::VoiceRecognition;
|
|
/** Stream session ID allocation strategy. Only active on Android 28+ */
|
|
SessionId mSessionId = SessionId::None;
|
|
|
|
/** Allowed Capture Policy. Only active on Android 29+ */
|
|
AllowedCapturePolicy mAllowedCapturePolicy = AllowedCapturePolicy::Unspecified;
|
|
|
|
/** Privacy Sensitive Mode. Only active on Android 30+ */
|
|
PrivacySensitiveMode mPrivacySensitiveMode = PrivacySensitiveMode::Unspecified;
|
|
|
|
/** Control the name of the package creating the stream. Only active on Android 31+ */
|
|
std::string mPackageName;
|
|
/** Control the attribution tag of the context creating the stream. Only active on Android 31+ */
|
|
std::string mAttributionTag;
|
|
|
|
/** Whether the content is already spatialized. Only used on Android 32+ */
|
|
bool mIsContentSpatialized = false;
|
|
/** Spatialization Behavior. Only active on Android 32+ */
|
|
SpatializationBehavior mSpatializationBehavior = SpatializationBehavior::Unspecified;
|
|
|
|
/** Hardware channel count. Only specified on Android 34+ AAudio streams */
|
|
int32_t mHardwareChannelCount = kUnspecified;
|
|
/** Hardware sample rate. Only specified on Android 34+ AAudio streams */
|
|
int32_t mHardwareSampleRate = kUnspecified;
|
|
/** Hardware format. Only specified on Android 34+ AAudio streams */
|
|
AudioFormat mHardwareFormat = AudioFormat::Unspecified;
|
|
|
|
// Control whether Oboe can convert channel counts to achieve optimal results.
|
|
bool mChannelConversionAllowed = false;
|
|
// Control whether Oboe can convert data formats to achieve optimal results.
|
|
bool mFormatConversionAllowed = false;
|
|
// Control whether and how Oboe can convert sample rates to achieve optimal results.
|
|
SampleRateConversionQuality mSampleRateConversionQuality = SampleRateConversionQuality::Medium;
|
|
|
|
std::vector<int32_t> mDeviceIds;
|
|
|
|
/** Validate stream parameters that might not be checked in lower layers */
|
|
virtual Result isValidConfig() {
|
|
switch (mFormat) {
|
|
case AudioFormat::Unspecified:
|
|
case AudioFormat::I16:
|
|
case AudioFormat::Float:
|
|
case AudioFormat::I24:
|
|
case AudioFormat::I32:
|
|
case AudioFormat::IEC61937:
|
|
case AudioFormat::MP3:
|
|
case AudioFormat::AAC_LC:
|
|
case AudioFormat::AAC_HE_V1:
|
|
case AudioFormat::AAC_HE_V2:
|
|
case AudioFormat::AAC_ELD:
|
|
case AudioFormat::AAC_XHE:
|
|
case AudioFormat::OPUS:
|
|
break;
|
|
|
|
default:
|
|
return Result::ErrorInvalidFormat;
|
|
}
|
|
|
|
switch (mSampleRateConversionQuality) {
|
|
case SampleRateConversionQuality::None:
|
|
case SampleRateConversionQuality::Fastest:
|
|
case SampleRateConversionQuality::Low:
|
|
case SampleRateConversionQuality::Medium:
|
|
case SampleRateConversionQuality::High:
|
|
case SampleRateConversionQuality::Best:
|
|
return Result::OK;
|
|
default:
|
|
return Result::ErrorIllegalArgument;
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace oboe
|
|
|
|
#endif /* OBOE_STREAM_BASE_H_ */
|