android 修改按键音通道

转载

技术极客领袖 2024-08-09 13:22:44

文章标签 android 修改按键音通道 android 数据采样率 java 文章分类 Android 移动开发

背景知识

对于音乐类型的音频资源，可以通过MediaPlayer来播放；
对于音调，可以通过ToneGenerator来播放；
对于提示音，可以通过Ringtone来播放；
对于游戏中的音频资源，可以通过SoundPool来播放。

ToneGenerator提供了对DTMF音（ITU-T Q.23），以及呼叫监督音（3GPP TS 22.001）、专用音（3GPP TS 31.111）中规定的音频的支持，根据呼叫状态和漫游状态，该文件产生的音频路径为下行音频或者传输给扬声器或耳机。需要说明的是，DTMF音为WAV格式，相关的音频类型定义位于ToneGenerator.h文件中

代码分析

1. java上层调用，每次new都会重新创建一个AudioTrack

ToneGenerator.java (frameworks\base\media\java\android\media)
android_media_ToneGenerator.cpp (frameworks\base\core\jni)

比如：

mToneGenerator = new ToneGenerator(AudioManager.STREAM_DTMF, 80);

2. ToneGenerator.cpp (frameworks\av\media\libaudioclient)

//每个按键音的定义，主要是频率，因为这是自动生成的PCM数据
const ToneGenerator::ToneDescriptor ToneGenerator::sToneDescriptors[] = {
{ .segments = { { .duration = ToneGenerator::TONEGEN_INF, .waveFreq = { 1336, 941, 0 }, 0, 0},
{ .duration = 0 , .waveFreq = { 0 }, 0, 0}},
.repeatCnt = ToneGenerator::TONEGEN_INF,
.repeatSegment = 0 }, // TONE_DTMF_0
...
}
 
