| /* AudioUtil.cpp |
| * |
| * Copyright (C) 2012 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 "AudioUtil" |
| //#define LOG_NDEBUG 0 |
| #include <utils/Log.h> |
| |
| #include "AudioUtil.h" |
| |
| int AudioUtil::printFormatFromEDID(unsigned char format) { |
| switch (format) { |
| case LPCM: |
| ALOGV("Format:LPCM"); |
| break; |
| case AC3: |
| ALOGV("Format:AC-3"); |
| break; |
| case MPEG1: |
| ALOGV("Format:MPEG1 (Layers 1 & 2)"); |
| break; |
| case MP3: |
| ALOGV("Format:MP3 (MPEG1 Layer 3)"); |
| break; |
| case MPEG2_MULTI_CHANNEL: |
| ALOGV("Format:MPEG2 (multichannel)"); |
| break; |
| case AAC: |
| ALOGV("Format:AAC"); |
| break; |
| case DTS: |
| ALOGV("Format:DTS"); |
| break; |
| case ATRAC: |
| ALOGV("Format:ATRAC"); |
| break; |
| case SACD: |
| ALOGV("Format:One-bit audio aka SACD"); |
| break; |
| case DOLBY_DIGITAL_PLUS: |
| ALOGV("Format:Dolby Digital +"); |
| break; |
| case DTS_HD: |
| ALOGV("Format:DTS-HD"); |
| break; |
| case MAT: |
| ALOGV("Format:MAT (MLP)"); |
| break; |
| case DST: |
| ALOGV("Format:DST"); |
| break; |
| case WMA_PRO: |
| ALOGV("Format:WMA Pro"); |
| break; |
| default: |
| ALOGV("Invalid format ID...."); |
| break; |
| } |
| return format; |
| } |
| |
| int AudioUtil::getSamplingFrequencyFromEDID(unsigned char byte) { |
| int nFreq = 0; |
| |
| if (byte & BIT(6)) { |
| ALOGV("192kHz"); |
| nFreq = 192000; |
| } else if (byte & BIT(5)) { |
| ALOGV("176kHz"); |
| nFreq = 176000; |
| } else if (byte & BIT(4)) { |
| ALOGV("96kHz"); |
| nFreq = 96000; |
| } else if (byte & BIT(3)) { |
| ALOGV("88.2kHz"); |
| nFreq = 88200; |
| } else if (byte & BIT(2)) { |
| ALOGV("48kHz"); |
| nFreq = 48000; |
| } else if (byte & BIT(1)) { |
| ALOGV("44.1kHz"); |
| nFreq = 44100; |
| } else if (byte & BIT(0)) { |
| ALOGV("32kHz"); |
| nFreq = 32000; |
| } |
| return nFreq; |
| } |
| |
| int AudioUtil::getBitsPerSampleFromEDID(unsigned char byte, |
| unsigned char format) { |
| int nBitsPerSample = 0; |
| if (format == 1) { |
| if (byte & BIT(2)) { |
| ALOGV("24bit"); |
| nBitsPerSample = 24; |
| } else if (byte & BIT(1)) { |
| ALOGV("20bit"); |
| nBitsPerSample = 20; |
| } else if (byte & BIT(0)) { |
| ALOGV("16bit"); |
| nBitsPerSample = 16; |
| } |
| } else { |
| ALOGV("not lpcm format, return 0"); |
| return 0; |
| } |
| return nBitsPerSample; |
| } |
| |
| bool AudioUtil::getHDMIAudioSinkCaps(EDID_AUDIO_INFO* pInfo) { |
| unsigned char channels[16]; |
| unsigned char formats[16]; |
| unsigned char frequency[16]; |
| unsigned char bitrate[16]; |
| unsigned char* data = NULL; |
| unsigned char* original_data_ptr = NULL; |
| int count = 0; |
| bool bRet = false; |
| const char* file = "/sys/class/graphics/fb1/audio_data_block"; |
| FILE* fpaudiocaps = fopen(file, "rb"); |
| if (fpaudiocaps) { |
| ALOGV("opened audio_caps successfully..."); |
| fseek(fpaudiocaps, 0, SEEK_END); |
| long size = ftell(fpaudiocaps); |
| ALOGV("audiocaps size is %ld\n",size); |
| data = (unsigned char*) malloc(size); |
| if (data) { |
| fseek(fpaudiocaps, 0, SEEK_SET); |
| original_data_ptr = data; |
| fread(data, 1, size, fpaudiocaps); |
| } |
| fclose(fpaudiocaps); |
| } else { |
| ALOGE("failed to open audio_caps"); |
| } |
| |
| if (pInfo && data) { |
| int length = 0; |
| memcpy(&count, data, sizeof(int)); |
| data+= sizeof(int); |
| ALOGV("#Audio Block Count is %d",count); |
| memcpy(&length, data, sizeof(int)); |
| data += sizeof(int); |
| ALOGV("Total length is %d",length); |
| unsigned int sad[MAX_SHORT_AUDIO_DESC_CNT]; |
| int nblockindex = 0; |
| int nCountDesc = 0; |
| while (length >= MIN_AUDIO_DESC_LENGTH && count < MAX_SHORT_AUDIO_DESC_CNT) { |
| sad[nblockindex] = (unsigned int)data[0] + ((unsigned int)data[1] << 8) |
| + ((unsigned int)data[2] << 16); |
| nblockindex+=1; |
| nCountDesc++; |
| length -= MIN_AUDIO_DESC_LENGTH; |
| data += MIN_AUDIO_DESC_LENGTH; |
| } |
| memset(pInfo, 0, sizeof(EDID_AUDIO_INFO)); |
| pInfo->nAudioBlocks = nCountDesc; |
| ALOGV("Total # of audio descriptors %d",nCountDesc); |
| int nIndex = 0; |
| while (nCountDesc--) { |
| channels [nIndex] = (sad[nIndex] & 0x7) + 1; |
| formats [nIndex] = (sad[nIndex] & 0xFF) >> 3; |
| frequency[nIndex] = (sad[nIndex] >> 8) & 0xFF; |
| bitrate [nIndex] = (sad[nIndex] >> 16) & 0xFF; |
| nIndex++; |
| } |
| bRet = true; |
| for (int i = 0; i < pInfo->nAudioBlocks; i++) { |
| ALOGV("AUDIO DESC BLOCK # %d\n",i); |
| |
| pInfo->AudioBlocksArray[i].nChannels = channels[i]; |
| ALOGV("pInfo->AudioBlocksArray[i].nChannels %d\n", pInfo->AudioBlocksArray[i].nChannels); |
| |
| ALOGV("Format Byte %d\n", formats[i]); |
| pInfo->AudioBlocksArray[i].nFormatId = (EDID_AUDIO_FORMAT_ID)printFormatFromEDID(formats[i]); |
| ALOGV("pInfo->AudioBlocksArray[i].nFormatId %d",pInfo->AudioBlocksArray[i].nFormatId); |
| |
| ALOGV("Frequency Byte %d\n", frequency[i]); |
| pInfo->AudioBlocksArray[i].nSamplingFreq = getSamplingFrequencyFromEDID(frequency[i]); |
| ALOGV("pInfo->AudioBlocksArray[i].nSamplingFreq %d",pInfo->AudioBlocksArray[i].nSamplingFreq); |
| |
| ALOGV("BitsPerSample Byte %d\n", bitrate[i]); |
| pInfo->AudioBlocksArray[i].nBitsPerSample = getBitsPerSampleFromEDID(bitrate[i],formats[i]); |
| ALOGV("pInfo->AudioBlocksArray[i].nBitsPerSample %d",pInfo->AudioBlocksArray[i].nBitsPerSample); |
| } |
| getSpeakerAllocation(pInfo); |
| } |
| if (original_data_ptr) |
| free(original_data_ptr); |
| |
| return bRet; |
| } |
| |
| bool AudioUtil::getSpeakerAllocation(EDID_AUDIO_INFO* pInfo) { |
| int count = 0; |
| bool bRet = false; |
| unsigned char* data = NULL; |
| unsigned char* original_data_ptr = NULL; |
| const char* spkrfile = "/sys/class/graphics/fb1/spkr_alloc_data_block"; |
| FILE* fpspkrfile = fopen(spkrfile, "rb"); |
| if(fpspkrfile) { |
| ALOGV("opened spkr_alloc_data_block successfully..."); |
| fseek(fpspkrfile,0,SEEK_END); |
| long size = ftell(fpspkrfile); |
| ALOGV("fpspkrfile size is %ld\n",size); |
| data = (unsigned char*)malloc(size); |
| if(data) { |
| original_data_ptr = data; |
| fseek(fpspkrfile,0,SEEK_SET); |
| fread(data,1,size,fpspkrfile); |
| } |
| fclose(fpspkrfile); |
| } else { |
| ALOGE("failed to open fpspkrfile"); |
| } |
| |
| if(pInfo && data) { |
| int length = 0; |
| memcpy(&count, data, sizeof(int)); |
| ALOGV("Count is %d",count); |
| data += sizeof(int); |
| memcpy(&length, data, sizeof(int)); |
| ALOGV("Total length is %d",length); |
| data+= sizeof(int); |
| ALOGV("Total speaker allocation Block count # %d\n",count); |
| bRet = true; |
| for (int i = 0; i < count; i++) { |
| ALOGV("Speaker Allocation BLOCK # %d\n",i); |
| pInfo->nSpeakerAllocation[0] = data[0]; |
| pInfo->nSpeakerAllocation[1] = data[1]; |
| pInfo->nSpeakerAllocation[2] = data[2]; |
| ALOGV("pInfo->nSpeakerAllocation %x %x %x\n", data[0],data[1],data[2]); |
| |
| |
| if (pInfo->nSpeakerAllocation[0] & BIT(7)) { |
| ALOGV("FLW/FRW"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(6)) { |
| ALOGV("RLC/RRC"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(5)) { |
| ALOGV("FLC/FRC"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(4)) { |
| ALOGV("RC"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(3)) { |
| ALOGV("RL/RR"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(2)) { |
| ALOGV("FC"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(1)) { |
| ALOGV("LFE"); |
| } else if (pInfo->nSpeakerAllocation[0] & BIT(0)) { |
| ALOGV("FL/FR"); |
| } |
| |
| if (pInfo->nSpeakerAllocation[1] & BIT(2)) { |
| ALOGV("FCH"); |
| } else if (pInfo->nSpeakerAllocation[1] & BIT(1)) { |
| ALOGV("TC"); |
| } else if (pInfo->nSpeakerAllocation[1] & BIT(0)) { |
| ALOGV("FLH/FRH"); |
| } |
| } |
| } |
| if (original_data_ptr) |
| free(original_data_ptr); |
| return bRet; |
| } |
