| /* |
| ** |
| ** Copyright 2014, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #define LOG_TAG "AudioHAL:alsa_utils" |
| |
| #include "alsa_utils.h" |
| |
| #ifndef ALSA_UTILS_PRINT_FORMATS |
| #define ALSA_UTILS_PRINT_FORMATS 1 |
| #endif |
| |
| int find_alsa_card_by_name(const char* name) { |
| int card_id = 0; |
| int ret = -1; |
| int fd; |
| |
| do { |
| int fd; |
| int amt; |
| char tmp[256]; |
| |
| snprintf(tmp, sizeof(tmp), "/proc/asound/card%d/id", card_id); |
| tmp[sizeof(tmp) - 1] = 0; |
| fd = open(tmp, O_RDONLY); |
| if (fd < 0) |
| break; |
| |
| amt = read(fd, tmp, sizeof(tmp) - 1); |
| if (amt > 0) { |
| // replace the '\n' at the end of the proc file with '\0' |
| tmp[amt - 1] = 0; |
| if (!strcmp(name, tmp)) |
| ret = card_id; |
| } |
| |
| close(fd); |
| |
| card_id++; |
| } while (ret < 0); |
| |
| ALOGI("%s: returning card %d for name %s", __func__, ret, name); |
| return ret; |
| } |
| |
| #ifdef __cplusplus |
| #include <tinyalsa/asoundlib.h> |
| #include <utils/misc.h> |
| |
| namespace android { |
| |
| static const char *kCtrlNames[] = { |
| "Basic Audio Supported", |
| "Speaker Allocation", |
| "Audio Mode Count", |
| "Audio Mode To Query", |
| "Query Mode : Format", |
| "Query Mode : Max Ch Count", |
| "Query Mode : Sample Rate Mask", |
| "Query Mode : PCM Bits/Sample Mask", |
| "Query Mode : Max Compressed Bitrate" |
| }; |
| static const size_t kCtrlCount = sizeof(kCtrlNames)/sizeof(*kCtrlNames); |
| static const size_t kBasicAudNdx = 0; |
| static const size_t kSpeakerAlloc = 1; |
| static const size_t kModeCntNdx = 2; |
| static const size_t kModeSelNdx = 3; |
| static const size_t kFmtNdx = 4; |
| static const size_t kMaxChCntNdx = 5; |
| static const size_t kSampRateNdx = 6; |
| static const size_t kBPSNdx = 7; |
| static const size_t kMaxCompBRNdx = 8; |
| |
| HDMIAudioCaps::HDMIAudioCaps() |
| { |
| // Its unlikely we will need storage for more than 16 modes, but if we do, |
| // the vector will resize for us. |
| mModes.setCapacity(16); |
| reset(); |
| } |
| |
| bool HDMIAudioCaps::loadCaps(int ALSADeviceID) { |
| bool ret = false; |
| struct mixer* mixer = NULL; |
| struct mixer_ctl* ctrls[kCtrlCount] = {NULL}; |
| int tmp, mode_cnt; |
| Mutex::Autolock _l(mLock); |
| |
| ALOGE("%s: start", __func__); |
| |
| reset_l(); |
| |
| // Open the mixer for the chosen ALSA device |
| if (NULL == (mixer = mixer_open(ALSADeviceID))) { |
| ALOGE("%s: mixer_open(%d) failed", __func__, ALSADeviceID); |
| goto bailout; |
| } |
| |
| // Gather handles to all of the controls we will need in order to enumerate |
| // the audio capabilities of this HDMI link. No need to free/release these |
| // later, they are just pointers into the tinyalsa mixer structure itself. |
| for (size_t i = 0; i < kCtrlCount; ++i) { |
| ctrls[i] = mixer_get_ctl_by_name(mixer, kCtrlNames[i]); |
| if (NULL == ctrls[i]) { |
| ALOGE("%s: mixer_get_ctrl_by_name(%s) failed", __func__, kCtrlNames[i]); |
| goto bailout; |
| } |
| } |
| |
| // Start by checking to see if this HDMI connection supports even basic |
| // audio. If it does not, there is no point in proceeding. |
| if ((tmp = mixer_ctl_get_value(ctrls[kBasicAudNdx], 0)) <= 0) { |
| ALOGI("%s: Basic audio not supported by attached device", __func__); |
| goto bailout; |
| } |
| |
| // Looks like we support basic audio. Get a count of the available |
| // non-basic modes. |
| mBasicAudioSupported = true; |
| if ((mode_cnt = mixer_ctl_get_value(ctrls[kModeCntNdx], 0)) < 0) |
| goto bailout; |
| |
| // Fetch the speaker allocation data block, if available. |
| if ((tmp = mixer_ctl_get_value(ctrls[kSpeakerAlloc], 0)) < 0) |
| goto bailout; |
| mSpeakerAlloc = static_cast<uint16_t>(tmp); |
| ALOGI("%s: Speaker Allocation Map for attached device is: 0x%hx", __func__, mSpeakerAlloc); |
| |
| // If there are no non-basic modes available, then we are done. Be sure to |
| // flag this as a successful operation. |
| if (!mode_cnt) { |
| ret = true; |
| goto bailout; |
| } |
| |
| // Now enumerate the non-basic modes. Any errors at this point in time |
| // should indicate that the HDMI cable was unplugged and we should just |
| // abort with an empty set of audio capabilities. |
| for (int i = 0; i < mode_cnt; ++i) { |
| Mode m; |
| |
| // Pick the mode we want to fetch info for. |
| if (mixer_ctl_set_value(ctrls[kModeSelNdx], 0, i) < 0) |
| goto bailout; |
| |
| // Now fetch the common fields. |
| if ((tmp = mixer_ctl_get_value(ctrls[kFmtNdx], 0)) < 0) |
| goto bailout; |
| m.fmt = static_cast<AudFormat>(tmp); |
| ALOGI("Got mode %d from ALSA driver.", m.fmt); |
| |
| if ((tmp = mixer_ctl_get_value(ctrls[kMaxChCntNdx], 0)) < 0) |
| goto bailout; |
| m.max_ch = static_cast<uint32_t>(tmp); |
| |
| if ((tmp = mixer_ctl_get_value(ctrls[kSampRateNdx], 0)) < 0) |
| goto bailout; |
| m.sr_bitmask = static_cast<uint32_t>(tmp); |
| |
| // Now for the mode dependent fields. Only LPCM has the bits-per-sample |
| // mask. Only AC3 through ATRAC have the compressed bitrate field. |
| m.bps_bitmask = 0; |
| m.comp_bitrate = 0; |
| |
| if (m.fmt == kFmtLPCM) { |
| if ((tmp = mixer_ctl_get_value(ctrls[kBPSNdx], 0)) < 0) |
| goto bailout; |
| m.bps_bitmask = static_cast<uint32_t>(tmp); |
| } else if ((m.fmt >= kFmtAC3) && (m.fmt <= kFmtATRAC)) { // FIXME ATRAC is not last format!? |
| // FIXME SHould we extend the range up to kFmtDTSHD or kFmtMPGSUR? |
| if ((tmp = mixer_ctl_get_value(ctrls[kMaxCompBRNdx], 0)) < 0) |
| goto bailout; |
| m.comp_bitrate = static_cast<uint32_t>(tmp); |
| } |
| |
| // Finally, sanity check the info. If it passes, add it to the vector |
| // of available modes. |
| if (sanityCheckMode(m)) { |
| ALOGI("Passed sanity check for mode %d from ALSA driver.", m.fmt); |
| mModes.add(m); |
| } |
| } |
| |
| // Looks like we managed to enumerate all of the modes before someone |
| // unplugged the HDMI cable. Signal success and get out. |
| ret = true; |
| |
| bailout: |
| if (NULL != mixer) |
| mixer_close(mixer); |
| |
| if (!ret) |
| reset_l(); |
| |
| return ret; |
| } |
| |
| void HDMIAudioCaps::reset() { |
| Mutex::Autolock _l(mLock); |
| reset_l(); |
| } |
| |
| void HDMIAudioCaps::reset_l() { |
| mBasicAudioSupported = false; |
| mSpeakerAlloc = 0; |
| mModes.clear(); |
| } |
| |
| void HDMIAudioCaps::getRatesForAF(String8& rates) { |
| Mutex::Autolock _l(mLock); |
| rates.clear(); |
| |
| // If the sink does not support basic audio, then it supports no audio. |
| if (!mBasicAudioSupported) |
| return; |
| |
| // Basic audio always supports from 32k through 38k. |
| uint32_t tmp = kSR_32000 | kSR_44100 | kSR_48000; |
| |
| // To keep things simple, only report mode information for the PCM mode |
| // which supports the maximum number of channels. |
| ssize_t ndx = getMaxChModeNdx_l(); |
| if (ndx >= 0) |
| tmp |= mModes[ndx].sr_bitmask; |
| |
| bool first = true; |
| for (uint32_t i = 1; tmp; i <<= 1) { |
| if (i & tmp) { |
| rates.appendFormat(first ? "%d" : "|%d", srMaskToSR(i)); |
| first = false; |
| tmp &= ~i; |
| } |
| } |
| } |
| |
| void HDMIAudioCaps::getFmtsForAF(String8& fmts) { |
| Mutex::Autolock _l(mLock); |
| fmts.clear(); |
| |
| // If the sink does not support basic audio, then it supports no audio. |
| if (!mBasicAudioSupported) { |
| ALOGI("ALSAFORMATS: basic audio not supported"); |
| return; |
| } |
| |
| // These names must match formats in android.media.AudioFormat |
| fmts.append("AUDIO_FORMAT_PCM_16_BIT|AUDIO_FORMAT_PCM_8_24_BIT"); |
| // TODO: when we can start to expect 20 and 24 bit audio modes coming from |
| // AF, we need to implement support to enumerate those modes. |
| |
| for (size_t i = 0; i < mModes.size(); ++i) { |
| switch (mModes[i].fmt) { |
| case kFmtAC3: |
| fmts.append("|AUDIO_FORMAT_AC3"); |
| break; |
| case kFmtEAC3: |
| fmts.append("|AUDIO_FORMAT_E_AC3"); |
| break; |
| case kFmtDTS: |
| fmts.append("|AUDIO_FORMAT_DTS"); |
| break; |
| case kFmtDTSHD: |
| fmts.append("|AUDIO_FORMAT_DTS_HD"); |
| break; |
| default: |
| break; |
| } |
| } |
| // HDMI supports IEC61937 S/PDIF audio wrapper. |
| fmts.append("|AUDIO_FORMAT_IEC61937"); |
| |
| #if ALSA_UTILS_PRINT_FORMATS |
| ALOGI("ALSAFORMATS: formats = %s", fmts.string()); |
| |
| for (size_t i = 0; i < mModes.size(); ++i) { |
| ALOGI("ALSAFORMATS: ------- fmt[%d] = 0x%08X = %s", |
| i, mModes[i].fmt, fmtToString(mModes[i].fmt)); |
| ALOGI("ALSAFORMATS: comp_bitrate[%d] = 0x%08X = %d", |
| i, mModes[i].comp_bitrate, mModes[i].comp_bitrate); |
| ALOGI("ALSAFORMATS: max_ch[%d] = 0x%08X = %d", |
| i, mModes[i].max_ch, mModes[i].max_ch); |
| ALOGI("ALSAFORMATS: bps_bitmask[%d] = 0x%08X", i, mModes[i].bps_bitmask); |
| uint32_t bpsm = mModes[i].bps_bitmask; |
| while(bpsm) { |
| uint32_t bpsm_next = bpsm & (bpsm - 1); |
| uint32_t bpsm_single = bpsm ^ bpsm_next; |
| if (bpsm_single) { |
| ALOGI("ALSAFORMATS: bits = %d", bpsMaskToBPS(bpsm_single)); |
| } |
| bpsm = bpsm_next; |
| } |
| ALOGI("ALSAFORMATS: sr_bitmask[%d] = 0x%08X", i, mModes[i].sr_bitmask); |
| uint32_t srs = mModes[i].sr_bitmask; |
| while(srs) { |
| uint32_t srs_next = srs & (srs - 1); |
| uint32_t srs_single = srs ^ srs_next; |
| if (srs_single) { |
| ALOGI("ALSAFORMATS: srate = %d", srMaskToSR(srs_single)); |
| } |
| srs = srs_next; |
| } |
| } |
| #endif /* ALSA_UTILS_PRINT_FORMATS */ |
| } |
| |
| void HDMIAudioCaps::getChannelMasksForAF(String8& masks) { |
| Mutex::Autolock _l(mLock); |
| masks.clear(); |
| |
| // If the sink does not support basic audio, then it supports no audio. |
| if (!mBasicAudioSupported) |
| return; |
| |
| masks.append("AUDIO_CHANNEL_OUT_STEREO"); |
| |
| // To keep things simple, only report mode information for the mode |
| // which supports the maximum number of channels. |
| ssize_t ndx = getMaxChModeNdx_l(); |
| if (ndx < 0) |
| return; |
| |
| if (mModes[ndx].max_ch >= 6) { |
| if (masks.length()) |
| masks.append("|"); |
| |
| masks.append((mModes[ndx].max_ch >= 8) |
| ? "AUDIO_CHANNEL_OUT_5POINT1|AUDIO_CHANNEL_OUT_7POINT1" |
| : "AUDIO_CHANNEL_OUT_5POINT1"); |
| } |
| } |
| |
| ssize_t HDMIAudioCaps::getMaxChModeNdx_l() { |
| ssize_t max_ch_ndx = -1; |
| uint32_t max_ch = 0; |
| |
| for (size_t i = 0; i < mModes.size(); ++i) { |
| if (max_ch < mModes[i].max_ch) { |
| max_ch = mModes[i].max_ch; |
| max_ch_ndx = i; |
| } |
| } |
| |
| return max_ch_ndx; |
| } |
| |
| bool HDMIAudioCaps::supportsFormat(audio_format_t format, |
| uint32_t sampleRate, |
| uint32_t channelCount, |
| bool isIec958NonAudio) { |
| Mutex::Autolock _l(mLock); |
| |
| ALOGV("supportsFormat() format = 0x%08X, sampleRate = %u, channels = 0x%08X, iec958 = %d", |
| format, sampleRate, channelCount, isIec958NonAudio ? 1 : 0); |
| // If the sink does not support basic audio, then it supports no audio. |
| if (!mBasicAudioSupported) |
| return false; |
| |
| AudFormat alsaFormat; |
| switch (audio_get_main_format(format)) { |
| case AUDIO_FORMAT_PCM: alsaFormat = kFmtLPCM; break; |
| case AUDIO_FORMAT_AC3: alsaFormat = kFmtAC3; break; |
| case AUDIO_FORMAT_E_AC3: alsaFormat = kFmtAC3; break; // FIXME should this be kFmtEAC3? |
| case AUDIO_FORMAT_DTS: alsaFormat = kFmtDTS; break; |
| case AUDIO_FORMAT_DTS_HD: alsaFormat = kFmtDTSHD; break; |
| case AUDIO_FORMAT_IEC61937: |
| alsaFormat = kFmtLPCM; |
| isIec958NonAudio = true; |
| break; |
| default: |
| ALOGE("supportsFormat() says format %#x not supported", format); |
| return false; |
| } |
| |
| // EAC3 uses a PCM sample rate of 4X the base rate. |
| // We try to detect that situation and allow 4X rate even if the |
| // EDID does not report that it is supported. |
| // This rate was chosen because it is between the region of typical PCM rates |
| // and the extreme rates used for IEC61973. |
| // It is > 96000 and < 4*32000. |
| const uint32_t maxReasonableRate = 100000; // FIXME review for N |
| if (isIec958NonAudio && (alsaFormat == kFmtLPCM) && (sampleRate > maxReasonableRate)) { |
| ALOGI("supportsFormat() dividing sample %u by 4 to test support for EAC3 over HDMI", |
| sampleRate); |
| sampleRate = sampleRate / 4; |
| } |
| |
| SRMask srMask; |
| switch (sampleRate) { |
| case 32000: srMask = kSR_32000; break; |
| case 44100: srMask = kSR_44100; break; |
| case 48000: srMask = kSR_48000; break; |
| case 88200: srMask = kSR_88200; break; |
| case 96000: srMask = kSR_96000; break; |
| case 176400: srMask = kSR_176400; break; |
| case 192000: srMask = kSR_192000; break; |
| default: return false; |
| } |
| |
| // if PCM then determine actual bits per sample. |
| if (alsaFormat == kFmtLPCM) { |
| BPSMask bpsMask; |
| switch (format) { |
| // FIXME: (legacy code). We match on 16 bits, but on Fugu we hard code to use |
| // PCM_FORMAT_S24_LE. |
| case AUDIO_FORMAT_PCM_16_BIT: // fall through |
| case AUDIO_FORMAT_PCM_8_24_BIT: |
| case AUDIO_FORMAT_IEC61937: |
| bpsMask = kBPS_16bit; |
| break; |
| default: |
| return false; |
| } |
| |
| // Is the caller requesting basic audio? If so, we should be good to go. |
| // Otherwise, we need to check the mode table. |
| if ((2 == channelCount) && (sampleRate <= 48000)) |
| return true; |
| |
| // Check the modes in the table to see if there is one which |
| // supports the caller's format. |
| for (size_t i = 0; i < mModes.size(); ++i) { |
| const Mode& m = mModes[i]; |
| if ((m.fmt == kFmtLPCM) && |
| (m.max_ch >= channelCount) && |
| (m.sr_bitmask & srMask) && |
| (m.bps_bitmask & bpsMask)) |
| return true; |
| } |
| } else { |
| // Check the modes in the table to see if there is one which |
| // supports the caller's format. |
| for (size_t i = 0; i < mModes.size(); ++i) { |
| const Mode& m = mModes[i]; |
| // ignore bps_bitmask |
| if ((m.fmt == alsaFormat) && |
| (m.max_ch >= channelCount) && |
| (m.sr_bitmask & srMask)) |
| return true; |
| } |
| } |
| |
| // Looks like no compatible modes were found. |
| return false; |
| } |
| |
| bool HDMIAudioCaps::sanityCheckMode(const Mode& m) { |
| if ((m.fmt < kFmtLPCM) || (m.fmt > kFmtMPGSUR)) |
| return false; |
| |
| if (m.max_ch > 8) |
| return false; |
| |
| if (m.sr_bitmask & ~(kSR_32000 | kSR_44100 | kSR_48000 | kSR_88200 | |
| kSR_96000 | kSR_176400 | kSR_192000)) |
| return false; |
| |
| if (m.bps_bitmask & ~(kBPS_16bit | kBPS_20bit | kBPS_24bit)) |
| return false; |
| |
| return true; |
| } |
| |
| const char* HDMIAudioCaps::fmtToString(AudFormat fmt) { |
| static const char* fmts[] = { |
| "invalid", "LPCM", "AC-3", "MPEG-1", "MPEG-1 Layer 3", |
| "MPEG-2", "AAC-LC", "DTS", "ATRAC", "DSD", "E-AC3", |
| "DTS-HD", "MLP", "DST", "WMA Pro", "Extended" }; |
| |
| if (fmt >= NELEM(fmts)) |
| return "invalid"; |
| |
| return fmts[fmt]; |
| } |
| |
| uint32_t HDMIAudioCaps::srMaskToSR(uint32_t mask) { |
| switch (mask) { |
| case kSR_32000: return 32000; |
| case kSR_44100: return 44100; |
| case kSR_48000: return 48000; |
| case kSR_88200: return 88200; |
| case kSR_96000: return 96000; |
| case kSR_176400: return 176400; |
| case kSR_192000: return 192000; |
| default: return 0; |
| } |
| } |
| |
| uint32_t HDMIAudioCaps::bpsMaskToBPS(uint32_t mask) { |
| switch (mask) { |
| case kBPS_16bit: return 16; |
| case kBPS_20bit: return 20; |
| case kBPS_24bit: return 24; |
| default: return 0; |
| } |
| } |
| |
| const char* HDMIAudioCaps::saMaskToString(uint32_t mask) { |
| switch (mask) { |
| case kSA_FLFR: return "Front Left/Right"; |
| case kSA_LFE: return "LFE"; |
| case kSA_FC: return "Front Center"; |
| case kSA_RLRR: return "Rear Left/Right"; |
| case kSA_RC: return "Rear Center"; |
| case kSA_FLCFRC: return "Front Left/Right Center"; |
| case kSA_RLCRRC: return "Rear Left/Right Center"; |
| case kSA_FLWFRW: return "Front Left/Right Wide"; |
| case kSA_FLHFRH: return "Front Left/Right High"; |
| case kSA_TC: return "Top Center (overhead)"; |
| case kSA_FCH: return "Front Center High"; |
| default: return "unknown"; |
| } |
| } |
| |
| } // namespace android |
| #endif // __cplusplus |
