1 /* 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 #ifndef LEGACY_AUDIO_STREAM_LEGACY_H 18 #define LEGACY_AUDIO_STREAM_LEGACY_H 19 20 #include <media/AudioTimestamp.h> 21 #include <media/AudioSystem.h> 22 23 #include <aaudio/AAudio.h> 24 25 #include "AudioStream.h" 26 #include "AAudioLegacy.h" 27 #include "utility/AAudioUtilities.h" 28 #include "utility/FixedBlockAdapter.h" 29 30 namespace aaudio { 31 32 33 typedef void (*aaudio_legacy_callback_t)(int event, void* user, void *info); 34 35 enum { 36 /** 37 * Request that the callback function should fill the data buffer of an output stream, 38 * or process the data of an input stream. 39 * The address parameter passed to the callback function will point to a data buffer. 40 * For an input stream, the data is read-only. 41 * The value1 parameter will be the number of frames. 42 * The value2 parameter is reserved and will be set to zero. 43 * The callback should return AAUDIO_CALLBACK_RESULT_CONTINUE or AAUDIO_CALLBACK_RESULT_STOP. 44 */ 45 AAUDIO_CALLBACK_OPERATION_PROCESS_DATA, 46 47 /** 48 * Inform the callback function that the stream was disconnected. 49 * The address parameter passed to the callback function will be NULL. 50 * The value1 will be an error code or AAUDIO_OK. 51 * The value2 parameter is reserved and will be set to zero. 52 * The callback return value will be ignored. 53 */ 54 AAUDIO_CALLBACK_OPERATION_DISCONNECTED, 55 }; 56 typedef int32_t aaudio_callback_operation_t; 57 58 59 class AudioStreamLegacy : public AudioStream, public FixedBlockProcessor { 60 public: 61 AudioStreamLegacy(); 62 63 virtual ~AudioStreamLegacy(); 64 65 aaudio_legacy_callback_t getLegacyCallback(); 66 67 int32_t callDataCallbackFrames(uint8_t *buffer, int32_t numFrames); 68 69 // This is public so it can be called from the C callback function. 70 // This is called from the AudioTrack/AudioRecord client. 71 virtual void processCallback(int event, void *info) = 0; 72 73 void processCallbackCommon(aaudio_callback_operation_t opcode, void *info); 74 75 // Implement FixedBlockProcessor 76 int32_t onProcessFixedBlock(uint8_t *buffer, int32_t numBytes) override; 77 78 virtual int64_t incrementClientFrameCounter(int32_t frames) = 0; 79 getFramesWritten()80 virtual int64_t getFramesWritten() override { 81 return mFramesWritten.get(); 82 } 83 getFramesRead()84 virtual int64_t getFramesRead() override { 85 return mFramesRead.get(); 86 } 87 88 protected: 89 90 class StreamDeviceCallback : public android::AudioSystem::AudioDeviceCallback 91 { 92 public: 93 StreamDeviceCallback(AudioStreamLegacy * parent)94 StreamDeviceCallback(AudioStreamLegacy *parent) : mParent(parent) {} ~StreamDeviceCallback()95 virtual ~StreamDeviceCallback() {} 96 onAudioDeviceUpdate(audio_io_handle_t audioIo __unused,audio_port_handle_t deviceId)97 virtual void onAudioDeviceUpdate(audio_io_handle_t audioIo __unused, 98 audio_port_handle_t deviceId) { 99 if (mParent != nullptr) { 100 mParent->onAudioDeviceUpdate(deviceId); 101 } 102 } 103 104 AudioStreamLegacy *mParent; 105 }; 106 107 aaudio_result_t getBestTimestamp(clockid_t clockId, 108 int64_t *framePosition, 109 int64_t *timeNanoseconds, 110 android::ExtendedTimestamp *extendedTimestamp); 111 112 void onAudioDeviceUpdate(audio_port_handle_t deviceId); 113 114 /* 115 * Check to see whether a callback thread has requested a disconnected. 116 * @param errorCallbackEnabled set true to call errorCallback on disconnect 117 * @return AAUDIO_OK or AAUDIO_ERROR_DISCONNECTED 118 */ 119 aaudio_result_t checkForDisconnectRequest(bool errorCallbackEnabled); 120 121 void forceDisconnect(bool errorCallbackEnabled = true); 122 incrementFramesWritten(int32_t frames)123 int64_t incrementFramesWritten(int32_t frames) { 124 return mFramesWritten.increment(frames); 125 } 126 incrementFramesRead(int32_t frames)127 int64_t incrementFramesRead(int32_t frames) { 128 return mFramesRead.increment(frames); 129 } 130 131 MonotonicCounter mFramesWritten; 132 MonotonicCounter mFramesRead; 133 MonotonicCounter mTimestampPosition; 134 135 FixedBlockAdapter *mBlockAdapter = nullptr; 136 aaudio_wrapping_frames_t mPositionWhenStarting = 0; 137 int32_t mCallbackBufferSize = 0; 138 const android::sp<StreamDeviceCallback> mDeviceCallback; 139 140 AtomicRequestor mRequestDisconnect; 141 }; 142 143 } /* namespace aaudio */ 144 145 #endif //LEGACY_AUDIO_STREAM_LEGACY_H 146