AudioStreamBuilder.h revision e2fbb59e729f6c3cade3b531f6f6411417ccbf40 
1/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef AAUDIO_AUDIO_STREAM_BUILDER_H
18#define AAUDIO_AUDIO_STREAM_BUILDER_H
19
20#include <stdint.h>
21
22#include <aaudio/AAudio.h>
23
24#include "AudioStream.h"
25
26namespace aaudio {
27
28/**
29 * Factory class for an AudioStream.
30 */
31class AudioStreamBuilder {
32public:
33    AudioStreamBuilder();
34
35    ~AudioStreamBuilder();
36
37    int getSamplesPerFrame() const {
38        return mSamplesPerFrame;
39    }
40
41    /**
42     * This is also known as channelCount.
43     */
44    AudioStreamBuilder* setSamplesPerFrame(int samplesPerFrame) {
45        mSamplesPerFrame = samplesPerFrame;
46        return this;
47    }
48
49    aaudio_direction_t getDirection() const {
50        return mDirection;
51    }
52
53    AudioStreamBuilder* setDirection(aaudio_direction_t direction) {
54        mDirection = direction;
55        return this;
56    }
57
58    int32_t getSampleRate() const {
59        return mSampleRate;
60    }
61
62    AudioStreamBuilder* setSampleRate(int32_t sampleRate) {
63        mSampleRate = sampleRate;
64        return this;
65    }
66
67    aaudio_audio_format_t getFormat() const {
68        return mFormat;
69    }
70
71    AudioStreamBuilder *setFormat(aaudio_audio_format_t format) {
72        mFormat = format;
73        return this;
74    }
75
76    aaudio_sharing_mode_t getSharingMode() const {
77        return mSharingMode;
78    }
79
80    AudioStreamBuilder* setSharingMode(aaudio_sharing_mode_t sharingMode) {
81        mSharingMode = sharingMode;
82        return this;
83    }
84
85    bool isSharingModeMatchRequired() const {
86        return mSharingModeMatchRequired;
87    }
88
89    AudioStreamBuilder* setSharingModeMatchRequired(bool required) {
90        mSharingModeMatchRequired = required;
91        return this;
92    }
93
94    int32_t getBufferCapacity() const {
95        return mBufferCapacity;
96    }
97
98    AudioStreamBuilder* setBufferCapacity(int32_t frames) {
99        mBufferCapacity = frames;
100        return this;
101    }
102
103    int32_t getPerformanceMode() const {
104        return mPerformanceMode;
105    }
106
107    AudioStreamBuilder* setPerformanceMode(aaudio_performance_mode_t performanceMode) {
108        mPerformanceMode = performanceMode;
109        return this;
110    }
111
112    int32_t getDeviceId() const {
113        return mDeviceId;
114    }
115
116    AudioStreamBuilder* setDeviceId(int32_t deviceId) {
117        mDeviceId = deviceId;
118        return this;
119    }
120
121    AAudioStream_dataCallback getDataCallbackProc() const {
122        return mDataCallbackProc;
123    }
124
125    AudioStreamBuilder* setDataCallbackProc(AAudioStream_dataCallback proc) {
126        mDataCallbackProc = proc;
127        return this;
128    }
129
130    void *getDataCallbackUserData() const {
131        return mDataCallbackUserData;
132    }
133
134    AudioStreamBuilder* setDataCallbackUserData(void *userData) {
135        mDataCallbackUserData = userData;
136        return this;
137    }
138
139    AAudioStream_errorCallback getErrorCallbackProc() const {
140        return mErrorCallbackProc;
141    }
142
143    AudioStreamBuilder* setErrorCallbackProc(AAudioStream_errorCallback proc) {
144        mErrorCallbackProc = proc;
145        return this;
146    }
147
148    AudioStreamBuilder* setErrorCallbackUserData(void *userData) {
149        mErrorCallbackUserData = userData;
150        return this;
151    }
152
153    void *getErrorCallbackUserData() const {
154        return mErrorCallbackUserData;
155    }
156
157    int32_t getFramesPerDataCallback() const {
158        return mFramesPerDataCallback;
159    }
160
161    AudioStreamBuilder* setFramesPerDataCallback(int32_t sizeInFrames) {
162        mFramesPerDataCallback = sizeInFrames;
163        return this;
164    }
165
166    aaudio_result_t build(AudioStream **streamPtr);
167
168private:
169    int32_t                    mSamplesPerFrame = AAUDIO_UNSPECIFIED;
170    int32_t                    mSampleRate = AAUDIO_UNSPECIFIED;
171    int32_t                    mDeviceId = AAUDIO_DEVICE_UNSPECIFIED;
172    aaudio_sharing_mode_t      mSharingMode = AAUDIO_SHARING_MODE_SHARED;
173    bool                       mSharingModeMatchRequired = false; // must match sharing mode requested
174    aaudio_audio_format_t      mFormat = AAUDIO_FORMAT_UNSPECIFIED;
175    aaudio_direction_t         mDirection = AAUDIO_DIRECTION_OUTPUT;
176    int32_t                    mBufferCapacity = AAUDIO_UNSPECIFIED;
177    aaudio_performance_mode_t  mPerformanceMode = AAUDIO_PERFORMANCE_MODE_NONE;
178
179    AAudioStream_dataCallback  mDataCallbackProc = nullptr;  // external callback functions
180    void                      *mDataCallbackUserData = nullptr;
181    int32_t                    mFramesPerDataCallback = AAUDIO_UNSPECIFIED; // frames
182
183    AAudioStream_errorCallback mErrorCallbackProc = nullptr;
184    void                      *mErrorCallbackUserData = nullptr;
185};
186
187} /* namespace aaudio */
188
189#endif //AAUDIO_AUDIO_STREAM_BUILDER_H
190