你好！这里是风筝的博客，
欢迎和我一起交流。
Android framework中的代码每个平台基本都是大同小异，只有Hal上代码才是厂商特制，每个平台都不相同，这里以MTK平台为例，记录下MTK平台Hal audio音频录音代码流程。
调用大致流程如下
AudioALSAHardwa: openInputStream()
AudioALSAStreamManager: openInputStream()
AudioALSAStreamIn: AudioALSAStreamIn //new AudioALSAStreamIn
AudioALSAStreamIn: set() //done, devices: 0x80000004, flags: 0, acoustics: 0x0, format: 0x1, sampleRate: 48000/48000, num_channels: 12/2, buffer_size: 3840, tempDebugflag: 0
AudioALSAStreamIn: checkOpenStreamFormat
AudioALSAStreamIn: checkOpenStreamChannels
AudioALSAStreamIn: checkOpenStreamSampleRate
AudioALSAHardware: createAudioPatch()
AudioALSAStreamManager: setParameters() //IOport = 70, keyValuePairs = input_source=1;routing=-2147483644
AudioALSAStreamIn: setParameters()
AudioALSAStreamManager: routingInputDevice()// input_device: 0x80000004 => 0x80000004
AudioALSAStreamIn: read()
AudioALSAStreamIn: open()
AudioALSAStreamManager: createCaptureHandler()
AudioALSAStreamManager: ulStreamAttributeTargetCustomization
AudioALSACaptureDataProviderNormal: AudioALSACaptureDataProviderNormal()
AudioALSACaptureDataProviderBase: AudioALSACaptureDataProviderBase()
AudioALSACaptureHandlerNormal: AudioALSACaptureHandlerNormal()
AudioALSACaptureHandlerNormal: init()
AudioALSACaptureHandlerNormal: open()//input_device = 0x80000004, input_source = 0x1, sample_rate=48000, num_channels=2 //里面配置period_count channels...
AudioALSACaptureDataProviderBase: AudioALSACaptureDataProviderBase()
AudioALSACaptureDataProviderDspRaw: AudioALSACaptureDataProviderDspRaw()
AudioALSACaptureDataClientAurisysNormal: AudioALSACaptureDataClientAurisysNormal(+) //mCaptureDataClient = new AudioALSACaptureDataClientAurisysNormal
AudioALSACaptureDataProviderBase: configStreamAttribute() //audio_mode: 0 => 0, input_device: 0x0 => 0x80000004, flag: 0x0 => 0x0, input_source: 0->1, output_device: 0x0 => 0x2, sample_rate: 0 => 48000, period_us: 0 => 0, DSP out sample_rate: 0 => 48000
AudioALSACaptureDataProviderBase: attach
AudioALSACaptureDataProviderDspRaw: open(+) //里面配置format、channels
AudioALSADeviceConfigManager: ApplyDeviceTurnonSequenceByName() DeviceName = ADDA_TO_CAPTURE1 descriptor->DeviceStatusCounte = 0
AudioALSACaptureDataProviderBase: enablePmicInputDevice
AudioALSAHardwareResourceManager: +startInputDevice()
AudioALSADeviceConfigManager: ApplyDeviceTurnonSequenceByName() DeviceName = builtin_Mic_DualMic descriptor->DeviceStatusCounte = 0
AudioALSACaptureDataProviderBase: getInputSampleRate()
AudioMTKGainController: +SetCaptureGain() //mode=0, source=1, input device=0x80000004, output device=0x2
AudioMTKGainController: ApplyMicGain()
AudioALSACaptureDataProviderDspRaw: openApHwPcm(), mPcm = 0xf2b55260
AudioDspStreamManager: addCaptureDataProvider() //添加到mCaptureDataProviderVector
AudioDspStreamManager: openCaptureDspHwPcm(), mDspHwPcm = 0xf2b55340
pthread_create(&hReadThread, NULL, AudioALSACaptureDataProviderDspRaw::readThread, (void *)this); //创建线程
AudioALSACaptureDataProviderDspRaw: +readThread()
AudioALSACaptureDataProviderBase: waitPcmStart
AudioALSACaptureDataProviderBase: pcm_start
AudioALSACaptureDataProviderBase: pcmRead
AudioALSACaptureDataProviderBase: provideCaptureDataToAllClients
AudioALSACaptureDataClientAurisysNormal: copyCaptureDataToClient() //提供数据给client，然后继续Read，如此循环
pthread_create(&hProcessThread, NULL, AudioALSACaptureDataClientAurisysNormal::processThread, (void *)this); //创建线程
AudioALSACaptureDataClientAurisysNormal: processThread
AudioALSACaptureHandlerNormal: read()
bytes = mCaptureDataClient->read(buffer, bytes);
AudioMTKStreamInInterface *AudioALSAStreamManager::openInputStream(
uint32_t devices,
int *format,
uint32_t *channels,
uint32_t *sampleRate,
status_t *status,
audio_in_acoustics_t acoustics,
uint32_t input_flag) {
//检查参数配置
if (format == NULL || channels == NULL || sampleRate == NULL || status == NULL) {
ALOGE("%s(), NULL pointer!! format = %p, channels = %p, sampleRate = %p, status = %p",
__FUNCTION__, format, channels, sampleRate, status);
if (status != NULL) { *status = INVALID_OPERATION; }
return NULL;
}
ALOGD("%s(), devices = 0x%x, format = 0x%x, channels = 0x%x, sampleRate = %d, status = %d, acoustics = 0x%x, input_flag 0x%x",
__FUNCTION__, devices, *format, *channels, *sampleRate, *status, acoustics, input_flag);
// create stream in
AudioALSAStreamIn *pAudioALSAStreamIn = new AudioALSAStreamIn();
//主要set一些参数
pAudioALSAStreamIn->set(devices, format, channels, sampleRate, status, acoustics, input_flag);
pAudioALSAStreamIn->setIdentity(mStreamInIndex);
mStreamInVector.add(mStreamInIndex, pAudioALSAStreamIn);//添加到mStreamInVector
return pAudioALSAStreamIn;
}
status_t AudioALSAStreamIn::set(
uint32_t devices,
int *format,
uint32_t *channels,
uint32_t *sampleRate,
status_t *status,
audio_in_acoustics_t acoustics, uint32_t flags) {
// check format
if (checkOpenStreamFormat(static_cast<audio_devices_t>(devices), format) == false) {
*status = BAD_VALUE;
}
// check channel mask
if (checkOpenStreamChannels(static_cast<audio_devices_t>(devices), channels) == false) {
*status = BAD_VALUE;
}
// check sample rate
if (checkOpenStreamSampleRate(static_cast<audio_devices_t>(devices), sampleRate) == false) {
*status = BAD_VALUE;
}
// config stream attribute，主要配置参数
if (*status == NO_ERROR) {
// format
mStreamAttributeTarget.audio_format = static_cast<audio_format_t>(*format);
// channel
mStreamAttributeTarget.audio_channel_mask = static_cast<audio_channel_mask_t>(*channels);
mStreamAttributeTarget.num_channels = popcount(*channels);
// sample rate
mStreamAttributeTarget.sample_rate = *sampleRate;
// devices
mStreamAttributeTarget.input_device = static_cast<audio_devices_t>(devices);
// acoustics flags
mStreamAttributeTarget.acoustics_mask = static_cast<audio_in_acoustics_t>(acoustics);
}
}
上层服务会通过setParameters下发参数给HAL，这里下发的参数是：IOport = 70, keyValuePairs = input_source=1;routing=-2147483644
status_t AudioALSAStreamIn::setParameters(const String8 &keyValuePairs) {
/// routing
if (param.getInt(keyRouting, value) == NO_ERROR) {
status = mStreamManager->routingInputDevice(this, mStreamAttributeTarget.input_device, inputdevice);
}
}
//setParameters里面解析参数，本次参数主要是要route操作
status_t AudioALSAStreamManager::routingInputDevice(AudioALSAStreamIn *pAudioALSAStreamIn,
const audio_devices_t current_input_device,
audio_devices_t input_device) {
//如果要route的device和上次的一样，则直接返回
if (input_device == AUDIO_DEVICE_NONE ||
input_device == current_input_device) {
ALOGW("-%s(), input_device(0x%x) is AUDIO_DEVICE_NONE(0x%x) or current_input_device(0x%x), return",
__FUNCTION__,
input_device, AUDIO_DEVICE_NONE, current_input_device);
return NO_ERROR;
}
//如果要切换设备，先suspend挂起
setAllInputStreamsSuspend(true, false);
standbyAllInputStreams();
if (mStreamInVector.size() > 0) {
for (size_t i = 0; i < mStreamInVector.size(); i++) {
if ((input_device == AUDIO_DEVICE_IN_FM_TUNER) || (current_input_device == AUDIO_DEVICE_IN_FM_TUNER) ||
(input_device == AUDIO_DEVICE_IN_TELEPHONY_RX) || (current_input_device == AUDIO_DEVICE_IN_TELEPHONY_RX)) {
if (pAudioALSAStreamIn == mStreamInVector[i]) {
status = mStreamInVector[i]->routing(input_device);
ASSERT(status == NO_ERROR);
}
} else {
//这里就是实际route操作
status = mStreamInVector[i]->routing(input_device);
ASSERT(status == NO_ERROR);
}
}
}
//suspend恢复
setAllInputStreamsSuspend(false, false);
}
接下来就是最重要的read调用了，上层服务会调用read函数来读取录音数据：
ssize_t AudioALSAStreamIn::read(void *buffer, ssize_t bytes) {
/// check open
if (mStandby == true) {
status = open();
}
}
open是放在read里面来做的：
status_t AudioALSAStreamIn::open() {
if (mStandby == true) {
// create capture handler
ASSERT(mCaptureHandler == NULL);
mCaptureHandler = mStreamManager->createCaptureHandler(&mStreamAttributeTarget);
if (mCaptureHandler == NULL) {
status = BAD_VALUE;
return status;
}
// open audio hardware
status = mCaptureHandler->open();
mStandby = false;
}
return status;
}
先创建CaptureHandler，不同的设备和源会创建不同的CaptureHandler执行类，之后open对应的CaptureHandler。
可以留一下createCaptureHandler的逻辑，主要还是对设备做区分：
AudioALSACaptureHandlerBase *AudioALSAStreamManager::createCaptureHandler(
// Init input stream attribute here配置stream_attribute_target
stream_attribute_target->audio_mode = mAudioMode; // set mode to stream attribute for mic gain setting
stream_attribute_target->output_devices = current_output_devices; // set output devices to stream attribute for mic gain setting and BesRecord parameter
stream_attribute_target->micmute = mMicMute;
//客制化通路，设置APP2场景可以使得normal 录音也走voip，这样就可以跑aec算法消除回声
/* StreamAttribute customization for scene */
ulStreamAttributeTargetCustomization(stream_attribute_target);
//语音唤醒
if (stream_attribute_target->input_source == AUDIO_SOURCE_HOTWORD) {
if (mAudioALSAVoiceWakeUpController->getVoiceWakeUpEnable() == false) {
mAudioALSAVoiceWakeUpController->setVoiceWakeUpEnable(true);
}
if (mVoiceWakeUpNeedOn == true) {
mAudioALSAVoiceWakeUpController->SeamlessRecordEnable();
}
pCaptureHandler = new AudioALSACaptureHandlerVOW(stream_attribute_target);
} else if (stream_attribute_target->input_source == AUDIO_SOURCE_VOICE_UNLOCK ||
stream_attribute_target->input_source == AUDIO_SOURCE_ECHO_REFERENCE) {
pCaptureHandler = new AudioALSACaptureHandlerSyncIO(stream_attribute_target);
//实网通话
} else if (isPhoneCallOpen() == true) {
pCaptureHandler = new AudioALSACaptureHandlerVoice(stream_attribute_target);
//客制化AEC场景
} else if ((stream_attribute_target->NativePreprocess_Info.PreProcessEffect_AECOn == true) ||
(stream_attribute_target->input_source == AUDIO_SOURCE_VOICE_COMMUNICATION) ||
(stream_attribute_target->input_source == AUDIO_SOURCE_CUSTOMIZATION1) || //MagiASR enable AEC
(stream_attribute_target->input_source == AUDIO_SOURCE_CUSTOMIZATION2)) { //Normal REC with AEC
AudioALSAHardwareResourceManager::getInstance()->setHDRRecord(false); // turn off HRD record for VoIP
switch (stream_attribute_target->input_device) {
case AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET: {
if (stream_attribute_target->output_devices & AUDIO_DEVICE_OUT_ALL_SCO) {
pCaptureHandler = new AudioALSACaptureHandlerAEC(stream_attribute_target);
} else {
pCaptureHandler = new AudioALSACaptureHandlerBT(stream_attribute_target);
}
break;
}
case AUDIO_DEVICE_IN_USB_DEVICE:
case AUDIO_DEVICE_IN_USB_HEADSET:
#if defined(MTK_AURISYS_FRAMEWORK_SUPPORT)
pCaptureHandler = new AudioALSACaptureHandlerAEC(stream_attribute_target);
#else
pCaptureHandler = new AudioALSACaptureHandlerUsb(stream_attribute_target);
#endif
break;
default: {
if (isAdspOptionEnable() &&
((isCaptureOffload(stream_attribute_target) && !isIEMsOn &&
!AudioALSACaptureDataProviderNormal::getInstance()->getNormalOn()) ||
isBleInputDevice(stream_attribute_target->input_device))) {
pCaptureHandler = new AudioALSACaptureHandlerDsp(stream_attribute_target);
} else {
pCaptureHandler = new AudioALSACaptureHandlerAEC(stream_attribute_target);
}
break;
}
}//switch
} else {
switch (stream_attribute_target->input_device) {
case AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET: {
pCaptureHandler = new AudioALSACaptureHandlerBT(stream_attribute_target);
break;
}
case AUDIO_DEVICE_IN_USB_DEVICE:
case AUDIO_DEVICE_IN_USB_HEADSET:
pCaptureHandler = new AudioALSACaptureHandlerUsb(stream_attribute_target);
break;
case AUDIO_DEVICE_IN_BUILTIN_MIC:
case AUDIO_DEVICE_IN_BACK_MIC:
case AUDIO_DEVICE_IN_WIRED_HEADSET:
case AUDIO_DEVICE_IN_BLE_HEADSET:
case AUDIO_DEVICE_IN_BUS:
default: {
if (AudioSmartPaController::getInstance()->isInCalibration()) {
pCaptureHandler = new AudioALSACaptureHandlerNormal(stream_attribute_target);
break;
}
if (isAdspOptionEnable() &&
!(AUDIO_INPUT_FLAG_MMAP_NOIRQ & stream_attribute_target->mAudioInputFlags) &&((isCaptureOffload(stream_attribute_target) && !isIEMsOn &&
!AudioALSACaptureDataProviderNormal::getInstance()->getNormalOn()) ||
isBleInputDevice(stream_attribute_target->input_device))) {
if (isPhoneCallOpen() == true) {
pCaptureHandler = new AudioALSACaptureHandlerVoice(stream_attribute_target);
} else {
pCaptureHandler = new AudioALSACaptureHandlerDsp(stream_attribute_target);
}
} else {
pCaptureHandler = new AudioALSACaptureHandlerNormal(stream_attribute_target);
}
break;
}
}//switch
}
// save capture handler object in vector
mCaptureHandlerVector.add(mCaptureHandlerIndex, pCaptureHandler);
return pCaptureHandler;
}
createCaptureHandler里面逻辑还是比较多的，这里我们分析AUDIO_DEVICE_IN_BUILTIN_MIC，也就是普通MIC录音场景，也就是AudioALSACaptureHandlerNormal。
status_t AudioALSACaptureHandlerNormal::open() {
if (!AudioSmartPaController::getInstance()->isInCalibration()) {
if (isAdspOptionEnable() &&
(AudioDspStreamManager::getInstance()->getDspRawInHandlerEnable(mStreamAttributeTarget->mAudioInputFlags) > 0) &&
(AudioDspStreamManager::getInstance()->getDspInHandlerEnable(mStreamAttributeTarget->mAudioInputFlags) > 0) && !isIEMsOn &&
!AudioALSACaptureDataProviderNormal::getInstance()->getNormalOn()) {
mCaptureDataClient = new AudioALSACaptureDataClientAurisysNormal(AudioALSACaptureDataProviderDspRaw::getInstance(),
mStreamAttributeTarget, NULL); // NULL: w/o AEC
} else {
mCaptureDataClient = new AudioALSACaptureDataClientAurisysNormal(AudioALSACaptureDataProviderNormal::getInstance(),
mStreamAttributeTarget, NULL); // NULL: w/o AEC
}
} else {
mCaptureDataClient = new AudioALSACaptureDataClientAurisysNormal(AudioALSACaptureDataProviderEchoRefExt::getInstance(),
mStreamAttributeTarget, NULL); // NULL: w/o AEC
}
}
这里主要走的是AudioALSACaptureDataClientAurisysNormal，DataProvider是AudioALSACaptureDataProviderDspRaw（这个后面表述）。
继续看下AudioALSACaptureDataClientAurisysNormal
AudioALSACaptureDataClientAurisysNormal::AudioALSACaptureDataClientAurisysNormal(
AudioALSACaptureDataProviderBase *pCaptureDataProvider,
stream_attribute_t *stream_attribute_target,
AudioALSACaptureDataProviderBase *pCaptureDataProviderEchoRef) {
// config attribute for input device
mCaptureDataProvider->configStreamAttribute(mStreamAttributeTarget);
// attach client to capture data provider (after data buf ready)
mCaptureDataProvider->attach(this);
// get latency (for library, but not data provider)
mLatency = (IsLowLatencyCapture()) ? UPLINK_LOW_LATENCY_MS : UPLINK_NORMAL_LATENCY_MS;
if (mAudioALSAVolumeController != NULL) {
mAudioALSAVolumeController->SetCaptureGain(mStreamAttributeTarget->audio_mode,
mStreamAttributeTarget->input_source,
mStreamAttributeTarget->input_device,
mStreamAttributeTarget->output_devices);
}
// create lib manager,aurisys用于dsp里面传递算法
CreateAurisysLibManager();
// depop，MTK在录音时会丢弃前面一段数据避免杂音
drop_ms = getDropMs(mStreamAttributeTarget);
if (drop_ms) {
if ((drop_ms % mLatency) != 0) { // drop data size need to align interrupt rate
drop_ms = ((drop_ms / mLatency) + 1) * mLatency; // cell()
}
mDropPopSize = (audio_bytes_per_sample(mStreamAttributeTarget->audio_format) *
mStreamAttributeTarget->num_channels *
mStreamAttributeTarget->sample_rate *
drop_ms) / 1000;
}
// processThread
ret = pthread_create(&hProcessThread, NULL,
AudioALSACaptureDataClientAurisysNormal::processThread,
(void *)this);
}
- 配置Attribute
- DataProvider attach，提供录音数据
- 计算Latency ，录音间隔延时
- 设置gain增益
- 创建aurisys，算法会用到
- 计算录音开头需要丢弃的数据大小mDropPopSize，避免录音开头有杂音
- 创建线程去读取录音数据
void *AudioALSACaptureDataClientAurisysNormal::processThread(void *arg) {
/* process thread created */
client->mProcessThreadLaunched = true;
/* get buffer address */
raw_ul = &client->mRawDataBuf;//ringbuf地址
processed = &client->mProcessedDataBuf;
while (client->mEnable == true) {
data_count_raw_ul = audio_ringbuf_count(raw_ul);
// data not reary, wait data
if ((data_count_raw_ul < client->mRawDataPeriodBufSize) ||
(client->IsAECEnable() == true &&
((client->mIsEchoRefDataSync == false && client->isNeedSkipSyncEchoRef() == false) ||
data_count_raw_aec < client->mEchoRefDataPeriodBufSize))) {
wait_result = AL_WAIT_MS(client->mRawDataBufLock, MAX_PROCESS_DATA_WAIT_TIME_OUT_MS);
}
// copy data
audio_pool_buf_copy_from_ringbuf(ul_in, raw_ul, client->mRawDataPeriodBufSize);
aurisys_process_ul_only(manager,
ul_in,
ul_out,
ul_aec);
// depop
if (client->mDropPopSize > 0) {
ALOGV("data_count %u, mDropPopSize %u, %dL", data_count, client->mDropPopSize, __LINE__);
if (data_count >= client->mDropPopSize) {
audio_ringbuf_drop_data(&ul_out->ringbuf, client->mDropPopSize);
data_count -= client->mDropPopSize;
client->mDropPopSize = 0;
} else {
audio_ringbuf_drop_data(&ul_out->ringbuf, data_count);
client->mDropPopSize -= data_count;
data_count = 0;
}
}
// copy to processed buf and signal read()
audio_ringbuf_copy_from_linear(processed, effect_buf, data_count);
}
pthread_exit(NULL);
return NULL;
}
线程里面会不停循环的从client->mRawDataBuf这个ringbuf的里面copy数据出来，这个数据也就是录音数据，同时会通过aurisys ul过一道算法处理，然后通过之前在AudioALSACaptureDataClientAurisysNormal算出的mDropPopSize，丢弃一段数据避免录音杂音。
那么问题来了，为什么ringbuf里面会有录音数据呢？是谁提供的呢？
这就是之前说的：DataProvider是AudioALSACaptureDataProviderDspRaw
之前在AudioALSACaptureDataClientAurisysNormal::AudioALSACaptureDataClientAurisysNormal中有调用：mCaptureDataProvider->attach(this);
mCaptureDataProvider也就是传入的AudioALSACaptureDataProviderDspRaw！
void AudioALSACaptureDataProviderBase::attach(IAudioALSACaptureDataClient *pCaptureDataClient) {
mCaptureDataClientVector.add(pCaptureDataClient->getIdentity(), pCaptureDataClient);
size = (uint32_t)mCaptureDataClientVector.size();
// open pcm interface when 1st attach
if (size == 1) {
mOpenIndex++;
open();
} else {
if (!hasLowLatencyCapture && pCaptureDataClient->IsLowLatencyCapture()) {
// update HW interrupt rate by HW sample rate
updateReadSize(getPeriodBufSize(pStreamAttr, UPLINK_NORMAL_LATENCY_MS) *
lowLatencyMs / UPLINK_NORMAL_LATENCY_MS);
if (mCaptureDataProviderType != CAPTURE_PROVIDER_DSP) {
mHardwareResourceManager->setULInterruptRate(mStreamAttributeSource.sample_rate *
lowLatencyMs / 1000);
} else if (isAdspOptionEnable()) {
AudioDspStreamManager::getInstance()->UpdateCaptureDspLatency();
}
}
enablePmicInputDevice(true);
}
}
第一次录音时，size必定等于1，所以会进入open函数：
status_t AudioALSACaptureDataProviderDspRaw::open() {
unsigned int feature_id = CAPTURE_RAW_FEATURE_ID;
//发送给DSP需要录音原数据
mAudioMessengerIPI->registerAdspFeature(feature_id);
if (AudioALSAHardwareResourceManager::getInstance()->getNumPhoneMicSupport() > 2 && mStreamAttributeSource.input_device != AUDIO_DEVICE_IN_WIRED_HEADSET) {
mApTurnOnSequence = AUDIO_CTL_ADDA_TO_CAPTURE1_4CH;
} else {
mApTurnOnSequence = AUDIO_CTL_ADDA_TO_CAPTURE1;
}
//打开对应通路控件
AudioALSADeviceConfigManager::getInstance()->ApplyDeviceTurnonSequenceByName(mApTurnOnSequence);
//配置mStreamAttributeSource参数
/* Reset frames readed counter */
mStreamAttributeSource.Time_Info.total_frames_readed = 0;
mStreamAttributeSource.sample_rate = getInputSampleRate(mStreamAttributeSource.input_device,
mStreamAttributeSource.output_devices);
mStreamAttributeSource.audio_format = AUDIO_FORMAT_PCM_8_24_BIT;
if (mStreamAttributeSource.input_device == AUDIO_DEVICE_IN_WIRED_HEADSET ||
mStreamAttributeSource.input_source == AUDIO_SOURCE_UNPROCESSED){
mStreamAttributeSource.num_channels = 1;
} else {
mStreamAttributeSource.num_channels = 2;
}
mStreamAttributeSource.latency = mlatency;
//配置mConfig
setApHwPcm();
//DMA传输完成之后的回调函数：processDmaMsgWrapper
mAudioMessengerIPI->registerDmaCbk(
TASK_SCENE_CAPTURE_RAW,
0x2000,
0xF000,
processDmaMsgWrapper,
this);
mAudioALSAVolumeController->SetCaptureGain(mStreamAttributeSource.audio_mode,
mStreamAttributeSource.input_source,
mStreamAttributeSource.input_device,
mStreamAttributeSource.output_devices);
openApHwPcm();// pcmOpen
AudioDspStreamManager::getInstance()->addCaptureDataProvider(this);//pcm_prepare pcm_start
int ret = pthread_create(&hReadThread, NULL, AudioALSACaptureDataProviderDspRaw::readThread, (void *)this);
}
open里面，主要就是操作到底层里面pcm_open和pcm_start，开始录音，然后就是最重要的readThread线程了！
void *AudioALSACaptureDataProviderDspRaw::readThread(void *arg) {
pDataProvider->waitPcmStart();
// read raw data from alsa driver
char linear_buffer[kReadBufferSizeNormal];
while (pDataProvider->mEnable == true) {
//从底层读取录音数据，放到linear_buffer
ret = pDataProvider->pcmRead(pDataProvider->mPcm, linear_buffer, kReadBufferSize);
// use ringbuf format to save buffer info
pDataProvider->mPcmReadBuf.pBufBase = linear_buffer;
pDataProvider->mPcmReadBuf.bufLen = Read_Size + 1; // +1: avoid pRead == pWrite
pDataProvider->mPcmReadBuf.pRead = linear_buffer;
pDataProvider->mPcmReadBuf.pWrite = linear_buffer + Read_Size;
pDataProvider->provideCaptureDataToAllClients(open_index);
}
pthread_exit(NULL);
return NULL;
}
重点来了，这里就是在线程中不断的从alsa底层中读取到录音数据到linear_buffer中，然后放到pDataProvider->mPcmReadBuf.pBufBase中，提供给所有clien，也就是我们AudioALSACaptureDataClientAurisysNormal。
void AudioALSACaptureDataProviderBase::provideCaptureDataToAllClients(const uint32_t open_index) {
for (size_t i = 0; i < mCaptureDataClientVector.size(); i++) {
pCaptureDataClient = mCaptureDataClientVector[i];
pCaptureDataClient->copyCaptureDataToClient(mPcmReadBuf);
}
}
类似于广播一样的机制，查询所有ClientVector，并且将录音数据提供出去。
为什么MTK要设计成这样子呢？
这样有个好处，就是使得即使有多个AudioStreamIn，但每个AudioStreamIn实例client中有各自的环形Readbuffer，从硬件来的数据会扔到各自的环形Readbuffer中，从而互不影响。
uint32_t AudioALSACaptureDataClientAurisysNormal::copyCaptureDataToClient(RingBuf pcm_read_buf) {
pcm_read_buf_wrap.base = pcm_read_buf.pBufBase;
pcm_read_buf_wrap.read = pcm_read_buf.pRead;
pcm_read_buf_wrap.write = pcm_read_buf.pWrite;
pcm_read_buf_wrap.size = pcm_read_buf.bufLen;
audio_ringbuf_copy_from_ringbuf_all(&mRawDataBuf, &pcm_read_buf_wrap);
}
最后就是将数据填装到mRawDataBuf了，这样就可以在AudioALSACaptureDataClientAurisysNormal::processThread中拿到录音数据了。
总的来说，录音流程还是比较简单的，核心就是AudioALSACaptureDataProviderDspRaw::readThread负责生产数据，AudioALSACaptureDataClientAurisysNormal::processThread负责消耗数据，一个生产者-消费者模型。
