AudioStreamBase.h

/*
 * 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 {
 
class AudioStreamBase {
 
public:
 
    AudioStreamBase() {}
 
    virtual ~AudioStreamBase() = default;
 
    // This class only contains primitives so we can use default constructor and copy methods.
 
    AudioStreamBase(const AudioStreamBase&) = default;
 
    AudioStreamBase& operator=(const AudioStreamBase&) = default;
 
    int32_t getChannelCount() const { return mChannelCount; }
 
    Direction getDirection() const { return mDirection; }
 
    int32_t getSampleRate() const { return mSampleRate; }
 
    int32_t getFramesPerCallback() const { return getFramesPerDataCallback(); }
 
    int32_t getFramesPerDataCallback() const { return mFramesPerCallback; }
 
    AudioFormat getFormat() const { return mFormat; }
 
    virtual int32_t getBufferSizeInFrames() { return mBufferSizeInFrames; }
 
    virtual int32_t getBufferCapacityInFrames() const { return mBufferCapacityInFrames; }
 
    SharingMode getSharingMode() const { return mSharingMode; }
 
    PerformanceMode getPerformanceMode() const { return mPerformanceMode; }
 
    int32_t getDeviceId() const {
        return mDeviceIds.empty() ? kUnspecified :  mDeviceIds[0];
    }
 
    std::vector<int32_t> getDeviceIds() const {
        return mDeviceIds;
    }
 
    AudioStreamDataCallback *getDataCallback() const {
        return mDataCallback;
    }
 
    AudioStreamPartialDataCallback* getPartialDataCallback() const {
        return mPartialDataCallback;
    }
 
    AudioStreamErrorCallback *getErrorCallback() const {
        return mErrorCallback;
    }
 
    std::shared_ptr<AudioStreamPresentationCallback> getPresentationCallback() const {
        return mSharedPresentationCallback;
    }
 
    bool isDataCallbackSpecified() const {
        return mDataCallback != nullptr;
    }
 
    bool isPartialDataCallbackSpecified() const {
        return mPartialDataCallback != nullptr;
    }
 
    bool anyDataCallbackSpecified() const {
        return isDataCallbackSpecified() || isPartialDataCallbackSpecified();
    }
 
    bool isErrorCallbackSpecified() const {
        return mErrorCallback != nullptr;
    }
 
    bool isPresentationCallbackSpecified() const {
        return mSharedPresentationCallback != nullptr;
    }
 
    Usage getUsage() const { return mUsage; }
 
    ContentType getContentType() const { return mContentType; }
 
    InputPreset getInputPreset() const { return mInputPreset; }
 
    SessionId getSessionId() const { return mSessionId; }
 
    bool isContentSpatialized() const { return mIsContentSpatialized; }
 
    SpatializationBehavior getSpatializationBehavior() const { return mSpatializationBehavior; }
 
    AllowedCapturePolicy getAllowedCapturePolicy() const { return mAllowedCapturePolicy; }
 
    PrivacySensitiveMode getPrivacySensitiveMode() const { return mPrivacySensitiveMode; }
 
    std::string getPackageName() const { return mPackageName; }
 
    std::string getAttributionTag() const { return mAttributionTag; }
 
    bool isChannelConversionAllowed() const {
        return mChannelConversionAllowed;
    }
 
    bool  isFormatConversionAllowed() const {
        return mFormatConversionAllowed;
    }
 
    SampleRateConversionQuality getSampleRateConversionQuality() const {
        return mSampleRateConversionQuality;
    }
 
    ChannelMask getChannelMask() const {
        return mChannelMask;
    }
 
    int32_t getHardwareChannelCount() const { return mHardwareChannelCount; }
 
    int32_t getHardwareSampleRate() const { return mHardwareSampleRate; }
 
    AudioFormat getHardwareFormat() const { return mHardwareFormat; }
 
protected:
    AudioStreamDataCallback        *mDataCallback = nullptr;
    std::shared_ptr<AudioStreamDataCallback> mSharedDataCallback;
 
    AudioStreamPartialDataCallback  *mPartialDataCallback = nullptr;
    std::shared_ptr<AudioStreamPartialDataCallback> mSharedPartialDataCallback;
 
    AudioStreamErrorCallback       *mErrorCallback = nullptr;
    std::shared_ptr<AudioStreamErrorCallback> mSharedErrorCallback;
 
    std::shared_ptr<AudioStreamPresentationCallback> mSharedPresentationCallback;
 
    int32_t                         mFramesPerCallback = kUnspecified;
    int32_t                         mChannelCount = kUnspecified;
    int32_t                         mSampleRate = kUnspecified;
    int32_t                         mBufferCapacityInFrames = kUnspecified;
    int32_t                         mBufferSizeInFrames = kUnspecified;
    ChannelMask                     mChannelMask = ChannelMask::Unspecified;
 
    SharingMode                     mSharingMode = SharingMode::Shared;
    AudioFormat                     mFormat = AudioFormat::Unspecified;
    Direction                       mDirection = Direction::Output;
    PerformanceMode                 mPerformanceMode = PerformanceMode::None;
 
    Usage                           mUsage = Usage::Media;
    ContentType                     mContentType = ContentType::Music;
    InputPreset                     mInputPreset = InputPreset::VoiceRecognition;
    SessionId                       mSessionId = SessionId::None;
 
    AllowedCapturePolicy            mAllowedCapturePolicy = AllowedCapturePolicy::Unspecified;
 
    PrivacySensitiveMode            mPrivacySensitiveMode = PrivacySensitiveMode::Unspecified;
 
    std::string                     mPackageName;
    std::string                     mAttributionTag;
 
    bool                            mIsContentSpatialized = false;
    SpatializationBehavior          mSpatializationBehavior = SpatializationBehavior::Unspecified;
 
    int32_t                         mHardwareChannelCount = kUnspecified;
    int32_t                         mHardwareSampleRate = kUnspecified;
    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;
 
    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_ */