Home | History | Annotate | Download | only in libaudio
      1 /*
      2 **
      3 ** Copyright 2014, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 #define LOG_TAG "AudioHAL:alsa_utils"
     19 
     20 #include "alsa_utils.h"
     21 
     22 #ifndef ALSA_UTILS_PRINT_FORMATS
     23 #define ALSA_UTILS_PRINT_FORMATS  1
     24 #endif
     25 
     26 int find_alsa_card_by_name(const char* name) {
     27     int card_id = 0;
     28     int ret = -1;
     29     int fd;
     30 
     31     do {
     32         int fd;
     33         int amt;
     34         char tmp[256];
     35 
     36         snprintf(tmp, sizeof(tmp), "/proc/asound/card%d/id", card_id);
     37         tmp[sizeof(tmp) - 1] = 0;
     38         fd = open(tmp, O_RDONLY);
     39         if (fd < 0)
     40             break;
     41 
     42         amt = read(fd, tmp, sizeof(tmp) - 1);
     43         if (amt > 0) {
     44             // replace the '\n' at the end of the proc file with '\0'
     45             tmp[amt - 1] = 0;
     46             if (!strcmp(name, tmp))
     47                 ret = card_id;
     48         }
     49 
     50         close(fd);
     51 
     52         card_id++;
     53     } while (ret < 0);
     54 
     55     ALOGI("%s: returning card %d for name %s", __func__, ret, name);
     56     return ret;
     57 }
     58 
     59 #ifdef __cplusplus
     60 #include <tinyalsa/asoundlib.h>
     61 #include <utils/misc.h>
     62 
     63 namespace android {
     64 
     65 static const char *kCtrlNames[] = {
     66     "Basic Audio Supported",
     67     "Speaker Allocation",
     68     "Audio Mode Count",
     69     "Audio Mode To Query",
     70     "Query Mode : Format",
     71     "Query Mode : Max Ch Count",
     72     "Query Mode : Sample Rate Mask",
     73     "Query Mode : PCM Bits/Sample Mask",
     74     "Query Mode : Max Compressed Bitrate"
     75 };
     76 static const size_t kCtrlCount    = sizeof(kCtrlNames)/sizeof(*kCtrlNames);
     77 static const size_t kBasicAudNdx  = 0;
     78 static const size_t kSpeakerAlloc = 1;
     79 static const size_t kModeCntNdx   = 2;
     80 static const size_t kModeSelNdx   = 3;
     81 static const size_t kFmtNdx       = 4;
     82 static const size_t kMaxChCntNdx  = 5;
     83 static const size_t kSampRateNdx  = 6;
     84 static const size_t kBPSNdx       = 7;
     85 static const size_t kMaxCompBRNdx = 8;
     86 
     87 HDMIAudioCaps::HDMIAudioCaps()
     88 {
     89     // Its unlikely we will need storage for more than 16 modes, but if we do,
     90     // the vector will resize for us.
     91     mModes.setCapacity(16);
     92     reset();
     93 }
     94 
     95 bool HDMIAudioCaps::loadCaps(int ALSADeviceID) {
     96     bool ret = false;
     97     struct mixer* mixer = NULL;
     98     struct mixer_ctl* ctrls[kCtrlCount] = {NULL};
     99     int tmp, mode_cnt;
    100     Mutex::Autolock _l(mLock);
    101 
    102     ALOGE("%s: start", __func__);
    103 
    104     reset_l();
    105 
    106     // Open the mixer for the chosen ALSA device
    107     if (NULL == (mixer = mixer_open(ALSADeviceID))) {
    108         ALOGE("%s: mixer_open(%d) failed", __func__, ALSADeviceID);
    109         goto bailout;
    110     }
    111 
    112     // Gather handles to all of the controls we will need in order to enumerate
    113     // the audio capabilities of this HDMI link.  No need to free/release these
    114     // later, they are just pointers into the tinyalsa mixer structure itself.
    115     for (size_t i = 0; i < kCtrlCount; ++i) {
    116         ctrls[i] = mixer_get_ctl_by_name(mixer, kCtrlNames[i]);
    117         if (NULL == ctrls[i]) {
    118             ALOGE("%s: mixer_get_ctrl_by_name(%s) failed", __func__, kCtrlNames[i]);
    119             goto bailout;
    120 	}
    121     }
    122 
    123     // Start by checking to see if this HDMI connection supports even basic
    124     // audio.  If it does not, there is no point in proceeding.
    125     if ((tmp = mixer_ctl_get_value(ctrls[kBasicAudNdx], 0)) <= 0) {
    126         ALOGI("%s: Basic audio not supported by attached device", __func__);
    127         goto bailout;
    128     }
    129 
    130     // Looks like we support basic audio.  Get a count of the available
    131     // non-basic modes.
    132     mBasicAudioSupported = true;
    133     if ((mode_cnt = mixer_ctl_get_value(ctrls[kModeCntNdx], 0)) < 0)
    134         goto bailout;
    135 
    136     // Fetch the speaker allocation data block, if available.
    137     if ((tmp = mixer_ctl_get_value(ctrls[kSpeakerAlloc], 0)) < 0)
    138         goto bailout;
    139     mSpeakerAlloc = static_cast<uint16_t>(tmp);
    140     ALOGI("%s: Speaker Allocation Map for attached device is: 0x%hx", __func__, mSpeakerAlloc);
    141 
    142     // If there are no non-basic modes available, then we are done.  Be sure to
    143     // flag this as a successful operation.
    144     if (!mode_cnt) {
    145         ret = true;
    146         goto bailout;
    147     }
    148 
    149     // Now enumerate the non-basic modes.  Any errors at this point in time
    150     // should indicate that the HDMI cable was unplugged and we should just
    151     // abort with an empty set of audio capabilities.
    152     for (int i = 0; i < mode_cnt; ++i) {
    153         Mode m;
    154 
    155         // Pick the mode we want to fetch info for.
    156         if (mixer_ctl_set_value(ctrls[kModeSelNdx], 0, i) < 0)
    157             goto bailout;
    158 
    159         // Now fetch the common fields.
    160         if ((tmp = mixer_ctl_get_value(ctrls[kFmtNdx], 0)) < 0)
    161             goto bailout;
    162         m.fmt = static_cast<AudFormat>(tmp);
    163         ALOGI("Got mode %d from ALSA driver.", m.fmt);
    164 
    165         if ((tmp = mixer_ctl_get_value(ctrls[kMaxChCntNdx], 0)) < 0)
    166             goto bailout;
    167         m.max_ch = static_cast<uint32_t>(tmp);
    168 
    169         if ((tmp = mixer_ctl_get_value(ctrls[kSampRateNdx], 0)) < 0)
    170             goto bailout;
    171         m.sr_bitmask = static_cast<uint32_t>(tmp);
    172 
    173         // Now for the mode dependent fields.  Only LPCM has the bits-per-sample
    174         // mask.  Only AC3 through ATRAC have the compressed bitrate field.
    175         m.bps_bitmask = 0;
    176         m.comp_bitrate = 0;
    177 
    178         if (m.fmt == kFmtLPCM) {
    179             if ((tmp = mixer_ctl_get_value(ctrls[kBPSNdx], 0)) < 0)
    180                 goto bailout;
    181             m.bps_bitmask = static_cast<uint32_t>(tmp);
    182         } else if ((m.fmt >= kFmtAC3) && (m.fmt <= kFmtATRAC)) { // FIXME ATRAC is not last format!?
    183             // FIXME SHould we extend the range up to kFmtDTSHD or kFmtMPGSUR?
    184             if ((tmp = mixer_ctl_get_value(ctrls[kMaxCompBRNdx], 0)) < 0)
    185                 goto bailout;
    186             m.comp_bitrate = static_cast<uint32_t>(tmp);
    187         }
    188 
    189         // Finally, sanity check the info.  If it passes, add it to the vector
    190         // of available modes.
    191         if (sanityCheckMode(m))  {
    192             ALOGI("Passed sanity check for mode %d from ALSA driver.", m.fmt);
    193             mModes.add(m);
    194         }
    195     }
    196 
    197     // Looks like we managed to enumerate all of the modes before someone
    198     // unplugged the HDMI cable.  Signal success and get out.
    199     ret = true;
    200 
    201 bailout:
    202     if (NULL != mixer)
    203         mixer_close(mixer);
    204 
    205     if (!ret)
    206         reset_l();
    207 
    208     return ret;
    209 }
    210 
    211 void HDMIAudioCaps::reset() {
    212     Mutex::Autolock _l(mLock);
    213     reset_l();
    214 }
    215 
    216 void HDMIAudioCaps::reset_l() {
    217     mBasicAudioSupported = false;
    218     mSpeakerAlloc = 0;
    219     mModes.clear();
    220 }
    221 
    222 void HDMIAudioCaps::getFmtsForAF(String8& fmts) {
    223     Mutex::Autolock _l(mLock);
    224     fmts.clear();
    225 
    226     // If the sink does not support basic audio, then it supports no audio.
    227     if (!mBasicAudioSupported) {
    228         ALOGI("ALSAFORMATS: basic audio not supported");
    229         return;
    230     }
    231 
    232     // These names must match formats in android.media.AudioFormat
    233     fmts.append("AUDIO_FORMAT_PCM_16_BIT|AUDIO_FORMAT_PCM_8_24_BIT");
    234     // TODO: when we can start to expect 20 and 24 bit audio modes coming from
    235     // AF, we need to implement support to enumerate those modes.
    236 
    237     for (size_t i = 0; i < mModes.size(); ++i) {
    238         switch (mModes[i].fmt) {
    239             case kFmtAC3:
    240                 fmts.append("|AUDIO_FORMAT_AC3");
    241                 break;
    242             case kFmtEAC3:
    243                 fmts.append("|AUDIO_FORMAT_E_AC3");
    244                 break;
    245             case kFmtDTS:
    246                 fmts.append("|AUDIO_FORMAT_DTS");
    247                 break;
    248             case kFmtDTSHD:
    249                 fmts.append("|AUDIO_FORMAT_DTS_HD");
    250                 break;
    251             default:
    252                 break;
    253         }
    254     }
    255     // HDMI supports IEC61937 S/PDIF audio wrapper.
    256     fmts.append("|AUDIO_FORMAT_IEC61937");
    257 
    258 #if ALSA_UTILS_PRINT_FORMATS
    259     ALOGI("ALSAFORMATS: formats = %s", fmts.string());
    260 
    261     for (size_t i = 0; i < mModes.size(); ++i) {
    262         ALOGI("ALSAFORMATS: ------- fmt[%d] = 0x%08X = %s",
    263             i, mModes[i].fmt, fmtToString(mModes[i].fmt));
    264         ALOGI("ALSAFORMATS:   comp_bitrate[%d] = 0x%08X = %d",
    265             i, mModes[i].comp_bitrate, mModes[i].comp_bitrate);
    266         ALOGI("ALSAFORMATS:   max_ch[%d] = 0x%08X = %d",
    267             i, mModes[i].max_ch, mModes[i].max_ch);
    268         ALOGI("ALSAFORMATS:   bps_bitmask[%d] = 0x%08X", i, mModes[i].bps_bitmask);
    269         uint32_t bpsm = mModes[i].bps_bitmask;
    270         while(bpsm) {
    271             uint32_t bpsm_next = bpsm & (bpsm - 1);
    272             uint32_t bpsm_single = bpsm ^ bpsm_next;
    273             if (bpsm_single) {
    274                 ALOGI("ALSAFORMATS:      bits  = %d", bpsMaskToBPS(bpsm_single));
    275             }
    276             bpsm = bpsm_next;
    277         }
    278         ALOGI("ALSAFORMATS:   sr_bitmask[%d] = 0x%08X", i, mModes[i].sr_bitmask);
    279         uint32_t srs = mModes[i].sr_bitmask;
    280         while(srs) {
    281             uint32_t srs_next = srs & (srs - 1);
    282             uint32_t srs_single = srs ^ srs_next;
    283             if (srs_single) {
    284                 ALOGI("ALSAFORMATS:      srate = %d", srMaskToSR(srs_single));
    285             }
    286             srs = srs_next;
    287         }
    288     }
    289 #endif /* ALSA_UTILS_PRINT_FORMATS */
    290 }
    291 
    292 /* static */
    293 HDMIAudioCaps::AudFormat HDMIAudioCaps::alsaFormatFromAndroidFormat(audio_format_t format)
    294 {
    295     AudFormat alsaFormat = kFmtInvalid;
    296     switch (audio_get_main_format(format)) {
    297         case AUDIO_FORMAT_PCM: alsaFormat = kFmtLPCM; break;
    298         case AUDIO_FORMAT_AC3: alsaFormat = kFmtAC3; break;
    299         case AUDIO_FORMAT_E_AC3: alsaFormat = kFmtAC3; break; // FIXME should this be kFmtEAC3?
    300         case AUDIO_FORMAT_DTS: alsaFormat = kFmtDTS; break;
    301         case AUDIO_FORMAT_DTS_HD: alsaFormat = kFmtDTSHD; break;
    302         case AUDIO_FORMAT_IEC61937: alsaFormat = kFmtLPCM; break;
    303         default:
    304             ALOGE("supportsFormat() says format %#x not supported", format);
    305             break;
    306     }
    307     return alsaFormat;
    308 }
    309 
    310 const HDMIAudioCaps::Mode *HDMIAudioCaps::getModeForFormat(HDMIAudioCaps::AudFormat format)
    311 {
    312     for (size_t i = 0; i < mModes.size(); ++i) {
    313         if (mModes[i].fmt == format) {
    314             return &mModes[i];
    315         }
    316     }
    317     return nullptr;
    318 }
    319 
    320 void HDMIAudioCaps::getRatesForAF(String8& rates, audio_format_t format) {
    321     Mutex::Autolock _l(mLock);
    322     rates.clear();
    323 
    324     // If the sink does not support basic audio, then it supports no audio.
    325     if (!mBasicAudioSupported)
    326         return;
    327 
    328     uint32_t tmp = 0;
    329     // No format provided: returns rates for format with max channels
    330     if (format == AUDIO_FORMAT_INVALID) {
    331         ssize_t ndx = getMaxChModeNdx_l();
    332         if (ndx >= 0)
    333             tmp = mModes[ndx].sr_bitmask;
    334     } else {
    335         AudFormat alsaFormat = alsaFormatFromAndroidFormat(format);
    336         if (alsaFormat == kFmtInvalid) {
    337             return;
    338         }
    339         const Mode *mode =  getModeForFormat(alsaFormat);
    340         if (mode == nullptr) {
    341             return;
    342         }
    343         tmp = mode->sr_bitmask;
    344     }
    345     bool first = true;
    346     for (uint32_t i = 1; tmp; i <<= 1) {
    347         if (i & tmp) {
    348             rates.appendFormat(first ? "%d" : "|%d", srMaskToSR(i));
    349             first = false;
    350             tmp &= ~i;
    351         }
    352     }
    353 }
    354 
    355 void HDMIAudioCaps::getChannelMasksForAF(String8& masks, audio_format_t format) {
    356     Mutex::Autolock _l(mLock);
    357     masks.clear();
    358     const Mode *mode = nullptr;
    359 
    360     // If the sink does not support basic audio, then it supports no audio.
    361     if (!mBasicAudioSupported)
    362         return;
    363 
    364     if (format == AUDIO_FORMAT_INVALID) {
    365         // To keep things simple, only report mode information for the mode
    366         // which supports the maximum number of channels.
    367         ssize_t ndx = getMaxChModeNdx_l();
    368         if (ndx < 0)
    369             return;
    370         mode = &mModes[ndx];
    371     } else {
    372         AudFormat alsaFormat = alsaFormatFromAndroidFormat(format);
    373         if (alsaFormat == kFmtInvalid) {
    374             return;
    375         }
    376         mode = getModeForFormat(alsaFormat);
    377         if (mode == nullptr) {
    378             return;
    379         }
    380     }
    381 
    382     if (mode != nullptr) {
    383         // allow mono for non-pcm formats, e.g. AC3
    384         if (mode->max_ch >= 1 && mode->fmt != kFmtLPCM) {
    385             masks.append("AUDIO_CHANNEL_OUT_MONO");
    386         }
    387         if (mode->max_ch >= 2) {
    388             if (masks.length()) masks.append("|");
    389             masks.append("AUDIO_CHANNEL_OUT_STEREO");
    390         }
    391         if (mode->max_ch >= 4) {
    392             if (masks.length()) masks.append("|");
    393             masks.append("AUDIO_CHANNEL_OUT_QUAD");
    394         }
    395         if (mode->max_ch >= 6) {
    396             if (masks.length()) masks.append("|");
    397             masks.append("AUDIO_CHANNEL_OUT_5POINT1");
    398         }
    399         if (mode->max_ch >= 8) {
    400             if (masks.length()) masks.append("|");
    401             masks.append("AUDIO_CHANNEL_OUT_7POINT1");
    402         }
    403     }
    404 }
    405 
    406 ssize_t HDMIAudioCaps::getMaxChModeNdx_l() {
    407     ssize_t max_ch_ndx = -1;
    408     uint32_t max_ch = 0;
    409 
    410     for (size_t i = 0; i < mModes.size(); ++i) {
    411         if (max_ch < mModes[i].max_ch) {
    412             max_ch = mModes[i].max_ch;
    413             max_ch_ndx = i;
    414         }
    415     }
    416 
    417     return max_ch_ndx;
    418 }
    419 
    420 bool HDMIAudioCaps::supportsFormat(audio_format_t format,
    421                                       uint32_t sampleRate,
    422                                       uint32_t channelCount,
    423                                       bool isIec958NonAudio) {
    424     Mutex::Autolock _l(mLock);
    425 
    426     ALOGV("supportsFormat() format = 0x%08X, sampleRate = %u, channels = 0x%08X, iec958 = %d",
    427                 format, sampleRate, channelCount, isIec958NonAudio ? 1 : 0);
    428     // If the sink does not support basic audio, then it supports no audio.
    429     if (!mBasicAudioSupported)
    430         return false;
    431 
    432     AudFormat alsaFormat = alsaFormatFromAndroidFormat(format);
    433     if (alsaFormat == kFmtInvalid)
    434         return false;
    435 
    436     isIec958NonAudio |= (format == AUDIO_FORMAT_IEC61937);
    437 
    438     // EAC3 uses a PCM sample rate of 4X the base rate.
    439     // We try to detect that situation and allow 4X rate even if the
    440     // EDID does not report that it is supported.
    441     // This rate was chosen because it is between the region of typical PCM rates
    442     // and the extreme rates used for IEC61973.
    443     // It is > 96000 and < 4*32000.
    444     const uint32_t maxReasonableRate = 100000; // FIXME review for N
    445     if (isIec958NonAudio && (alsaFormat == kFmtLPCM) && (sampleRate > maxReasonableRate)) {
    446         ALOGI("supportsFormat() dividing sample %u by 4 to test support for EAC3 over HDMI",
    447                 sampleRate);
    448         sampleRate = sampleRate / 4;
    449     }
    450 
    451     SRMask srMask;
    452     switch (sampleRate) {
    453         case 32000:  srMask = kSR_32000;  break;
    454         case 44100:  srMask = kSR_44100;  break;
    455         case 48000:  srMask = kSR_48000;  break;
    456         case 88200:  srMask = kSR_88200;  break;
    457         case 96000:  srMask = kSR_96000;  break;
    458         case 176400: srMask = kSR_176400; break;
    459         case 192000: srMask = kSR_192000; break;
    460         default: return false;
    461     }
    462 
    463     // if PCM then determine actual bits per sample.
    464     if (alsaFormat == kFmtLPCM) {
    465         BPSMask bpsMask;
    466         switch (format) {
    467         // FIXME: (legacy code). We match on 16 bits, but on Fugu we hard code to use
    468         // PCM_FORMAT_S24_LE.
    469             case AUDIO_FORMAT_PCM_16_BIT: // fall through
    470             case AUDIO_FORMAT_PCM_8_24_BIT:
    471             case AUDIO_FORMAT_IEC61937:
    472                 bpsMask = kBPS_16bit;
    473                 break;
    474             default:
    475                 return false;
    476         }
    477 
    478         // Is the caller requesting basic audio?  If so, we should be good to go.
    479         // Otherwise, we need to check the mode table.
    480         if ((2 == channelCount) && (sampleRate <= 48000))
    481             return true;
    482 
    483         // Check the modes in the table to see if there is one which
    484         // supports the caller's format.
    485         for (size_t i = 0; i < mModes.size(); ++i) {
    486             const Mode& m = mModes[i];
    487             if ((m.fmt == kFmtLPCM) &&
    488                 (m.max_ch >= channelCount) &&
    489                 (m.sr_bitmask & srMask) &&
    490                 (m.bps_bitmask & bpsMask))
    491                 return true;
    492         }
    493     } else {
    494         // Check the modes in the table to see if there is one which
    495         // supports the caller's format.
    496         for (size_t i = 0; i < mModes.size(); ++i) {
    497             const Mode& m = mModes[i];
    498             // ignore bps_bitmask
    499             if ((m.fmt == alsaFormat) &&
    500                 (m.max_ch >= channelCount) &&
    501                 (m.sr_bitmask & srMask))
    502                 return true;
    503         }
    504     }
    505 
    506     // Looks like no compatible modes were found.
    507     return false;
    508 }
    509 
    510 bool HDMIAudioCaps::sanityCheckMode(const Mode& m) {
    511     if ((m.fmt < kFmtLPCM) || (m.fmt > kFmtMPGSUR))
    512         return false;
    513 
    514     if (m.max_ch > 8)
    515         return false;
    516 
    517     if (m.sr_bitmask & ~(kSR_32000 | kSR_44100 | kSR_48000 | kSR_88200 |
    518                          kSR_96000 | kSR_176400 | kSR_192000))
    519         return false;
    520 
    521     if (m.bps_bitmask & ~(kBPS_16bit | kBPS_20bit | kBPS_24bit))
    522         return false;
    523 
    524     return true;
    525 }
    526 
    527 const char* HDMIAudioCaps::fmtToString(AudFormat fmt) {
    528     static const char* fmts[] = {
    529         "invalid", "LPCM", "AC-3", "MPEG-1", "MPEG-1 Layer 3",
    530         "MPEG-2", "AAC-LC", "DTS", "ATRAC", "DSD", "E-AC3",
    531         "DTS-HD", "MLP", "DST", "WMA Pro", "Extended" };
    532 
    533     if (fmt >= NELEM(fmts))
    534         return "invalid";
    535 
    536     return fmts[fmt];
    537 }
    538 
    539 uint32_t HDMIAudioCaps::srMaskToSR(uint32_t mask) {
    540     switch (mask) {
    541         case kSR_32000: return 32000;
    542         case kSR_44100: return 44100;
    543         case kSR_48000: return 48000;
    544         case kSR_88200: return 88200;
    545         case kSR_96000: return 96000;
    546         case kSR_176400: return 176400;
    547         case kSR_192000: return 192000;
    548         default: return 0;
    549     }
    550 }
    551 
    552 uint32_t HDMIAudioCaps::bpsMaskToBPS(uint32_t mask) {
    553     switch (mask) {
    554         case kBPS_16bit: return 16;
    555         case kBPS_20bit: return 20;
    556         case kBPS_24bit: return 24;
    557         default: return 0;
    558     }
    559 }
    560 
    561 const char* HDMIAudioCaps::saMaskToString(uint32_t mask) {
    562     switch (mask) {
    563         case kSA_FLFR:   return "Front Left/Right";
    564         case kSA_LFE:    return "LFE";
    565         case kSA_FC:     return "Front Center";
    566         case kSA_RLRR:   return "Rear Left/Right";
    567         case kSA_RC:     return "Rear Center";
    568         case kSA_FLCFRC: return "Front Left/Right Center";
    569         case kSA_RLCRRC: return "Rear Left/Right Center";
    570         case kSA_FLWFRW: return "Front Left/Right Wide";
    571         case kSA_FLHFRH: return "Front Left/Right High";
    572         case kSA_TC:     return "Top Center (overhead)";
    573         case kSA_FCH:    return "Front Center High";
    574         default: return "unknown";
    575     }
    576 }
    577 
    578 }  // namespace android
    579 #endif  // __cplusplus
    580