1 /* ALSAStreamOps.cpp
2  **
3  ** Copyright 2008-2009 Wind River Systems
4  ** Copyright (c) 2011, Code Aurora Forum. All rights reserved.
5  **
6  ** Licensed under the Apache License, Version 2.0 (the "License");
7  ** you may not use this file except in compliance with the License.
8  ** You may obtain a copy of the License at
9  **
10  **     http://www.apache.org/licenses/LICENSE-2.0
11  **
12  ** Unless required by applicable law or agreed to in writing, software
13  ** distributed under the License is distributed on an "AS IS" BASIS,
14  ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  ** See the License for the specific language governing permissions and
16  ** limitations under the License.
17  */
18 
19 #include <errno.h>
20 #include <stdarg.h>
21 #include <sys/stat.h>
22 #include <fcntl.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <dlfcn.h>
26 
27 #define LOG_TAG "ALSAStreamOps"
28 //#define LOG_NDEBUG 0
29 #define LOG_NDDEBUG 0
30 #include <utils/Log.h>
31 #include <utils/String8.h>
32 
33 #include <cutils/properties.h>
34 #include <media/AudioRecord.h>
35 #include <hardware_legacy/power.h>
36 #include "AudioUtil.h"
37 #include "AudioHardwareALSA.h"
38 
39 namespace android_audio_legacy
40 {
41 
42 // unused 'enumVal;' is to catch error at compile time if enumVal ever changes
43 // or applied on a non-existent enum
44 #define ENUM_TO_STRING(var, enumVal) {var = #enumVal; enumVal;}
45 
46 // ----------------------------------------------------------------------------
47 
ALSAStreamOps(AudioHardwareALSA * parent,alsa_handle_t * handle)48 ALSAStreamOps::ALSAStreamOps(AudioHardwareALSA *parent, alsa_handle_t *handle) :
49     mParent(parent),
50     mHandle(handle)
51 {
52 }
53 
~ALSAStreamOps()54 ALSAStreamOps::~ALSAStreamOps()
55 {
56     Mutex::Autolock autoLock(mParent->mLock);
57 
58     if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
59        (!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
60         if((mParent->mVoipStreamCount)) {
61             mParent->mVoipStreamCount--;
62             if(mParent->mVoipStreamCount > 0) {
63                 ALOGD("ALSAStreamOps::close() Ignore");
64                 return ;
65             }
66        }
67        mParent->mVoipStreamCount = 0;
68        mParent->mVoipBitRate = 0;
69     }
70     close();
71 
72     for(ALSAHandleList::iterator it = mParent->mDeviceList.begin();
73             it != mParent->mDeviceList.end(); ++it) {
74             if (mHandle == &(*it)) {
75                 it->useCase[0] = 0;
76                 mParent->mDeviceList.erase(it);
77                 break;
78             }
79     }
80 }
81 
82 // use emulated popcount optimization
83 // http://www.df.lth.se/~john_e/gems/gem002d.html
popCount(uint32_t u)84 static inline uint32_t popCount(uint32_t u)
85 {
86     u = ((u&0x55555555) + ((u>>1)&0x55555555));
87     u = ((u&0x33333333) + ((u>>2)&0x33333333));
88     u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
89     u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
90     u = ( u&0x0000ffff) + (u>>16);
91     return u;
92 }
93 
set(int * format,uint32_t * channels,uint32_t * rate,uint32_t device)94 status_t ALSAStreamOps::set(int      *format,
95                             uint32_t *channels,
96                             uint32_t *rate,
97                             uint32_t device)
98 {
99     mDevices = device;
100     if (channels && *channels != 0) {
101         if (mHandle->channels != popCount(*channels))
102             return BAD_VALUE;
103     } else if (channels) {
104         if (mHandle->devices & AudioSystem::DEVICE_OUT_ALL) {
105             switch(*channels) {
106                 case AUDIO_CHANNEL_OUT_5POINT1: // 5.0
107                 case (AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER): // 5.1
108                 case AUDIO_CHANNEL_OUT_QUAD:
109                 case AUDIO_CHANNEL_OUT_STEREO:
110                 case AUDIO_CHANNEL_OUT_MONO:
111                     break;
112                 default:
113                     *channels = AUDIO_CHANNEL_OUT_STEREO;
114                     return BAD_VALUE;
115             }
116         } else {
117             switch(*channels) {
118 #ifdef QCOM_SSR_ENABLED
119                 // For 5.1 recording
120                 case AudioSystem::CHANNEL_IN_5POINT1:
121 #endif
122                     // Do not fall through...
123                 case AUDIO_CHANNEL_IN_MONO:
124                 case AUDIO_CHANNEL_IN_STEREO:
125                 case AUDIO_CHANNEL_IN_FRONT_BACK:
126                     break;
127                 default:
128                     *channels = AUDIO_CHANNEL_IN_MONO;
129                     return BAD_VALUE;
130             }
131         }
132     }
133 
134     if (rate && *rate > 0) {
135         if (mHandle->sampleRate != *rate)
136             return BAD_VALUE;
137     } else if (rate) {
138         *rate = mHandle->sampleRate;
139     }
140 
141     snd_pcm_format_t iformat = mHandle->format;
142 
143     if (format) {
144         switch(*format) {
145             case AudioSystem::FORMAT_DEFAULT:
146                 break;
147 
148             case AudioSystem::PCM_16_BIT:
149                 iformat = SNDRV_PCM_FORMAT_S16_LE;
150                 break;
151             case AudioSystem::AMR_NB:
152             case AudioSystem::AMR_WB:
153 #ifdef QCOM_QCHAT_ENABLED
154             case AudioSystem::EVRC:
155             case AudioSystem::EVRCB:
156             case AudioSystem::EVRCWB:
157 #endif
158                 iformat = *format;
159                 break;
160 
161             case AudioSystem::PCM_8_BIT:
162                 iformat = SNDRV_PCM_FORMAT_S8;
163                 break;
164 
165             default:
166                 ALOGE("Unknown PCM format %i. Forcing default", *format);
167                 break;
168         }
169 
170         if (mHandle->format != iformat)
171             return BAD_VALUE;
172 
173         switch(iformat) {
174             case SNDRV_PCM_FORMAT_S16_LE:
175                 *format = AudioSystem::PCM_16_BIT;
176                 break;
177             case SNDRV_PCM_FORMAT_S8:
178                 *format = AudioSystem::PCM_8_BIT;
179                 break;
180             default:
181                 break;
182         }
183     }
184 
185     return NO_ERROR;
186 }
187 
setParameters(const String8 & keyValuePairs)188 status_t ALSAStreamOps::setParameters(const String8& keyValuePairs)
189 {
190     AudioParameter param = AudioParameter(keyValuePairs);
191     String8 key = String8(AudioParameter::keyRouting);
192     int device;
193 
194 #ifdef SEPERATED_AUDIO_INPUT
195     String8 key_input = String8(AudioParameter::keyInputSource);
196     int source;
197 
198     if (param.getInt(key_input, source) == NO_ERROR) {
199         ALOGD("setParameters(), input_source = %d", source);
200         mParent->mALSADevice->setInput(source);
201         param.remove(key_input);
202     }
203 #endif
204 
205     if (param.getInt(key, device) == NO_ERROR) {
206         // Ignore routing if device is 0.
207         ALOGD("setParameters(): keyRouting with device 0x%x", device);
208         // reset to speaker when disconnecting HDMI to avoid timeout due to write errors
209         if ((device == 0) && (mDevices == AudioSystem::DEVICE_OUT_AUX_DIGITAL)) {
210             device = AudioSystem::DEVICE_OUT_SPEAKER;
211         }
212         if (device)
213             mDevices = device;
214         else
215             ALOGV("must not change mDevices to 0");
216 
217         if(device) {
218             mParent->doRouting(device);
219         }
220         param.remove(key);
221     }
222 #ifdef QCOM_FM_ENABLED
223     else {
224         key = String8(AudioParameter::keyHandleFm);
225         if (param.getInt(key, device) == NO_ERROR) {
226         ALOGD("setParameters(): handleFm with device %d", device);
227         mDevices = device;
228             if(device) {
229                 mParent->handleFm(device);
230             }
231             param.remove(key);
232         }
233     }
234 #endif
235 
236     return NO_ERROR;
237 }
238 
getParameters(const String8 & keys)239 String8 ALSAStreamOps::getParameters(const String8& keys)
240 {
241     AudioParameter param = AudioParameter(keys);
242     String8 value;
243     String8 key = String8(AudioParameter::keyRouting);
244 
245     if (param.get(key, value) == NO_ERROR) {
246         param.addInt(key, (int)mDevices);
247     }
248     else {
249 #ifdef QCOM_VOIP_ENABLED
250         key = String8(AudioParameter::keyVoipCheck);
251         if (param.get(key, value) == NO_ERROR) {
252             if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
253                (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP))))
254                 param.addInt(key, true);
255             else
256                 param.addInt(key, false);
257         }
258 #endif
259     }
260     key = String8(AUDIO_PARAMETER_STREAM_SUP_CHANNELS);
261     if (param.get(key, value) == NO_ERROR) {
262         EDID_AUDIO_INFO info = { 0 };
263         bool first = true;
264         value = String8();
265         if (AudioUtil::getHDMIAudioSinkCaps(&info)) {
266             for (int i = 0; i < info.nAudioBlocks && i < MAX_EDID_BLOCKS; i++) {
267                 String8 append;
268                 switch (info.AudioBlocksArray[i].nChannels) {
269                 //Do not handle stereo output in Multi-channel cases
270                 //Stereo case is handled in normal playback path
271                 case 6:
272                     ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_5POINT1);
273                     break;
274                 case 8:
275                     ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_7POINT1);
276                     break;
277                 default:
278                     ALOGD("Unsupported number of channels %d", info.AudioBlocksArray[i].nChannels);
279                     break;
280                 }
281                 if (!append.isEmpty()) {
282                     value += (first ? append : String8("|") + append);
283                     first = false;
284                 }
285             }
286         } else {
287             ALOGE("Failed to get HDMI sink capabilities");
288         }
289         param.add(key, value);
290     }
291     ALOGV("getParameters() %s", param.toString().string());
292     return param.toString();
293 }
294 
sampleRate() const295 uint32_t ALSAStreamOps::sampleRate() const
296 {
297     return mHandle->sampleRate;
298 }
299 
300 //
301 // Return the number of bytes (not frames)
302 //
bufferSize() const303 size_t ALSAStreamOps::bufferSize() const
304 {
305     ALOGV("bufferSize() returns %d", mHandle->bufferSize);
306     return mHandle->bufferSize;
307 }
308 
format() const309 int ALSAStreamOps::format() const
310 {
311     int audioSystemFormat;
312 
313     snd_pcm_format_t ALSAFormat = mHandle->format;
314 
315     switch(ALSAFormat) {
316         case SNDRV_PCM_FORMAT_S8:
317              audioSystemFormat = AudioSystem::PCM_8_BIT;
318              break;
319 
320         case AudioSystem::AMR_NB:
321         case AudioSystem::AMR_WB:
322 #ifdef QCOM_QCHAT_ENABLED
323         case AudioSystem::EVRC:
324         case AudioSystem::EVRCB:
325         case AudioSystem::EVRCWB:
326 #endif
327             audioSystemFormat = mHandle->format;
328             break;
329         case SNDRV_PCM_FORMAT_S16_LE:
330             audioSystemFormat = AudioSystem::PCM_16_BIT;
331             break;
332 
333         default:
334             LOG_FATAL("Unknown AudioSystem bit width %d!", audioSystemFormat);
335             audioSystemFormat = AudioSystem::PCM_16_BIT;
336             break;
337     }
338 
339     ALOGV("ALSAFormat:0x%x,audioSystemFormat:0x%x",ALSAFormat,audioSystemFormat);
340     return audioSystemFormat;
341 }
342 
channels() const343 uint32_t ALSAStreamOps::channels() const
344 {
345     return mHandle->channelMask;
346 }
347 
close()348 void ALSAStreamOps::close()
349 {
350     ALOGD("close");
351     if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
352        (!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
353        mParent->mVoipBitRate = 0;
354        mParent->mVoipStreamCount = 0;
355     }
356     mParent->mALSADevice->close(mHandle);
357 }
358 
359 //
360 // Set playback or capture PCM device.  It's possible to support audio output
361 // or input from multiple devices by using the ALSA plugins, but this is
362 // not supported for simplicity.
363 //
364 // The AudioHardwareALSA API does not allow one to set the input routing.
365 //
366 // If the "routes" value does not map to a valid device, the default playback
367 // device is used.
368 //
open(int mode)369 status_t ALSAStreamOps::open(int mode)
370 {
371     ALOGD("open");
372     return mParent->mALSADevice->open(mHandle);
373 }
374 
375 }       // namespace androidi_audio_legacy
376