blob: 1bb9e53ca64d3276ecbd13ab7fa66e23038c25dc [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 Burkc8f372c2017-03-28 11:32:39 -070024#include <aaudio/AAudio.h>
Phil Burk7f6b40d2017-02-09 13:18:38 -080025#include "utility/AudioClock.h"
Phil Burkc8f372c2017-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 Burkc8f372c2017-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 Burkc8f372c2017-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 Burkc8f372c2017-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
64 // TODO Support UNSPECIFIED in AudioTrack. For now, 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 Burke1ce4912016-11-21 10:40:25 -080071 // TODO add more performance options
72 audio_output_flags_t flags = (audio_output_flags_t) AUDIO_OUTPUT_FLAG_FAST;
Phil Burkc8f372c2017-03-28 11:32:39 -070073
74 int32_t frameCount = builder.getBufferCapacity();
75 ALOGD("AudioStreamTrack::open(), requested buffer capacity %d", frameCount);
76
77 int32_t notificationFrames = 0;
78
Phil Burke1ce4912016-11-21 10:40:25 -080079 // TODO implement an unspecified AudioTrack format then use that.
Phil Burkc8f372c2017-03-28 11:32:39 -070080 audio_format_t format = (getFormat() == AAUDIO_FORMAT_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080081 ? AUDIO_FORMAT_PCM_FLOAT
Phil Burk5ed503c2017-02-01 09:38:15 -080082 : AAudioConvert_aaudioToAndroidDataFormat(getFormat());
Phil Burke1ce4912016-11-21 10:40:25 -080083
Phil Burkc8f372c2017-03-28 11:32:39 -070084 // Setup the callback if there is one.
85 AudioTrack::callback_t callback = nullptr;
86 void *callbackData = nullptr;
87 // Note that TRANSFER_SYNC does not allow FAST track
88 AudioTrack::transfer_type streamTransferType = AudioTrack::transfer_type::TRANSFER_SYNC;
89 if (builder.getDataCallbackProc() != nullptr) {
90 streamTransferType = AudioTrack::transfer_type::TRANSFER_CALLBACK;
91 callback = getLegacyCallback();
92 callbackData = this;
93
94 notificationFrames = builder.getFramesPerDataCallback();
95 // If the total buffer size is unspecified then base the size on the burst size.
96 if (frameCount == AAUDIO_UNSPECIFIED) {
97 // Take advantage of a special trick that allows us to create a buffer
98 // that is some multiple of the burst size.
99 notificationFrames = 0 - DEFAULT_BURSTS_PER_BUFFER_CAPACITY;
100 }
101 }
102 mCallbackBufferSize = builder.getFramesPerDataCallback();
103
104 ALOGD("AudioStreamTrack::open(), notificationFrames = %d", notificationFrames);
Phil Burke1ce4912016-11-21 10:40:25 -0800105 mAudioTrack = new AudioTrack(
106 (audio_stream_type_t) AUDIO_STREAM_MUSIC,
107 getSampleRate(),
108 format,
109 channelMask,
110 frameCount,
111 flags,
112 callback,
Phil Burkc8f372c2017-03-28 11:32:39 -0700113 callbackData,
114 notificationFrames,
Phil Burke1ce4912016-11-21 10:40:25 -0800115 AUDIO_SESSION_ALLOCATE,
Phil Burkc8f372c2017-03-28 11:32:39 -0700116 streamTransferType
Phil Burke1ce4912016-11-21 10:40:25 -0800117 );
118
119 // Did we get a valid track?
120 status_t status = mAudioTrack->initCheck();
Phil Burkd8bdcab2017-01-03 17:20:30 -0800121 ALOGD("AudioStreamTrack::open(), initCheck() returned %d", status);
Phil Burkdec33ab2017-01-17 14:48:16 -0800122 if (status != NO_ERROR) {
Phil Burke1ce4912016-11-21 10:40:25 -0800123 close();
124 ALOGE("AudioStreamTrack::open(), initCheck() returned %d", status);
Phil Burk5ed503c2017-02-01 09:38:15 -0800125 return AAudioConvert_androidToAAudioResult(status);
Phil Burke1ce4912016-11-21 10:40:25 -0800126 }
127
128 // Get the actual values from the AudioTrack.
129 setSamplesPerFrame(mAudioTrack->channelCount());
130 setSampleRate(mAudioTrack->getSampleRate());
Phil Burkc8f372c2017-03-28 11:32:39 -0700131 aaudio_audio_format_t aaudioFormat =
132 AAudioConvert_androidToAAudioDataFormat(mAudioTrack->format());
133 setFormat(aaudioFormat);
134
135 // We may need to pass the data through a block size adapter to guarantee constant size.
136 if (mCallbackBufferSize != AAUDIO_UNSPECIFIED) {
137 int callbackSizeBytes = getBytesPerFrame() * mCallbackBufferSize;
138 mFixedBlockReader.open(callbackSizeBytes);
139 mBlockAdapter = &mFixedBlockReader;
140 } else {
141 mBlockAdapter = nullptr;
142 }
Phil Burke1ce4912016-11-21 10:40:25 -0800143
Phil Burk5ed503c2017-02-01 09:38:15 -0800144 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burk7f6b40d2017-02-09 13:18:38 -0800145 setDeviceId(mAudioTrack->getRoutedDeviceId());
Phil Burke1ce4912016-11-21 10:40:25 -0800146
Phil Burk5ed503c2017-02-01 09:38:15 -0800147 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800148}
149
Phil Burk5ed503c2017-02-01 09:38:15 -0800150aaudio_result_t AudioStreamTrack::close()
Phil Burke1ce4912016-11-21 10:40:25 -0800151{
152 // TODO maybe add close() or release() to AudioTrack API then call it from here
Phil Burk5ed503c2017-02-01 09:38:15 -0800153 if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burke1ce4912016-11-21 10:40:25 -0800154 mAudioTrack.clear(); // TODO is this right?
Phil Burk5ed503c2017-02-01 09:38:15 -0800155 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800156 }
Phil Burkc8f372c2017-03-28 11:32:39 -0700157 mFixedBlockReader.close();
Phil Burk5ed503c2017-02-01 09:38:15 -0800158 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800159}
160
Phil Burkc8f372c2017-03-28 11:32:39 -0700161void AudioStreamTrack::processCallback(int event, void *info) {
162
163 switch (event) {
164 case AudioTrack::EVENT_MORE_DATA:
165 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, info);
166 break;
167
168 // Stream got rerouted so we disconnect.
169 case AudioTrack::EVENT_NEW_IAUDIOTRACK:
170 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_DISCONNECTED, info);
171 break;
172
173 default:
174 break;
175 }
176 return;
177}
178
Phil Burk5ed503c2017-02-01 09:38:15 -0800179aaudio_result_t AudioStreamTrack::requestStart()
Phil Burke1ce4912016-11-21 10:40:25 -0800180{
Phil Burkc8f372c2017-03-28 11:32:39 -0700181 std::lock_guard<std::mutex> lock(mStreamMutex);
182
Phil Burkd8bdcab2017-01-03 17:20:30 -0800183 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800184 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800185 }
186 // Get current position so we can detect when the track is playing.
187 status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
188 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800189 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800190 }
Phil Burkc8f372c2017-03-28 11:32:39 -0700191
Phil Burke1ce4912016-11-21 10:40:25 -0800192 err = mAudioTrack->start();
193 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800194 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800195 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800196 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burke1ce4912016-11-21 10:40:25 -0800197 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800198 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800199}
200
Phil Burk5ed503c2017-02-01 09:38:15 -0800201aaudio_result_t AudioStreamTrack::requestPause()
Phil Burke1ce4912016-11-21 10:40:25 -0800202{
Phil Burkc8f372c2017-03-28 11:32:39 -0700203 std::lock_guard<std::mutex> lock(mStreamMutex);
204
Phil Burkd8bdcab2017-01-03 17:20:30 -0800205 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800206 return AAUDIO_ERROR_INVALID_STATE;
207 } else if (getState() != AAUDIO_STREAM_STATE_STARTING
208 && getState() != AAUDIO_STREAM_STATE_STARTED) {
Phil Burkc8f372c2017-03-28 11:32:39 -0700209 ALOGE("requestPause(), called when state is %s",
210 AAudio_convertStreamStateToText(getState()));
Phil Burk5ed503c2017-02-01 09:38:15 -0800211 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800212 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800213 setState(AAUDIO_STREAM_STATE_PAUSING);
Phil Burke1ce4912016-11-21 10:40:25 -0800214 mAudioTrack->pause();
215 status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
216 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800217 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800218 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800219 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800220}
221
Phil Burk5ed503c2017-02-01 09:38:15 -0800222aaudio_result_t AudioStreamTrack::requestFlush() {
Phil Burkc8f372c2017-03-28 11:32:39 -0700223 std::lock_guard<std::mutex> lock(mStreamMutex);
224
Phil Burkd8bdcab2017-01-03 17:20:30 -0800225 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800226 return AAUDIO_ERROR_INVALID_STATE;
227 } else if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
228 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800229 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800230 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burke1ce4912016-11-21 10:40:25 -0800231 incrementFramesRead(getFramesWritten() - getFramesRead());
232 mAudioTrack->flush();
233 mFramesWritten.reset32();
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::requestStop() {
Phil Burkc8f372c2017-03-28 11:32:39 -0700238 std::lock_guard<std::mutex> lock(mStreamMutex);
239
Phil Burkd8bdcab2017-01-03 17:20:30 -0800240 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800241 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800242 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800243 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burke1ce4912016-11-21 10:40:25 -0800244 incrementFramesRead(getFramesWritten() - getFramesRead()); // TODO review
245 mAudioTrack->stop();
246 mFramesWritten.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800247 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800248}
249
Phil Burkc8f372c2017-03-28 11:32:39 -0700250aaudio_result_t AudioStreamTrack::updateStateWhileWaiting()
Phil Burke1ce4912016-11-21 10:40:25 -0800251{
252 status_t err;
Phil Burk5ed503c2017-02-01 09:38:15 -0800253 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800254 switch (getState()) {
255 // TODO add better state visibility to AudioTrack
Phil Burk5ed503c2017-02-01 09:38:15 -0800256 case AAUDIO_STREAM_STATE_STARTING:
Phil Burke1ce4912016-11-21 10:40:25 -0800257 if (mAudioTrack->hasStarted()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800258 setState(AAUDIO_STREAM_STATE_STARTED);
Phil Burke1ce4912016-11-21 10:40:25 -0800259 }
260 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800261 case AAUDIO_STREAM_STATE_PAUSING:
Phil Burke1ce4912016-11-21 10:40:25 -0800262 if (mAudioTrack->stopped()) {
263 err = mAudioTrack->getPosition(&position);
264 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800265 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800266 } else if (position == mPositionWhenPausing) {
267 // Has stream really stopped advancing?
Phil Burk5ed503c2017-02-01 09:38:15 -0800268 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800269 }
270 mPositionWhenPausing = position;
271 }
272 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800273 case AAUDIO_STREAM_STATE_FLUSHING:
Phil Burke1ce4912016-11-21 10:40:25 -0800274 {
275 err = mAudioTrack->getPosition(&position);
276 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800277 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800278 } else if (position == 0) {
279 // Advance frames read to match written.
Phil Burk5ed503c2017-02-01 09:38:15 -0800280 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burke1ce4912016-11-21 10:40:25 -0800281 }
282 }
283 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800284 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800285 if (mAudioTrack->stopped()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800286 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burke1ce4912016-11-21 10:40:25 -0800287 }
288 break;
289 default:
290 break;
291 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800292 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800293}
294
Phil Burk5ed503c2017-02-01 09:38:15 -0800295aaudio_result_t AudioStreamTrack::write(const void *buffer,
Phil Burk3316d5e2017-02-15 11:23:01 -0800296 int32_t numFrames,
297 int64_t timeoutNanoseconds)
Phil Burke1ce4912016-11-21 10:40:25 -0800298{
Phil Burk3316d5e2017-02-15 11:23:01 -0800299 int32_t bytesPerFrame = getBytesPerFrame();
300 int32_t numBytes;
Phil Burk5ed503c2017-02-01 09:38:15 -0800301 aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
302 if (result != AAUDIO_OK) {
Phil Burke1ce4912016-11-21 10:40:25 -0800303 return result;
304 }
305
306 // TODO add timeout to AudioTrack
307 bool blocking = timeoutNanoseconds > 0;
308 ssize_t bytesWritten = mAudioTrack->write(buffer, numBytes, blocking);
309 if (bytesWritten == WOULD_BLOCK) {
310 return 0;
311 } else if (bytesWritten < 0) {
312 ALOGE("invalid write, returned %d", (int)bytesWritten);
Phil Burk5ed503c2017-02-01 09:38:15 -0800313 return AAudioConvert_androidToAAudioResult(bytesWritten);
Phil Burke1ce4912016-11-21 10:40:25 -0800314 }
Phil Burk3316d5e2017-02-15 11:23:01 -0800315 int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -0800316 incrementFramesWritten(framesWritten);
317 return framesWritten;
318}
319
Phil Burk3316d5e2017-02-15 11:23:01 -0800320aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
Phil Burke1ce4912016-11-21 10:40:25 -0800321{
322 ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800323 if (result < 0) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800324 return AAudioConvert_androidToAAudioResult(result);
Phil Burke1ce4912016-11-21 10:40:25 -0800325 } else {
Phil Burk3316d5e2017-02-15 11:23:01 -0800326 return result;
Phil Burke1ce4912016-11-21 10:40:25 -0800327 }
328}
329
Phil Burk3316d5e2017-02-15 11:23:01 -0800330int32_t AudioStreamTrack::getBufferSize() const
Phil Burke1ce4912016-11-21 10:40:25 -0800331{
Phil Burk3316d5e2017-02-15 11:23:01 -0800332 return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800333}
334
Phil Burk3316d5e2017-02-15 11:23:01 -0800335int32_t AudioStreamTrack::getBufferCapacity() const
Phil Burke1ce4912016-11-21 10:40:25 -0800336{
Phil Burk3316d5e2017-02-15 11:23:01 -0800337 return static_cast<int32_t>(mAudioTrack->frameCount());
Phil Burke1ce4912016-11-21 10:40:25 -0800338}
339
340int32_t AudioStreamTrack::getXRunCount() const
341{
342 return static_cast<int32_t>(mAudioTrack->getUnderrunCount());
343}
344
345int32_t AudioStreamTrack::getFramesPerBurst() const
346{
Phil Burk34758222017-03-27 15:26:14 -0700347 return static_cast<int32_t>(mAudioTrack->getNotificationPeriodInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800348}
349
Phil Burk3316d5e2017-02-15 11:23:01 -0800350int64_t AudioStreamTrack::getFramesRead() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800351 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800352 status_t result;
353 switch (getState()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800354 case AAUDIO_STREAM_STATE_STARTING:
355 case AAUDIO_STREAM_STATE_STARTED:
356 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800357 result = mAudioTrack->getPosition(&position);
358 if (result == OK) {
359 mFramesRead.update32(position);
360 }
361 break;
362 default:
363 break;
364 }
365 return AudioStream::getFramesRead();
366}
Phil Burk2b3db3b2017-03-28 10:25:21 -0700367
368aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
369 int64_t *framePosition,
370 int64_t *timeNanoseconds) {
371 ExtendedTimestamp extendedTimestamp;
372 status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
373 if (status != NO_ERROR) {
374 return AAudioConvert_androidToAAudioResult(status);
375 }
376 // TODO Merge common code into AudioStreamLegacy after rebasing.
377 int timebase;
Phil Burkc8f372c2017-03-28 11:32:39 -0700378 switch (clockId) {
Phil Burk2b3db3b2017-03-28 10:25:21 -0700379 case CLOCK_BOOTTIME:
380 timebase = ExtendedTimestamp::TIMEBASE_BOOTTIME;
381 break;
382 case CLOCK_MONOTONIC:
383 timebase = ExtendedTimestamp::TIMEBASE_MONOTONIC;
384 break;
385 default:
386 ALOGE("getTimestamp() - Unrecognized clock type %d", (int) clockId);
387 return AAUDIO_ERROR_UNEXPECTED_VALUE;
388 break;
389 }
390 status = extendedTimestamp.getBestTimestamp(framePosition, timeNanoseconds, timebase);
391 return AAudioConvert_androidToAAudioResult(status);
392}