alsa_wrapper.cc 14 KB

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