blob: ff87c2825f2829ca3593d2e413c9683b0006fd83 [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>
25#include "AudioClock.h"
26#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 Burke1ce4912016-11-21 10:40:25 -0800145
Phil Burk5ed503c2017-02-01 09:38:15 -0800146 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800147}
148
Phil Burk5ed503c2017-02-01 09:38:15 -0800149aaudio_result_t AudioStreamTrack::close()
Phil Burke1ce4912016-11-21 10:40:25 -0800150{
151 // TODO maybe add close() or release() to AudioTrack API then call it from here
Phil Burk5ed503c2017-02-01 09:38:15 -0800152 if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burke1ce4912016-11-21 10:40:25 -0800153 mAudioTrack.clear(); // TODO is this right?
Phil Burk5ed503c2017-02-01 09:38:15 -0800154 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800155 }
Phil Burkc8f372c2017-03-28 11:32:39 -0700156 mFixedBlockReader.close();
Phil Burk5ed503c2017-02-01 09:38:15 -0800157 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800158}
159
Phil Burkc8f372c2017-03-28 11:32:39 -0700160void AudioStreamTrack::processCallback(int event, void *info) {
161
162 switch (event) {
163 case AudioTrack::EVENT_MORE_DATA:
164 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, info);
165 break;
166
167 // Stream got rerouted so we disconnect.
168 case AudioTrack::EVENT_NEW_IAUDIOTRACK:
169 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_DISCONNECTED, info);
170 break;
171
172 default:
173 break;
174 }
175 return;
176}
177
Phil Burk5ed503c2017-02-01 09:38:15 -0800178aaudio_result_t AudioStreamTrack::requestStart()
Phil Burke1ce4912016-11-21 10:40:25 -0800179{
Phil Burkc8f372c2017-03-28 11:32:39 -0700180 std::lock_guard<std::mutex> lock(mStreamMutex);
181
Phil Burkd8bdcab2017-01-03 17:20:30 -0800182 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800183 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800184 }
185 // Get current position so we can detect when the track is playing.
186 status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
187 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800188 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800189 }
Phil Burkc8f372c2017-03-28 11:32:39 -0700190
Phil Burke1ce4912016-11-21 10:40:25 -0800191 err = mAudioTrack->start();
192 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800193 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800194 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800195 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burke1ce4912016-11-21 10:40:25 -0800196 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800197 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800198}
199
Phil Burk5ed503c2017-02-01 09:38:15 -0800200aaudio_result_t AudioStreamTrack::requestPause()
Phil Burke1ce4912016-11-21 10:40:25 -0800201{
Phil Burkc8f372c2017-03-28 11:32:39 -0700202 std::lock_guard<std::mutex> lock(mStreamMutex);
203
Phil Burkd8bdcab2017-01-03 17:20:30 -0800204 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800205 return AAUDIO_ERROR_INVALID_STATE;
206 } else if (getState() != AAUDIO_STREAM_STATE_STARTING
207 && getState() != AAUDIO_STREAM_STATE_STARTED) {
Phil Burkc8f372c2017-03-28 11:32:39 -0700208 ALOGE("requestPause(), called when state is %s",
209 AAudio_convertStreamStateToText(getState()));
Phil Burk5ed503c2017-02-01 09:38:15 -0800210 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800211 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800212 setState(AAUDIO_STREAM_STATE_PAUSING);
Phil Burke1ce4912016-11-21 10:40:25 -0800213 mAudioTrack->pause();
214 status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
215 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800216 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800217 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800218 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800219}
220
Phil Burk5ed503c2017-02-01 09:38:15 -0800221aaudio_result_t AudioStreamTrack::requestFlush() {
Phil Burkc8f372c2017-03-28 11:32:39 -0700222 std::lock_guard<std::mutex> lock(mStreamMutex);
223
Phil Burkd8bdcab2017-01-03 17:20:30 -0800224 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800225 return AAUDIO_ERROR_INVALID_STATE;
226 } else if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
227 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800228 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800229 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burke1ce4912016-11-21 10:40:25 -0800230 incrementFramesRead(getFramesWritten() - getFramesRead());
231 mAudioTrack->flush();
232 mFramesWritten.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800233 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800234}
235
Phil Burk5ed503c2017-02-01 09:38:15 -0800236aaudio_result_t AudioStreamTrack::requestStop() {
Phil Burkc8f372c2017-03-28 11:32:39 -0700237 std::lock_guard<std::mutex> lock(mStreamMutex);
238
Phil Burkd8bdcab2017-01-03 17:20:30 -0800239 if (mAudioTrack.get() == nullptr) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800240 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800241 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800242 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burke1ce4912016-11-21 10:40:25 -0800243 incrementFramesRead(getFramesWritten() - getFramesRead()); // TODO review
244 mAudioTrack->stop();
245 mFramesWritten.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800246 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800247}
248
Phil Burkc8f372c2017-03-28 11:32:39 -0700249aaudio_result_t AudioStreamTrack::updateStateWhileWaiting()
Phil Burke1ce4912016-11-21 10:40:25 -0800250{
251 status_t err;
Phil Burk5ed503c2017-02-01 09:38:15 -0800252 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800253 switch (getState()) {
254 // TODO add better state visibility to AudioTrack
Phil Burk5ed503c2017-02-01 09:38:15 -0800255 case AAUDIO_STREAM_STATE_STARTING:
Phil Burke1ce4912016-11-21 10:40:25 -0800256 if (mAudioTrack->hasStarted()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800257 setState(AAUDIO_STREAM_STATE_STARTED);
Phil Burke1ce4912016-11-21 10:40:25 -0800258 }
259 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800260 case AAUDIO_STREAM_STATE_PAUSING:
Phil Burke1ce4912016-11-21 10:40:25 -0800261 if (mAudioTrack->stopped()) {
262 err = mAudioTrack->getPosition(&position);
263 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800264 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800265 } else if (position == mPositionWhenPausing) {
266 // Has stream really stopped advancing?
Phil Burk5ed503c2017-02-01 09:38:15 -0800267 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800268 }
269 mPositionWhenPausing = position;
270 }
271 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800272 case AAUDIO_STREAM_STATE_FLUSHING:
Phil Burke1ce4912016-11-21 10:40:25 -0800273 {
274 err = mAudioTrack->getPosition(&position);
275 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800276 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800277 } else if (position == 0) {
278 // Advance frames read to match written.
Phil Burk5ed503c2017-02-01 09:38:15 -0800279 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burke1ce4912016-11-21 10:40:25 -0800280 }
281 }
282 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800283 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800284 if (mAudioTrack->stopped()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800285 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burke1ce4912016-11-21 10:40:25 -0800286 }
287 break;
288 default:
289 break;
290 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800291 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800292}
293
Phil Burk5ed503c2017-02-01 09:38:15 -0800294aaudio_result_t AudioStreamTrack::write(const void *buffer,
Phil Burk3316d5e2017-02-15 11:23:01 -0800295 int32_t numFrames,
296 int64_t timeoutNanoseconds)
Phil Burke1ce4912016-11-21 10:40:25 -0800297{
Phil Burk3316d5e2017-02-15 11:23:01 -0800298 int32_t bytesPerFrame = getBytesPerFrame();
299 int32_t numBytes;
Phil Burk5ed503c2017-02-01 09:38:15 -0800300 aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
301 if (result != AAUDIO_OK) {
Phil Burke1ce4912016-11-21 10:40:25 -0800302 return result;
303 }
304
305 // TODO add timeout to AudioTrack
306 bool blocking = timeoutNanoseconds > 0;
307 ssize_t bytesWritten = mAudioTrack->write(buffer, numBytes, blocking);
308 if (bytesWritten == WOULD_BLOCK) {
309 return 0;
310 } else if (bytesWritten < 0) {
311 ALOGE("invalid write, returned %d", (int)bytesWritten);
Phil Burk5ed503c2017-02-01 09:38:15 -0800312 return AAudioConvert_androidToAAudioResult(bytesWritten);
Phil Burke1ce4912016-11-21 10:40:25 -0800313 }
Phil Burk3316d5e2017-02-15 11:23:01 -0800314 int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -0800315 incrementFramesWritten(framesWritten);
316 return framesWritten;
317}
318
Phil Burk3316d5e2017-02-15 11:23:01 -0800319aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
Phil Burke1ce4912016-11-21 10:40:25 -0800320{
321 ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800322 if (result < 0) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800323 return AAudioConvert_androidToAAudioResult(result);
Phil Burke1ce4912016-11-21 10:40:25 -0800324 } else {
Phil Burk3316d5e2017-02-15 11:23:01 -0800325 return result;
Phil Burke1ce4912016-11-21 10:40:25 -0800326 }
327}
328
Phil Burk3316d5e2017-02-15 11:23:01 -0800329int32_t AudioStreamTrack::getBufferSize() const
Phil Burke1ce4912016-11-21 10:40:25 -0800330{
Phil Burk3316d5e2017-02-15 11:23:01 -0800331 return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800332}
333
Phil Burk3316d5e2017-02-15 11:23:01 -0800334int32_t AudioStreamTrack::getBufferCapacity() const
Phil Burke1ce4912016-11-21 10:40:25 -0800335{
Phil Burk3316d5e2017-02-15 11:23:01 -0800336 return static_cast<int32_t>(mAudioTrack->frameCount());
Phil Burke1ce4912016-11-21 10:40:25 -0800337}
338
339int32_t AudioStreamTrack::getXRunCount() const
340{
341 return static_cast<int32_t>(mAudioTrack->getUnderrunCount());
342}
343
344int32_t AudioStreamTrack::getFramesPerBurst() const
345{
Phil Burk34758222017-03-27 15:26:14 -0700346 return static_cast<int32_t>(mAudioTrack->getNotificationPeriodInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800347}
348
Phil Burk3316d5e2017-02-15 11:23:01 -0800349int64_t AudioStreamTrack::getFramesRead() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800350 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800351 status_t result;
352 switch (getState()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800353 case AAUDIO_STREAM_STATE_STARTING:
354 case AAUDIO_STREAM_STATE_STARTED:
355 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800356 result = mAudioTrack->getPosition(&position);
357 if (result == OK) {
358 mFramesRead.update32(position);
359 }
360 break;
361 default:
362 break;
363 }
364 return AudioStream::getFramesRead();
365}
Phil Burk2b3db3b2017-03-28 10:25:21 -0700366
367aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
368 int64_t *framePosition,
369 int64_t *timeNanoseconds) {
370 ExtendedTimestamp extendedTimestamp;
371 status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
372 if (status != NO_ERROR) {
373 return AAudioConvert_androidToAAudioResult(status);
374 }
375 // TODO Merge common code into AudioStreamLegacy after rebasing.
376 int timebase;
Phil Burkc8f372c2017-03-28 11:32:39 -0700377 switch (clockId) {
Phil Burk2b3db3b2017-03-28 10:25:21 -0700378 case CLOCK_BOOTTIME:
379 timebase = ExtendedTimestamp::TIMEBASE_BOOTTIME;
380 break;
381 case CLOCK_MONOTONIC:
382 timebase = ExtendedTimestamp::TIMEBASE_MONOTONIC;
383 break;
384 default:
385 ALOGE("getTimestamp() - Unrecognized clock type %d", (int) clockId);
386 return AAUDIO_ERROR_UNEXPECTED_VALUE;
387 break;
388 }
389 status = extendedTimestamp.getBestTimestamp(framePosition, timeNanoseconds, timebase);
390 return AAudioConvert_androidToAAudioResult(status);
391}