1 /*
2  * Copyright 2017 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 "AudioStreamLegacy"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20 
21 #include <stdint.h>
22 
23 #include <aaudio/AAudio.h>
24 #include <audio_utils/primitives.h>
25 #include <media/AudioTrack.h>
26 #include <media/AudioTimestamp.h>
27 #include <utils/String16.h>
28 
29 #include "core/AudioStream.h"
30 #include "legacy/AudioStreamLegacy.h"
31 
32 using namespace android;
33 using namespace aaudio;
34 
AudioStreamLegacy()35 AudioStreamLegacy::AudioStreamLegacy()
36         : AudioStream()
37         , mDeviceCallback(new StreamDeviceCallback(this)) {
38 }
39 
~AudioStreamLegacy()40 AudioStreamLegacy::~AudioStreamLegacy() {
41 }
42 
43 // Called from AudioTrack.cpp or AudioRecord.cpp
AudioStreamLegacy_callback(int event,void * userData,void * info)44 static void AudioStreamLegacy_callback(int event, void* userData, void *info) {
45     AudioStreamLegacy *streamLegacy = (AudioStreamLegacy *) userData;
46     streamLegacy->processCallback(event, info);
47 }
48 
getLegacyCallback()49 aaudio_legacy_callback_t AudioStreamLegacy::getLegacyCallback() {
50     return AudioStreamLegacy_callback;
51 }
52 
callDataCallbackFrames(uint8_t * buffer,int32_t numFrames)53 aaudio_data_callback_result_t AudioStreamLegacy::callDataCallbackFrames(uint8_t *buffer,
54                                                                         int32_t numFrames) {
55     void *finalAudioData = buffer;
56     if (getDirection() == AAUDIO_DIRECTION_INPUT) {
57         // Increment before because we already got the data from the device.
58         incrementFramesRead(numFrames);
59         finalAudioData = (void *) maybeConvertDeviceData(buffer, numFrames);
60     }
61 
62     // Call using the AAudio callback interface.
63     aaudio_data_callback_result_t callbackResult = maybeCallDataCallback(finalAudioData, numFrames);
64 
65     if (callbackResult == AAUDIO_CALLBACK_RESULT_CONTINUE
66             && getDirection() == AAUDIO_DIRECTION_OUTPUT) {
67         // Increment after because we are going to write the data to the device.
68         incrementFramesWritten(numFrames);
69     }
70     return callbackResult;
71 }
72 
73 // Implement FixedBlockProcessor
onProcessFixedBlock(uint8_t * buffer,int32_t numBytes)74 int32_t AudioStreamLegacy::onProcessFixedBlock(uint8_t *buffer, int32_t numBytes) {
75     int32_t numFrames = numBytes / getBytesPerDeviceFrame();
76     return (int32_t) callDataCallbackFrames(buffer, numFrames);
77 }
78 
processCallbackCommon(aaudio_callback_operation_t opcode,void * info)79 void AudioStreamLegacy::processCallbackCommon(aaudio_callback_operation_t opcode, void *info) {
80     aaudio_data_callback_result_t callbackResult;
81     // This illegal size can be used to tell AudioRecord or AudioTrack to stop calling us.
82     // This takes advantage of them killing the stream when they see a size out of range.
83     // That is an undocumented behavior.
84     // TODO add to API in AudioRecord and AudioTrack
85     const size_t SIZE_STOP_CALLBACKS = SIZE_MAX;
86 
87     switch (opcode) {
88         case AAUDIO_CALLBACK_OPERATION_PROCESS_DATA: {
89             (void) checkForDisconnectRequest(true);
90 
91             // Note that this code assumes an AudioTrack::Buffer is the same as
92             // AudioRecord::Buffer
93             // TODO define our own AudioBuffer and pass it from the subclasses.
94             AudioTrack::Buffer *audioBuffer = static_cast<AudioTrack::Buffer *>(info);
95             if (getState() == AAUDIO_STREAM_STATE_DISCONNECTED) {
96                 ALOGW("processCallbackCommon() data, stream disconnected");
97                 audioBuffer->size = SIZE_STOP_CALLBACKS;
98             } else if (!mCallbackEnabled.load()) {
99                 ALOGW("processCallbackCommon() no data because callback disabled");
100                 audioBuffer->size = SIZE_STOP_CALLBACKS;
101             } else {
102                 if (audioBuffer->frameCount == 0) {
103                     ALOGW("processCallbackCommon() data, frameCount is zero");
104                     return;
105                 }
106 
107                 // If the caller specified an exact size then use a block size adapter.
108                 if (mBlockAdapter != nullptr) {
109                     int32_t byteCount = audioBuffer->frameCount * getBytesPerDeviceFrame();
110                     callbackResult = mBlockAdapter->processVariableBlock(
111                             (uint8_t *) audioBuffer->raw, byteCount);
112                 } else {
113                     // Call using the AAudio callback interface.
114                     callbackResult = callDataCallbackFrames((uint8_t *)audioBuffer->raw,
115                                                             audioBuffer->frameCount);
116                 }
117                 if (callbackResult == AAUDIO_CALLBACK_RESULT_CONTINUE) {
118                     audioBuffer->size = audioBuffer->frameCount * getBytesPerDeviceFrame();
119                 } else {
120                     if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
121                         ALOGD("%s() callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
122                     } else {
123                         ALOGW("%s() callback returned invalid result = %d",
124                               __func__, callbackResult);
125                     }
126                     audioBuffer->size = 0;
127                     systemStopFromCallback();
128                     // Disable the callback just in case the system keeps trying to call us.
129                     mCallbackEnabled.store(false);
130                 }
131 
132                 if (updateStateMachine() != AAUDIO_OK) {
133                     forceDisconnect();
134                     mCallbackEnabled.store(false);
135                 }
136             }
137         }
138             break;
139 
140         // Stream got rerouted so we disconnect.
141         case AAUDIO_CALLBACK_OPERATION_DISCONNECTED:
142             ALOGD("processCallbackCommon() stream disconnected");
143             forceDisconnect();
144             mCallbackEnabled.store(false);
145             break;
146 
147         default:
148             break;
149     }
150 }
151 
checkForDisconnectRequest(bool errorCallbackEnabled)152 aaudio_result_t AudioStreamLegacy::checkForDisconnectRequest(bool errorCallbackEnabled) {
153     if (mRequestDisconnect.isRequested()) {
154         ALOGD("checkForDisconnectRequest() mRequestDisconnect acknowledged");
155         forceDisconnect(errorCallbackEnabled);
156         mRequestDisconnect.acknowledge();
157         mCallbackEnabled.store(false);
158         return AAUDIO_ERROR_DISCONNECTED;
159     } else {
160         return AAUDIO_OK;
161     }
162 }
163 
forceDisconnect(bool errorCallbackEnabled)164 void AudioStreamLegacy::forceDisconnect(bool errorCallbackEnabled) {
165     if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
166         setState(AAUDIO_STREAM_STATE_DISCONNECTED);
167         if (errorCallbackEnabled) {
168             maybeCallErrorCallback(AAUDIO_ERROR_DISCONNECTED);
169         }
170     }
171 }
172 
getBestTimestamp(clockid_t clockId,int64_t * framePosition,int64_t * timeNanoseconds,ExtendedTimestamp * extendedTimestamp)173 aaudio_result_t AudioStreamLegacy::getBestTimestamp(clockid_t clockId,
174                                                    int64_t *framePosition,
175                                                    int64_t *timeNanoseconds,
176                                                    ExtendedTimestamp *extendedTimestamp) {
177     int timebase;
178     switch (clockId) {
179         case CLOCK_BOOTTIME:
180             timebase = ExtendedTimestamp::TIMEBASE_BOOTTIME;
181             break;
182         case CLOCK_MONOTONIC:
183             timebase = ExtendedTimestamp::TIMEBASE_MONOTONIC;
184             break;
185         default:
186             ALOGE("getTimestamp() - Unrecognized clock type %d", (int) clockId);
187             return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
188             break;
189     }
190     ExtendedTimestamp::Location location = ExtendedTimestamp::Location::LOCATION_INVALID;
191     int64_t localPosition;
192     status_t status = extendedTimestamp->getBestTimestamp(&localPosition, timeNanoseconds,
193                                                           timebase, &location);
194     if (status == OK) {
195         // use MonotonicCounter to prevent retrograde motion.
196         mTimestampPosition.update32((int32_t) localPosition);
197         *framePosition = mTimestampPosition.get();
198     }
199 
200 //    ALOGD("getBestTimestamp() fposition: server = %6lld, kernel = %6lld, location = %d",
201 //          (long long) extendedTimestamp->mPosition[ExtendedTimestamp::Location::LOCATION_SERVER],
202 //          (long long) extendedTimestamp->mPosition[ExtendedTimestamp::Location::LOCATION_KERNEL],
203 //          (int)location);
204     return AAudioConvert_androidToAAudioResult(status);
205 }
206 
onAudioDeviceUpdate(audio_port_handle_t deviceId)207 void AudioStreamLegacy::onAudioDeviceUpdate(audio_port_handle_t deviceId)
208 {
209     // Device routing is a common source of errors and DISCONNECTS.
210     // Please leave this log in place.
211     ALOGD("%s() devId %d => %d", __func__, (int) getDeviceId(), (int)deviceId);
212     if (getDeviceId() != AAUDIO_UNSPECIFIED && getDeviceId() != deviceId &&
213             getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
214         // Note that isDataCallbackActive() is affected by state so call it before DISCONNECTING.
215         // If we have a data callback and the stream is active, then ask the data callback
216         // to DISCONNECT and call the error callback.
217         if (isDataCallbackActive()) {
218             ALOGD("onAudioDeviceUpdate() request DISCONNECT in data callback due to device change");
219             // If the stream is stopped before the data callback has a chance to handle the
220             // request then the requestStop() and requestPause() methods will handle it after
221             // the callback has stopped.
222             mRequestDisconnect.request();
223         } else {
224             ALOGD("onAudioDeviceUpdate() DISCONNECT the stream now");
225             forceDisconnect();
226         }
227     }
228     setDeviceId(deviceId);
229 }
230