程序博客网 > nas 文件拷贝 软件

android soundrecorder之二 应用层到HAL实现

来源：互联网 发布：nas 文件拷贝 软件 编辑：程序博客网 时间：2024/04/30 19:27

转载请标注原文地址：http://blog.csdn.net/uranus_wm/article/details/12748559

前一篇文章介绍了linux alsa初始化的过程，并根据dai_link创建了设备节点，提供给上层应用作为访问接口

这篇文章主要介绍下android soundrecorder从应用层到HAL层的代码框架

后面一片文章重点介绍linux部分，然后说明一下音频数据在内存中的流向和一些相关的调试方法

首先还是看图：

更正说明：tinyalsa访问设备节点应该是/dev/snd/pcmCxDxp, /dev/snd/pcmCxDxc和/dev/snd/controlCx，画图时没有确认造成笔误

这个框图大致把soundrecorder从app到framework到HAL的类图画了出来

有些子类父类继承关系没有表示出来，从soundrecorder到AudioRecord基本就是一条线下来

我也没有详细去看代码，stagefright这一块很庞大，实现了多种mime格式的编解码

音频数据生成文件保存在sd卡中应该是在MPEG4Writer这里完成的，这个没有细看

我们重点看下AudioSystem，AudioPolicyService，AudioFlinger和AudioHardware这块。

以open_record()和get_input()这两个方法为例我们看下这几个类之间的调用关系

从AudioRecord.cpp开始，文件位置：frameworks\base\media\libmedia\AudioRecord.cpp

[cpp] view plaincopyprint?
  1. status_t AudioRecord::openRecord_l( 
  2.         uint32_t sampleRate, 
  3.         uint32_t format, 
  4.         uint32_t channelMask, 
  5.         int frameCount, 
  6.         uint32_t flags, 
  7.         audio_io_handle_t input) 
  8. { 
  9.     status_t status; 
  10.     const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); 
  11.     sp<IAudioRecord> record = audioFlinger->openRecord(getpid(), input, 
  12.                                                        sampleRate, format, 
  13.                                                        channelMask, 
  14.                                                        frameCount, 
  15.                                                        ((uint16_t)flags) << 16, 
  16.                                                        &mSessionId, 
  17.                                                        &status); 
  18. ... 
  19. } 
  20. audio_io_handle_t AudioRecord::getInput_l() 
  21. { 
  22.     mInput = AudioSystem::getInput(mInputSource, 
  23.                                 mCblk->sampleRate, 
  24.                                 mFormat, 
  25.                                 mChannelMask, 
  26.                                 (audio_in_acoustics_t)mFlags, 
  27.                                 mSessionId); 
  28.     return mInput; 
  29. } 

可以看到openRecord_l()直接用AudioSystem这个静态类获取AudioFlinger这个service

[cpp] view plaincopyprint?
  1. const sp<IAudioFlinger>& AudioSystem::get_audio_flinger() 
  2. { 
  3.     Mutex::Autolock _l(gLock); 
  4.     if (gAudioFlinger.get() == 0) { 
  5.         sp<IServiceManager> sm = defaultServiceManager(); 
  6.         sp<IBinder> binder; 
  7.         do { 
  8.             binder = sm->getService(String16("media.audio_flinger")); 
  9.         } while(true); 
  10.         if (gAudioFlingerClient == NULL) { 
  11.             gAudioFlingerClient = new AudioFlingerClient(); 
  12.         }  
  13.         binder->linkToDeath(gAudioFlingerClient); 
  14.         gAudioFlinger = interface_cast<IAudioFlinger>(binder); 
  15.         gAudioFlinger->registerClient(gAudioFlingerClient); 
  16.     } 
  17.     return gAudioFlinger; 
  18. } 

这里我碰到个问题，get_audio_flinger从ServiceManager获取audio_flinger service，但是我找了半天没有找到add这个service的地方

找到的朋友可以提醒我一下

另外一个getInput_l()，这是一个通路选择的方法，android也用一个service来维护：AudioPolicyService

这个Service对应一个虚拟的硬件设备，由audio_policy_hal提供接口访问，这么做我估计是为了结构上比较清晰，但是代码看起来就有点绕了

从上面类图来看getInput_l()的调用过程：

从AudioSystem->AudioPolicyService->audio_policy_hal->AudioPolicyManagerBase->AudioPolicyCompatClient->AudioPolicyService->AudioFlinger