ToneGenerator::ToneGenerator(audio_stream_type_t streamType, float volume, bool threadCanCallJava) {
//获取对应audio流的采样率
if (AudioSystem::getOutputSamplingRate(&mSamplingRate, streamType) != NO_ERROR) {
 
// Generate tone by chunks of 20 ms to keep cadencing precision
mProcessSize = (mSamplingRate * 20) / 1000;
 
if (initAudioTrack()) {
}
 
bool ToneGenerator::initAudioTrack() { //初始化播放tone的audiotrack
// Open audio track in mono, PCM 16bit, default sampling rate.
mpAudioTrack = new AudioTrack();
attr = AudioSystem::streamTypeToAttributes(streamType); //streamType = STREAM_DTMF
status_t status = mpAudioTrack->set(
AUDIO_STREAM_DEFAULT,
0, // sampleRate
AUDIO_FORMAT_PCM_16_BIT, //一次采样用16bit的数据
AUDIO_CHANNEL_OUT_MONO, //单声道
frameCount, //mProcessSize
AUDIO_OUTPUT_FLAG_FAST,
audioCallback,
this, // user
0, // notificationFrames
0, // sharedBuffer
mThreadCanCallJava,
AUDIO_SESSION_ALLOCATE,
AudioTrack::TRANSFER_CALLBACK,
nullptr,
AUDIO_UID_INVALID,
-1,
&attr);
mpAudioTrack->setVolume(mVolume);
}
 
//播放对应按键音, durationMs = -1
bool ToneGenerator::startTone(tone_type toneType, int durationMs) {
// Get descriptor for requested tone
mpNewToneDesc = &sToneDescriptors[toneType];
 
if (mState == TONE_INIT) {
if (prepareWave()) {
ALOGV("Immediate start, time %d", (unsigned int)(systemTime()/1000000));
lResult = true;
mState = TONE_STARTING;
if (clock_gettime(CLOCK_MONOTONIC, &mStartTime) != 0) {
mStartTime.tv_sec = 0;
}
mLock.unlock();
mpAudioTrack->start(); //开始播放声音，会调用audioCallback回调函数
mLock.lock();
if (mState == TONE_STARTING) {
ALOGV("Wait for start callback");
lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));//等待声音数据准备好
if (lStatus != NO_ERROR) {
ALOGE("--- Immediate start timed out, status %d", lStatus);
mState = TONE_IDLE;
lResult = false;
}
}
} else {
mState = TONE_IDLE;
}
} else {
 
}
 
bool ToneGenerator::prepareWave() {
// Remove existing wave generators if any
clearWaveGens(); //清除mWaveGens
mpToneDesc = mpNewToneDesc;
mMaxSmp = TONEGEN_INF;//因为mDurationMs == -1，设置播放数据无限大
 
while (mpToneDesc->segments[segmentIdx].duration) {
// Get total number of sine waves: needed to adapt sine wave gain.
unsigned int lNumWaves = numWaves(segmentIdx);//得到有两种频率的声音
unsigned int freqIdx = 0;
unsigned int frequency = mpToneDesc->segments[segmentIdx].waveFreq[freqIdx];
while (frequency) {
// Instantiate a wave generator if ot already done for this frequency
if (mWaveGens.indexOfKey(frequency) == NAME_NOT_FOUND) {
ToneGenerator::WaveGenerator *lpWaveGen =
new ToneGenerator::WaveGenerator(mSamplingRate, //采样率
frequency, //声音频率
TONEGEN_GAIN/lNumWaves); //声音大小
mWaveGens.add(frequency, lpWaveGen);
}
frequency = mpNewToneDesc->segments[segmentIdx].waveFreq[++freqIdx];
}
segmentIdx++;
}
}
 
//只要开始播放，audiotrack会通过该回调函数一直请求数据，一直到stop
void ToneGenerator::audioCallback(int event, void* user, void *info) {
AudioTrack::Buffer *buffer = static_cast<AudioTrack::Buffer *>(info); //获取存放声音的buffer
ToneGenerator *lpToneGen = static_cast<ToneGenerator *>(user);
int16_t *lpOut = buffer->i16;
unsigned int lNumSmp = buffer->size/sizeof(int16_t); //存放声音缓存的大小
const ToneDescriptor *lpToneDesc = lpToneGen->mpToneDesc; //获取按键音的描述参数
 
while (lNumSmp) {
switch (lpToneGen->mState) {
case TONE_PLAYING:
lWaveCmd = WaveGenerator::WAVEGEN_CONT;
break;
case TONE_STARTING:
ALOGV("Starting Cbk");
lWaveCmd = WaveGenerator::WAVEGEN_START;
break;
case TONE_STOPPED:
ALOGV("Stopped Cbk");
goto audioCallback_EndLoop;
}
 
// Exit if tone sequence is over， 用于检验无限播放时的退出
if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0 ||
lpToneGen->mTotalSmp > lpToneGen->mMaxSmp) {
if (lpToneGen->mState == TONE_PLAYING) {
lpToneGen->mState = TONE_STOPPING;
}
if (lpToneDesc->segments[lpToneGen->mCurSegment].duration == 0) {
goto audioCallback_EndLoop;
}
// fade out before stopping if maximum duration reached
lWaveCmd = WaveGenerator::WAVEGEN_STOP;
lpToneGen->mNextSegSmp = TONEGEN_INF; // forced to skip state machine management below
}
 
if (lGenSmp) {
unsigned int lFreqIdx = 0;
uint16_t lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[lFreqIdx];
while (lFrequency != 0) {
WaveGenerator *lpWaveGen = lpToneGen->mWaveGens.valueFor(lFrequency);
lpWaveGen->getSamples(lpOut, lGenSmp, lWaveCmd); //根据频率生成pcm数据
lFrequency = lpToneDesc->segments[lpToneGen->mCurSegment].waveFreq[++lFreqIdx];
}
}
 
audioCallback_EndLoop:
switch (lpToneGen->mState) {
case TONE_STARTING:
ALOGV("Cbk starting track");
lpToneGen->mState = TONE_PLAYING;
lSignal = true;
break;
case TONE_STOPPING:
ALOGV("Cbk Stopping");
lpToneGen->mState = TONE_STOPPED;
// Force loop exit
lNumSmp = 0;
break;
case TONE_STOPPED:
lpToneGen->mState = TONE_INIT;
ALOGV("Cbk Stopped track");
lpToneGen->mpAudioTrack->stop(); //停止播放声音，整个循环从此退出！！！
// Force loop exit
lNumSmp = 0;
buffer->size = 0;
lSignal = true;
break;
}
if (lSignal)
lpToneGen->mWaitCbkCond.broadcast();
}
}
 
void ToneGenerator::stopTone() {
ALOGV("stopTone");
if (mState != TONE_IDLE && mState != TONE_INIT) {
if (mState == TONE_PLAYING || mState == TONE_STARTING || mState == TONE_RESTARTING) {
struct timespec stopTime;
// If the start time is valid, make sure that the number of audio samples produced
// corresponds at least to the time between the start and stop commands.
// This is needed in case of cold start of the output stream.
if ((mStartTime.tv_sec != 0) && (clock_gettime(CLOCK_MONOTONIC, &stopTime) == 0)) {
time_t sec = stopTime.tv_sec - mStartTime.tv_sec;
auto nsec = stopTime.tv_nsec - mStartTime.tv_nsec;
if (nsec < 0) {
--sec;
nsec += 1000000000;
}
 
if ((sec + 1) > ((time_t)(INT_MAX / mSamplingRate))) {
mMaxSmp = sec * mSamplingRate;
} else {
// mSamplingRate is always > 1000
sec = sec * 1000 + nsec / 1000000; // duration in milliseconds
//通过设置最大的声音播放数据大小来控制播放结束
mMaxSmp = (unsigned int)(((int64_t)sec * mSamplingRate) / 1000);
}
ALOGV("stopTone() forcing mMaxSmp to %d, total for far %d", mMaxSmp, mTotalSmp);
} else {
mState = TONE_STOPPING;
}
}
ALOGV("waiting cond");
status_t lStatus = mWaitCbkCond.waitRelative(mLock, seconds(3));
}