Oboe  1.0
A library for creating real-time audio apps on Android
AudioStream.h
1 /*
2  * Copyright 2016 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 OBOE_STREAM_H_
18 #define OBOE_STREAM_H_
19 
20 #include <cstdint>
21 #include <ctime>
22 #include "oboe/Definitions.h"
23 #include "oboe/ResultWithValue.h"
24 #include "oboe/AudioStreamBuilder.h"
25 #include "oboe/AudioStreamBase.h"
26 
29 namespace oboe {
30 
37 constexpr int64_t kDefaultTimeoutNanos = (2000 * kNanosPerMillisecond);
38 
42 class AudioStream : public AudioStreamBase {
43 public:
44 
45  AudioStream() {}
46 
52  explicit AudioStream(const AudioStreamBuilder &builder);
53 
54  virtual ~AudioStream() = default;
55 
64  virtual Result open();
65 
69  virtual Result close() = 0;
70 
75  virtual Result start(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
76 
81  virtual Result pause(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
82 
87  virtual Result flush(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
88 
93  virtual Result stop(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
94 
95  /* Asynchronous requests.
96  * Use waitForStateChange() if you need to wait for completion.
97  */
98 
103  virtual Result requestStart() = 0;
104 
109  virtual Result requestPause() = 0;
110 
115  virtual Result requestFlush() = 0;
116 
121  virtual Result requestStop() = 0;
122 
128  virtual StreamState getState() = 0;
129 
154  virtual Result waitForStateChange(StreamState inputState,
155  StreamState *nextState,
156  int64_t timeoutNanoseconds) = 0;
157 
170  virtual ResultWithValue<int32_t> setBufferSizeInFrames(int32_t requestedFrames) {
171  return Result::ErrorUnimplemented;
172  }
173 
187  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
188  }
189 
193  virtual bool isXRunCountSupported() const = 0;
194 
200  virtual int32_t getFramesPerBurst() = 0;
201 
207  bool isPlaying();
208 
216  int32_t getBytesPerFrame() const { return mChannelCount * getBytesPerSample(); }
217 
224  int32_t getBytesPerSample() const;
225 
232  virtual int64_t getFramesWritten() { return mFramesWritten; }
233 
240  virtual int64_t getFramesRead() { return mFramesRead; }
241 
266  return ResultWithValue<double>(Result::ErrorUnimplemented);
267  }
268 
285  virtual Result getTimestamp(clockid_t clockId,
286  int64_t *framePosition,
287  int64_t *timeNanoseconds) {
288  return Result::ErrorUnimplemented;
289  }
290 
291  // ============== I/O ===========================
304  virtual ResultWithValue<int32_t> write(const void *buffer,
305  int32_t numFrames,
306  int64_t timeoutNanoseconds) {
307  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
308  }
309 
322  virtual ResultWithValue<int32_t> read(void *buffer,
323  int32_t numFrames,
324  int64_t timeoutNanoseconds) {
325  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
326  }
327 
333  virtual AudioApi getAudioApi() const = 0;
334 
340  bool usesAAudio() const {
341  return getAudioApi() == AudioApi::AAudio;
342  }
343 
352  virtual void *getUnderlyingStream() const {
353  return nullptr;
354  }
355 
356 protected:
357 
364  virtual int64_t incrementFramesWritten(int32_t frames) {
365  return mFramesWritten += frames;
366  }
367 
374  virtual int64_t incrementFramesRead(int32_t frames) {
375  return mFramesRead += frames;
376  }
377 
384  virtual Result waitForStateTransition(StreamState startingState,
385  StreamState endingState,
386  int64_t timeoutNanoseconds);
387 
395  virtual DataCallbackResult onDefaultCallback(void *audioData, int numFrames) {
396  return DataCallbackResult::Stop;
397  }
398 
407  DataCallbackResult fireCallback(void *audioData, int numFrames);
408 
412  virtual void setNativeFormat(AudioFormat format) {
413  mNativeFormat = format;
414  }
415 
416  AudioFormat mNativeFormat = AudioFormat::Invalid;
417 
423  int64_t mFramesWritten = 0;
424 
430  int64_t mFramesRead = 0;
431 
432 private:
433  int mPreviousScheduler = -1;
434 };
435 
436 } // namespace oboe
437 
438 #endif /* OBOE_STREAM_H_ */
virtual Result stop(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
Definition: AudioStreamBuilder.h:28
virtual int64_t incrementFramesRead(int32_t frames)
Definition: AudioStream.h:374
bool usesAAudio() const
Definition: AudioStream.h:340
virtual Result flush(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
int32_t getBytesPerFrame() const
Definition: AudioStream.h:216
DataCallbackResult fireCallback(void *audioData, int numFrames)
virtual Result start(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
constexpr int64_t kDefaultTimeoutNanos
Definition: AudioStream.h:37
virtual ResultWithValue< int32_t > getXRunCount() const
Definition: AudioStream.h:186
virtual void * getUnderlyingStream() const
Definition: AudioStream.h:352
int64_t mFramesWritten
Definition: AudioStream.h:423
Result
Definition: Definitions.h:140
virtual int64_t getFramesWritten()
Definition: AudioStream.h:232
virtual Result close()=0
virtual ResultWithValue< int32_t > setBufferSizeInFrames(int32_t requestedFrames)
Definition: AudioStream.h:170
virtual StreamState getState()=0
int32_t mChannelCount
Definition: AudioStreamBase.h:135
virtual void setNativeFormat(AudioFormat format)
Definition: AudioStream.h:412
AudioApi
Definition: Definitions.h:216
virtual Result waitForStateTransition(StreamState startingState, StreamState endingState, int64_t timeoutNanoseconds)
virtual int32_t getFramesPerBurst()=0
int64_t mFramesRead
Definition: AudioStream.h:430
virtual ResultWithValue< double > calculateLatencyMillis()
Definition: AudioStream.h:265
virtual Result open()
virtual int64_t getFramesRead()
Definition: AudioStream.h:240
Definition: AudioStream.h:42
AudioFormat
Definition: Definitions.h:103
DataCallbackResult
Definition: Definitions.h:128
virtual Result requestPause()=0
Definition: AudioStreamBase.h:29
virtual ResultWithValue< int32_t > read(void *buffer, int32_t numFrames, int64_t timeoutNanoseconds)
Definition: AudioStream.h:322
constexpr int64_t kNanosPerMillisecond
Definition: Definitions.h:52
virtual ResultWithValue< int32_t > write(const void *buffer, int32_t numFrames, int64_t timeoutNanoseconds)
Definition: AudioStream.h:304
virtual DataCallbackResult onDefaultCallback(void *audioData, int numFrames)
Definition: AudioStream.h:395
virtual int64_t incrementFramesWritten(int32_t frames)
Definition: AudioStream.h:364
virtual Result requestStop()=0
virtual AudioApi getAudioApi() const =0
virtual Result getTimestamp(clockid_t clockId, int64_t *framePosition, int64_t *timeNanoseconds)
Definition: AudioStream.h:285
virtual Result waitForStateChange(StreamState inputState, StreamState *nextState, int64_t timeoutNanoseconds)=0
StreamState
Definition: Definitions.h:67
Definition: AudioStream.h:29
virtual bool isXRunCountSupported() const =0
virtual Result requestStart()=0
virtual Result pause(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
virtual Result requestFlush()=0
int32_t getBytesPerSample() const
Definition: ResultWithValue.h:47