[cpp] view plaincopyprint?
  1. 文件位置：frameworks\base\media\libmedia\AudioSystem.cpp 
  2.  
  3. audio_io_handle_t AudioSystem::getInput(int inputSource, 
  4.                                     uint32_t samplingRate, 
  5.                                     uint32_t format, 
  6.                                     uint32_t channels, 
  7.                                     audio_in_acoustics_t acoustics, 
  8.                                     int sessionId) 
  9. { 
  10.     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); 
  11.     if (aps == 0) return 0; 
  12.     return aps->getInput(inputSource, samplingRate, format, channels, acoustics, sessionId); 
  13. } 
  14.  
  15. 文件位置：frameworks\base\services\audioflinger\AudioPolicyService.cpp 
  16.  
  17. audio_io_handle_t AudioPolicyService::getInput(int inputSource, 
  18.                                     uint32_t samplingRate, 
  19.                                     uint32_t format, 
  20.                                     uint32_t channels, 
  21.                                     audio_in_acoustics_t acoustics, 
  22.                                     int audioSession) 
  23. { 
  24.     if (mpAudioPolicy == NULL) { 
  25.         return 0; 
  26.     } 
  27.     Mutex::Autolock _l(mLock); 
  28.     audio_io_handle_t input = mpAudioPolicy->get_input(mpAudioPolicy, inputSource, samplingRate, 
  29.                                                        format, channels, acoustics); 
  30.  
  31. } 
  32.  
  33. 文件位置：hardware\libhardware_legacy\audio\audio_policy_hal.cpp 
  34.  
  35. static audio_io_handle_t ap_get_input(struct audio_policy *pol,int inputSource, 
  36.                                       uint32_t sampling_rate, 
  37.                                       uint32_t format, 
  38.                                       uint32_t channels, 
  39.                                       audio_in_acoustics_t acoustics) 
  40. { 
  41.     struct legacy_audio_policy *lap = to_lap(pol); 
  42.     return lap->apm->getInput(inputSource, sampling_rate, format, channels, 
  43.                               (AudioSystem::audio_in_acoustics)acoustics); 
  44. } 
  45.  
  46. 文件位置：hardware\libhardware_legacy\audio\AudioPolicyManagerBase.cpp 
  47.  
  48. audio_io_handle_t AudioPolicyManagerBase::getInput(int inputSource, 
  49.                                     uint32_t samplingRate, 
  50.                                     uint32_t format, 
  51.                                     uint32_t channels, 
  52.                                     AudioSystem::audio_in_acoustics acoustics) 
  53. { 
  54.     input = mpClientInterface->openInput(&inputDesc->mDevice, 
  55.                                     &inputDesc->mSamplingRate, 
  56.                                     &inputDesc->mFormat, 
  57.                                     &inputDesc->mChannels, 
  58.                                     inputDesc->mAcoustics); 
  59.  
  60. } 
  61.  
  62. 文件位置：hardware\libhardware_legacy\audio\AudioPolicyCompatClient.cpp 
  63.  
  64. audio_io_handle_t AudioPolicyCompatClient::openOutput(uint32_t *pDevices, 
  65.                                 uint32_t *pSamplingRate, 
  66.                                 uint32_t *pFormat, 
  67.                                 uint32_t *pChannels, 
  68.                                 uint32_t *pLatencyMs, 
  69.                                 AudioSystem::output_flags flags) 
  70. { 
  71.     return mServiceOps->open_output(mService, pDevices, pSamplingRate, pFormat, 
  72.                                     pChannels, pLatencyMs, 
  73.                                     (audio_policy_output_flags_t)flags); 
  74. } 
  75.  
  76. static audio_io_handle_t aps_open_input(void *service, 
  77.                                             uint32_t *pDevices, 
  78.                                             uint32_t *pSamplingRate, 
  79.                                             uint32_t *pFormat, 
  80.                                             uint32_t *pChannels, 
  81.                                             uint32_t acoustics) 
  82. { 
  83.     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); 
  84.     return af->openInput(pDevices, pSamplingRate, pFormat, pChannels, 
  85.                          acoustics); 
  86. } 

其关键就是AudioPolicyService将一个aps_ops结构体一层层传给AudioPolicyCompatClient，最后又调回到AudioPolicyService，这个地方有点绕

[cpp] view plaincopyprint?
  1. namespace { 
  2.     struct audio_policy_service_ops aps_ops = { 
  3.         open_output           : aps_open_output, 
  4.         open_duplicate_output : aps_open_dup_output, 
  5.         close_output          : aps_close_output, 
  6.         suspend_output        : aps_suspend_output, 
  7.         restore_output        : aps_restore_output, 
  8.         open_input            : aps_open_input, 
  9.         close_input           : aps_close_input, 
  10.         set_stream_volume     : aps_set_stream_volume, 
  11.         set_stream_output     : aps_set_stream_output, 
  12.         set_parameters        : aps_set_parameters, 
  13.         get_parameters        : aps_get_parameters, 
  14.         start_tone            : aps_start_tone, 
  15.         stop_tone             : aps_stop_tone, 
  16.         set_voice_volume      : aps_set_voice_volume, 
  17.         move_effects          : aps_move_effects, 
  18.     }; 
  19. }; // namespace <unnamed> 

