1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "media/audio/alsa/alsa_wrapper.h"
6
7 namespace media {
8
9 AlsaWrapper::AlsaWrapper() = default;
10
11 AlsaWrapper::~AlsaWrapper() = default;
12
PcmOpen(snd_pcm_t ** handle,const char * name,snd_pcm_stream_t stream,int mode)13 int AlsaWrapper::PcmOpen(snd_pcm_t** handle, const char* name,
14 snd_pcm_stream_t stream, int mode) {
15 return snd_pcm_open(handle, name, stream, mode);
16 }
17
DeviceNameHint(int card,const char * iface,void *** hints)18 int AlsaWrapper::DeviceNameHint(int card, const char* iface, void*** hints) {
19 return snd_device_name_hint(card, iface, hints);
20 }
21
DeviceNameGetHint(const void * hint,const char * id)22 char* AlsaWrapper::DeviceNameGetHint(const void* hint, const char* id) {
23 return snd_device_name_get_hint(hint, id);
24 }
25
DeviceNameFreeHint(void ** hints)26 int AlsaWrapper::DeviceNameFreeHint(void** hints) {
27 return snd_device_name_free_hint(hints);
28 }
29
CardNext(int * rcard)30 int AlsaWrapper::CardNext(int* rcard) {
31 return snd_card_next(rcard);
32 }
33
PcmClose(snd_pcm_t * handle)34 int AlsaWrapper::PcmClose(snd_pcm_t* handle) {
35 return snd_pcm_close(handle);
36 }
37
PcmPrepare(snd_pcm_t * handle)38 int AlsaWrapper::PcmPrepare(snd_pcm_t* handle) {
39 return snd_pcm_prepare(handle);
40 }
41
PcmDrain(snd_pcm_t * handle)42 int AlsaWrapper::PcmDrain(snd_pcm_t* handle) {
43 return snd_pcm_drain(handle);
44 }
45
PcmDrop(snd_pcm_t * handle)46 int AlsaWrapper::PcmDrop(snd_pcm_t* handle) {
47 return snd_pcm_drop(handle);
48 }
49
PcmDelay(snd_pcm_t * handle,snd_pcm_sframes_t * delay)50 int AlsaWrapper::PcmDelay(snd_pcm_t* handle, snd_pcm_sframes_t* delay) {
51 return snd_pcm_delay(handle, delay);
52 }
53
PcmResume(snd_pcm_t * handle)54 int AlsaWrapper::PcmResume(snd_pcm_t* handle) {
55 return snd_pcm_resume(handle);
56 }
57
PcmWritei(snd_pcm_t * handle,const void * buffer,snd_pcm_uframes_t size)58 snd_pcm_sframes_t AlsaWrapper::PcmWritei(snd_pcm_t* handle,
59 const void* buffer,
60 snd_pcm_uframes_t size) {
61 return snd_pcm_writei(handle, buffer, size);
62 }
63
PcmReadi(snd_pcm_t * handle,void * buffer,snd_pcm_uframes_t size)64 snd_pcm_sframes_t AlsaWrapper::PcmReadi(snd_pcm_t* handle,
65 void* buffer,
66 snd_pcm_uframes_t size) {
67 return snd_pcm_readi(handle, buffer, size);
68 }
69
PcmRecover(snd_pcm_t * handle,int err,int silent)70 int AlsaWrapper::PcmRecover(snd_pcm_t* handle, int err, int silent) {
71 return snd_pcm_recover(handle, err, silent);
72 }
73
PcmName(snd_pcm_t * handle)74 const char* AlsaWrapper::PcmName(snd_pcm_t* handle) {
75 return snd_pcm_name(handle);
76 }
77
PcmSetParams(snd_pcm_t * handle,snd_pcm_format_t format,snd_pcm_access_t access,unsigned int channels,unsigned int rate,int soft_resample,unsigned int latency)78 int AlsaWrapper::PcmSetParams(snd_pcm_t* handle, snd_pcm_format_t format,
79 snd_pcm_access_t access, unsigned int channels,
80 unsigned int rate, int soft_resample,
81 unsigned int latency) {
82 return snd_pcm_set_params(handle,
83 format,
84 access,
85 channels,
86 rate,
87 soft_resample,
88 latency);
89 }
90
PcmGetParams(snd_pcm_t * handle,snd_pcm_uframes_t * buffer_size,snd_pcm_uframes_t * period_size)91 int AlsaWrapper::PcmGetParams(snd_pcm_t* handle, snd_pcm_uframes_t* buffer_size,
92 snd_pcm_uframes_t* period_size) {
93 return snd_pcm_get_params(handle, buffer_size, period_size);
94 }
95
PcmHwParamsMalloc(snd_pcm_hw_params_t ** hw_params)96 int AlsaWrapper::PcmHwParamsMalloc(snd_pcm_hw_params_t** hw_params) {
97 return snd_pcm_hw_params_malloc(hw_params);
98 }
99
PcmHwParamsAny(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params)100 int AlsaWrapper::PcmHwParamsAny(snd_pcm_t* handle,
101 snd_pcm_hw_params_t* hw_params) {
102 return snd_pcm_hw_params_any(handle, hw_params);
103 }
104
PcmHwParamsCanResume(snd_pcm_hw_params_t * hw_params)105 int AlsaWrapper::PcmHwParamsCanResume(snd_pcm_hw_params_t* hw_params) {
106 return snd_pcm_hw_params_can_resume(hw_params);
107 }
108
PcmHwParamsSetRateResample(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,unsigned int value)109 int AlsaWrapper::PcmHwParamsSetRateResample(snd_pcm_t* handle,
110 snd_pcm_hw_params_t* hw_params,
111 unsigned int value) {
112 return snd_pcm_hw_params_set_rate_resample(handle, hw_params, value);
113 }
114
PcmHwParamsSetRateNear(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,unsigned int * rate,int * direction)115 int AlsaWrapper::PcmHwParamsSetRateNear(snd_pcm_t* handle,
116 snd_pcm_hw_params_t* hw_params,
117 unsigned int* rate,
118 int* direction) {
119 return snd_pcm_hw_params_set_rate_near(handle, hw_params, rate, direction);
120 }
121
PcmHwParamsTestFormat(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,snd_pcm_format_t format)122 int AlsaWrapper::PcmHwParamsTestFormat(snd_pcm_t* handle,
123 snd_pcm_hw_params_t* hw_params,
124 snd_pcm_format_t format) {
125 return snd_pcm_hw_params_test_format(handle, hw_params, format);
126 }
127
PcmFormatSize(snd_pcm_format_t format,size_t samples)128 int AlsaWrapper::PcmFormatSize(snd_pcm_format_t format, size_t samples) {
129 return snd_pcm_format_size(format, samples);
130 }
131
PcmHwParamsGetChannelsMin(const snd_pcm_hw_params_t * hw_params,unsigned int * min_channels)132 int AlsaWrapper::PcmHwParamsGetChannelsMin(const snd_pcm_hw_params_t* hw_params,
133 unsigned int* min_channels) {
134 return snd_pcm_hw_params_get_channels_min(hw_params, min_channels);
135 }
136
PcmHwParamsGetChannelsMax(const snd_pcm_hw_params_t * hw_params,unsigned int * max_channels)137 int AlsaWrapper::PcmHwParamsGetChannelsMax(const snd_pcm_hw_params_t* hw_params,
138 unsigned int* max_channels) {
139 return snd_pcm_hw_params_get_channels_min(hw_params, max_channels);
140 }
141
PcmHwParamsSetFormat(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,snd_pcm_format_t format)142 int AlsaWrapper::PcmHwParamsSetFormat(snd_pcm_t* handle,
143 snd_pcm_hw_params_t* hw_params,
144 snd_pcm_format_t format) {
145 return snd_pcm_hw_params_set_format(handle, hw_params, format);
146 }
147
PcmHwParamsSetAccess(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,snd_pcm_access_t access)148 int AlsaWrapper::PcmHwParamsSetAccess(snd_pcm_t* handle,
149 snd_pcm_hw_params_t* hw_params,
150 snd_pcm_access_t access) {
151 return snd_pcm_hw_params_set_access(handle, hw_params, access);
152 }
153
PcmHwParamsSetChannels(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,unsigned int channels)154 int AlsaWrapper::PcmHwParamsSetChannels(snd_pcm_t* handle,
155 snd_pcm_hw_params_t* hw_params,
156 unsigned int channels) {
157 return snd_pcm_hw_params_set_channels(handle, hw_params, channels);
158 }
159
PcmHwParamsSetBufferSizeNear(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,snd_pcm_uframes_t * buffer_size)160 int AlsaWrapper::PcmHwParamsSetBufferSizeNear(snd_pcm_t* handle,
161 snd_pcm_hw_params_t* hw_params,
162 snd_pcm_uframes_t* buffer_size) {
163 return snd_pcm_hw_params_set_buffer_size_near(handle, hw_params, buffer_size);
164 }
165
PcmHwParamsSetPeriodSizeNear(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params,snd_pcm_uframes_t * period_size,int * direction)166 int AlsaWrapper::PcmHwParamsSetPeriodSizeNear(snd_pcm_t* handle,
167 snd_pcm_hw_params_t* hw_params,
168 snd_pcm_uframes_t* period_size,
169 int* direction) {
170 return snd_pcm_hw_params_set_period_size_near(handle, hw_params, period_size,
171 direction);
172 }
173
PcmHwParams(snd_pcm_t * handle,snd_pcm_hw_params_t * hw_params)174 int AlsaWrapper::PcmHwParams(snd_pcm_t* handle,
175 snd_pcm_hw_params_t* hw_params) {
176 return snd_pcm_hw_params(handle, hw_params);
177 }
178
PcmHwParamsFree(snd_pcm_hw_params_t * hw_params)179 void AlsaWrapper::PcmHwParamsFree(snd_pcm_hw_params_t* hw_params) {
180 return snd_pcm_hw_params_free(hw_params);
181 }
182
PcmSwParamsMalloc(snd_pcm_sw_params_t ** sw_params)183 int AlsaWrapper::PcmSwParamsMalloc(snd_pcm_sw_params_t** sw_params) {
184 return snd_pcm_sw_params_malloc(sw_params);
185 }
186
PcmSwParamsCurrent(snd_pcm_t * handle,snd_pcm_sw_params_t * sw_params)187 int AlsaWrapper::PcmSwParamsCurrent(snd_pcm_t* handle,
188 snd_pcm_sw_params_t* sw_params) {
189 return snd_pcm_sw_params_current(handle, sw_params);
190 }
191
PcmSwParamsSetStartThreshold(snd_pcm_t * handle,snd_pcm_sw_params_t * sw_params,snd_pcm_uframes_t start_threshold)192 int AlsaWrapper::PcmSwParamsSetStartThreshold(
193 snd_pcm_t* handle,
194 snd_pcm_sw_params_t* sw_params,
195 snd_pcm_uframes_t start_threshold) {
196 return snd_pcm_sw_params_set_start_threshold(handle, sw_params,
197 start_threshold);
198 }
199
PcmSwParamsSetAvailMin(snd_pcm_t * handle,snd_pcm_sw_params_t * sw_params,snd_pcm_uframes_t period_size)200 int AlsaWrapper::PcmSwParamsSetAvailMin(snd_pcm_t* handle,
201 snd_pcm_sw_params_t* sw_params,
202 snd_pcm_uframes_t period_size) {
203 return snd_pcm_sw_params_set_avail_min(handle, sw_params, period_size);
204 }
205
PcmSwParams(snd_pcm_t * handle,snd_pcm_sw_params_t * sw_params)206 int AlsaWrapper::PcmSwParams(snd_pcm_t* handle,
207 snd_pcm_sw_params_t* sw_params) {
208 return snd_pcm_sw_params(handle, sw_params);
209 }
210
PcmSwParamsFree(snd_pcm_sw_params_t * sw_params)211 void AlsaWrapper::PcmSwParamsFree(snd_pcm_sw_params_t* sw_params) {
212 return snd_pcm_sw_params_free(sw_params);
213 }
214
PcmAvailUpdate(snd_pcm_t * handle)215 snd_pcm_sframes_t AlsaWrapper::PcmAvailUpdate(snd_pcm_t* handle) {
216 return snd_pcm_avail_update(handle);
217 }
218
PcmState(snd_pcm_t * handle)219 snd_pcm_state_t AlsaWrapper::PcmState(snd_pcm_t* handle) {
220 return snd_pcm_state(handle);
221 }
222
StrError(int errnum)223 const char* AlsaWrapper::StrError(int errnum) {
224 return snd_strerror(errnum);
225 }
226
PcmStart(snd_pcm_t * handle)227 int AlsaWrapper::PcmStart(snd_pcm_t* handle) {
228 return snd_pcm_start(handle);
229 }
230
MixerOpen(snd_mixer_t ** mixer,int mode)231 int AlsaWrapper::MixerOpen(snd_mixer_t** mixer, int mode) {
232 return snd_mixer_open(mixer, mode);
233 }
234
MixerAttach(snd_mixer_t * mixer,const char * name)235 int AlsaWrapper::MixerAttach(snd_mixer_t* mixer, const char* name) {
236 return snd_mixer_attach(mixer, name);
237 }
238
MixerElementRegister(snd_mixer_t * mixer,struct snd_mixer_selem_regopt * options,snd_mixer_class_t ** classp)239 int AlsaWrapper::MixerElementRegister(snd_mixer_t* mixer,
240 struct snd_mixer_selem_regopt* options,
241 snd_mixer_class_t** classp) {
242 return snd_mixer_selem_register(mixer, options, classp);
243 }
244
MixerFree(snd_mixer_t * mixer)245 void AlsaWrapper::MixerFree(snd_mixer_t* mixer) {
246 snd_mixer_free(mixer);
247 }
248
MixerDetach(snd_mixer_t * mixer,const char * name)249 int AlsaWrapper::MixerDetach(snd_mixer_t* mixer, const char* name) {
250 return snd_mixer_detach(mixer, name);
251 }
252
MixerClose(snd_mixer_t * mixer)253 int AlsaWrapper::MixerClose(snd_mixer_t* mixer) {
254 return snd_mixer_close(mixer);
255 }
256
MixerLoad(snd_mixer_t * mixer)257 int AlsaWrapper::MixerLoad(snd_mixer_t* mixer) {
258 return snd_mixer_load(mixer);
259 }
260
MixerFirstElem(snd_mixer_t * mixer)261 snd_mixer_elem_t* AlsaWrapper::MixerFirstElem(snd_mixer_t* mixer) {
262 return snd_mixer_first_elem(mixer);
263 }
264
MixerNextElem(snd_mixer_elem_t * elem)265 snd_mixer_elem_t* AlsaWrapper::MixerNextElem(snd_mixer_elem_t* elem) {
266 return snd_mixer_elem_next(elem);
267 }
268
MixerSelemIsActive(snd_mixer_elem_t * elem)269 int AlsaWrapper::MixerSelemIsActive(snd_mixer_elem_t* elem) {
270 return snd_mixer_selem_is_active(elem);
271 }
272
MixerSelemName(snd_mixer_elem_t * elem)273 const char* AlsaWrapper::MixerSelemName(snd_mixer_elem_t* elem) {
274 return snd_mixer_selem_get_name(elem);
275 }
276
MixerSelemSetCaptureVolumeAll(snd_mixer_elem_t * elem,long value)277 int AlsaWrapper::MixerSelemSetCaptureVolumeAll(
278 snd_mixer_elem_t* elem, long value) {
279 return snd_mixer_selem_set_capture_volume_all(elem, value);
280 }
281
MixerSelemGetCaptureVolume(snd_mixer_elem_t * elem,snd_mixer_selem_channel_id_t channel,long * value)282 int AlsaWrapper::MixerSelemGetCaptureVolume(
283 snd_mixer_elem_t* elem, snd_mixer_selem_channel_id_t channel, long* value) {
284 return snd_mixer_selem_get_capture_volume(elem, channel, value);
285 }
286
MixerSelemHasCaptureVolume(snd_mixer_elem_t * elem)287 int AlsaWrapper::MixerSelemHasCaptureVolume(snd_mixer_elem_t* elem) {
288 return snd_mixer_selem_has_capture_volume(elem);
289 }
290
MixerSelemGetCaptureVolumeRange(snd_mixer_elem_t * elem,long * min,long * max)291 int AlsaWrapper::MixerSelemGetCaptureVolumeRange(snd_mixer_elem_t* elem,
292 long* min, long* max) {
293 return snd_mixer_selem_get_capture_volume_range(elem, min, max);
294 }
295
MixerElemGetCallbackPrivate(const snd_mixer_elem_t * obj)296 void* AlsaWrapper::MixerElemGetCallbackPrivate(const snd_mixer_elem_t* obj) {
297 return snd_mixer_elem_get_callback_private(obj);
298 }
299
MixerElemSetCallback(snd_mixer_elem_t * obj,snd_mixer_elem_callback_t val)300 void AlsaWrapper::MixerElemSetCallback(snd_mixer_elem_t* obj,
301 snd_mixer_elem_callback_t val) {
302 snd_mixer_elem_set_callback(obj, val);
303 }
304
MixerElemSetCallbackPrivate(snd_mixer_elem_t * obj,void * val)305 void AlsaWrapper::MixerElemSetCallbackPrivate(snd_mixer_elem_t* obj,
306 void* val) {
307 snd_mixer_elem_set_callback_private(obj, val);
308 }
309
MixerFindSelem(snd_mixer_t * mixer,const snd_mixer_selem_id_t * id)310 snd_mixer_elem_t* AlsaWrapper::MixerFindSelem(snd_mixer_t* mixer,
311 const snd_mixer_selem_id_t* id) {
312 return snd_mixer_find_selem(mixer, id);
313 }
314
MixerHandleEvents(snd_mixer_t * mixer)315 int AlsaWrapper::MixerHandleEvents(snd_mixer_t* mixer) {
316 return snd_mixer_handle_events(mixer);
317 }
318
MixerPollDescriptors(snd_mixer_t * mixer,struct pollfd * pfds,unsigned int space)319 int AlsaWrapper::MixerPollDescriptors(snd_mixer_t* mixer,
320 struct pollfd* pfds,
321 unsigned int space) {
322 return snd_mixer_poll_descriptors(mixer, pfds, space);
323 }
324
MixerPollDescriptorsCount(snd_mixer_t * mixer)325 int AlsaWrapper::MixerPollDescriptorsCount(snd_mixer_t* mixer) {
326 return snd_mixer_poll_descriptors_count(mixer);
327 }
328
MixerSelemGetPlaybackSwitch(snd_mixer_elem_t * elem,snd_mixer_selem_channel_id_t channel,int * value)329 int AlsaWrapper::MixerSelemGetPlaybackSwitch(
330 snd_mixer_elem_t* elem,
331 snd_mixer_selem_channel_id_t channel,
332 int* value) {
333 return snd_mixer_selem_get_playback_switch(elem, channel, value);
334 }
335
MixerSelemGetPlaybackVolume(snd_mixer_elem_t * elem,snd_mixer_selem_channel_id_t channel,long * value)336 int AlsaWrapper::MixerSelemGetPlaybackVolume(
337 snd_mixer_elem_t* elem,
338 snd_mixer_selem_channel_id_t channel,
339 long* value) {
340 return snd_mixer_selem_get_playback_volume(elem, channel, value);
341 }
342
MixerSelemGetPlaybackVolumeRange(snd_mixer_elem_t * elem,long * min,long * max)343 int AlsaWrapper::MixerSelemGetPlaybackVolumeRange(snd_mixer_elem_t* elem,
344 long* min,
345 long* max) {
346 return snd_mixer_selem_get_playback_volume_range(elem, min, max);
347 }
348
MixerSelemHasPlaybackSwitch(snd_mixer_elem_t * elem)349 int AlsaWrapper::MixerSelemHasPlaybackSwitch(snd_mixer_elem_t* elem) {
350 return snd_mixer_selem_has_playback_switch(elem);
351 }
352
MixerSelemIdSetIndex(snd_mixer_selem_id_t * obj,unsigned int val)353 void AlsaWrapper::MixerSelemIdSetIndex(snd_mixer_selem_id_t* obj,
354 unsigned int val) {
355 snd_mixer_selem_id_set_index(obj, val);
356 }
357
MixerSelemIdSetName(snd_mixer_selem_id_t * obj,const char * val)358 void AlsaWrapper::MixerSelemIdSetName(snd_mixer_selem_id_t* obj,
359 const char* val) {
360 snd_mixer_selem_id_set_name(obj, val);
361 }
362
MixerSelemSetPlaybackSwitch(snd_mixer_elem_t * elem,snd_mixer_selem_channel_id_t channel,int value)363 int AlsaWrapper::MixerSelemSetPlaybackSwitch(
364 snd_mixer_elem_t* elem,
365 snd_mixer_selem_channel_id_t channel,
366 int value) {
367 return snd_mixer_selem_set_playback_switch(elem, channel, value);
368 }
369
MixerSelemSetPlaybackVolumeAll(snd_mixer_elem_t * elem,long value)370 int AlsaWrapper::MixerSelemSetPlaybackVolumeAll(snd_mixer_elem_t* elem,
371 long value) {
372 return snd_mixer_selem_set_playback_volume_all(elem, value);
373 }
374
MixerSelemIdMalloc(snd_mixer_selem_id_t ** ptr)375 int AlsaWrapper::MixerSelemIdMalloc(snd_mixer_selem_id_t** ptr) {
376 return snd_mixer_selem_id_malloc(ptr);
377 }
378
MixerSelemIdFree(snd_mixer_selem_id_t * obj)379 void AlsaWrapper::MixerSelemIdFree(snd_mixer_selem_id_t* obj) {
380 snd_mixer_selem_id_free(obj);
381 }
382
383 } // namespace media
384