blob: 9c433cd4ee2ef37b602a5acee474ff92167877b0 [file] [log] [blame]
Phil Burke1ce4912016-11-21 10:40:25 -08001/*
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#define LOG_TAG "AudioStreamTrack"
18//#define LOG_NDEBUG 0
19#include <utils/Log.h>
20
21#include <stdint.h>
22#include <media/AudioTrack.h>
Phil Burke1ce4912016-11-21 10:40:25 -080023
Phil Burke4d7bb42017-03-28 11:32:39 -070024#include <aaudio/AAudio.h>
Phil Burkc0c70e32017-02-09 13:18:38 -080025#include "utility/AudioClock.h"
Phil Burke4d7bb42017-03-28 11:32:39 -070026#include "legacy/AudioStreamLegacy.h"
27#include "legacy/AudioStreamTrack.h"
28#include "utility/FixedBlockReader.h"
Phil Burke1ce4912016-11-21 10:40:25 -080029
30using namespace android;
Phil Burk5ed503c2017-02-01 09:38:15 -080031using namespace aaudio;
Phil Burke1ce4912016-11-21 10:40:25 -080032
Phil Burke4d7bb42017-03-28 11:32:39 -070033// Arbitrary and somewhat generous number of bursts.
34#define DEFAULT_BURSTS_PER_BUFFER_CAPACITY 8
35
Phil Burke1ce4912016-11-21 10:40:25 -080036/*
37 * Create a stream that uses the AudioTrack.
38 */
39AudioStreamTrack::AudioStreamTrack()
Phil Burke4d7bb42017-03-28 11:32:39 -070040 : AudioStreamLegacy()
41 , mFixedBlockReader(*this)
Phil Burke1ce4912016-11-21 10:40:25 -080042{
43}
44
45AudioStreamTrack::~AudioStreamTrack()
46{
Phil Burk5ed503c2017-02-01 09:38:15 -080047 const aaudio_stream_state_t state = getState();
48 bool bad = !(state == AAUDIO_STREAM_STATE_UNINITIALIZED || state == AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -080049 ALOGE_IF(bad, "stream not closed, in state %d", state);
50}
51
Phil Burk5ed503c2017-02-01 09:38:15 -080052aaudio_result_t AudioStreamTrack::open(const AudioStreamBuilder& builder)
Phil Burke1ce4912016-11-21 10:40:25 -080053{
Phil Burk5ed503c2017-02-01 09:38:15 -080054 aaudio_result_t result = AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -080055
56 result = AudioStream::open(builder);
57 if (result != OK) {
58 return result;
59 }
60
Phil Burke4d7bb42017-03-28 11:32:39 -070061 ALOGD("AudioStreamTrack::open = %p", this);
62
Phil Burke1ce4912016-11-21 10:40:25 -080063 // Try to create an AudioTrack
Phil Burk5204d312017-05-04 17:16:13 -070064 // Use stereo if unspecified.
Phil Burk5ed503c2017-02-01 09:38:15 -080065 int32_t samplesPerFrame = (getSamplesPerFrame() == AAUDIO_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080066 ? 2 : getSamplesPerFrame();
67 audio_channel_mask_t channelMask = audio_channel_out_mask_from_count(samplesPerFrame);
Phil Burkd8bdcab2017-01-03 17:20:30 -080068 ALOGD("AudioStreamTrack::open(), samplesPerFrame = %d, channelMask = 0x%08x",
Phil Burke1ce4912016-11-21 10:40:25 -080069 samplesPerFrame, channelMask);
70
Phil Burke2fbb592017-05-01 15:05:52 -070071 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
Phil Burk30a70772017-05-16 11:20:36 -070072 aaudio_performance_mode_t perfMode = getPerformanceMode();
73 switch(perfMode) {
Phil Burke2fbb592017-05-01 15:05:52 -070074 case AAUDIO_PERFORMANCE_MODE_LOW_LATENCY:
75 // Bypass the normal mixer and go straight to the FAST mixer.
76 flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_RAW);
77 break;
78
79 case AAUDIO_PERFORMANCE_MODE_POWER_SAVING:
80 // This uses a mixer that wakes up less often than the FAST mixer.
81 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
82 break;
83
84 case AAUDIO_PERFORMANCE_MODE_NONE:
85 default:
86 // No flags. Use a normal mixer in front of the FAST mixer.
87 break;
88 }
Phil Burke4d7bb42017-03-28 11:32:39 -070089
90 int32_t frameCount = builder.getBufferCapacity();
91 ALOGD("AudioStreamTrack::open(), requested buffer capacity %d", frameCount);
92
93 int32_t notificationFrames = 0;
94
Phil Burke4d7bb42017-03-28 11:32:39 -070095 audio_format_t format = (getFormat() == AAUDIO_FORMAT_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080096 ? AUDIO_FORMAT_PCM_FLOAT
Phil Burk5ed503c2017-02-01 09:38:15 -080097 : AAudioConvert_aaudioToAndroidDataFormat(getFormat());
Phil Burke1ce4912016-11-21 10:40:25 -080098
Phil Burke4d7bb42017-03-28 11:32:39 -070099 // Setup the callback if there is one.
100 AudioTrack::callback_t callback = nullptr;
101 void *callbackData = nullptr;
102 // Note that TRANSFER_SYNC does not allow FAST track
103 AudioTrack::transfer_type streamTransferType = AudioTrack::transfer_type::TRANSFER_SYNC;
104 if (builder.getDataCallbackProc() != nullptr) {
105 streamTransferType = AudioTrack::transfer_type::TRANSFER_CALLBACK;
106 callback = getLegacyCallback();
107 callbackData = this;
108
Phil Burke4d7bb42017-03-28 11:32:39 -0700109 // If the total buffer size is unspecified then base the size on the burst size.
Phil Burk4485d412017-05-09 15:55:02 -0700110 if (frameCount == 0
111 && ((flags & AUDIO_OUTPUT_FLAG_FAST) != 0)) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700112 // Take advantage of a special trick that allows us to create a buffer
113 // that is some multiple of the burst size.
114 notificationFrames = 0 - DEFAULT_BURSTS_PER_BUFFER_CAPACITY;
Phil Burk4485d412017-05-09 15:55:02 -0700115 } else {
116 notificationFrames = builder.getFramesPerDataCallback();
Phil Burke4d7bb42017-03-28 11:32:39 -0700117 }
118 }
119 mCallbackBufferSize = builder.getFramesPerDataCallback();
120
121 ALOGD("AudioStreamTrack::open(), notificationFrames = %d", notificationFrames);
Phil Burke1ce4912016-11-21 10:40:25 -0800122 mAudioTrack = new AudioTrack(
123 (audio_stream_type_t) AUDIO_STREAM_MUSIC,
124 getSampleRate(),
125 format,
126 channelMask,
127 frameCount,
128 flags,
129 callback,
Phil Burke4d7bb42017-03-28 11:32:39 -0700130 callbackData,
131 notificationFrames,
Phil Burke1ce4912016-11-21 10:40:25 -0800132 AUDIO_SESSION_ALLOCATE,
Phil Burke4d7bb42017-03-28 11:32:39 -0700133 streamTransferType
Phil Burke1ce4912016-11-21 10:40:25 -0800134 );
135
136 // Did we get a valid track?
137 status_t status = mAudioTrack->initCheck();
Phil Burkd8bdcab2017-01-03 17:20:30 -0800138 ALOGD("AudioStreamTrack::open(), initCheck() returned %d", status);
Phil Burkdec33ab2017-01-17 14:48:16 -0800139 if (status != NO_ERROR) {
Phil Burke1ce4912016-11-21 10:40:25 -0800140 close();
141 ALOGE("AudioStreamTrack::open(), initCheck() returned %d", status);
Phil Burk5ed503c2017-02-01 09:38:15 -0800142 return AAudioConvert_androidToAAudioResult(status);
Phil Burke1ce4912016-11-21 10:40:25 -0800143 }
144
145 // Get the actual values from the AudioTrack.
146 setSamplesPerFrame(mAudioTrack->channelCount());
147 setSampleRate(mAudioTrack->getSampleRate());
Phil Burke4d7bb42017-03-28 11:32:39 -0700148 aaudio_audio_format_t aaudioFormat =
149 AAudioConvert_androidToAAudioDataFormat(mAudioTrack->format());
150 setFormat(aaudioFormat);
151
152 // We may need to pass the data through a block size adapter to guarantee constant size.
153 if (mCallbackBufferSize != AAUDIO_UNSPECIFIED) {
154 int callbackSizeBytes = getBytesPerFrame() * mCallbackBufferSize;
155 mFixedBlockReader.open(callbackSizeBytes);
156 mBlockAdapter = &mFixedBlockReader;
157 } else {
158 mBlockAdapter = nullptr;
159 }
Phil Burke1ce4912016-11-21 10:40:25 -0800160
Phil Burk5ed503c2017-02-01 09:38:15 -0800161 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burkc0c70e32017-02-09 13:18:38 -0800162 setDeviceId(mAudioTrack->getRoutedDeviceId());
Phil Burke1ce4912016-11-21 10:40:25 -0800163
Phil Burk30a70772017-05-16 11:20:36 -0700164 // Update performance mode based on the actual stream.
165 // For example, if the sample rate is not allowed then you won't get a FAST track.
166 audio_output_flags_t actualFlags = mAudioTrack->getFlags();
167 aaudio_performance_mode_t actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_NONE;
168 if ((actualFlags & (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_RAW))
169 == (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_RAW)) {
170 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
171
172 } else if ((actualFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
173 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_POWER_SAVING;
174 }
175 setPerformanceMode(actualPerformanceMode);
176 // Log warning if we did not get what we asked for.
177 ALOGW_IF(actualFlags != flags,
178 "AudioStreamTrack::open() flags changed from 0x%08X to 0x%08X",
179 flags, actualFlags);
180 ALOGW_IF(actualPerformanceMode != perfMode,
181 "AudioStreamTrack::open() perfMode changed from %d to %d",
182 perfMode, actualPerformanceMode);
183
Phil Burk5ed503c2017-02-01 09:38:15 -0800184 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800185}
186
Phil Burk5ed503c2017-02-01 09:38:15 -0800187aaudio_result_t AudioStreamTrack::close()
Phil Burke1ce4912016-11-21 10:40:25 -0800188{
Phil Burk5ed503c2017-02-01 09:38:15 -0800189 if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk5204d312017-05-04 17:16:13 -0700190 mAudioTrack.clear();
Phil Burk5ed503c2017-02-01 09:38:15 -0800191 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800192 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700193 mFixedBlockReader.close();
Phil Burk5ed503c2017-02-01 09:38:15 -0800194 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800195}
196
Phil Burke4d7bb42017-03-28 11:32:39 -0700197void AudioStreamTrack::processCallback(int event, void *info) {
198
199 switch (event) {
200 case AudioTrack::EVENT_MORE_DATA:
201 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, info);
202 break;
203
204 // Stream got rerouted so we disconnect.
205 case AudioTrack::EVENT_NEW_IAUDIOTRACK:
206 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_DISCONNECTED, info);
207 break;
208
209 default:
210 break;
211 }
212 return;
213}
214
Phil Burk5ed503c2017-02-01 09:38:15 -0800215aaudio_result_t AudioStreamTrack::requestStart()
Phil Burke1ce4912016-11-21 10:40:25 -0800216{
Phil Burke4d7bb42017-03-28 11:32:39 -0700217 std::lock_guard<std::mutex> lock(mStreamMutex);
218
Phil Burkd8bdcab2017-01-03 17:20:30 -0800219 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800220 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800221 }
222 // Get current position so we can detect when the track is playing.
223 status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
224 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800225 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800226 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700227
Phil Burke1ce4912016-11-21 10:40:25 -0800228 err = mAudioTrack->start();
229 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800230 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800231 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800232 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burke1ce4912016-11-21 10:40:25 -0800233 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800234 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800235}
236
Phil Burk5ed503c2017-02-01 09:38:15 -0800237aaudio_result_t AudioStreamTrack::requestPause()
Phil Burke1ce4912016-11-21 10:40:25 -0800238{
Phil Burke4d7bb42017-03-28 11:32:39 -0700239 std::lock_guard<std::mutex> lock(mStreamMutex);
240
Phil Burkd8bdcab2017-01-03 17:20:30 -0800241 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800242 return AAUDIO_ERROR_INVALID_STATE;
243 } else if (getState() != AAUDIO_STREAM_STATE_STARTING
244 && getState() != AAUDIO_STREAM_STATE_STARTED) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700245 ALOGE("requestPause(), called when state is %s",
246 AAudio_convertStreamStateToText(getState()));
Phil Burk5ed503c2017-02-01 09:38:15 -0800247 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800248 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800249 setState(AAUDIO_STREAM_STATE_PAUSING);
Phil Burke1ce4912016-11-21 10:40:25 -0800250 mAudioTrack->pause();
251 status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
252 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800253 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800254 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800255 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800256}
257
Phil Burk5ed503c2017-02-01 09:38:15 -0800258aaudio_result_t AudioStreamTrack::requestFlush() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700259 std::lock_guard<std::mutex> lock(mStreamMutex);
260
Phil Burkd8bdcab2017-01-03 17:20:30 -0800261 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800262 return AAUDIO_ERROR_INVALID_STATE;
263 } else if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
264 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800265 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800266 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burke1ce4912016-11-21 10:40:25 -0800267 incrementFramesRead(getFramesWritten() - getFramesRead());
268 mAudioTrack->flush();
269 mFramesWritten.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800270 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800271}
272
Phil Burk5ed503c2017-02-01 09:38:15 -0800273aaudio_result_t AudioStreamTrack::requestStop() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700274 std::lock_guard<std::mutex> lock(mStreamMutex);
275
Phil Burkd8bdcab2017-01-03 17:20:30 -0800276 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800277 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800278 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800279 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burke1ce4912016-11-21 10:40:25 -0800280 incrementFramesRead(getFramesWritten() - getFramesRead()); // TODO review
281 mAudioTrack->stop();
282 mFramesWritten.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800283 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800284}
285
Phil Burke4d7bb42017-03-28 11:32:39 -0700286aaudio_result_t AudioStreamTrack::updateStateWhileWaiting()
Phil Burke1ce4912016-11-21 10:40:25 -0800287{
288 status_t err;
Phil Burk5ed503c2017-02-01 09:38:15 -0800289 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800290 switch (getState()) {
291 // TODO add better state visibility to AudioTrack
Phil Burk5ed503c2017-02-01 09:38:15 -0800292 case AAUDIO_STREAM_STATE_STARTING:
Phil Burke1ce4912016-11-21 10:40:25 -0800293 if (mAudioTrack->hasStarted()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800294 setState(AAUDIO_STREAM_STATE_STARTED);
Phil Burke1ce4912016-11-21 10:40:25 -0800295 }
296 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800297 case AAUDIO_STREAM_STATE_PAUSING:
Phil Burke1ce4912016-11-21 10:40:25 -0800298 if (mAudioTrack->stopped()) {
299 err = mAudioTrack->getPosition(&position);
300 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800301 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800302 } else if (position == mPositionWhenPausing) {
303 // Has stream really stopped advancing?
Phil Burk5ed503c2017-02-01 09:38:15 -0800304 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800305 }
306 mPositionWhenPausing = position;
307 }
308 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800309 case AAUDIO_STREAM_STATE_FLUSHING:
Phil Burke1ce4912016-11-21 10:40:25 -0800310 {
311 err = mAudioTrack->getPosition(&position);
312 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800313 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800314 } else if (position == 0) {
Phil Burk5204d312017-05-04 17:16:13 -0700315 // TODO Advance frames read to match written.
Phil Burk5ed503c2017-02-01 09:38:15 -0800316 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burke1ce4912016-11-21 10:40:25 -0800317 }
318 }
319 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800320 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800321 if (mAudioTrack->stopped()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800322 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burke1ce4912016-11-21 10:40:25 -0800323 }
324 break;
325 default:
326 break;
327 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800328 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800329}
330
Phil Burk5ed503c2017-02-01 09:38:15 -0800331aaudio_result_t AudioStreamTrack::write(const void *buffer,
Phil Burk3316d5e2017-02-15 11:23:01 -0800332 int32_t numFrames,
333 int64_t timeoutNanoseconds)
Phil Burke1ce4912016-11-21 10:40:25 -0800334{
Phil Burk3316d5e2017-02-15 11:23:01 -0800335 int32_t bytesPerFrame = getBytesPerFrame();
336 int32_t numBytes;
Phil Burk5ed503c2017-02-01 09:38:15 -0800337 aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
338 if (result != AAUDIO_OK) {
Phil Burke1ce4912016-11-21 10:40:25 -0800339 return result;
340 }
341
342 // TODO add timeout to AudioTrack
343 bool blocking = timeoutNanoseconds > 0;
344 ssize_t bytesWritten = mAudioTrack->write(buffer, numBytes, blocking);
345 if (bytesWritten == WOULD_BLOCK) {
346 return 0;
347 } else if (bytesWritten < 0) {
348 ALOGE("invalid write, returned %d", (int)bytesWritten);
Phil Burk5ed503c2017-02-01 09:38:15 -0800349 return AAudioConvert_androidToAAudioResult(bytesWritten);
Phil Burke1ce4912016-11-21 10:40:25 -0800350 }
Phil Burk3316d5e2017-02-15 11:23:01 -0800351 int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -0800352 incrementFramesWritten(framesWritten);
353 return framesWritten;
354}
355
Phil Burk3316d5e2017-02-15 11:23:01 -0800356aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
Phil Burke1ce4912016-11-21 10:40:25 -0800357{
358 ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800359 if (result < 0) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800360 return AAudioConvert_androidToAAudioResult(result);
Phil Burke1ce4912016-11-21 10:40:25 -0800361 } else {
Phil Burk3316d5e2017-02-15 11:23:01 -0800362 return result;
Phil Burke1ce4912016-11-21 10:40:25 -0800363 }
364}
365
Phil Burk3316d5e2017-02-15 11:23:01 -0800366int32_t AudioStreamTrack::getBufferSize() const
Phil Burke1ce4912016-11-21 10:40:25 -0800367{
Phil Burk3316d5e2017-02-15 11:23:01 -0800368 return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800369}
370
Phil Burk3316d5e2017-02-15 11:23:01 -0800371int32_t AudioStreamTrack::getBufferCapacity() const
Phil Burke1ce4912016-11-21 10:40:25 -0800372{
Phil Burk3316d5e2017-02-15 11:23:01 -0800373 return static_cast<int32_t>(mAudioTrack->frameCount());
Phil Burke1ce4912016-11-21 10:40:25 -0800374}
375
376int32_t AudioStreamTrack::getXRunCount() const
377{
378 return static_cast<int32_t>(mAudioTrack->getUnderrunCount());
379}
380
381int32_t AudioStreamTrack::getFramesPerBurst() const
382{
Phil Burkb5884022017-03-27 15:26:14 -0700383 return static_cast<int32_t>(mAudioTrack->getNotificationPeriodInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800384}
385
Phil Burk3316d5e2017-02-15 11:23:01 -0800386int64_t AudioStreamTrack::getFramesRead() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800387 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800388 status_t result;
389 switch (getState()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800390 case AAUDIO_STREAM_STATE_STARTING:
391 case AAUDIO_STREAM_STATE_STARTED:
392 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burk4c5129b2017-04-28 15:17:32 -0700393 case AAUDIO_STREAM_STATE_PAUSING:
394 case AAUDIO_STREAM_STATE_PAUSED:
Phil Burke1ce4912016-11-21 10:40:25 -0800395 result = mAudioTrack->getPosition(&position);
396 if (result == OK) {
397 mFramesRead.update32(position);
398 }
399 break;
400 default:
401 break;
402 }
403 return AudioStream::getFramesRead();
404}
Phil Burk35e80f32017-03-28 10:25:21 -0700405
406aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
407 int64_t *framePosition,
408 int64_t *timeNanoseconds) {
409 ExtendedTimestamp extendedTimestamp;
410 status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
411 if (status != NO_ERROR) {
412 return AAudioConvert_androidToAAudioResult(status);
413 }
Phil Burk5204d312017-05-04 17:16:13 -0700414 return getBestTimestamp(clockId, framePosition, timeNanoseconds, &extendedTimestamp);
Phil Burk35e80f32017-03-28 10:25:21 -0700415}