blob: 21b0627d2e852db0a2ba702aa785926946f5707e [file] [log] [blame]
Kevin Rocard4bcd67f2018-02-28 14:33:38 -08001/*
2 * Copyright (C) 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
Kevin Rocarddf9b4202018-05-10 19:56:08 -070017#ifndef ANDROID_HARDWARE_STREAM_HAL_HIDL_H
18#define ANDROID_HARDWARE_STREAM_HAL_HIDL_H
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080019
20#include <atomic>
21
Mikhail Naganov6718c392022-01-27 22:17:21 +000022#include PATH(android/hardware/audio/CORE_TYPES_FILE_VERSION/IStream.h)
Kevin Rocard95213bf2018-11-08 17:16:57 -080023#include PATH(android/hardware/audio/FILE_VERSION/IStreamIn.h)
24#include PATH(android/hardware/audio/FILE_VERSION/IStreamOut.h)
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080025#include <fmq/EventFlag.h>
26#include <fmq/MessageQueue.h>
Mikhail Naganov6718c392022-01-27 22:17:21 +000027#include <media/audiohal/EffectHalInterface.h>
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080028#include <media/audiohal/StreamHalInterface.h>
Andy Hung638f45b2021-01-18 20:02:56 -080029#include <mediautils/Synchronization.h>
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080030
31#include "ConversionHelperHidl.h"
32#include "StreamPowerLog.h"
33
Mikhail Naganov6718c392022-01-27 22:17:21 +000034using ::android::hardware::audio::CORE_TYPES_CPP_VERSION::IStream;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080035using ::android::hardware::EventFlag;
36using ::android::hardware::MessageQueue;
37using ::android::hardware::Return;
Kevin Rocard070e7512018-05-22 09:29:13 -070038using ReadParameters = ::android::hardware::audio::CPP_VERSION::IStreamIn::ReadParameters;
39using ReadStatus = ::android::hardware::audio::CPP_VERSION::IStreamIn::ReadStatus;
40using WriteCommand = ::android::hardware::audio::CPP_VERSION::IStreamOut::WriteCommand;
41using WriteStatus = ::android::hardware::audio::CPP_VERSION::IStreamOut::WriteStatus;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080042
43namespace android {
44
45class DeviceHalHidl;
46
47class StreamHalHidl : public virtual StreamHalInterface, public ConversionHelperHidl
48{
49 public:
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080050 // Return size of input/output buffer in bytes for this stream - eg. 4800.
51 virtual status_t getBufferSize(size_t *size);
52
Mikhail Naganov560637e2021-03-31 22:40:13 +000053 // Return the base configuration of the stream:
54 // - channel mask;
55 // - format - e.g. AUDIO_FORMAT_PCM_16_BIT;
56 // - sampling rate in Hz - eg. 44100.
57 virtual status_t getAudioProperties(audio_config_base_t *configBase);
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080058
59 // Set audio stream parameters.
60 virtual status_t setParameters(const String8& kvPairs);
61
62 // Get audio stream parameters.
63 virtual status_t getParameters(const String8& keys, String8 *values);
64
65 // Add or remove the effect on the stream.
66 virtual status_t addEffect(sp<EffectHalInterface> effect);
67 virtual status_t removeEffect(sp<EffectHalInterface> effect);
68
69 // Put the audio hardware input/output into standby mode.
70 virtual status_t standby();
71
Andy Hung61589a42021-06-16 09:37:53 -070072 virtual status_t dump(int fd, const Vector<String16>& args) override;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080073
74 // Start a stream operating in mmap mode.
75 virtual status_t start();
76
77 // Stop a stream operating in mmap mode.
78 virtual status_t stop();
79
80 // Retrieve information on the data buffer in mmap mode.
81 virtual status_t createMmapBuffer(int32_t minSizeFrames,
82 struct audio_mmap_buffer_info *info);
83
84 // Get current read/write position in the mmap buffer
85 virtual status_t getMmapPosition(struct audio_mmap_position *position);
86
87 // Set the priority of the thread that interacts with the HAL
88 // (must match the priority of the audioflinger's thread that calls 'read' / 'write')
89 virtual status_t setHalThreadPriority(int priority);
90
Ytai Ben-Tsvif997ffe2022-02-03 16:38:16 -080091 status_t legacyCreateAudioPatch(const struct audio_port_config& port,
92 std::optional<audio_source_t> source,
93 audio_devices_t type) override;
94
95 status_t legacyReleaseAudioPatch() override;
96
Kevin Rocard4bcd67f2018-02-28 14:33:38 -080097 protected:
98 // Subclasses can not be constructed directly by clients.
99 explicit StreamHalHidl(IStream *stream);
100
Andy Hungacb5b982021-01-20 10:12:00 -0800101 ~StreamHalHidl() override;
102
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800103 status_t getCachedBufferSize(size_t *size);
104
Mikhail Naganov247b5f92021-01-15 19:16:12 +0000105 status_t getHalPid(pid_t *pid);
106
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800107 bool requestHalThreadPriority(pid_t threadPid, pid_t threadId);
108
109 // mStreamPowerLog is used for audio signal power logging.
110 StreamPowerLog mStreamPowerLog;
111
112 private:
113 const int HAL_THREAD_PRIORITY_DEFAULT = -1;
Andy Hung638f45b2021-01-18 20:02:56 -0800114 IStream * const mStream;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800115 int mHalThreadPriority;
116 size_t mCachedBufferSize;
117};
118
119class StreamOutHalHidl : public StreamOutHalInterface, public StreamHalHidl {
120 public:
121 // Return the frame size (number of bytes per sample) of a stream.
122 virtual status_t getFrameSize(size_t *size);
123
124 // Return the audio hardware driver estimated latency in milliseconds.
125 virtual status_t getLatency(uint32_t *latency);
126
127 // Use this method in situations where audio mixing is done in the hardware.
128 virtual status_t setVolume(float left, float right);
129
Mikhail Naganovac917ac2018-11-28 14:03:52 -0800130 // Selects the audio presentation (if available).
131 virtual status_t selectPresentation(int presentationId, int programId);
132
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800133 // Write audio buffer to driver.
134 virtual status_t write(const void *buffer, size_t bytes, size_t *written);
135
136 // Return the number of audio frames written by the audio dsp to DAC since
137 // the output has exited standby.
138 virtual status_t getRenderPosition(uint32_t *dspFrames);
139
140 // Get the local time at which the next write to the audio driver will be presented.
141 virtual status_t getNextWriteTimestamp(int64_t *timestamp);
142
143 // Set the callback for notifying completion of non-blocking write and drain.
144 virtual status_t setCallback(wp<StreamOutHalInterfaceCallback> callback);
145
146 // Returns whether pause and resume operations are supported.
147 virtual status_t supportsPauseAndResume(bool *supportsPause, bool *supportsResume);
148
149 // Notifies to the audio driver to resume playback following a pause.
150 virtual status_t pause();
151
152 // Notifies to the audio driver to resume playback following a pause.
153 virtual status_t resume();
154
155 // Returns whether drain operation is supported.
156 virtual status_t supportsDrain(bool *supportsDrain);
157
158 // Requests notification when data buffered by the driver/hardware has been played.
159 virtual status_t drain(bool earlyNotify);
160
161 // Notifies to the audio driver to flush the queued data.
162 virtual status_t flush();
163
164 // Return a recent count of the number of audio frames presented to an external observer.
165 virtual status_t getPresentationPosition(uint64_t *frames, struct timespec *timestamp);
166
Kevin Rocarda8975a72018-03-27 10:16:52 -0700167 // Called when the metadata of the stream's source has been changed.
168 status_t updateSourceMetadata(const SourceMetadata& sourceMetadata) override;
169
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800170 // Methods used by StreamOutCallback (HIDL).
171 void onWriteReady();
172 void onDrainReady();
173 void onError();
174
Kuowei Lid4adbdb2020-08-13 14:44:25 +0800175 // Returns the Dual Mono mode presentation setting.
176 status_t getDualMonoMode(audio_dual_mono_mode_t* mode) override;
177
178 // Sets the Dual Mono mode presentation on the output device.
179 status_t setDualMonoMode(audio_dual_mono_mode_t mode) override;
180
181 // Returns the Audio Description Mix level in dB.
182 status_t getAudioDescriptionMixLevel(float* leveldB) override;
183
184 // Sets the Audio Description Mix level in dB.
185 status_t setAudioDescriptionMixLevel(float leveldB) override;
186
187 // Retrieves current playback rate parameters.
188 status_t getPlaybackRateParameters(audio_playback_rate_t* playbackRate) override;
189
190 // Sets the playback rate parameters that control playback behavior.
191 status_t setPlaybackRateParameters(const audio_playback_rate_t& playbackRate) override;
192
jiabinf6eb4c32020-02-25 14:06:25 -0800193 status_t setEventCallback(const sp<StreamOutHalInterfaceEventCallback>& callback) override;
194
195 // Methods used by StreamCodecFormatCallback (HIDL).
196 void onCodecFormatChanged(const std::basic_string<uint8_t>& metadataBs);
197
Eric Laurentafa586b2022-01-27 21:10:55 +0100198 status_t setLatencyMode(audio_latency_mode_t mode) override;
199 status_t getRecommendedLatencyModes(std::vector<audio_latency_mode_t> *modes) override;
200 status_t setLatencyModeCallback(
201 const sp<StreamOutHalInterfaceLatencyModeCallback>& callback) override;
202
203 void onRecommendedLatencyModeChanged(const std::vector<audio_latency_mode_t>& modes);
204
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800205 private:
206 friend class DeviceHalHidl;
207 typedef MessageQueue<WriteCommand, hardware::kSynchronizedReadWrite> CommandMQ;
208 typedef MessageQueue<uint8_t, hardware::kSynchronizedReadWrite> DataMQ;
209 typedef MessageQueue<WriteStatus, hardware::kSynchronizedReadWrite> StatusMQ;
210
Andy Hung638f45b2021-01-18 20:02:56 -0800211 mediautils::atomic_wp<StreamOutHalInterfaceCallback> mCallback;
212 mediautils::atomic_wp<StreamOutHalInterfaceEventCallback> mEventCallback;
Eric Laurentafa586b2022-01-27 21:10:55 +0100213 mediautils::atomic_wp<StreamOutHalInterfaceLatencyModeCallback> mLatencyModeCallback;
214
Mikhail Naganov6718c392022-01-27 22:17:21 +0000215 const sp<::android::hardware::audio::CPP_VERSION::IStreamOut> mStream;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800216 std::unique_ptr<CommandMQ> mCommandMQ;
217 std::unique_ptr<DataMQ> mDataMQ;
218 std::unique_ptr<StatusMQ> mStatusMQ;
219 std::atomic<pid_t> mWriterClient;
220 EventFlag* mEfGroup;
221
222 // Can not be constructed directly by clients.
Mikhail Naganov6718c392022-01-27 22:17:21 +0000223 StreamOutHalHidl(const sp<::android::hardware::audio::CPP_VERSION::IStreamOut>& stream);
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800224
225 virtual ~StreamOutHalHidl();
226
227 using WriterCallback = std::function<void(const WriteStatus& writeStatus)>;
228 status_t callWriterThread(
229 WriteCommand cmd, const char* cmdName,
230 const uint8_t* data, size_t dataSize, WriterCallback callback);
231 status_t prepareForWriting(size_t bufferSize);
232};
233
234class StreamInHalHidl : public StreamInHalInterface, public StreamHalHidl {
235 public:
236 // Return the frame size (number of bytes per sample) of a stream.
237 virtual status_t getFrameSize(size_t *size);
238
239 // Set the input gain for the audio driver.
240 virtual status_t setGain(float gain);
241
242 // Read audio buffer in from driver.
243 virtual status_t read(void *buffer, size_t bytes, size_t *read);
244
245 // Return the amount of input frames lost in the audio driver.
246 virtual status_t getInputFramesLost(uint32_t *framesLost);
247
248 // Return a recent count of the number of audio frames received and
249 // the clock time associated with that frame count.
250 virtual status_t getCapturePosition(int64_t *frames, int64_t *time);
251
jiabin9ff780e2018-03-19 18:19:52 -0700252 // Get active microphones
253 virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
254
Paul McLean03a6e6a2018-12-04 10:54:13 -0700255 // Set microphone direction (for processing)
Paul McLean12340082019-03-19 09:35:05 -0600256 virtual status_t setPreferredMicrophoneDirection(
257 audio_microphone_direction_t direction) override;
Paul McLean03a6e6a2018-12-04 10:54:13 -0700258
259 // Set microphone zoom (for processing)
Paul McLean12340082019-03-19 09:35:05 -0600260 virtual status_t setPreferredMicrophoneFieldDimension(float zoom) override;
Paul McLean03a6e6a2018-12-04 10:54:13 -0700261
Kevin Rocarda8975a72018-03-27 10:16:52 -0700262 // Called when the metadata of the stream's sink has been changed.
263 status_t updateSinkMetadata(const SinkMetadata& sinkMetadata) override;
264
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800265 private:
266 friend class DeviceHalHidl;
267 typedef MessageQueue<ReadParameters, hardware::kSynchronizedReadWrite> CommandMQ;
268 typedef MessageQueue<uint8_t, hardware::kSynchronizedReadWrite> DataMQ;
269 typedef MessageQueue<ReadStatus, hardware::kSynchronizedReadWrite> StatusMQ;
270
Mikhail Naganov6718c392022-01-27 22:17:21 +0000271 const sp<::android::hardware::audio::CPP_VERSION::IStreamIn> mStream;
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800272 std::unique_ptr<CommandMQ> mCommandMQ;
273 std::unique_ptr<DataMQ> mDataMQ;
274 std::unique_ptr<StatusMQ> mStatusMQ;
275 std::atomic<pid_t> mReaderClient;
276 EventFlag* mEfGroup;
277
278 // Can not be constructed directly by clients.
Mikhail Naganov6718c392022-01-27 22:17:21 +0000279 StreamInHalHidl(const sp<::android::hardware::audio::CPP_VERSION::IStreamIn>& stream);
Kevin Rocard4bcd67f2018-02-28 14:33:38 -0800280
281 virtual ~StreamInHalHidl();
282
283 using ReaderCallback = std::function<void(const ReadStatus& readStatus)>;
284 status_t callReaderThread(
285 const ReadParameters& params, const char* cmdName, ReaderCallback callback);
286 status_t prepareForReading(size_t bufferSize);
287};
288
289} // namespace android
290
Kevin Rocarddf9b4202018-05-10 19:56:08 -0700291#endif // ANDROID_HARDWARE_STREAM_HAL_HIDL_H