回过头我们还是看AudioFlinger.cpp这个文件，其内部包含好几个子类

class MixerThread是一个混音器，他可以将多个音频OutputTrack和InputTrack混合到一起，像正在播放的mp3是一个OutputTrack，录音是一个InputTrack

class DirectOutputThread是指不经过混音，直接输出的thread

class RecordThread就是我们soundRecorder用到的thread

class PlaybackThread支持混音输出的thread

AudioFlinger还是增加音效，功能很强，由于我调试的时间也短，还没能完全涉及到！

AudioFlinger之所以可以实现音频数据的输入输出是因为audio_hw_hal提供了硬件抽象层接口：

文件位置：hardware\libhardware_legacy\audio\audio_hw_hal.cpp

[cpp] view plaincopyprint?
  1. static int legacy_adev_open(const hw_module_t* module,const char* name, 
  2.                             hw_device_t** device) 
  3. { 
  4.     struct legacy_audio_device *ladev; 
  5.     int ret; 
  6.     ladev = (struct legacy_audio_device *)calloc(1,sizeof(*ladev)); 
  7.     if (!ladev) 
  8.         return -ENOMEM; 
  9.  
  10.     ladev->device.common.tag = HARDWARE_DEVICE_TAG; 
  11.     ladev->device.common.version = 0; 
  12.     ladev->device.common.module = const_cast<hw_module_t*>(module); 
  13.     ladev->device.common.close = legacy_adev_close; 
  14.     ladev->device.get_supported_devices = adev_get_supported_devices; 
  15.     ladev->device.init_check = adev_init_check; 
  16.     ladev->device.set_voice_volume = adev_set_voice_volume; 
  17.     ladev->device.set_master_volume = adev_set_master_volume; 
  18.     ladev->device.set_mode = adev_set_mode; 
  19.     ladev->device.set_mic_mute = adev_set_mic_mute; 
  20.     ladev->device.get_mic_mute = adev_get_mic_mute; 
  21.     ladev->device.set_parameters = adev_set_parameters; 
  22.     ladev->device.get_parameters = adev_get_parameters; 
  23.     ladev->device.get_input_buffer_size = adev_get_input_buffer_size; 
  24.     ladev->device.open_output_stream = adev_open_output_stream; 
  25.     ladev->device.close_output_stream = adev_close_output_stream; 
  26.     ladev->device.open_input_stream = adev_open_input_stream; 
  27.     ladev->device.close_input_stream = adev_close_input_stream; 
  28.     ladev->device.dump = adev_dump; 
  29.  
  30.     ladev->hwif = createAudioHardware(); 
  31.     if (!ladev->hwif) { 
  32.         ret = -EIO; 
  33.         goto err_create_audio_hw; 
  34.     } 
  35.  
  36.     *device = &ladev->device.common; 
  37.  
  38.     return 0; 
  39. } 
  40. static struct hw_module_methods_t legacy_audio_module_methods = { 
  41.         open: legacy_adev_open 
  42. }; 
  43.  
  44. struct legacy_audio_module HAL_MODULE_INFO_SYM = { 
  45.     module: { 
  46.         common: { 
  47.             tag: HARDWARE_MODULE_TAG, 
  48.             version_major: 1, 
  49.             version_minor: 0, 
  50.             id: AUDIO_HARDWARE_MODULE_ID, 
  51.             name: "LEGACY Audio HW HAL", 
  52.             author: "The Android Open Source Project", 
  53.             methods: &legacy_audio_module_methods, 
  54.             dso : NULL, 
  55.             reserved : {0}, 
  56.         }, 
  57.     }, 
  58. }; 

不同的平台都有自己的AudioHardware具体实现

借用一本android培训书籍的框图看下AudioHardware的层级架构，作者好像是韩超


可以看到对于输入流和输出流，从JAVA层到HAL层都有一个对应的子类来负责

在AudioHardware里面录音用到的就是AudioStreamIn，如下面这个方法：

[cpp] view plaincopyprint?
  1. status_t AudioHardware::AudioStreamInALSA::getNextBuffer(struct resampler_buffer *buffer) 
  2. { 
  3.     if (mInputFramesIn == 0) { 
  4.         TRACE_DRIVER_IN(DRV_PCM_READ) 
  5.         mReadStatus = pcm_read(mPcm,(void*) mInputBuf, AUDIO_HW_IN_PERIOD_SZ * frameSize()); 
  6.         TRACE_DRIVER_OUT 
  7.         if (mReadStatus != 0) { 
  8.             buffer->raw = NULL; 
  9.             buffer->frame_count = 0; 
  10.             return mReadStatus; 
  11.         } 
  12.         mInputFramesIn = AUDIO_HW_IN_PERIOD_SZ; 
  13.     } 
  14.     buffer->frame_count = (buffer->frame_count > mInputFramesIn) ? mInputFramesIn:buffer->frame_count; 
  15.     buffer->i16 = mInputBuf + (AUDIO_HW_IN_PERIOD_SZ - mInputFramesIn) * mChannelCount; 
  16.  
  17.     return mReadStatus; 
  18. } 

