Oboe  1.2
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 <atomic>
21 #include <cstdint>
22 #include <ctime>
23 #include <mutex>
24 #include "oboe/Definitions.h"
25 #include "oboe/ResultWithValue.h"
26 #include "oboe/AudioStreamBuilder.h"
27 #include "oboe/AudioStreamBase.h"
28 
31 namespace oboe {
32 
39 constexpr int64_t kDefaultTimeoutNanos = (2000 * kNanosPerMillisecond);
40 
44 class AudioStream : public AudioStreamBase {
45 public:
46 
47  AudioStream() {}
48 
54  explicit AudioStream(const AudioStreamBuilder &builder);
55 
56  virtual ~AudioStream() = default;
57 
66  virtual Result open();
67 
71  virtual Result close();
72 
77  virtual Result start(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
78 
83  virtual Result pause(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
84 
89  virtual Result flush(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
90 
95  virtual Result stop(int64_t timeoutNanoseconds = kDefaultTimeoutNanos);
96 
97  /* Asynchronous requests.
98  * Use waitForStateChange() if you need to wait for completion.
99  */
100 
105  virtual Result requestStart() = 0;
106 
111  virtual Result requestPause() = 0;
112 
117  virtual Result requestFlush() = 0;
118 
123  virtual Result requestStop() = 0;
124 
130  virtual StreamState getState() = 0;
131 
159  virtual Result waitForStateChange(StreamState inputState,
160  StreamState *nextState,
161  int64_t timeoutNanoseconds) = 0;
162 
175  virtual ResultWithValue<int32_t> setBufferSizeInFrames(int32_t requestedFrames) {
176  return Result::ErrorUnimplemented;
177  }
178 
192  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
193  }
194 
198  virtual bool isXRunCountSupported() const = 0;
199 
205  virtual int32_t getFramesPerBurst() = 0;
206 
214  int32_t getBytesPerFrame() const { return mChannelCount * getBytesPerSample(); }
215 
222  int32_t getBytesPerSample() const;
223 
230  virtual int64_t getFramesWritten();
231 
238  virtual int64_t getFramesRead();
239 
264  return ResultWithValue<double>(Result::ErrorUnimplemented);
265  }
266 
282  virtual Result getTimestamp(clockid_t clockId,
283  int64_t *framePosition,
284  int64_t *timeNanoseconds) {
285  return Result::ErrorUnimplemented;
286  }
287 
303  virtual ResultWithValue<FrameTimestamp> getTimestamp(clockid_t clockId){
304  return Result::ErrorUnimplemented;
305  }
306 
307  // ============== I/O ===========================
320  virtual ResultWithValue<int32_t> write(const void *buffer,
321  int32_t numFrames,
322  int64_t timeoutNanoseconds) {
323  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
324  }
325 
338  virtual ResultWithValue<int32_t> read(void *buffer,
339  int32_t numFrames,
340  int64_t timeoutNanoseconds) {
341  return ResultWithValue<int32_t>(Result::ErrorUnimplemented);
342  }
343 
349  virtual AudioApi getAudioApi() const = 0;
350 
356  bool usesAAudio() const {
357  return getAudioApi() == AudioApi::AAudio;
358  }
359 
368  virtual void *getUnderlyingStream() const {
369  return nullptr;
370  }
371 
375  void launchStopThread();
376 
377 protected:
378 
385  virtual Result waitForStateTransition(StreamState startingState,
386  StreamState endingState,
387  int64_t timeoutNanoseconds);
388 
396  virtual DataCallbackResult onDefaultCallback(void *audioData, int numFrames) {
397  return DataCallbackResult::Stop;
398  }
399 
408  DataCallbackResult fireDataCallback(void *audioData, int numFrames);
409 
413  virtual void updateFramesWritten() = 0;
414 
418  virtual void updateFramesRead() = 0;
419 
424  return mDataCallbackEnabled;
425  }
426 
431  void setDataCallbackEnabled(bool enabled) {
432  mDataCallbackEnabled = enabled;
433  }
434 
441  std::atomic<int64_t> mFramesWritten{};
442 
449  std::atomic<int64_t> mFramesRead{};
450 
451  std::mutex mLock; // for synchronizing start/stop/close
452 
453 private:
454  int mPreviousScheduler = -1;
455 
456  std::atomic<bool> mDataCallbackEnabled{};
457 
458 };
459 
460 } // namespace oboe
461 
462 #endif /* OBOE_STREAM_H_ */
virtual Result stop(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
Definition: AudioStreamBuilder.h:28
void setDataCallbackEnabled(bool enabled)
Definition: AudioStream.h:431
bool usesAAudio() const
Definition: AudioStream.h:356
virtual Result flush(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
int32_t getBytesPerFrame() const
Definition: AudioStream.h:214
virtual Result start(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
constexpr int64_t kDefaultTimeoutNanos
Definition: AudioStream.h:39
virtual ResultWithValue< int32_t > getXRunCount() const
Definition: AudioStream.h:191
std::atomic< int64_t > mFramesWritten
Definition: AudioStream.h:441
DataCallbackResult fireDataCallback(void *audioData, int numFrames)
virtual void * getUnderlyingStream() const
Definition: AudioStream.h:368
virtual void updateFramesWritten()=0
virtual int64_t getFramesWritten()
virtual ResultWithValue< int32_t > setBufferSizeInFrames(int32_t requestedFrames)
Definition: AudioStream.h:175
virtual StreamState getState()=0
int32_t mChannelCount
Definition: AudioStreamBase.h:135
DataCallbackResult
Definition: Definitions.h:119
AudioApi
Definition: Definitions.h:213
virtual Result waitForStateTransition(StreamState startingState, StreamState endingState, int64_t timeoutNanoseconds)
virtual int32_t getFramesPerBurst()=0
virtual Result close()
virtual ResultWithValue< double > calculateLatencyMillis()
Definition: AudioStream.h:263
virtual Result open()
virtual int64_t getFramesRead()
Definition: AudioStream.h:44
bool isDataCallbackEnabled()
Definition: AudioStream.h:423
virtual ResultWithValue< FrameTimestamp > getTimestamp(clockid_t clockId)
Definition: AudioStream.h:303
virtual Result requestPause()=0
std::atomic< int64_t > mFramesRead
Definition: AudioStream.h:449
Definition: AudioStreamBase.h:29
virtual ResultWithValue< int32_t > read(void *buffer, int32_t numFrames, int64_t timeoutNanoseconds)
Definition: AudioStream.h:338
constexpr int64_t kNanosPerMillisecond
Definition: Definitions.h:43
virtual ResultWithValue< int32_t > write(const void *buffer, int32_t numFrames, int64_t timeoutNanoseconds)
Definition: AudioStream.h:320
virtual DataCallbackResult onDefaultCallback(void *audioData, int numFrames)
Definition: AudioStream.h:396
virtual Result requestStop()=0
virtual AudioApi getAudioApi() const =0
virtual Result getTimestamp(clockid_t clockId, int64_t *framePosition, int64_t *timeNanoseconds)
Definition: AudioStream.h:282
virtual Result waitForStateChange(StreamState inputState, StreamState *nextState, int64_t timeoutNanoseconds)=0
Result
Definition: Definitions.h:131
Definition: AudioStream.h:31
virtual bool isXRunCountSupported() const =0
virtual Result requestStart()=0
StreamState
Definition: Definitions.h:58
virtual Result pause(int64_t timeoutNanoseconds=kDefaultTimeoutNanos)
virtual Result requestFlush()=0
virtual void updateFramesRead()=0
int32_t getBytesPerSample() const
Definition: ResultWithValue.h:47