blob: c2ce9a2b13d4aa000e0ec17a5a03d81f939f80b4 [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
Phil Burk965650e2017-09-07 21:00:09 -070017#define LOG_TAG "AudioStreamTrack"
Phil Burke1ce4912016-11-21 10:40:25 -080018//#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
61 // Try to create an AudioTrack
Phil Burk5204d312017-05-04 17:16:13 -070062 // Use stereo if unspecified.
Phil Burk5ed503c2017-02-01 09:38:15 -080063 int32_t samplesPerFrame = (getSamplesPerFrame() == AAUDIO_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080064 ? 2 : getSamplesPerFrame();
65 audio_channel_mask_t channelMask = audio_channel_out_mask_from_count(samplesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -080066
Phil Burke2fbb592017-05-01 15:05:52 -070067 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
Phil Burk30a70772017-05-16 11:20:36 -070068 aaudio_performance_mode_t perfMode = getPerformanceMode();
69 switch(perfMode) {
Phil Burke2fbb592017-05-01 15:05:52 -070070 case AAUDIO_PERFORMANCE_MODE_LOW_LATENCY:
71 // Bypass the normal mixer and go straight to the FAST mixer.
72 flags = (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_RAW);
73 break;
74
75 case AAUDIO_PERFORMANCE_MODE_POWER_SAVING:
76 // This uses a mixer that wakes up less often than the FAST mixer.
77 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
78 break;
79
80 case AAUDIO_PERFORMANCE_MODE_NONE:
81 default:
82 // No flags. Use a normal mixer in front of the FAST mixer.
83 break;
84 }
Phil Burke4d7bb42017-03-28 11:32:39 -070085
Phil Burkcf5f6d22017-05-26 12:35:07 -070086 size_t frameCount = (size_t)builder.getBufferCapacity();
Phil Burke4d7bb42017-03-28 11:32:39 -070087
88 int32_t notificationFrames = 0;
89
Phil Burke4d7bb42017-03-28 11:32:39 -070090 audio_format_t format = (getFormat() == AAUDIO_FORMAT_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080091 ? AUDIO_FORMAT_PCM_FLOAT
Phil Burk5ed503c2017-02-01 09:38:15 -080092 : AAudioConvert_aaudioToAndroidDataFormat(getFormat());
Phil Burke1ce4912016-11-21 10:40:25 -080093
Phil Burke4d7bb42017-03-28 11:32:39 -070094 // Setup the callback if there is one.
95 AudioTrack::callback_t callback = nullptr;
96 void *callbackData = nullptr;
97 // Note that TRANSFER_SYNC does not allow FAST track
98 AudioTrack::transfer_type streamTransferType = AudioTrack::transfer_type::TRANSFER_SYNC;
99 if (builder.getDataCallbackProc() != nullptr) {
100 streamTransferType = AudioTrack::transfer_type::TRANSFER_CALLBACK;
101 callback = getLegacyCallback();
102 callbackData = this;
103
Phil Burke4d7bb42017-03-28 11:32:39 -0700104 // If the total buffer size is unspecified then base the size on the burst size.
Phil Burk4485d412017-05-09 15:55:02 -0700105 if (frameCount == 0
106 && ((flags & AUDIO_OUTPUT_FLAG_FAST) != 0)) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700107 // Take advantage of a special trick that allows us to create a buffer
108 // that is some multiple of the burst size.
109 notificationFrames = 0 - DEFAULT_BURSTS_PER_BUFFER_CAPACITY;
Phil Burk4485d412017-05-09 15:55:02 -0700110 } else {
111 notificationFrames = builder.getFramesPerDataCallback();
Phil Burke4d7bb42017-03-28 11:32:39 -0700112 }
113 }
114 mCallbackBufferSize = builder.getFramesPerDataCallback();
115
Phil Burkfbf031e2017-10-12 15:58:31 -0700116 ALOGD("open(), request notificationFrames = %d, frameCount = %u",
Phil Burkcf5f6d22017-05-26 12:35:07 -0700117 notificationFrames, (uint)frameCount);
Phil Burk965650e2017-09-07 21:00:09 -0700118 mAudioTrack = new AudioTrack(); // TODO review
Eric Laurentfb00fc72017-05-25 18:17:12 -0700119 if (getDeviceId() != AAUDIO_UNSPECIFIED) {
120 mAudioTrack->setOutputDevice(getDeviceId());
121 }
122 mAudioTrack->set(
Phil Burke1ce4912016-11-21 10:40:25 -0800123 (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,
Eric Laurentfb00fc72017-05-25 18:17:12 -0700132 0 /*sharedBuffer*/,
133 false /*threadCanCallJava*/,
Phil Burke1ce4912016-11-21 10:40:25 -0800134 AUDIO_SESSION_ALLOCATE,
Phil Burke4d7bb42017-03-28 11:32:39 -0700135 streamTransferType
Phil Burke1ce4912016-11-21 10:40:25 -0800136 );
137
138 // Did we get a valid track?
139 status_t status = mAudioTrack->initCheck();
Phil Burkdec33ab2017-01-17 14:48:16 -0800140 if (status != NO_ERROR) {
Phil Burke1ce4912016-11-21 10:40:25 -0800141 close();
Phil Burkfbf031e2017-10-12 15:58:31 -0700142 ALOGE("open(), initCheck() returned %d", status);
Phil Burk5ed503c2017-02-01 09:38:15 -0800143 return AAudioConvert_androidToAAudioResult(status);
Phil Burke1ce4912016-11-21 10:40:25 -0800144 }
145
Phil Burk965650e2017-09-07 21:00:09 -0700146 doSetVolume();
Eric Laurent1d32e9f2017-06-02 14:01:32 -0700147
Phil Burke1ce4912016-11-21 10:40:25 -0800148 // Get the actual values from the AudioTrack.
149 setSamplesPerFrame(mAudioTrack->channelCount());
Phil Burk9dca9822017-05-26 14:27:43 -0700150 aaudio_format_t aaudioFormat =
Phil Burke4d7bb42017-03-28 11:32:39 -0700151 AAudioConvert_androidToAAudioDataFormat(mAudioTrack->format());
152 setFormat(aaudioFormat);
153
Phil Burkcf5f6d22017-05-26 12:35:07 -0700154 int32_t actualSampleRate = mAudioTrack->getSampleRate();
155 ALOGW_IF(actualSampleRate != getSampleRate(),
Phil Burkfbf031e2017-10-12 15:58:31 -0700156 "open() sampleRate changed from %d to %d",
Phil Burkcf5f6d22017-05-26 12:35:07 -0700157 getSampleRate(), actualSampleRate);
158 setSampleRate(actualSampleRate);
159
Phil Burke4d7bb42017-03-28 11:32:39 -0700160 // We may need to pass the data through a block size adapter to guarantee constant size.
161 if (mCallbackBufferSize != AAUDIO_UNSPECIFIED) {
162 int callbackSizeBytes = getBytesPerFrame() * mCallbackBufferSize;
163 mFixedBlockReader.open(callbackSizeBytes);
164 mBlockAdapter = &mFixedBlockReader;
165 } else {
166 mBlockAdapter = nullptr;
167 }
Phil Burke1ce4912016-11-21 10:40:25 -0800168
Phil Burk5ed503c2017-02-01 09:38:15 -0800169 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burkc0c70e32017-02-09 13:18:38 -0800170 setDeviceId(mAudioTrack->getRoutedDeviceId());
Eric Laurentfb00fc72017-05-25 18:17:12 -0700171 mAudioTrack->addAudioDeviceCallback(mDeviceCallback);
Phil Burke1ce4912016-11-21 10:40:25 -0800172
Phil Burk09c27ca2017-08-24 22:12:56 -0700173 // Update performance mode based on the actual stream flags.
Phil Burk30a70772017-05-16 11:20:36 -0700174 // For example, if the sample rate is not allowed then you won't get a FAST track.
175 audio_output_flags_t actualFlags = mAudioTrack->getFlags();
176 aaudio_performance_mode_t actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_NONE;
Phil Burk09c27ca2017-08-24 22:12:56 -0700177 // We may not get the RAW flag. But as long as we get the FAST flag we can call it LOW_LATENCY.
178 if ((actualFlags & AUDIO_OUTPUT_FLAG_FAST) != 0) {
Phil Burk30a70772017-05-16 11:20:36 -0700179 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
Phil Burk30a70772017-05-16 11:20:36 -0700180 } else if ((actualFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
181 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_POWER_SAVING;
182 }
183 setPerformanceMode(actualPerformanceMode);
Phil Burkefa56002017-08-02 15:07:21 -0700184
185 setSharingMode(AAUDIO_SHARING_MODE_SHARED); // EXCLUSIVE mode not supported in legacy
186
Phil Burk30a70772017-05-16 11:20:36 -0700187 // Log warning if we did not get what we asked for.
188 ALOGW_IF(actualFlags != flags,
Phil Burkfbf031e2017-10-12 15:58:31 -0700189 "open() flags changed from 0x%08X to 0x%08X",
Phil Burk30a70772017-05-16 11:20:36 -0700190 flags, actualFlags);
191 ALOGW_IF(actualPerformanceMode != perfMode,
Phil Burkfbf031e2017-10-12 15:58:31 -0700192 "open() perfMode changed from %d to %d",
Phil Burk30a70772017-05-16 11:20:36 -0700193 perfMode, actualPerformanceMode);
194
Phil Burk5ed503c2017-02-01 09:38:15 -0800195 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800196}
197
Phil Burk5ed503c2017-02-01 09:38:15 -0800198aaudio_result_t AudioStreamTrack::close()
Phil Burke1ce4912016-11-21 10:40:25 -0800199{
Phil Burk5ed503c2017-02-01 09:38:15 -0800200 if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk965650e2017-09-07 21:00:09 -0700201 mAudioTrack->removeAudioDeviceCallback(mDeviceCallback);
Phil Burk5ed503c2017-02-01 09:38:15 -0800202 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800203 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700204 mFixedBlockReader.close();
Phil Burk5ed503c2017-02-01 09:38:15 -0800205 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800206}
207
Phil Burke4d7bb42017-03-28 11:32:39 -0700208void AudioStreamTrack::processCallback(int event, void *info) {
209
210 switch (event) {
211 case AudioTrack::EVENT_MORE_DATA:
212 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, info);
213 break;
214
215 // Stream got rerouted so we disconnect.
216 case AudioTrack::EVENT_NEW_IAUDIOTRACK:
217 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_DISCONNECTED, info);
218 break;
219
220 default:
221 break;
222 }
223 return;
224}
225
Phil Burk965650e2017-09-07 21:00:09 -0700226aaudio_result_t AudioStreamTrack::requestStart() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700227 std::lock_guard<std::mutex> lock(mStreamMutex);
228
Phil Burkd8bdcab2017-01-03 17:20:30 -0800229 if (mAudioTrack.get() == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700230 ALOGE("requestStart() no AudioTrack");
Phil Burk5ed503c2017-02-01 09:38:15 -0800231 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800232 }
233 // Get current position so we can detect when the track is playing.
234 status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
235 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800236 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800237 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700238
Phil Burk965650e2017-09-07 21:00:09 -0700239 err = mAudioTrack->start();
Phil Burke1ce4912016-11-21 10:40:25 -0800240 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800241 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800242 } else {
Eric Laurentfb00fc72017-05-25 18:17:12 -0700243 onStart();
Phil Burk5ed503c2017-02-01 09:38:15 -0800244 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burke1ce4912016-11-21 10:40:25 -0800245 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800246 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800247}
248
Phil Burk965650e2017-09-07 21:00:09 -0700249aaudio_result_t AudioStreamTrack::requestPause() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700250 std::lock_guard<std::mutex> lock(mStreamMutex);
251
Phil Burkd8bdcab2017-01-03 17:20:30 -0800252 if (mAudioTrack.get() == nullptr) {
Phil Burk965650e2017-09-07 21:00:09 -0700253 ALOGE("requestPause() no AudioTrack");
Phil Burk5ed503c2017-02-01 09:38:15 -0800254 return AAUDIO_ERROR_INVALID_STATE;
255 } else if (getState() != AAUDIO_STREAM_STATE_STARTING
256 && getState() != AAUDIO_STREAM_STATE_STARTED) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700257 ALOGE("requestPause(), called when state is %s",
258 AAudio_convertStreamStateToText(getState()));
Phil Burk5ed503c2017-02-01 09:38:15 -0800259 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800260 }
Eric Laurentfb00fc72017-05-25 18:17:12 -0700261 onStop();
Phil Burk5ed503c2017-02-01 09:38:15 -0800262 setState(AAUDIO_STREAM_STATE_PAUSING);
Phil Burk965650e2017-09-07 21:00:09 -0700263 mAudioTrack->pause();
Phil Burk2d5ba532017-09-06 14:36:11 -0700264 checkForDisconnectRequest();
Phil Burke1ce4912016-11-21 10:40:25 -0800265 status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
266 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800267 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800268 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800269 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800270}
271
Phil Burk5ed503c2017-02-01 09:38:15 -0800272aaudio_result_t AudioStreamTrack::requestFlush() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700273 std::lock_guard<std::mutex> lock(mStreamMutex);
274
Phil Burkd8bdcab2017-01-03 17:20:30 -0800275 if (mAudioTrack.get() == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700276 ALOGE("requestFlush() no AudioTrack");
Phil Burk5ed503c2017-02-01 09:38:15 -0800277 return AAUDIO_ERROR_INVALID_STATE;
278 } else if (getState() != AAUDIO_STREAM_STATE_PAUSED) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700279 ALOGE("requestFlush() not paused");
Phil Burk5ed503c2017-02-01 09:38:15 -0800280 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800281 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800282 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burke1ce4912016-11-21 10:40:25 -0800283 incrementFramesRead(getFramesWritten() - getFramesRead());
284 mAudioTrack->flush();
285 mFramesWritten.reset32();
Phil Burk7328a802017-08-30 09:29:48 -0700286 mTimestampPosition.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800287 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800288}
289
Phil Burk5ed503c2017-02-01 09:38:15 -0800290aaudio_result_t AudioStreamTrack::requestStop() {
Phil Burke4d7bb42017-03-28 11:32:39 -0700291 std::lock_guard<std::mutex> lock(mStreamMutex);
292
Phil Burkd8bdcab2017-01-03 17:20:30 -0800293 if (mAudioTrack.get() == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700294 ALOGE("requestStop() no AudioTrack");
Phil Burk5ed503c2017-02-01 09:38:15 -0800295 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800296 }
Eric Laurentfb00fc72017-05-25 18:17:12 -0700297 onStop();
Phil Burk5ed503c2017-02-01 09:38:15 -0800298 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burke1ce4912016-11-21 10:40:25 -0800299 incrementFramesRead(getFramesWritten() - getFramesRead()); // TODO review
Phil Burk7328a802017-08-30 09:29:48 -0700300 mTimestampPosition.set(getFramesWritten());
Phil Burke1ce4912016-11-21 10:40:25 -0800301 mFramesWritten.reset32();
Phil Burk7328a802017-08-30 09:29:48 -0700302 mTimestampPosition.reset32();
Phil Burk965650e2017-09-07 21:00:09 -0700303 mAudioTrack->stop();
Phil Burk2d5ba532017-09-06 14:36:11 -0700304 checkForDisconnectRequest();
Phil Burk5ed503c2017-02-01 09:38:15 -0800305 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800306}
307
Phil Burk0befec62017-07-28 15:12:13 -0700308aaudio_result_t AudioStreamTrack::updateStateMachine()
Phil Burke1ce4912016-11-21 10:40:25 -0800309{
310 status_t err;
Phil Burk5ed503c2017-02-01 09:38:15 -0800311 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800312 switch (getState()) {
313 // TODO add better state visibility to AudioTrack
Phil Burk5ed503c2017-02-01 09:38:15 -0800314 case AAUDIO_STREAM_STATE_STARTING:
Phil Burke1ce4912016-11-21 10:40:25 -0800315 if (mAudioTrack->hasStarted()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800316 setState(AAUDIO_STREAM_STATE_STARTED);
Phil Burke1ce4912016-11-21 10:40:25 -0800317 }
318 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800319 case AAUDIO_STREAM_STATE_PAUSING:
Phil Burke1ce4912016-11-21 10:40:25 -0800320 if (mAudioTrack->stopped()) {
321 err = mAudioTrack->getPosition(&position);
322 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800323 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800324 } else if (position == mPositionWhenPausing) {
325 // Has stream really stopped advancing?
Phil Burk5ed503c2017-02-01 09:38:15 -0800326 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800327 }
328 mPositionWhenPausing = position;
329 }
330 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800331 case AAUDIO_STREAM_STATE_FLUSHING:
Phil Burke1ce4912016-11-21 10:40:25 -0800332 {
333 err = mAudioTrack->getPosition(&position);
334 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800335 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800336 } else if (position == 0) {
Phil Burk5204d312017-05-04 17:16:13 -0700337 // TODO Advance frames read to match written.
Phil Burk5ed503c2017-02-01 09:38:15 -0800338 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burke1ce4912016-11-21 10:40:25 -0800339 }
340 }
341 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800342 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800343 if (mAudioTrack->stopped()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800344 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burke1ce4912016-11-21 10:40:25 -0800345 }
346 break;
347 default:
348 break;
349 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800350 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800351}
352
Phil Burk5ed503c2017-02-01 09:38:15 -0800353aaudio_result_t AudioStreamTrack::write(const void *buffer,
Phil Burk3316d5e2017-02-15 11:23:01 -0800354 int32_t numFrames,
355 int64_t timeoutNanoseconds)
Phil Burke1ce4912016-11-21 10:40:25 -0800356{
Phil Burk3316d5e2017-02-15 11:23:01 -0800357 int32_t bytesPerFrame = getBytesPerFrame();
358 int32_t numBytes;
Phil Burk5ed503c2017-02-01 09:38:15 -0800359 aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
360 if (result != AAUDIO_OK) {
Phil Burke1ce4912016-11-21 10:40:25 -0800361 return result;
362 }
363
Eric Laurentfb00fc72017-05-25 18:17:12 -0700364 if (getState() == AAUDIO_STREAM_STATE_DISCONNECTED) {
365 return AAUDIO_ERROR_DISCONNECTED;
366 }
367
Phil Burke1ce4912016-11-21 10:40:25 -0800368 // TODO add timeout to AudioTrack
369 bool blocking = timeoutNanoseconds > 0;
370 ssize_t bytesWritten = mAudioTrack->write(buffer, numBytes, blocking);
371 if (bytesWritten == WOULD_BLOCK) {
372 return 0;
373 } else if (bytesWritten < 0) {
374 ALOGE("invalid write, returned %d", (int)bytesWritten);
Eric Laurentfb00fc72017-05-25 18:17:12 -0700375 // in this context, a DEAD_OBJECT is more likely to be a disconnect notification due to
376 // AudioTrack invalidation
377 if (bytesWritten == DEAD_OBJECT) {
378 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
379 return AAUDIO_ERROR_DISCONNECTED;
380 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800381 return AAudioConvert_androidToAAudioResult(bytesWritten);
Phil Burke1ce4912016-11-21 10:40:25 -0800382 }
Phil Burk3316d5e2017-02-15 11:23:01 -0800383 int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -0800384 incrementFramesWritten(framesWritten);
Phil Burk0befec62017-07-28 15:12:13 -0700385
386 result = updateStateMachine();
387 if (result != AAUDIO_OK) {
388 return result;
389 }
390
Phil Burke1ce4912016-11-21 10:40:25 -0800391 return framesWritten;
392}
393
Phil Burk3316d5e2017-02-15 11:23:01 -0800394aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
Phil Burke1ce4912016-11-21 10:40:25 -0800395{
396 ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800397 if (result < 0) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800398 return AAudioConvert_androidToAAudioResult(result);
Phil Burke1ce4912016-11-21 10:40:25 -0800399 } else {
Phil Burk3316d5e2017-02-15 11:23:01 -0800400 return result;
Phil Burke1ce4912016-11-21 10:40:25 -0800401 }
402}
403
Phil Burk3316d5e2017-02-15 11:23:01 -0800404int32_t AudioStreamTrack::getBufferSize() const
Phil Burke1ce4912016-11-21 10:40:25 -0800405{
Phil Burk3316d5e2017-02-15 11:23:01 -0800406 return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800407}
408
Phil Burk3316d5e2017-02-15 11:23:01 -0800409int32_t AudioStreamTrack::getBufferCapacity() const
Phil Burke1ce4912016-11-21 10:40:25 -0800410{
Phil Burk3316d5e2017-02-15 11:23:01 -0800411 return static_cast<int32_t>(mAudioTrack->frameCount());
Phil Burke1ce4912016-11-21 10:40:25 -0800412}
413
414int32_t AudioStreamTrack::getXRunCount() const
415{
416 return static_cast<int32_t>(mAudioTrack->getUnderrunCount());
417}
418
419int32_t AudioStreamTrack::getFramesPerBurst() const
420{
Phil Burkb5884022017-03-27 15:26:14 -0700421 return static_cast<int32_t>(mAudioTrack->getNotificationPeriodInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800422}
423
Phil Burk3316d5e2017-02-15 11:23:01 -0800424int64_t AudioStreamTrack::getFramesRead() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800425 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800426 status_t result;
427 switch (getState()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800428 case AAUDIO_STREAM_STATE_STARTING:
429 case AAUDIO_STREAM_STATE_STARTED:
430 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burk4c5129b2017-04-28 15:17:32 -0700431 case AAUDIO_STREAM_STATE_PAUSING:
432 case AAUDIO_STREAM_STATE_PAUSED:
Phil Burke1ce4912016-11-21 10:40:25 -0800433 result = mAudioTrack->getPosition(&position);
434 if (result == OK) {
435 mFramesRead.update32(position);
436 }
437 break;
438 default:
439 break;
440 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700441 return AudioStreamLegacy::getFramesRead();
Phil Burke1ce4912016-11-21 10:40:25 -0800442}
Phil Burk35e80f32017-03-28 10:25:21 -0700443
444aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
445 int64_t *framePosition,
446 int64_t *timeNanoseconds) {
447 ExtendedTimestamp extendedTimestamp;
448 status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
Phil Burkc75d97f2017-09-08 15:48:36 -0700449 if (status == WOULD_BLOCK) {
450 return AAUDIO_ERROR_INVALID_STATE;
451 } if (status != NO_ERROR) {
Phil Burk35e80f32017-03-28 10:25:21 -0700452 return AAudioConvert_androidToAAudioResult(status);
453 }
Phil Burk7328a802017-08-30 09:29:48 -0700454 int64_t position = 0;
455 int64_t nanoseconds = 0;
456 aaudio_result_t result = getBestTimestamp(clockId, &position,
457 &nanoseconds, &extendedTimestamp);
458 if (result == AAUDIO_OK) {
459 if (position < getFramesWritten()) {
460 *framePosition = position;
461 *timeNanoseconds = nanoseconds;
462 return result;
463 } else {
464 return AAUDIO_ERROR_INVALID_STATE; // TODO review, documented but not consistent
465 }
466 }
467 return result;
Phil Burk35e80f32017-03-28 10:25:21 -0700468}
Phil Burk965650e2017-09-07 21:00:09 -0700469
470status_t AudioStreamTrack::doSetVolume() {
471 status_t status = NO_INIT;
472 if (mAudioTrack.get() != nullptr) {
473 float volume = getDuckAndMuteVolume();
474 mAudioTrack->setVolume(volume, volume);
475 status = NO_ERROR;
476 }
477 return status;
478}
479
480#if AAUDIO_USE_VOLUME_SHAPER
Phil Burk8a8a9e52017-09-12 16:25:15 -0700481
482using namespace android::media::VolumeShaper;
483
Phil Burk965650e2017-09-07 21:00:09 -0700484binder::Status AudioStreamTrack::applyVolumeShaper(
485 const VolumeShaper::Configuration& configuration,
486 const VolumeShaper::Operation& operation) {
487
488 sp<VolumeShaper::Configuration> spConfiguration = new VolumeShaper::Configuration(configuration);
489 sp<VolumeShaper::Operation> spOperation = new VolumeShaper::Operation(operation);
490
491 if (mAudioTrack.get() != nullptr) {
492 ALOGD("applyVolumeShaper() from IPlayer");
Phil Burk8a8a9e52017-09-12 16:25:15 -0700493 binder::Status status = mAudioTrack->applyVolumeShaper(spConfiguration, spOperation);
Phil Burk965650e2017-09-07 21:00:09 -0700494 if (status < 0) { // a non-negative value is the volume shaper id.
495 ALOGE("applyVolumeShaper() failed with status %d", status);
496 }
497 return binder::Status::fromStatusT(status);
498 } else {
499 ALOGD("applyVolumeShaper()"
500 " no AudioTrack for volume control from IPlayer");
501 return binder::Status::ok();
502 }
503}
504#endif