这里有个pcm_read()函数就是google为了调用linux alsa提供的文件接口专门写得一个适配层，命名为tinyalsa

从AudioHardware到tinyalsa主要完成的任务就是：

  1. 设置当前系统音频模式：通话模式，录音模式还是播放模式
  2. 配置dapm通路：即main_mic还是aux_mic，spreaker还是receiver还是headset，aif1还是aif2或者aif.x
  3. 音效，音量等参数配置
  4. 读取输入的pcm数据和传送输出的pcm数据

android4.0上面AudioSystem代码基本完善，我们调试一个codec主要的工作就三点：

  1. bsp配置如i2c，micbias配置
  2. kernel dai_link实现和snd_pcm_hardware的注册
  3. 代码量最大的就是这里dapm的配置

我这里给出wolfson wm8994在4412上面的一些配置表，经过测试工作正常

dapm全称是dynamic audio power management，其主要作用就是配置codec内部的muxer和mixer，已实现路径的切换

具体来讲需要一个单独的章节，这里先贴代码：

[cpp] view plaincopyprint?
  1. typedef struct AudioMixer_tag { 
  2.     const char *ctl; 
  3.     const int   val; 
  4. } AudioMixer; 
  5.  
  6. const AudioMixer device_out_SPK[] = { 
  7. #if defined (USES_I2S_AUDIO) || defined (USES_PCM_AUDIO) 
  8. /*AIF1 to DAC1*/ 
  9.     {"DAC1L Mixer AIF1.1 Switch", 1},// "OFF", "ON" 
  10.     {"DAC1R Mixer AIF1.1 Switch", 1},// "OFF", "ON" 
  11.     {"DAC1 Switch", 1}, // "OFF OFF", "ON ON" 
  12.     {"DAC1 Volume", 96}, //[0,1..96]:[MUTE,-71.62db..0db] 0610h_0611h 
  13. /*DAC1 to SPK*/ 
  14.     {"SPKL DAC1 Switch", 1}, // "OFF", "ON" 
  15.     {"SPKL DAC1 Volume", 1},// [0..1]:[-3db..0db] 0022h 
  16.     {"SPKR DAC1 Switch", 1}, // "OFF", "ON" 
  17.     {"SPKR DAC1 Volume", 1},// [0..1]:[-3db..0db] 0023h 
  18.     {"Speaker Mixer Volume", 3}, // [0..3]:[MUTE,-12db,-6db,0db] 0022h_0023h 
  19.     {"Speaker Volume", 63},// [0..63]:[-57db..+6db] 0026h_0027h 
  20.     {"SPKL Boost SPKL Switch", 1}, // "OFF OFF", "ON ON" 
  21.     {"SPKR Boost SPKR Switch", 1},// "OFF OFF", "ON ON" 
  22.     {"Speaker Boost Volume", 7}, // [0..7]:[0db..+12db] 0025h 
  23. /*DAC1 to Headphone*/ 
  24.     {"Right Headphone Mux", 1}, // "Mixer","DAC" 
  25.     {"Left Headphone Mux", 1}, // "Mixer","DAC" 
  26.     {"Headphone Switch", 1}, // "HP MUTE","UNMUTE" 
  27. #elif defined(USES_SPDIF_AUDIO) 
  28. #endif 
  29.     {NULL, NULL} 
  30. }; 
  31. const AudioMixer device_out_RING_SPK[] = { 
  32. /*AIF1 to DAC1*/ 
  33.     {"DAC1L Mixer AIF1.1 Switch", 1},// "OFF", "ON" 
  34.     {"DAC1R Mixer AIF1.1 Switch", 1},// "OFF", "ON" 
  35.     {"DAC1 Switch", 1}, // "OFF OFF", "ON ON" 
  36.     {"DAC1 Volume", 96}, //[0,1..96]:[MUTE,-71.62db..0db] 0610h_0611h 
  37. /*DAC1 to SPK*/ 
  38.     {"SPKL DAC1 Switch", 1}, // "OFF", "ON" 
  39.     {"SPKL DAC1 Volume", 1},// [0..1]:[-3db..0db] 0022h 
  40.     {"SPKR DAC1 Switch", 1}, // "OFF", "ON" 
  41.     {"SPKR DAC1 Volume", 1},// [0..1]:[-3db..0db] 0023h 
  42.     {"Speaker Mixer Volume", 3}, // [0..3]:[MUTE,-12db,-6db,0db] 0022h_0023h 
  43.     {"Speaker Volume", 63},// [0..63]:[-57db..+6db] 0026h_0027h 
  44.     {"SPKL Boost SPKL Switch", 1}, // "OFF OFF", "ON ON" 
  45.     {"SPKR Boost SPKR Switch", 1},// "OFF OFF", "ON ON" 
  46.     {"Speaker Boost Volume", 7}, // [0..7]:[0db..+12db] 0025h 
  47.     {NULL, NULL} 
  48. }; 
  49.  
  50. const AudioMixer device_voice_RCV[] = {  
  51. #if defined (USES_I2S_AUDIO) || defined (USES_PCM_AUDIO) 
  52. //Main_MIC(IN1L N_VMID) to MIXIN to ADC to DAC2 Mixer to AIF2(ADCDAT2) 
  53. //Main_MIC(IN1L N_VMID) to MIXINL 
  54.     {"IN1L PGA IN1LN Switch", 1}, //OFF,IN1LN 
  55.     {"IN1L PGA IN1LP Switch", 1},//VMID,IN1LP 
  56.     {"IN1L Switch", 1}, //[0..1]:[MUTE..UNMUTE] ,0018h:b7 
  57.     {"IN1L Volume", 12}, //[1..31]:[-16.5db..+30db],0018h 
  58.     {"MIXINL IN1L Switch", 1}, 
  59.     {"MIXINL IN1L Volume",1},//[0..1]:[0db..+30db]],0029h 
  60. /*ADCL to AIF2ADC*/ 
  61.     {"ADCL Mux", 0}, //ADC,DMIC 
  62.     {"Left Sidetone", 0}, //_D__DMIC1,DMIC2 
  63.     {"AIF2DAC2L Mixer Left Sidetone Switch", 1},//,0604h 
  64.     //{"AIF2DAC2R Mixer Left Sidetone Switch", 1}, //,0605h 
  65.     {"DAC2 Left Sidetone Volume", 12}, //[0..12]:[-36db..0db],0603h 
  66.     {"DAC2 Right Sidetone Volume", 12},//[0..12]:[-36db..0db],0603h 
  67.     //////{"AIF2DAC2L Mixer AIF2 Switch", 1}, //,0604h ////////////////++ test 
  68.     //////{"AIF2DAC2R Mixer AIF2 Switch", 1}, //,0604h ////////////////++ test 
  69.     {"AIF2ADCL Source", 0},//Left,Right 
  70.     //{"AIF2ADCR Source", 0}, //Left,Right 
  71.     {"AIF2ADC Mux", 0}, //AIF2ADCDAT,AIF3DACDAT 
  72.     //{"AIF2ADC Volume", 119}, //[0,1..119]:[MUTE,-71.625db..+17.625db],0500h_0501h default:C0 eq 0db 
  73.     {"DAC2 Switch", 1}, //[0..1]:[UNMUTE..MUTE] 0612h_0613h 
  74.     {"DAC2 Volume", 96}, //[0,1..96]:[MUTE,-71.62db..0db] 0612h_0613h 
  75.  
  76. //BB_in AIF2DAC(DACDAT2) to DAC1_R to MIXOUTL_R to SPKMIXL_R to SPK 
  77. /*MIXIN to MIXOUT for mic to hp test*/ 
  78.     //{"Left Output Mixer Left Input Switch", 1}, // "OFF", "ON" ,002dh ///////////////+ 
  79.     //{"Right Output Mixer Left Input Switch", 1}, // "OFF", "ON" ,002eh //////////////+ 
  80. /*ADCL to DAC1 for sidetone*/ 
  81.     {"DAC1L Mixer Left Sidetone Switch", 1}, 
  82.     {"DAC1R Mixer Left Sidetone Switch", 1}, 
  83.     {"DAC1 Left Sidetone Volume", 0}, //[0..12]:[-36db..0db],0603h 
  84.     {"DAC1 Right Sidetone Volume", 0},//[0..12]:[-36db..0db],0603h 
  85. /*AIF2DAC to DAC1*/ 
  86.     {"AIF2DAC Mux", 0}, // AIF2DACDAT,AIF3DACDAT 
  87.     {"DAC1L Mixer AIF2 Switch", 1},// "OFF", "ON" ,0601h 
  88.     {"DAC1R Mixer AIF2 Switch", 1}, // "OFF", "ON" ,0602h 
  89.     {"DAC1 Switch", 1}, // "OFF OFF", "ON ON" 
  90. /*DAC1 to HP*/ 
  91.     {"Left Output Mixer DAC Switch", 1},// "OFF OFF", "ON ON" 
  92.     {"Right Output Mixer DAC Switch", 1},// "OFF OFF", "ON ON" 
  93.     {"Output Switch", 1},// "OFF OFF", "ON ON" 
  94.      
  95.     {"Right Headphone Mux", 0},// "Mixer","DAC" 
  96.     {"Left Headphone Mux", 0},  // "Mixer","DAC" 
  97.     {"Headphone Switch", 1},// "HP MUTE","UNMUTE" 
  98. #elif defined(USES_SPDIF_AUDIO) 
  99. #endif 
  100.     {NULL, NULL} 
  101. }; 
  102. const AudioMixer device_input_Main_Mic[] = { 
  103. #if defined (USES_I2S_AUDIO) || defined (USES_PCM_AUDIO) 
  104. //Main_MIC(IN1L N_VMID) to MIXIN to ADC to DAC2 Mixer to AIF2(ADCDAT2) 
  105. //Main_MIC(IN1L N_VMID) to MIXINL 
  106.     {"IN1L PGA IN1LN Switch", 1}, //OFF,IN1LN 
  107.     {"IN1L PGA IN1LP Switch", 1},//VMID,IN1LP 
  108.     {"IN1L Switch", 1}, //[0..1]:[MUTE..UNMUTE] ,0018h:b7 
  109.     {"IN1L Volume", 12}, //[1..31]:[-16.5db..+30db],0018h 
  110.     {"MIXINL IN1L Switch", 1}, 
  111.     {"MIXINL IN1L Volume",1},//[0..1]:[0db..+30db]],0029h 
  112. /*ADCL to AIF1ADC*/ 
  113.     {"ADCL Mux", 0}, //ADC,DMIC 
  114.     {"AIF1ADCL Source", 0}, //Left,Right 
  115.     {"AIF1ADCR Source", 0},//Left,Right 
  116.     {"AIF1ADC1 Volume", 119}, //[0,1..119]:[MUTE,-71.625db..+17.625db],0400h_0401h default:C0 eq 0db 
  117.     {"AIF1ADC1L DRC Switch",1}, 
  118.     {"AIF1ADC1R DRC Switch",1}, 
  119.     {"AIF1ADC1L Mixer ADC/DMIC Switch",1}, 
  120.     {"AIF1ADC1R Mixer ADC/DMIC Switch",1}, 
  121. #elif defined(USES_SPDIF_AUDIO) 
  122. #endif 
  123.     {NULL, NULL} 
  124. }; 

