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 
80 
getFramesWritten()81     virtual int64_t getFramesWritten() override {
82         return mFramesWritten.get();
83     }
84 
getFramesRead()85     virtual int64_t getFramesRead() override {
86         return mFramesRead.get();
87     }
88 
89 protected:
90 
91     class StreamDeviceCallback : public android::AudioSystem::AudioDeviceCallback
92     {
93     public:
94 
StreamDeviceCallback(AudioStreamLegacy * parent)95         StreamDeviceCallback(AudioStreamLegacy *parent) : mParent(parent) {}
~StreamDeviceCallback()96         virtual ~StreamDeviceCallback() {}
97 
onAudioDeviceUpdate(audio_io_handle_t audioIo __unused,audio_port_handle_t deviceId)98         virtual void onAudioDeviceUpdate(audio_io_handle_t audioIo __unused,
99                                          audio_port_handle_t deviceId) {
100             if (mParent != nullptr) {
101                 mParent->onAudioDeviceUpdate(deviceId);
102             }
103         }
104 
105         AudioStreamLegacy *mParent;
106     };
107 
108     aaudio_result_t getBestTimestamp(clockid_t clockId,
109                                      int64_t *framePosition,
110                                      int64_t *timeNanoseconds,
111                                      android::ExtendedTimestamp *extendedTimestamp);
112 
113     void onAudioDeviceUpdate(audio_port_handle_t deviceId);
114 
115     /*
116      * Check to see whether a callback thread has requested a disconnected.
117      * @param errorCallbackEnabled set true to call errorCallback on disconnect
118      * @return AAUDIO_OK or AAUDIO_ERROR_DISCONNECTED
119      */
120     aaudio_result_t checkForDisconnectRequest(bool errorCallbackEnabled);
121 
122     void forceDisconnect(bool errorCallbackEnabled = true);
123 
incrementFramesWritten(int32_t frames)124     int64_t incrementFramesWritten(int32_t frames) {
125         return mFramesWritten.increment(frames);
126     }
127 
incrementFramesRead(int32_t frames)128     int64_t incrementFramesRead(int32_t frames) {
129         return mFramesRead.increment(frames);
130     }
131 
132     MonotonicCounter           mFramesWritten;
133     MonotonicCounter           mFramesRead;
134     MonotonicCounter           mTimestampPosition;
135 
136     FixedBlockAdapter         *mBlockAdapter = nullptr;
137     aaudio_wrapping_frames_t   mPositionWhenStarting = 0;
138     int32_t                    mCallbackBufferSize = 0;
139     const android::sp<StreamDeviceCallback>   mDeviceCallback;
140 
141     AtomicRequestor            mRequestDisconnect;
142 };
143 
144 } /* namespace aaudio */
145 
146 #endif //LEGACY_AUDIO_STREAM_LEGACY_H
147