legacy/alsa_sound/AudioUtil.cpp - LeafOS-Project/android_hardware_qcom_audio - Gitiles

 /* 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;
 }
	/* 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;
	}