每一行的{}里面有两个值，用“，”分开，实际上前一个值是有两部分组成，分别是“dest ctrl+control ctrl”，省略了src ctrl；后一个值通常是数字

注意这里的数字1不是true的意思，而是当前route里面的第几个的意思，是个index值，这个需要在wm8994驱动里面取对应查找

再说说AudioHardare

文件位置：\device\samsung\smdk_common\lib_audio\AudioHardware.cpp

重点关注下下面这些函数，当然函数很多，还得自己慢慢看代码

[cpp] view plaincopyprint?
  1. struct mixer *AudioHardware::openMixer_l() 
  2. { 
  3.     LOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 
  4.     if (mMixerOpenCnt++ == 0) { 
  5.         if (mMixer != NULL) { 
  6.             LOGE("openMixer_l() mMixerOpenCnt == 0 and mMixer == %p\n", mMixer); 
  7.             mMixerOpenCnt--; 
  8.             return NULL; 
  9.         } 
  10.         TRACE_DRIVER_IN(DRV_MIXER_OPEN) 
  11.         mMixer = mixer_open(0); 
  12.         TRACE_DRIVER_OUT 
  13.         if (mMixer == NULL) { 
  14.             LOGE("openMixer_l() cannot open mixer"); 
  15.             mMixerOpenCnt--; 
  16.             return NULL; 
  17.         } 
  18.     } 
  19.     return mMixer; 
  20. } 
  21.  
  22. struct pcm *AudioHardware::openPcmOut_l() 
  23. { 
  24.     LOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 
  25.     if (mPcmOpenCnt++ == 0) { 
  26.         if (mPcm != NULL) { 
  27.             LOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm); 
  28.             mPcmOpenCnt--; 
  29.             return NULL; 
  30.         } 
  31.         unsigned flags = PCM_OUT; 
  32.  
  33.         struct pcm_config config = { 
  34.             channels : 2, 
  35.             rate : AUDIO_HW_OUT_SAMPLERATE, 
  36.             period_size : AUDIO_HW_OUT_PERIOD_SZ, 
  37.             period_count : AUDIO_HW_OUT_PERIOD_CNT, 
  38.             format : PCM_FORMAT_S16_LE, 
  39.             start_threshold : 0, 
  40.             stop_threshold : 0, 
  41.             silence_threshold : 0, 
  42.         }; 
  43.  
  44.         TRACE_DRIVER_IN(DRV_PCM_OPEN) 
  45. #if defined(USES_PCM_AUDIO) || defined(USES_SPDIF_AUDIO) 
  46.         mPcm = pcm_open(0, 0, flags, &config); 
  47. #elif defined(USES_I2S_AUDIO) 
  48.         mPcm = pcm_open(0, 1, flags, &config); 
  49. #endif 
  50.         TRACE_DRIVER_OUT 
  51.         if (!pcm_is_ready(mPcm)) { 
  52.             LOGE("openPcmOut_l() cannot open pcm_out driver: %s\n", pcm_get_error(mPcm)); 
  53.             TRACE_DRIVER_IN(DRV_PCM_CLOSE) 
  54.             pcm_close(mPcm); 
  55.             TRACE_DRIVER_OUT 
  56.             mPcmOpenCnt--; 
  57.             mPcm = NULL; 
  58.         } 
  59.     } 
  60.     return mPcm; 
  61. } 
  62.  
  63. const AudioMixer *AudioHardware::getInputRouteFromDevice(uint32_t device) 
  64. { 
  65.     if (mMicMute) { 
  66.         return device_input_MIC_OFF; 
  67.     } 
  68.  
  69.     switch (device) { 
  70.     case AudioSystem::DEVICE_IN_BUILTIN_MIC: 
  71.         return device_input_Main_Mic; 
  72.     case AudioSystem::DEVICE_IN_WIRED_HEADSET: 
  73.         return device_input_Hands_Free_Mic; 
  74.     case AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET: 
  75.         return device_input_BT_Sco_Mic; 
  76.     default: 
  77.         return device_input_MIC_OFF; 
  78.     } 
  79. } 
  80.  
  81. status_t AudioHardware::setMode(int mode) 
  82. { 
  83.     sp<AudioStreamOutALSA> spOut; 
  84.     sp<AudioStreamInALSA> spIn; 
  85.     status_t status; 
  86.  
  87.     // Mutex acquisition order is always out -> in -> hw 
  88.     AutoMutex lock(mLock); 
  89.  
  90.     spOut = mOutput; 
  91.     // spOut is not 0 here only if the output is active 
  92.  
  93.     spIn = getActiveInput_l(); 
  94.     while (spIn != 0) { 
  95.         int cnt = spIn->prepareLock(); 
  96.         mLock.unlock(); 
  97.         spIn->lock(); 
  98.         mLock.lock(); 
  99.         // make sure that another thread did not change input state while the 
  100.         // mutex is released 
  101.         if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) { 
  102.             break; 
  103.         } 
  104.         spIn->unlock(); 
  105.         spIn = getActiveInput_l(); 
  106.     } 
  107.     // spIn is not 0 here only if the input is active 
  108.  
  109.     int prevMode = mMode; 
  110.     status = AudioHardwareBase::setMode(mode); 
  111.     LOGV("setMode() : new %d, old %d", mMode, prevMode); 
  112.     if (status == NO_ERROR) { 
  113.         bool modeNeedsCPActive = mMode == AudioSystem::MODE_IN_CALL || 
  114.                                     mMode == AudioSystem::MODE_RINGTONE; 
  115.         // activate call clock in radio when entering in call or ringtone mode 
  116.         if (modeNeedsCPActive) 
  117.         { 
  118.             if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { 
  119.                 setCallClockSync(mRilClient, SOUND_CLOCK_START); 
  120.                 mActivatedCP = true; 
  121.             } 
  122.         } 
  123.  
  124.         if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) { 
  125.             if (spOut != 0) { 
  126.                 LOGV("setMode() in call force output standby"); 
  127.                 spOut->doStandby_l(); 
  128.             } 
  129.             if (spIn != 0) { 
  130.                 LOGV("setMode() in call force input standby"); 
  131.                 spIn->doStandby_l(); 
  132.             } 
  133.  
  134.             LOGV("setMode() openPcmOut_l()"); 
  135.             openPcmOut_l(); 
  136.             openMixer_l(); 
  137.             setInputSource_l(AUDIO_SOURCE_DEFAULT); 
  138.             setVoiceVolume_l(mVoiceVol); 
  139.             mInCallAudioMode = true; 
  140.         } 
  141.         if (mMode != AudioSystem::MODE_IN_CALL && mInCallAudioMode) { 
  142.             setInputSource_l(mInputSource); 
  143.             if (mMixer != NULL) { 
  144.                 TRACE_DRIVER_IN(DRV_MIXER_GET) 
  145.                 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer,"Playback Path"); 
  146.                 TRACE_DRIVER_OUT 
  147.                 if (ctl != NULL) { 
  148.                     LOGV("setMode() reset Playback Path to RCV"); 
  149.                     TRACE_DRIVER_IN(DRV_MIXER_SEL) 
  150.                     mixer_ctl_set_enum_by_string(ctl, "RCV"); 
  151.                     TRACE_DRIVER_OUT 
  152.                 } 
  153.             } 
  154.             LOGV("setMode() closePcmOut_l()"); 
  155.             closeMixer_l(); 
  156.             closePcmOut_l(); 
  157.  
  158.             if (spOut != 0) { 
  159.                 LOGV("setMode() off call force output standby"); 
  160.                 spOut->doStandby_l(); 
  161.             } 
  162.             if (spIn != 0) { 
  163.                 LOGV("setMode() off call force input standby"); 
  164.                 spIn->doStandby_l(); 
  165.             } 
  166.  
  167.             mInCallAudioMode = false; 
  168.         } 
  169.  
  170.         if (!modeNeedsCPActive) { 
  171.             if(mActivatedCP) 
  172.                 mActivatedCP = false; 
  173.         } 
  174.     } 
  175.  
  176.     return status; 
  177. } 

