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 "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 mDeviceId; }
 
    AudioStreamDataCallback *getDataCallback() const {
        return mDataCallback;
    }
 
    AudioStreamErrorCallback *getErrorCallback() const {
        return mErrorCallback;
    }
 
    bool isDataCallbackSpecified() const {
        return mDataCallback != nullptr;
    }
 
    bool isErrorCallbackSpecified() const {
        return mErrorCallback != nullptr;
    }
 
    Usage getUsage() const { return mUsage; }
 
    ContentType getContentType() const { return mContentType; }
 
    InputPreset getInputPreset() const { return mInputPreset; }
 
    SessionId getSessionId() const { return mSessionId; }
 
    bool isChannelConversionAllowed() const {
        return mChannelConversionAllowed;
    }
 
    bool  isFormatConversionAllowed() const {
        return mFormatConversionAllowed;
    }
 
    SampleRateConversionQuality getSampleRateConversionQuality() const {
        return mSampleRateConversionQuality;
    }
 
    ChannelMask getChannelMask() const {
        return mChannelMask;
    }
 
protected:
    AudioStreamDataCallback        *mDataCallback = nullptr;
    std::shared_ptr<AudioStreamDataCallback> mSharedDataCallback;
 
    AudioStreamErrorCallback       *mErrorCallback = nullptr;
    std::shared_ptr<AudioStreamErrorCallback> mSharedErrorCallback;
 
    int32_t                         mFramesPerCallback = kUnspecified;
    int32_t                         mChannelCount = kUnspecified;
    int32_t                         mSampleRate = kUnspecified;
    int32_t                         mDeviceId = 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;
 
    std::string                     mPackageName;
    std::string                     mAttributionTag;
 
    // 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::None;
 
    virtual Result isValidConfig() {
        switch (mFormat) {
            case AudioFormat::Unspecified:
            case AudioFormat::I16:
            case AudioFormat::Float:
            case AudioFormat::I24:
            case AudioFormat::I32:
                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_ */