mirror of
https://git.eden-emu.dev/eden-emu/eden.git
synced 2025-07-21 04:05:45 +00:00
709 lines
27 KiB
C++
709 lines
27 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_BUILDER_H_
|
|
#define OBOE_STREAM_BUILDER_H_
|
|
|
|
#include "oboe/Definitions.h"
|
|
#include "oboe/AudioStreamBase.h"
|
|
#include "oboe/Utilities.h"
|
|
#include "ResultWithValue.h"
|
|
|
|
namespace oboe {
|
|
|
|
// This depends on AudioStream, so we use forward declaration, it will close and delete the stream
|
|
struct StreamDeleterFunctor;
|
|
using ManagedStream = std::unique_ptr<AudioStream, StreamDeleterFunctor>;
|
|
|
|
/**
|
|
* Factory class for an audio Stream.
|
|
*/
|
|
class AudioStreamBuilder : public AudioStreamBase {
|
|
public:
|
|
|
|
AudioStreamBuilder() : AudioStreamBase() {}
|
|
|
|
AudioStreamBuilder(const AudioStreamBase &audioStreamBase): AudioStreamBase(audioStreamBase) {}
|
|
|
|
/**
|
|
* Request a specific number of channels.
|
|
*
|
|
* Default is kUnspecified. If the value is unspecified then
|
|
* the application should query for the actual value after the stream is opened.
|
|
*
|
|
* As the channel count here may be different from the corresponding channel count of
|
|
* provided channel mask used in setChannelMask(). The last called will be respected
|
|
* if this function and setChannelMask() are called.
|
|
*/
|
|
AudioStreamBuilder *setChannelCount(int channelCount) {
|
|
mChannelCount = channelCount;
|
|
mChannelMask = ChannelMask::Unspecified;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request a specific channel mask.
|
|
*
|
|
* Default is kUnspecified. If the value is unspecified then the application
|
|
* should query for the actual value after the stream is opened.
|
|
*
|
|
* As the corresponding channel count of provided channel mask here may be different
|
|
* from the channel count used in setChannelCount(). The last called will be respected
|
|
* if this function and setChannelCount() are called.
|
|
*
|
|
* As the setChannelMask API is available on Android 32+, this call will only take effects
|
|
* on Android 32+.
|
|
*/
|
|
AudioStreamBuilder *setChannelMask(ChannelMask channelMask) {
|
|
mChannelMask = channelMask;
|
|
mChannelCount = getChannelCountFromChannelMask(channelMask);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request the direction for a stream. The default is Direction::Output.
|
|
*
|
|
* @param direction Direction::Output or Direction::Input
|
|
*/
|
|
AudioStreamBuilder *setDirection(Direction direction) {
|
|
mDirection = direction;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request a specific sample rate in Hz.
|
|
*
|
|
* Default is kUnspecified. If the value is unspecified then
|
|
* the application should query for the actual value after the stream is opened.
|
|
*
|
|
* Technically, this should be called the "frame rate" or "frames per second",
|
|
* because it refers to the number of complete frames transferred per second.
|
|
* But it is traditionally called "sample rate". Se we use that term.
|
|
*
|
|
*/
|
|
AudioStreamBuilder *setSampleRate(int32_t sampleRate) {
|
|
mSampleRate = sampleRate;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @deprecated use `setFramesPerDataCallback` instead.
|
|
*/
|
|
AudioStreamBuilder *setFramesPerCallback(int framesPerCallback) {
|
|
return setFramesPerDataCallback(framesPerCallback);
|
|
}
|
|
|
|
/**
|
|
* Request a specific number of frames for the data callback.
|
|
*
|
|
* Default is kUnspecified. If the value is unspecified then
|
|
* the actual number may vary from callback to callback.
|
|
*
|
|
* If an application can handle a varying number of frames then we recommend
|
|
* leaving this unspecified. This allow the underlying API to optimize
|
|
* the callbacks. But if your application is, for example, doing FFTs or other block
|
|
* oriented operations, then call this function to get the sizes you need.
|
|
*
|
|
* Calling setFramesPerDataCallback() does not guarantee anything about timing.
|
|
* This just collects the data into a the number of frames that your app requires.
|
|
* We encourage leaving this unspecified in most cases.
|
|
*
|
|
* If this number is larger than the burst size, some bursts will not receive a callback.
|
|
* If this number is smaller than the burst size, there may be multiple callbacks in a single
|
|
* burst.
|
|
*
|
|
* @param framesPerCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setFramesPerDataCallback(int framesPerCallback) {
|
|
mFramesPerCallback = framesPerCallback;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request a sample data format, for example Format::Float.
|
|
*
|
|
* Default is Format::Unspecified. If the value is unspecified then
|
|
* the application should query for the actual value after the stream is opened.
|
|
*/
|
|
AudioStreamBuilder *setFormat(AudioFormat format) {
|
|
mFormat = format;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the requested buffer capacity in frames.
|
|
* BufferCapacityInFrames is the maximum possible BufferSizeInFrames.
|
|
*
|
|
* The final stream capacity may differ. For AAudio it should be at least this big.
|
|
* For OpenSL ES, it could be smaller.
|
|
*
|
|
* Default is kUnspecified.
|
|
*
|
|
* @param bufferCapacityInFrames the desired buffer capacity in frames or kUnspecified
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setBufferCapacityInFrames(int32_t bufferCapacityInFrames) {
|
|
mBufferCapacityInFrames = bufferCapacityInFrames;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Get the audio API which will be requested when opening the stream. No guarantees that this is
|
|
* the API which will actually be used. Query the stream itself to find out the API which is
|
|
* being used.
|
|
*
|
|
* If you do not specify the API, then AAudio will be used if isAAudioRecommended()
|
|
* returns true. Otherwise OpenSL ES will be used.
|
|
*
|
|
* @return the requested audio API
|
|
*/
|
|
AudioApi getAudioApi() const { return mAudioApi; }
|
|
|
|
/**
|
|
* If you leave this unspecified then Oboe will choose the best API
|
|
* for the device and SDK version at runtime.
|
|
*
|
|
* This should almost always be left unspecified, except for debugging purposes.
|
|
* Specifying AAudio will force Oboe to use AAudio on 8.0, which is extremely risky.
|
|
* Specifying OpenSLES should mainly be used to test legacy performance/functionality.
|
|
*
|
|
* If the caller requests AAudio and it is supported then AAudio will be used.
|
|
*
|
|
* @param audioApi Must be AudioApi::Unspecified, AudioApi::OpenSLES or AudioApi::AAudio.
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setAudioApi(AudioApi audioApi) {
|
|
mAudioApi = audioApi;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Is the AAudio API supported on this device?
|
|
*
|
|
* AAudio was introduced in the Oreo 8.0 release.
|
|
*
|
|
* @return true if supported
|
|
*/
|
|
static bool isAAudioSupported();
|
|
|
|
/**
|
|
* Is the AAudio API recommended this device?
|
|
*
|
|
* AAudio may be supported but not recommended because of version specific issues.
|
|
* AAudio is not recommended for Android 8.0 or earlier versions.
|
|
*
|
|
* @return true if recommended
|
|
*/
|
|
static bool isAAudioRecommended();
|
|
|
|
/**
|
|
* Request a mode for sharing the device.
|
|
* The requested sharing mode may not be available.
|
|
* So the application should query for the actual mode after the stream is opened.
|
|
*
|
|
* @param sharingMode SharingMode::Shared or SharingMode::Exclusive
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setSharingMode(SharingMode sharingMode) {
|
|
mSharingMode = sharingMode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request a performance level for the stream.
|
|
* This will determine the latency, the power consumption, and the level of
|
|
* protection from glitches.
|
|
*
|
|
* @param performanceMode for example, PerformanceMode::LowLatency
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setPerformanceMode(PerformanceMode performanceMode) {
|
|
mPerformanceMode = performanceMode;
|
|
return this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the intended use case for an output stream.
|
|
*
|
|
* The system will use this information to optimize the behavior of the stream.
|
|
* This could, for example, affect how volume and focus is handled for the stream.
|
|
* The usage is ignored for input streams.
|
|
*
|
|
* The default, if you do not call this function, is Usage::Media.
|
|
*
|
|
* Added in API level 28.
|
|
*
|
|
* @param usage the desired usage, eg. Usage::Game
|
|
*/
|
|
AudioStreamBuilder *setUsage(Usage usage) {
|
|
mUsage = usage;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the type of audio data that an output stream will carry.
|
|
*
|
|
* The system will use this information to optimize the behavior of the stream.
|
|
* This could, for example, affect whether a stream is paused when a notification occurs.
|
|
* The contentType is ignored for input streams.
|
|
*
|
|
* The default, if you do not call this function, is ContentType::Music.
|
|
*
|
|
* Added in API level 28.
|
|
*
|
|
* @param contentType the type of audio data, eg. ContentType::Speech
|
|
*/
|
|
AudioStreamBuilder *setContentType(ContentType contentType) {
|
|
mContentType = contentType;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the input (capture) preset for the stream.
|
|
*
|
|
* The system will use this information to optimize the behavior of the stream.
|
|
* This could, for example, affect which microphones are used and how the
|
|
* recorded data is processed.
|
|
*
|
|
* The default, if you do not call this function, is InputPreset::VoiceRecognition.
|
|
* That is because VoiceRecognition is the preset with the lowest latency
|
|
* on many platforms.
|
|
*
|
|
* Added in API level 28.
|
|
*
|
|
* @param inputPreset the desired configuration for recording
|
|
*/
|
|
AudioStreamBuilder *setInputPreset(InputPreset inputPreset) {
|
|
mInputPreset = inputPreset;
|
|
return this;
|
|
}
|
|
|
|
/** Set the requested session ID.
|
|
*
|
|
* The session ID can be used to associate a stream with effects processors.
|
|
* The effects are controlled using the Android AudioEffect Java API.
|
|
*
|
|
* The default, if you do not call this function, is SessionId::None.
|
|
*
|
|
* If set to SessionId::Allocate then a session ID will be allocated
|
|
* when the stream is opened.
|
|
*
|
|
* The allocated session ID can be obtained by calling AudioStream::getSessionId()
|
|
* and then used with this function when opening another stream.
|
|
* This allows effects to be shared between streams.
|
|
*
|
|
* Session IDs from Oboe can be used the Android Java APIs and vice versa.
|
|
* So a session ID from an Oboe stream can be passed to Java
|
|
* and effects applied using the Java AudioEffect API.
|
|
*
|
|
* Allocated session IDs will always be positive and nonzero.
|
|
*
|
|
* Added in API level 28.
|
|
*
|
|
* @param sessionId an allocated sessionID or SessionId::Allocate
|
|
*/
|
|
AudioStreamBuilder *setSessionId(SessionId sessionId) {
|
|
mSessionId = sessionId;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Request a stream to a specific audio input/output device given an audio device ID.
|
|
*
|
|
* In most cases, the primary device will be the appropriate device to use, and the
|
|
* deviceId can be left kUnspecified.
|
|
*
|
|
* The ID could be obtained from the Java AudioManager.
|
|
* AudioManager.getDevices() returns an array of AudioDeviceInfo,
|
|
* which contains a getId() method. That ID can be passed to this function.
|
|
*
|
|
* It is possible that you may not get the device that you requested.
|
|
* So if it is important to you, you should call
|
|
* stream->getDeviceId() after the stream is opened to
|
|
* verify the actual ID.
|
|
*
|
|
* Note that when using OpenSL ES, this will be ignored and the created
|
|
* stream will have deviceId kUnspecified.
|
|
*
|
|
* @param deviceId device identifier or kUnspecified
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setDeviceId(int32_t deviceId) {
|
|
mDeviceIds.clear();
|
|
if (deviceId != kUnspecified) {
|
|
mDeviceIds.push_back(deviceId);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specify whether this stream audio may or may not be captured by other apps or the system.
|
|
*
|
|
* The default is AllowedCapturePolicy::Unspecified which maps to AAUDIO_ALLOW_CAPTURE_BY_ALL.
|
|
*
|
|
* Note that an application can also set its global policy, in which case the most restrictive
|
|
* policy is always applied. See android.media.AudioAttributes.setAllowedCapturePolicy.
|
|
*
|
|
* Added in API level 29 to AAudio.
|
|
*
|
|
* @param inputPreset the desired level of opt-out from being captured.
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setAllowedCapturePolicy(AllowedCapturePolicy allowedCapturePolicy) {
|
|
mAllowedCapturePolicy = allowedCapturePolicy;
|
|
return this;
|
|
}
|
|
|
|
/** Indicates whether this input stream must be marked as privacy sensitive or not.
|
|
*
|
|
* When PrivacySensitiveMode::Enabled, this input stream is privacy sensitive and any
|
|
* concurrent capture is not permitted.
|
|
*
|
|
* This is off (PrivacySensitiveMode::Disabled) by default except when the input preset is
|
|
* InputPreset::VoiceRecognition or InputPreset::Camcorder
|
|
*
|
|
* Always takes precedence over default from input preset when set explicitly.
|
|
*
|
|
* Only relevant if the stream direction is Direction::Input and AAudio is used.
|
|
*
|
|
* Added in API level 30 to AAudio.
|
|
*
|
|
* @param privacySensitive PrivacySensitiveMode::Enabled if capture from this stream must be
|
|
* marked as privacy sensitive, PrivacySensitiveMode::Disabled if stream should be marked as
|
|
* not sensitive.
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setPrivacySensitiveMode(PrivacySensitiveMode privacySensitiveMode) {
|
|
mPrivacySensitiveMode = privacySensitiveMode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies whether the audio data of this output stream has already been processed for spatialization.
|
|
*
|
|
* If the stream has been processed for spatialization, setting this to true will prevent issues such as
|
|
* double-processing on platforms that will spatialize audio data.
|
|
*
|
|
* This is false by default.
|
|
*
|
|
* Available since API level 32.
|
|
*
|
|
* @param isContentSpatialized whether the content is already spatialized
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setIsContentSpatialized(bool isContentSpatialized) {
|
|
mIsContentSpatialized = isContentSpatialized;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the behavior affecting whether spatialization will be used.
|
|
*
|
|
* The AAudio system will use this information to select whether the stream will go through a
|
|
* spatializer effect or not when the effect is supported and enabled.
|
|
*
|
|
* This is SpatializationBehavior::Never by default.
|
|
*
|
|
* Available since API level 32.
|
|
*
|
|
* @param spatializationBehavior the desired spatialization behavior
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setSpatializationBehavior(SpatializationBehavior spatializationBehavior) {
|
|
mSpatializationBehavior = spatializationBehavior;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies an object to handle data related callbacks from the underlying API.
|
|
*
|
|
* <strong>Important: See AudioStreamCallback for restrictions on what may be called
|
|
* from the callback methods.</strong>
|
|
*
|
|
* We pass a shared_ptr so that the sharedDataCallback object cannot be deleted
|
|
* before the stream is deleted.
|
|
*
|
|
* @param sharedDataCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setDataCallback(std::shared_ptr<AudioStreamDataCallback> sharedDataCallback) {
|
|
// Use this raw pointer in the rest of the code to retain backwards compatibility.
|
|
mDataCallback = sharedDataCallback.get();
|
|
// Hold a shared_ptr to protect the raw pointer for the lifetime of the stream.
|
|
mSharedDataCallback = sharedDataCallback;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Pass a raw pointer to a data callback. This is not recommended because the dataCallback
|
|
* object might get deleted by the app while it is being used.
|
|
*
|
|
* @deprecated Call setDataCallback(std::shared_ptr<AudioStreamDataCallback>) instead.
|
|
* @param dataCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setDataCallback(AudioStreamDataCallback *dataCallback) {
|
|
mDataCallback = dataCallback;
|
|
mSharedDataCallback = nullptr;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies an object to handle error related callbacks from the underlying API.
|
|
* This can occur when a stream is disconnected because a headset is plugged in or unplugged.
|
|
* It can also occur if the audio service fails or if an exclusive stream is stolen by
|
|
* another stream.
|
|
*
|
|
* Note that error callbacks will only be called when a data callback has been specified
|
|
* and the stream is started. If you are not using a data callback then the read(), write()
|
|
* and requestStart() methods will return errors if the stream is disconnected.
|
|
*
|
|
* <strong>Important: See AudioStreamCallback for restrictions on what may be called
|
|
* from the callback methods.</strong>
|
|
*
|
|
* <strong>When an error callback occurs, the associated stream must be stopped and closed
|
|
* in a separate thread.</strong>
|
|
*
|
|
* We pass a shared_ptr so that the errorCallback object cannot be deleted before the stream is deleted.
|
|
* If the stream was created using a shared_ptr then the stream cannot be deleted before the
|
|
* error callback has finished running.
|
|
*
|
|
* @param sharedErrorCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setErrorCallback(std::shared_ptr<AudioStreamErrorCallback> sharedErrorCallback) {
|
|
// Use this raw pointer in the rest of the code to retain backwards compatibility.
|
|
mErrorCallback = sharedErrorCallback.get();
|
|
// Hold a shared_ptr to protect the raw pointer for the lifetime of the stream.
|
|
mSharedErrorCallback = sharedErrorCallback;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Pass a raw pointer to an error callback. This is not recommended because the errorCallback
|
|
* object might get deleted by the app while it is being used.
|
|
*
|
|
* @deprecated Call setErrorCallback(std::shared_ptr<AudioStreamErrorCallback>) instead.
|
|
* @param errorCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setErrorCallback(AudioStreamErrorCallback *errorCallback) {
|
|
mErrorCallback = errorCallback;
|
|
mSharedErrorCallback = nullptr;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies an object to handle data presentation related callbacks from the underlying API.
|
|
* This can occur when all data queued in the audio system for an offload stream has been
|
|
* played.
|
|
*
|
|
* Note that presentation callbacks will only be called when a data callback has been specified
|
|
* and the stream is started.
|
|
*
|
|
* <strong>Important: See AudioStreamCallback for restrictions on what may be called
|
|
* from the callback methods.</strong>
|
|
*
|
|
* We pass a shared_ptr so that the presentationCallback object cannot be deleted before the
|
|
* stream is deleted. If the stream was created using a shared_ptr then the stream cannot be
|
|
* deleted before the presentation callback has finished running.
|
|
*
|
|
* @param sharedPresentationCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setPresentationCallback(
|
|
std::shared_ptr<AudioStreamPresentationCallback> sharedPresentationCallback) {
|
|
mSharedPresentationCallback = sharedPresentationCallback;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies an object to handle data or error related callbacks from the underlying API.
|
|
*
|
|
* This is the equivalent of calling both setDataCallback() and setErrorCallback().
|
|
*
|
|
* <strong>Important: See AudioStreamCallback for restrictions on what may be called
|
|
* from the callback methods.</strong>
|
|
*
|
|
* @deprecated Call setDataCallback(std::shared_ptr<AudioStreamDataCallback>) and
|
|
* setErrorCallback(std::shared_ptr<AudioStreamErrorCallback>) instead.
|
|
* @param streamCallback
|
|
* @return pointer to the builder so calls can be chained
|
|
*/
|
|
AudioStreamBuilder *setCallback(AudioStreamCallback *streamCallback) {
|
|
// Use the same callback object for both, dual inheritance.
|
|
mDataCallback = streamCallback;
|
|
mErrorCallback = streamCallback;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* If true then Oboe might convert channel counts to achieve optimal results.
|
|
* On some versions of Android for example, stereo streams could not use a FAST track.
|
|
* So a mono stream might be used instead and duplicated to two channels.
|
|
* On some devices, mono streams might be broken, so a stereo stream might be opened
|
|
* and converted to mono.
|
|
*
|
|
* Default is false.
|
|
*/
|
|
AudioStreamBuilder *setChannelConversionAllowed(bool allowed) {
|
|
mChannelConversionAllowed = allowed;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* If true then Oboe might convert data formats to achieve optimal results.
|
|
* On some versions of Android, for example, a float stream could not get a
|
|
* low latency data path. So an I16 stream might be opened and converted to float.
|
|
*
|
|
* Default is false.
|
|
*/
|
|
AudioStreamBuilder *setFormatConversionAllowed(bool allowed) {
|
|
mFormatConversionAllowed = allowed;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specify the quality of the sample rate converter in Oboe.
|
|
*
|
|
* If set to None then Oboe will not do sample rate conversion. But the underlying APIs might
|
|
* still do sample rate conversion if you specify a sample rate.
|
|
* That can prevent you from getting a low latency stream.
|
|
*
|
|
* If you do the conversion in Oboe then you might still get a low latency stream.
|
|
*
|
|
* Default is SampleRateConversionQuality::Medium
|
|
*/
|
|
AudioStreamBuilder *setSampleRateConversionQuality(SampleRateConversionQuality quality) {
|
|
mSampleRateConversionQuality = quality;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Declare the name of the package creating the stream.
|
|
*
|
|
* This is usually {@code Context#getPackageName()}.
|
|
*
|
|
* The default, if you do not call this function, is a random package in the calling uid.
|
|
* The vast majority of apps have only one package per calling UID.
|
|
* If an invalid package name is set, input streams may not be given permission to
|
|
* record when started.
|
|
*
|
|
* The package name is usually the applicationId in your app's build.gradle file.
|
|
*
|
|
* Available since API level 31.
|
|
*
|
|
* @param packageName packageName of the calling app.
|
|
*/
|
|
AudioStreamBuilder *setPackageName(std::string packageName) {
|
|
mPackageName = packageName;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Declare the attribution tag of the context creating the stream.
|
|
*
|
|
* This is usually {@code Context#getAttributionTag()}.
|
|
*
|
|
* The default, if you do not call this function, is null.
|
|
*
|
|
* Available since API level 31.
|
|
*
|
|
* @param attributionTag attributionTag of the calling context.
|
|
*/
|
|
AudioStreamBuilder *setAttributionTag(std::string attributionTag) {
|
|
mAttributionTag = attributionTag;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @return true if AAudio will be used based on the current settings.
|
|
*/
|
|
bool willUseAAudio() const {
|
|
return (mAudioApi == AudioApi::AAudio && isAAudioSupported())
|
|
|| (mAudioApi == AudioApi::Unspecified && isAAudioRecommended());
|
|
}
|
|
|
|
/**
|
|
* Create and open a stream object based on the current settings.
|
|
*
|
|
* The caller owns the pointer to the AudioStream object
|
|
* and must delete it when finished.
|
|
*
|
|
* @deprecated Use openStream(std::shared_ptr<oboe::AudioStream> &stream) instead.
|
|
* @param stream pointer to a variable to receive the stream address
|
|
* @return OBOE_OK if successful or a negative error code
|
|
*/
|
|
Result openStream(AudioStream **stream);
|
|
|
|
/**
|
|
* Create and open a stream object based on the current settings.
|
|
*
|
|
* The caller shares the pointer to the AudioStream object.
|
|
* The shared_ptr is used internally by Oboe to prevent the stream from being
|
|
* deleted while it is being used by callbacks.
|
|
*
|
|
* @param stream reference to a shared_ptr to receive the stream address
|
|
* @return OBOE_OK if successful or a negative error code
|
|
*/
|
|
Result openStream(std::shared_ptr<oboe::AudioStream> &stream);
|
|
|
|
/**
|
|
* Create and open a ManagedStream object based on the current builder state.
|
|
*
|
|
* The caller must create a unique ptr, and pass by reference so it can be
|
|
* modified to point to an opened stream. The caller owns the unique ptr,
|
|
* and it will be automatically closed and deleted when going out of scope.
|
|
*
|
|
* @deprecated Use openStream(std::shared_ptr<oboe::AudioStream> &stream) instead.
|
|
* @param stream Reference to the ManagedStream (uniqueptr) used to keep track of stream
|
|
* @return OBOE_OK if successful or a negative error code.
|
|
*/
|
|
Result openManagedStream(ManagedStream &stream);
|
|
|
|
private:
|
|
|
|
/**
|
|
* Use this internally to implement opening with a shared_ptr.
|
|
*
|
|
* @param stream pointer to a variable to receive the stream address
|
|
* @return OBOE_OK if successful or a negative error code.
|
|
*/
|
|
Result openStreamInternal(AudioStream **streamPP);
|
|
|
|
/**
|
|
* @param other
|
|
* @return true if channels, format and sample rate match
|
|
*/
|
|
bool isCompatible(AudioStreamBase &other);
|
|
|
|
/**
|
|
* Create an AudioStream object. The AudioStream must be opened before use.
|
|
*
|
|
* The caller owns the pointer.
|
|
*
|
|
* @return pointer to an AudioStream object or nullptr.
|
|
*/
|
|
oboe::AudioStream *build();
|
|
|
|
AudioApi mAudioApi = AudioApi::Unspecified;
|
|
};
|
|
|
|
} // namespace oboe
|
|
|
|
#endif /* OBOE_STREAM_BUILDER_H_ */
|