blob: e359c1c9df78a8d2590a8508e7f70580c6935d82 [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 Burked816012018-02-06 12:40:50 -080025#include <system/audio.h>
Phil Burkc0c70e32017-02-09 13:18:38 -080026#include "utility/AudioClock.h"
Phil Burke4d7bb42017-03-28 11:32:39 -070027#include "legacy/AudioStreamLegacy.h"
28#include "legacy/AudioStreamTrack.h"
29#include "utility/FixedBlockReader.h"
Phil Burke1ce4912016-11-21 10:40:25 -080030
31using namespace android;
Phil Burk5ed503c2017-02-01 09:38:15 -080032using namespace aaudio;
Phil Burke1ce4912016-11-21 10:40:25 -080033
Phil Burke4d7bb42017-03-28 11:32:39 -070034// Arbitrary and somewhat generous number of bursts.
35#define DEFAULT_BURSTS_PER_BUFFER_CAPACITY 8
36
Phil Burke1ce4912016-11-21 10:40:25 -080037/*
38 * Create a stream that uses the AudioTrack.
39 */
40AudioStreamTrack::AudioStreamTrack()
Phil Burke4d7bb42017-03-28 11:32:39 -070041 : AudioStreamLegacy()
42 , mFixedBlockReader(*this)
Phil Burke1ce4912016-11-21 10:40:25 -080043{
44}
45
46AudioStreamTrack::~AudioStreamTrack()
47{
Phil Burk5ed503c2017-02-01 09:38:15 -080048 const aaudio_stream_state_t state = getState();
49 bool bad = !(state == AAUDIO_STREAM_STATE_UNINITIALIZED || state == AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -080050 ALOGE_IF(bad, "stream not closed, in state %d", state);
51}
52
Phil Burk5ed503c2017-02-01 09:38:15 -080053aaudio_result_t AudioStreamTrack::open(const AudioStreamBuilder& builder)
Phil Burke1ce4912016-11-21 10:40:25 -080054{
Phil Burk5ed503c2017-02-01 09:38:15 -080055 aaudio_result_t result = AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -080056
57 result = AudioStream::open(builder);
58 if (result != OK) {
59 return result;
60 }
61
Phil Burk8ffcf612018-05-23 14:38:07 -070062 const aaudio_session_id_t requestedSessionId = builder.getSessionId();
63 const audio_session_t sessionId = AAudioConvert_aaudioToAndroidSessionId(requestedSessionId);
64
Phil Burke1ce4912016-11-21 10:40:25 -080065 // Try to create an AudioTrack
Phil Burk5204d312017-05-04 17:16:13 -070066 // Use stereo if unspecified.
Phil Burk5ed503c2017-02-01 09:38:15 -080067 int32_t samplesPerFrame = (getSamplesPerFrame() == AAUDIO_UNSPECIFIED)
Phil Burke1ce4912016-11-21 10:40:25 -080068 ? 2 : getSamplesPerFrame();
69 audio_channel_mask_t channelMask = audio_channel_out_mask_from_count(samplesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -080070
Phil Burk8ffcf612018-05-23 14:38:07 -070071 audio_output_flags_t flags;
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.
Phil Burk8ffcf612018-05-23 14:38:07 -070076 // If the app asks for a sessionId then it means they want to use effects.
77 // So don't use RAW flag.
78 flags = (audio_output_flags_t) ((requestedSessionId == AAUDIO_SESSION_ID_NONE)
79 ? (AUDIO_OUTPUT_FLAG_FAST | AUDIO_OUTPUT_FLAG_RAW)
80 : (AUDIO_OUTPUT_FLAG_FAST));
Phil Burke2fbb592017-05-01 15:05:52 -070081 break;
82
83 case AAUDIO_PERFORMANCE_MODE_POWER_SAVING:
84 // This uses a mixer that wakes up less often than the FAST mixer.
85 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
86 break;
87
88 case AAUDIO_PERFORMANCE_MODE_NONE:
89 default:
90 // No flags. Use a normal mixer in front of the FAST mixer.
Phil Burk8ffcf612018-05-23 14:38:07 -070091 flags = AUDIO_OUTPUT_FLAG_NONE;
Phil Burke2fbb592017-05-01 15:05:52 -070092 break;
93 }
Phil Burke4d7bb42017-03-28 11:32:39 -070094
Phil Burkcf5f6d22017-05-26 12:35:07 -070095 size_t frameCount = (size_t)builder.getBufferCapacity();
Phil Burke4d7bb42017-03-28 11:32:39 -070096
97 int32_t notificationFrames = 0;
98
Phil Burk0127c1b2018-03-29 13:48:06 -070099 const audio_format_t format = (getFormat() == AUDIO_FORMAT_DEFAULT)
Phil Burke1ce4912016-11-21 10:40:25 -0800100 ? AUDIO_FORMAT_PCM_FLOAT
Phil Burk0127c1b2018-03-29 13:48:06 -0700101 : getFormat();
Phil Burke1ce4912016-11-21 10:40:25 -0800102
Phil Burke4d7bb42017-03-28 11:32:39 -0700103 // Setup the callback if there is one.
104 AudioTrack::callback_t callback = nullptr;
105 void *callbackData = nullptr;
106 // Note that TRANSFER_SYNC does not allow FAST track
107 AudioTrack::transfer_type streamTransferType = AudioTrack::transfer_type::TRANSFER_SYNC;
108 if (builder.getDataCallbackProc() != nullptr) {
109 streamTransferType = AudioTrack::transfer_type::TRANSFER_CALLBACK;
110 callback = getLegacyCallback();
111 callbackData = this;
112
Phil Burke4d7bb42017-03-28 11:32:39 -0700113 // If the total buffer size is unspecified then base the size on the burst size.
Phil Burk4485d412017-05-09 15:55:02 -0700114 if (frameCount == 0
115 && ((flags & AUDIO_OUTPUT_FLAG_FAST) != 0)) {
Phil Burke4d7bb42017-03-28 11:32:39 -0700116 // Take advantage of a special trick that allows us to create a buffer
117 // that is some multiple of the burst size.
118 notificationFrames = 0 - DEFAULT_BURSTS_PER_BUFFER_CAPACITY;
Phil Burk4485d412017-05-09 15:55:02 -0700119 } else {
120 notificationFrames = builder.getFramesPerDataCallback();
Phil Burke4d7bb42017-03-28 11:32:39 -0700121 }
122 }
123 mCallbackBufferSize = builder.getFramesPerDataCallback();
124
Phil Burkfbf031e2017-10-12 15:58:31 -0700125 ALOGD("open(), request notificationFrames = %d, frameCount = %u",
Phil Burkcf5f6d22017-05-26 12:35:07 -0700126 notificationFrames, (uint)frameCount);
Phil Burkee995392017-12-11 11:44:36 -0800127
128 // Don't call mAudioTrack->setDeviceId() because it will be overwritten by set()!
129 audio_port_handle_t selectedDeviceId = (getDeviceId() == AAUDIO_UNSPECIFIED)
130 ? AUDIO_PORT_HANDLE_NONE
131 : getDeviceId();
132
Phil Burkd4ccc622017-12-20 15:32:44 -0800133 const audio_content_type_t contentType =
134 AAudioConvert_contentTypeToInternal(builder.getContentType());
135 const audio_usage_t usage =
136 AAudioConvert_usageToInternal(builder.getUsage());
Kevin Rocard68646ba2019-03-20 13:26:49 -0700137 const audio_flags_mask_t attributesFlags =
138 AAudioConvert_allowCapturePolicyToAudioFlagsMask(builder.getAllowedCapturePolicy());
Phil Burkd4ccc622017-12-20 15:32:44 -0800139
140 const audio_attributes_t attributes = {
141 .content_type = contentType,
142 .usage = usage,
143 .source = AUDIO_SOURCE_DEFAULT, // only used for recording
Kevin Rocard68646ba2019-03-20 13:26:49 -0700144 .flags = attributesFlags,
Phil Burkd4ccc622017-12-20 15:32:44 -0800145 .tags = ""
146 };
147
Phil Burkee995392017-12-11 11:44:36 -0800148 mAudioTrack = new AudioTrack();
Eric Laurentfb00fc72017-05-25 18:17:12 -0700149 mAudioTrack->set(
Phil Burkd4ccc622017-12-20 15:32:44 -0800150 AUDIO_STREAM_DEFAULT, // ignored because we pass attributes below
Phil Burke1ce4912016-11-21 10:40:25 -0800151 getSampleRate(),
152 format,
153 channelMask,
154 frameCount,
155 flags,
156 callback,
Phil Burke4d7bb42017-03-28 11:32:39 -0700157 callbackData,
158 notificationFrames,
Phil Burkee995392017-12-11 11:44:36 -0800159 0, // DEFAULT sharedBuffer*/,
160 false, // DEFAULT threadCanCallJava
Phil Burk4e1af9f2018-01-03 15:54:35 -0800161 sessionId,
Phil Burkee995392017-12-11 11:44:36 -0800162 streamTransferType,
163 NULL, // DEFAULT audio_offload_info_t
164 AUDIO_UID_INVALID, // DEFAULT uid
165 -1, // DEFAULT pid
Phil Burkd4ccc622017-12-20 15:32:44 -0800166 &attributes,
Phil Burkee995392017-12-11 11:44:36 -0800167 // WARNING - If doNotReconnect set true then audio stops after plugging and unplugging
168 // headphones a few times.
169 false, // DEFAULT doNotReconnect,
170 1.0f, // DEFAULT maxRequiredSpeed
171 selectedDeviceId
172 );
Phil Burke1ce4912016-11-21 10:40:25 -0800173
174 // Did we get a valid track?
175 status_t status = mAudioTrack->initCheck();
Phil Burkdec33ab2017-01-17 14:48:16 -0800176 if (status != NO_ERROR) {
Phil Burke1ce4912016-11-21 10:40:25 -0800177 close();
Phil Burkfbf031e2017-10-12 15:58:31 -0700178 ALOGE("open(), initCheck() returned %d", status);
Phil Burk5ed503c2017-02-01 09:38:15 -0800179 return AAudioConvert_androidToAAudioResult(status);
Phil Burke1ce4912016-11-21 10:40:25 -0800180 }
181
Phil Burk965650e2017-09-07 21:00:09 -0700182 doSetVolume();
Eric Laurent1d32e9f2017-06-02 14:01:32 -0700183
Phil Burke1ce4912016-11-21 10:40:25 -0800184 // Get the actual values from the AudioTrack.
185 setSamplesPerFrame(mAudioTrack->channelCount());
Phil Burk0127c1b2018-03-29 13:48:06 -0700186 setFormat(mAudioTrack->format());
187 setDeviceFormat(mAudioTrack->format());
Phil Burke4d7bb42017-03-28 11:32:39 -0700188
Phil Burkcf5f6d22017-05-26 12:35:07 -0700189 int32_t actualSampleRate = mAudioTrack->getSampleRate();
190 ALOGW_IF(actualSampleRate != getSampleRate(),
Phil Burkfbf031e2017-10-12 15:58:31 -0700191 "open() sampleRate changed from %d to %d",
Phil Burkcf5f6d22017-05-26 12:35:07 -0700192 getSampleRate(), actualSampleRate);
193 setSampleRate(actualSampleRate);
194
Phil Burke4d7bb42017-03-28 11:32:39 -0700195 // We may need to pass the data through a block size adapter to guarantee constant size.
196 if (mCallbackBufferSize != AAUDIO_UNSPECIFIED) {
197 int callbackSizeBytes = getBytesPerFrame() * mCallbackBufferSize;
198 mFixedBlockReader.open(callbackSizeBytes);
199 mBlockAdapter = &mFixedBlockReader;
200 } else {
201 mBlockAdapter = nullptr;
202 }
Phil Burke1ce4912016-11-21 10:40:25 -0800203
Phil Burk5ed503c2017-02-01 09:38:15 -0800204 setState(AAUDIO_STREAM_STATE_OPEN);
Phil Burkc0c70e32017-02-09 13:18:38 -0800205 setDeviceId(mAudioTrack->getRoutedDeviceId());
Phil Burk4e1af9f2018-01-03 15:54:35 -0800206
207 aaudio_session_id_t actualSessionId =
208 (requestedSessionId == AAUDIO_SESSION_ID_NONE)
209 ? AAUDIO_SESSION_ID_NONE
210 : (aaudio_session_id_t) mAudioTrack->getSessionId();
211 setSessionId(actualSessionId);
212
Eric Laurentfb00fc72017-05-25 18:17:12 -0700213 mAudioTrack->addAudioDeviceCallback(mDeviceCallback);
Phil Burke1ce4912016-11-21 10:40:25 -0800214
Phil Burk09c27ca2017-08-24 22:12:56 -0700215 // Update performance mode based on the actual stream flags.
Phil Burk30a70772017-05-16 11:20:36 -0700216 // For example, if the sample rate is not allowed then you won't get a FAST track.
217 audio_output_flags_t actualFlags = mAudioTrack->getFlags();
218 aaudio_performance_mode_t actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_NONE;
Phil Burk09c27ca2017-08-24 22:12:56 -0700219 // We may not get the RAW flag. But as long as we get the FAST flag we can call it LOW_LATENCY.
220 if ((actualFlags & AUDIO_OUTPUT_FLAG_FAST) != 0) {
Phil Burk30a70772017-05-16 11:20:36 -0700221 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
Phil Burk30a70772017-05-16 11:20:36 -0700222 } else if ((actualFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
223 actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_POWER_SAVING;
224 }
225 setPerformanceMode(actualPerformanceMode);
Phil Burkefa56002017-08-02 15:07:21 -0700226
227 setSharingMode(AAUDIO_SHARING_MODE_SHARED); // EXCLUSIVE mode not supported in legacy
228
Phil Burk30a70772017-05-16 11:20:36 -0700229 // Log warning if we did not get what we asked for.
230 ALOGW_IF(actualFlags != flags,
Phil Burkfbf031e2017-10-12 15:58:31 -0700231 "open() flags changed from 0x%08X to 0x%08X",
Phil Burk30a70772017-05-16 11:20:36 -0700232 flags, actualFlags);
233 ALOGW_IF(actualPerformanceMode != perfMode,
Phil Burkfbf031e2017-10-12 15:58:31 -0700234 "open() perfMode changed from %d to %d",
Phil Burk30a70772017-05-16 11:20:36 -0700235 perfMode, actualPerformanceMode);
236
Phil Burk5ed503c2017-02-01 09:38:15 -0800237 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800238}
239
Phil Burk5ed503c2017-02-01 09:38:15 -0800240aaudio_result_t AudioStreamTrack::close()
Phil Burke1ce4912016-11-21 10:40:25 -0800241{
Phil Burk5ed503c2017-02-01 09:38:15 -0800242 if (getState() != AAUDIO_STREAM_STATE_CLOSED) {
Phil Burk965650e2017-09-07 21:00:09 -0700243 mAudioTrack->removeAudioDeviceCallback(mDeviceCallback);
Phil Burk5ed503c2017-02-01 09:38:15 -0800244 setState(AAUDIO_STREAM_STATE_CLOSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800245 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700246 mFixedBlockReader.close();
Phil Burk5ed503c2017-02-01 09:38:15 -0800247 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800248}
249
Phil Burke4d7bb42017-03-28 11:32:39 -0700250void AudioStreamTrack::processCallback(int event, void *info) {
251
252 switch (event) {
253 case AudioTrack::EVENT_MORE_DATA:
254 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, info);
255 break;
256
257 // Stream got rerouted so we disconnect.
258 case AudioTrack::EVENT_NEW_IAUDIOTRACK:
259 processCallbackCommon(AAUDIO_CALLBACK_OPERATION_DISCONNECTED, info);
260 break;
261
262 default:
263 break;
264 }
265 return;
266}
267
Phil Burk965650e2017-09-07 21:00:09 -0700268aaudio_result_t AudioStreamTrack::requestStart() {
Phil Burkd8bdcab2017-01-03 17:20:30 -0800269 if (mAudioTrack.get() == nullptr) {
Phil Burkfbf031e2017-10-12 15:58:31 -0700270 ALOGE("requestStart() no AudioTrack");
Phil Burk5ed503c2017-02-01 09:38:15 -0800271 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800272 }
273 // Get current position so we can detect when the track is playing.
274 status_t err = mAudioTrack->getPosition(&mPositionWhenStarting);
275 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800276 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800277 }
Phil Burke4d7bb42017-03-28 11:32:39 -0700278
Phil Burk9e9a95b2018-01-18 12:14:15 -0800279 // Enable callback before starting AudioTrack to avoid shutting
280 // down because of a race condition.
281 mCallbackEnabled.store(true);
Phil Burk965650e2017-09-07 21:00:09 -0700282 err = mAudioTrack->start();
Phil Burke1ce4912016-11-21 10:40:25 -0800283 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800284 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800285 } else {
Phil Burk5ed503c2017-02-01 09:38:15 -0800286 setState(AAUDIO_STREAM_STATE_STARTING);
Phil Burke1ce4912016-11-21 10:40:25 -0800287 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800288 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800289}
290
Phil Burk965650e2017-09-07 21:00:09 -0700291aaudio_result_t AudioStreamTrack::requestPause() {
Phil Burkd8bdcab2017-01-03 17:20:30 -0800292 if (mAudioTrack.get() == nullptr) {
Phil Burk1e83bee2018-12-17 14:15:20 -0800293 ALOGE("%s() no AudioTrack", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800294 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800295 }
Phil Burk5cc83c32017-11-28 15:43:18 -0800296
Phil Burk5ed503c2017-02-01 09:38:15 -0800297 setState(AAUDIO_STREAM_STATE_PAUSING);
Phil Burk965650e2017-09-07 21:00:09 -0700298 mAudioTrack->pause();
Phil Burk9e9a95b2018-01-18 12:14:15 -0800299 mCallbackEnabled.store(false);
Phil Burke1ce4912016-11-21 10:40:25 -0800300 status_t err = mAudioTrack->getPosition(&mPositionWhenPausing);
301 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800302 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800303 }
Phil Burk134f1972017-12-08 13:06:11 -0800304 return checkForDisconnectRequest(false);
Phil Burke1ce4912016-11-21 10:40:25 -0800305}
306
Phil Burk5ed503c2017-02-01 09:38:15 -0800307aaudio_result_t AudioStreamTrack::requestFlush() {
Phil Burkd8bdcab2017-01-03 17:20:30 -0800308 if (mAudioTrack.get() == nullptr) {
Phil Burk1e83bee2018-12-17 14:15:20 -0800309 ALOGE("%s() no AudioTrack", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800310 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800311 }
Phil Burk5cc83c32017-11-28 15:43:18 -0800312
Phil Burk5ed503c2017-02-01 09:38:15 -0800313 setState(AAUDIO_STREAM_STATE_FLUSHING);
Phil Burke1ce4912016-11-21 10:40:25 -0800314 incrementFramesRead(getFramesWritten() - getFramesRead());
315 mAudioTrack->flush();
Phil Burk2b6f1282018-05-10 15:26:30 -0700316 mFramesRead.reset32(); // service reads frames, service position reset on flush
Phil Burk7328a802017-08-30 09:29:48 -0700317 mTimestampPosition.reset32();
Phil Burk5ed503c2017-02-01 09:38:15 -0800318 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800319}
320
Phil Burk5ed503c2017-02-01 09:38:15 -0800321aaudio_result_t AudioStreamTrack::requestStop() {
Phil Burkd8bdcab2017-01-03 17:20:30 -0800322 if (mAudioTrack.get() == nullptr) {
Phil Burk1e83bee2018-12-17 14:15:20 -0800323 ALOGE("%s() no AudioTrack", __func__);
Phil Burk5ed503c2017-02-01 09:38:15 -0800324 return AAUDIO_ERROR_INVALID_STATE;
Phil Burke1ce4912016-11-21 10:40:25 -0800325 }
Phil Burk5cc83c32017-11-28 15:43:18 -0800326
Phil Burk5ed503c2017-02-01 09:38:15 -0800327 setState(AAUDIO_STREAM_STATE_STOPPING);
Phil Burk18c84762018-12-18 12:15:35 -0800328 mFramesRead.catchUpTo(getFramesWritten());
329 mTimestampPosition.catchUpTo(getFramesWritten());
Phil Burk2b6f1282018-05-10 15:26:30 -0700330 mFramesRead.reset32(); // service reads frames, service position reset on stop
Phil Burk7328a802017-08-30 09:29:48 -0700331 mTimestampPosition.reset32();
Phil Burk965650e2017-09-07 21:00:09 -0700332 mAudioTrack->stop();
Phil Burk9e9a95b2018-01-18 12:14:15 -0800333 mCallbackEnabled.store(false);
Phil Burk134f1972017-12-08 13:06:11 -0800334 return checkForDisconnectRequest(false);;
Phil Burke1ce4912016-11-21 10:40:25 -0800335}
336
Phil Burk0befec62017-07-28 15:12:13 -0700337aaudio_result_t AudioStreamTrack::updateStateMachine()
Phil Burke1ce4912016-11-21 10:40:25 -0800338{
339 status_t err;
Phil Burk5ed503c2017-02-01 09:38:15 -0800340 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800341 switch (getState()) {
342 // TODO add better state visibility to AudioTrack
Phil Burk5ed503c2017-02-01 09:38:15 -0800343 case AAUDIO_STREAM_STATE_STARTING:
Phil Burke1ce4912016-11-21 10:40:25 -0800344 if (mAudioTrack->hasStarted()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800345 setState(AAUDIO_STREAM_STATE_STARTED);
Phil Burke1ce4912016-11-21 10:40:25 -0800346 }
347 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800348 case AAUDIO_STREAM_STATE_PAUSING:
Phil Burke1ce4912016-11-21 10:40:25 -0800349 if (mAudioTrack->stopped()) {
350 err = mAudioTrack->getPosition(&position);
351 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800352 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800353 } else if (position == mPositionWhenPausing) {
354 // Has stream really stopped advancing?
Phil Burk5ed503c2017-02-01 09:38:15 -0800355 setState(AAUDIO_STREAM_STATE_PAUSED);
Phil Burke1ce4912016-11-21 10:40:25 -0800356 }
357 mPositionWhenPausing = position;
358 }
359 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800360 case AAUDIO_STREAM_STATE_FLUSHING:
Phil Burke1ce4912016-11-21 10:40:25 -0800361 {
362 err = mAudioTrack->getPosition(&position);
363 if (err != OK) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800364 return AAudioConvert_androidToAAudioResult(err);
Phil Burke1ce4912016-11-21 10:40:25 -0800365 } else if (position == 0) {
Phil Burk5204d312017-05-04 17:16:13 -0700366 // TODO Advance frames read to match written.
Phil Burk5ed503c2017-02-01 09:38:15 -0800367 setState(AAUDIO_STREAM_STATE_FLUSHED);
Phil Burke1ce4912016-11-21 10:40:25 -0800368 }
369 }
370 break;
Phil Burk5ed503c2017-02-01 09:38:15 -0800371 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burke1ce4912016-11-21 10:40:25 -0800372 if (mAudioTrack->stopped()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800373 setState(AAUDIO_STREAM_STATE_STOPPED);
Phil Burke1ce4912016-11-21 10:40:25 -0800374 }
375 break;
376 default:
377 break;
378 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800379 return AAUDIO_OK;
Phil Burke1ce4912016-11-21 10:40:25 -0800380}
381
Phil Burk5ed503c2017-02-01 09:38:15 -0800382aaudio_result_t AudioStreamTrack::write(const void *buffer,
Phil Burk3316d5e2017-02-15 11:23:01 -0800383 int32_t numFrames,
384 int64_t timeoutNanoseconds)
Phil Burke1ce4912016-11-21 10:40:25 -0800385{
Phil Burk3316d5e2017-02-15 11:23:01 -0800386 int32_t bytesPerFrame = getBytesPerFrame();
387 int32_t numBytes;
Phil Burk5ed503c2017-02-01 09:38:15 -0800388 aaudio_result_t result = AAudioConvert_framesToBytes(numFrames, bytesPerFrame, &numBytes);
389 if (result != AAUDIO_OK) {
Phil Burke1ce4912016-11-21 10:40:25 -0800390 return result;
391 }
392
Eric Laurentfb00fc72017-05-25 18:17:12 -0700393 if (getState() == AAUDIO_STREAM_STATE_DISCONNECTED) {
394 return AAUDIO_ERROR_DISCONNECTED;
395 }
396
Phil Burke1ce4912016-11-21 10:40:25 -0800397 // TODO add timeout to AudioTrack
398 bool blocking = timeoutNanoseconds > 0;
399 ssize_t bytesWritten = mAudioTrack->write(buffer, numBytes, blocking);
400 if (bytesWritten == WOULD_BLOCK) {
401 return 0;
402 } else if (bytesWritten < 0) {
403 ALOGE("invalid write, returned %d", (int)bytesWritten);
Eric Laurentfb00fc72017-05-25 18:17:12 -0700404 // in this context, a DEAD_OBJECT is more likely to be a disconnect notification due to
405 // AudioTrack invalidation
406 if (bytesWritten == DEAD_OBJECT) {
407 setState(AAUDIO_STREAM_STATE_DISCONNECTED);
408 return AAUDIO_ERROR_DISCONNECTED;
409 }
Phil Burk5ed503c2017-02-01 09:38:15 -0800410 return AAudioConvert_androidToAAudioResult(bytesWritten);
Phil Burke1ce4912016-11-21 10:40:25 -0800411 }
Phil Burk3316d5e2017-02-15 11:23:01 -0800412 int32_t framesWritten = (int32_t)(bytesWritten / bytesPerFrame);
Phil Burke1ce4912016-11-21 10:40:25 -0800413 incrementFramesWritten(framesWritten);
Phil Burk0befec62017-07-28 15:12:13 -0700414
415 result = updateStateMachine();
416 if (result != AAUDIO_OK) {
417 return result;
418 }
419
Phil Burke1ce4912016-11-21 10:40:25 -0800420 return framesWritten;
421}
422
Phil Burk3316d5e2017-02-15 11:23:01 -0800423aaudio_result_t AudioStreamTrack::setBufferSize(int32_t requestedFrames)
Phil Burke1ce4912016-11-21 10:40:25 -0800424{
425 ssize_t result = mAudioTrack->setBufferSizeInFrames(requestedFrames);
Phil Burk3316d5e2017-02-15 11:23:01 -0800426 if (result < 0) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800427 return AAudioConvert_androidToAAudioResult(result);
Phil Burke1ce4912016-11-21 10:40:25 -0800428 } else {
Phil Burk3316d5e2017-02-15 11:23:01 -0800429 return result;
Phil Burke1ce4912016-11-21 10:40:25 -0800430 }
431}
432
Phil Burk3316d5e2017-02-15 11:23:01 -0800433int32_t AudioStreamTrack::getBufferSize() const
Phil Burke1ce4912016-11-21 10:40:25 -0800434{
Phil Burk3316d5e2017-02-15 11:23:01 -0800435 return static_cast<int32_t>(mAudioTrack->getBufferSizeInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800436}
437
Phil Burk3316d5e2017-02-15 11:23:01 -0800438int32_t AudioStreamTrack::getBufferCapacity() const
Phil Burke1ce4912016-11-21 10:40:25 -0800439{
Phil Burk3316d5e2017-02-15 11:23:01 -0800440 return static_cast<int32_t>(mAudioTrack->frameCount());
Phil Burke1ce4912016-11-21 10:40:25 -0800441}
442
443int32_t AudioStreamTrack::getXRunCount() const
444{
445 return static_cast<int32_t>(mAudioTrack->getUnderrunCount());
446}
447
448int32_t AudioStreamTrack::getFramesPerBurst() const
449{
Phil Burkb5884022017-03-27 15:26:14 -0700450 return static_cast<int32_t>(mAudioTrack->getNotificationPeriodInFrames());
Phil Burke1ce4912016-11-21 10:40:25 -0800451}
452
Phil Burk3316d5e2017-02-15 11:23:01 -0800453int64_t AudioStreamTrack::getFramesRead() {
Phil Burk5ed503c2017-02-01 09:38:15 -0800454 aaudio_wrapping_frames_t position;
Phil Burke1ce4912016-11-21 10:40:25 -0800455 status_t result;
456 switch (getState()) {
Phil Burk5ed503c2017-02-01 09:38:15 -0800457 case AAUDIO_STREAM_STATE_STARTING:
458 case AAUDIO_STREAM_STATE_STARTED:
459 case AAUDIO_STREAM_STATE_STOPPING:
Phil Burk4c5129b2017-04-28 15:17:32 -0700460 case AAUDIO_STREAM_STATE_PAUSING:
461 case AAUDIO_STREAM_STATE_PAUSED:
Phil Burke1ce4912016-11-21 10:40:25 -0800462 result = mAudioTrack->getPosition(&position);
463 if (result == OK) {
464 mFramesRead.update32(position);
465 }
466 break;
467 default:
468 break;
469 }
Phil Burkec89b2e2017-06-20 15:05:06 -0700470 return AudioStreamLegacy::getFramesRead();
Phil Burke1ce4912016-11-21 10:40:25 -0800471}
Phil Burk35e80f32017-03-28 10:25:21 -0700472
473aaudio_result_t AudioStreamTrack::getTimestamp(clockid_t clockId,
474 int64_t *framePosition,
475 int64_t *timeNanoseconds) {
476 ExtendedTimestamp extendedTimestamp;
477 status_t status = mAudioTrack->getTimestamp(&extendedTimestamp);
Phil Burkc75d97f2017-09-08 15:48:36 -0700478 if (status == WOULD_BLOCK) {
479 return AAUDIO_ERROR_INVALID_STATE;
480 } if (status != NO_ERROR) {
Phil Burk35e80f32017-03-28 10:25:21 -0700481 return AAudioConvert_androidToAAudioResult(status);
482 }
Phil Burk7328a802017-08-30 09:29:48 -0700483 int64_t position = 0;
484 int64_t nanoseconds = 0;
485 aaudio_result_t result = getBestTimestamp(clockId, &position,
486 &nanoseconds, &extendedTimestamp);
487 if (result == AAUDIO_OK) {
488 if (position < getFramesWritten()) {
489 *framePosition = position;
490 *timeNanoseconds = nanoseconds;
491 return result;
492 } else {
493 return AAUDIO_ERROR_INVALID_STATE; // TODO review, documented but not consistent
494 }
495 }
496 return result;
Phil Burk35e80f32017-03-28 10:25:21 -0700497}
Phil Burk965650e2017-09-07 21:00:09 -0700498
499status_t AudioStreamTrack::doSetVolume() {
500 status_t status = NO_INIT;
501 if (mAudioTrack.get() != nullptr) {
502 float volume = getDuckAndMuteVolume();
503 mAudioTrack->setVolume(volume, volume);
504 status = NO_ERROR;
505 }
506 return status;
507}
508
509#if AAUDIO_USE_VOLUME_SHAPER
Phil Burk8a8a9e52017-09-12 16:25:15 -0700510
511using namespace android::media::VolumeShaper;
512
Phil Burk965650e2017-09-07 21:00:09 -0700513binder::Status AudioStreamTrack::applyVolumeShaper(
514 const VolumeShaper::Configuration& configuration,
515 const VolumeShaper::Operation& operation) {
516
517 sp<VolumeShaper::Configuration> spConfiguration = new VolumeShaper::Configuration(configuration);
518 sp<VolumeShaper::Operation> spOperation = new VolumeShaper::Operation(operation);
519
520 if (mAudioTrack.get() != nullptr) {
521 ALOGD("applyVolumeShaper() from IPlayer");
Phil Burk8a8a9e52017-09-12 16:25:15 -0700522 binder::Status status = mAudioTrack->applyVolumeShaper(spConfiguration, spOperation);
Phil Burk965650e2017-09-07 21:00:09 -0700523 if (status < 0) { // a non-negative value is the volume shaper id.
524 ALOGE("applyVolumeShaper() failed with status %d", status);
525 }
526 return binder::Status::fromStatusT(status);
527 } else {
528 ALOGD("applyVolumeShaper()"
529 " no AudioTrack for volume control from IPlayer");
530 return binder::Status::ok();
531 }
532}
533#endif