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     // This is used for exact matching by MediaMetrics. So do not change it.
132     // MediaMetricsConstants.h: AMEDIAMETRICS_PROP_CALLERNAME_VALUE_AAUDIO
133     static constexpr char     kCallerName[] = "aaudio";
134 
135     MonotonicCounter           mFramesWritten;
136     MonotonicCounter           mFramesRead;
137     MonotonicCounter           mTimestampPosition;
138 
139     FixedBlockAdapter         *mBlockAdapter = nullptr;
140     int32_t                    mBlockAdapterBytesPerFrame = 0;
141     aaudio_wrapping_frames_t   mPositionWhenStarting = 0;
142     int32_t                    mCallbackBufferSize = 0;
143     const android::sp<StreamDeviceCallback>   mDeviceCallback;
144 
145     AtomicRequestor            mRequestDisconnect;
146 
147 };
148 
149 } /* namespace aaudio */
150 
151 #endif //LEGACY_AUDIO_STREAM_LEGACY_H
152