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 // AlsaWrapper is a simple stateless class that wraps the alsa library commands
6 // we want to use.  It's purpose is to allow injection of a mock so that the
7 // higher level code is testable.
8 
9 #ifndef MEDIA_AUDIO_ALSA_ALSA_WRAPPER_H_
10 #define MEDIA_AUDIO_ALSA_ALSA_WRAPPER_H_
11 
12 #include <alsa/asoundlib.h>
13 
14 #include "base/macros.h"
15 #include "media/base/media_export.h"
16 
17 namespace media {
18 
19 class MEDIA_EXPORT AlsaWrapper {
20  public:
21   AlsaWrapper();
22   virtual ~AlsaWrapper();
23 
24   virtual int DeviceNameHint(int card, const char* iface, void*** hints);
25   virtual char* DeviceNameGetHint(const void* hint, const char* id);
26   virtual int DeviceNameFreeHint(void** hints);
27   virtual int CardNext(int* rcard);
28 
29   virtual int PcmOpen(snd_pcm_t** handle, const char* name,
30                       snd_pcm_stream_t stream, int mode);
31   virtual int PcmClose(snd_pcm_t* handle);
32   virtual int PcmPrepare(snd_pcm_t* handle);
33   virtual int PcmDrain(snd_pcm_t* handle);
34   virtual int PcmDrop(snd_pcm_t* handle);
35   virtual int PcmDelay(snd_pcm_t* handle, snd_pcm_sframes_t* delay);
36   virtual int PcmResume(snd_pcm_t* handle);
37   virtual snd_pcm_sframes_t PcmWritei(snd_pcm_t* handle,
38                                       const void* buffer,
39                                       snd_pcm_uframes_t size);
40   virtual snd_pcm_sframes_t PcmReadi(snd_pcm_t* handle,
41                                      void* buffer,
42                                      snd_pcm_uframes_t size);
43   virtual int PcmRecover(snd_pcm_t* handle, int err, int silent);
44   virtual int PcmSetParams(snd_pcm_t* handle, snd_pcm_format_t format,
45                            snd_pcm_access_t access, unsigned int channels,
46                            unsigned int rate, int soft_resample,
47                            unsigned int latency);
48   virtual int PcmGetParams(snd_pcm_t* handle, snd_pcm_uframes_t* buffer_size,
49                            snd_pcm_uframes_t* period_size);
50   virtual int PcmHwParamsMalloc(snd_pcm_hw_params_t** hw_params);
51   virtual int PcmHwParamsAny(snd_pcm_t* handle, snd_pcm_hw_params_t* hw_params);
52   virtual int PcmHwParamsCanResume(snd_pcm_hw_params_t* hw_params);
53   virtual int PcmHwParamsSetRateResample(snd_pcm_t* handle,
54                                          snd_pcm_hw_params_t* hw_params,
55                                          unsigned int value);
56   virtual int PcmHwParamsSetRateNear(snd_pcm_t* handle,
57                                      snd_pcm_hw_params_t* hw_params,
58                                      unsigned int* rate,
59                                      int* direction);
60   virtual int PcmHwParamsTestFormat(snd_pcm_t* handle,
61                                     snd_pcm_hw_params_t* hw_params,
62                                     snd_pcm_format_t format);
63   virtual int PcmFormatSize(snd_pcm_format_t format, size_t samples);
64   virtual int PcmHwParamsGetChannelsMin(const snd_pcm_hw_params_t* hw_params,
65                                         unsigned int* min_channels);
66   virtual int PcmHwParamsGetChannelsMax(const snd_pcm_hw_params_t* hw_params,
67                                         unsigned int* max_channels);
68   virtual int PcmHwParamsSetFormat(snd_pcm_t* handle,
69                                    snd_pcm_hw_params_t* hw_params,
70                                    snd_pcm_format_t format);
71   virtual int PcmHwParamsSetAccess(snd_pcm_t* handle,
72                                    snd_pcm_hw_params_t* hw_params,
73                                    snd_pcm_access_t access);
74   virtual int PcmHwParamsSetChannels(snd_pcm_t* handle,
75                                      snd_pcm_hw_params_t* hw_params,
76                                      unsigned int channels);
77   virtual int PcmHwParamsSetBufferSizeNear(snd_pcm_t* handle,
78                                            snd_pcm_hw_params_t* hw_params,
79                                            snd_pcm_uframes_t* buffer_size);
80   virtual int PcmHwParamsSetPeriodSizeNear(snd_pcm_t* handle,
81                                            snd_pcm_hw_params_t* hw_params,
82                                            snd_pcm_uframes_t* period_size,
83                                            int* direction);
84   virtual int PcmHwParams(snd_pcm_t* handle, snd_pcm_hw_params_t* hw_params);
85   virtual void PcmHwParamsFree(snd_pcm_hw_params_t* hw_params);
86   virtual int PcmSwParamsMalloc(snd_pcm_sw_params_t** sw_params);
87   virtual int PcmSwParamsCurrent(snd_pcm_t* handle,
88                                  snd_pcm_sw_params_t* sw_params);
89   virtual int PcmSwParamsSetStartThreshold(snd_pcm_t* handle,
90                                            snd_pcm_sw_params_t* sw_params,
91                                            snd_pcm_uframes_t start_threshold);
92   virtual int PcmSwParamsSetAvailMin(snd_pcm_t* handle,
93                                      snd_pcm_sw_params_t* sw_params,
94                                      snd_pcm_uframes_t period_size);
95   virtual int PcmSwParams(snd_pcm_t* handle, snd_pcm_sw_params_t* sw_params);
96   virtual void PcmSwParamsFree(snd_pcm_sw_params_t* sw_params);
97   virtual const char* PcmName(snd_pcm_t* handle);
98   virtual snd_pcm_sframes_t PcmAvailUpdate(snd_pcm_t* handle);
99   virtual snd_pcm_state_t PcmState(snd_pcm_t* handle);
100   virtual int PcmStart(snd_pcm_t* handle);
101 
102   virtual int MixerOpen(snd_mixer_t** mixer, int mode);
103   virtual int MixerAttach(snd_mixer_t* mixer, const char* name);
104   virtual int MixerElementRegister(snd_mixer_t* mixer,
105                                    struct snd_mixer_selem_regopt* options,
106                                    snd_mixer_class_t** classp);
107   virtual void MixerFree(snd_mixer_t* mixer);
108   virtual int MixerDetach(snd_mixer_t* mixer, const char* name);
109   virtual int MixerClose(snd_mixer_t* mixer);
110   virtual int MixerLoad(snd_mixer_t* mixer);
111   virtual snd_mixer_elem_t* MixerFirstElem(snd_mixer_t* mixer);
112   virtual snd_mixer_elem_t* MixerNextElem(snd_mixer_elem_t* elem);
113   virtual int MixerSelemIsActive(snd_mixer_elem_t* elem);
114   virtual const char* MixerSelemName(snd_mixer_elem_t* elem);
115   virtual int MixerSelemSetCaptureVolumeAll(snd_mixer_elem_t* elem, long value);
116   virtual int MixerSelemGetCaptureVolume(snd_mixer_elem_t* elem,
117                                          snd_mixer_selem_channel_id_t channel,
118                                          long* value);
119   virtual int MixerSelemHasCaptureVolume(snd_mixer_elem_t* elem);
120   virtual int MixerSelemGetCaptureVolumeRange(snd_mixer_elem_t* elem,
121                                               long* min, long* max);
122   virtual void* MixerElemGetCallbackPrivate(const snd_mixer_elem_t* obj);
123   virtual void MixerElemSetCallback(snd_mixer_elem_t* obj,
124                                     snd_mixer_elem_callback_t val);
125   virtual void MixerElemSetCallbackPrivate(snd_mixer_elem_t* obj, void* val);
126   virtual snd_mixer_elem_t* MixerFindSelem(snd_mixer_t* mixer,
127                                            const snd_mixer_selem_id_t* id);
128   virtual int MixerHandleEvents(snd_mixer_t* mixer);
129   virtual int MixerPollDescriptors(snd_mixer_t* mixer,
130                                    struct pollfd* pfds,
131                                    unsigned int space);
132   virtual int MixerPollDescriptorsCount(snd_mixer_t* mixer);
133   virtual int MixerSelemGetPlaybackSwitch(snd_mixer_elem_t* elem,
134                                           snd_mixer_selem_channel_id_t channel,
135                                           int* value);
136   virtual int MixerSelemGetPlaybackVolume(snd_mixer_elem_t* elem,
137                                           snd_mixer_selem_channel_id_t channel,
138                                           long* value);
139   virtual int MixerSelemGetPlaybackVolumeRange(snd_mixer_elem_t* elem,
140                                                long* min,
141                                                long* max);
142   virtual int MixerSelemHasPlaybackSwitch(snd_mixer_elem_t* elem);
143   virtual void MixerSelemIdSetIndex(snd_mixer_selem_id_t* obj,
144                                     unsigned int val);
145   virtual void MixerSelemIdSetName(snd_mixer_selem_id_t* obj, const char* val);
146   virtual int MixerSelemSetPlaybackSwitch(snd_mixer_elem_t* elem,
147                                           snd_mixer_selem_channel_id_t channel,
148                                           int value);
149   virtual int MixerSelemSetPlaybackVolumeAll(snd_mixer_elem_t* elem,
150                                              long value);
151   virtual int MixerSelemIdMalloc(snd_mixer_selem_id_t** ptr);
152   virtual void MixerSelemIdFree(snd_mixer_selem_id_t* obj);
153 
154   virtual const char* StrError(int errnum);
155 
156   DISALLOW_COPY_AND_ASSIGN(AlsaWrapper);
157 };
158 
159 }  // namespace media
160 
161 #endif  // MEDIA_AUDIO_ALSA_ALSA_WRAPPER_H_
162