特别是setMode这个函数，涉及到整个音频系统的状态，一定要搞清楚

然后就是mixer的设置，还好wolfson在驱动里面实现了debugfs，可以在tty控制台输出

# mount-t debugfs none /d

打开debugfs，然后进入codec对应目录：


通过cat codec_reg可以查看wm8994所有寄存器，还可以实时修改，修改立刻生效

进入dapm目录可以查看所有mixer，我们配置的dapm必须在这里有值出现，否则不识别

我们可以cat每个mixer，查看其状态：

注意当前SPKL状态为OFF，表示其不在开启的route通路上，或者说你希望开启的包含SPKL的route还没有开启

你需要检查这个route是否完整，音频信号在route里面通过就像能电流在电线内部一样，必须要有输入输出，分支也必须是环路

关于dapm后面再说，这里补充一个要点，就是AudioHardware里面pcm_open()时写的那个config：

[cpp] view plaincopyprint?
  1. struct pcm_config config = { 
  2.     channels : 2, 
  3.     rate : AUDIO_HW_OUT_SAMPLERATE, 
  4.     period_size : AUDIO_HW_OUT_PERIOD_SZ, 
  5.     period_count : AUDIO_HW_OUT_PERIOD_CNT, 
  6.     format : PCM_FORMAT_S16_LE, 
  7.     start_threshold : 0, 
  8.     stop_threshold : 0, 
  9.     silence_threshold : 0, 
  10. }; 

我在最开始调试的时候在这里浪费了很多时间，关键就在这个config值得配置上，它和codec_dai,cpu_dai和snd_pcm_hardware都有关系

需要仔细检查，这个在snd_pcm_open的时候会做一系列rules检查，下一章我再重点讲一下！

更多0

 

0 0
nas 文件拷贝 软件 nas 文件拷贝 软件
原创粉丝点击
热门IT博客
指针数组指针数组
python获取当前时间python获取当前时间
java编程思想第4版 pdf
firefox js引擎
铜陵网络台袁晋明
电脑怎么登录淘宝号
php web
网络面板和网线接法
cnc手工编程实例
homer英语软件
专车软件
中国域名网官网
oracle数据库导出sql
水性互穿网络防腐底漆
52弹弓淘宝店
知乎和百度知道哪个好
女神联盟英雄进阶数据
泰州网络推广找泰公
巨人网络史玉柱的故事
数据统计分析系统
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 怎样做西红柿炒鸡蛋 怎么做西红柿炒鸡蛋好吃 孕妇能吃韭菜炒鸡蛋吗 如何制作西红柿炒鸡蛋 孕妇可以吃韭菜炒鸡蛋吗 怀孕可以吃韭菜炒鸡蛋吗 生炒柠檬鸭 家常鸭肉怎么炒好吃 爆炒鸭肉 腊鸭炒什么好吃 鸭肉和什么一起炒好吃 鸭怎么炒好吃 炒鸭血的做法大全家常 怎样炒鸭肉好吃 怎么炒鸭肉好吃又简单 鸭血怎样炒好吃 炒鸭血的家常做法 炒鸭肉的家常做法 韭菜炒鸭血的做法 爆炒鸭心 鸭蛋怎样炒不腥还嫩 鸭蛋和什么一起炒好吃 咸鸭蛋炒茄子 烤鸭蛋 炒黄瓜片 香脆炒黄瓜 鸡蛋炒黄瓜片 火腿炒黄瓜 清炒黄瓜片 黄瓜炒木耳 炝炒黄瓜 西红柿炒黄瓜 清炒黄瓜怎么做好吃 黄瓜鸡蛋怎么炒 银耳炒黄瓜 西红柿炒黄瓜的家常做法大全 黄瓜鸡蛋炒饭 黄瓜炒西红柿的做法 黄瓜鸡蛋炒着吃减肥吗 黄瓜怎样炒好吃 炒贵金属

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里