Android Opensl es无法获取频率（kHz）

我在Android中遇到OpenSL ES的频率问题。 使用OpenSL ES，我想创建具有44.1kHz波形的正弦波。 我的源代码如下。 跟随源产生44.1Hz正弦波，但不产生44.1Hz正弦波。某处我缺少x1000（k）。 有人能给我一些指导吗？根据OpenSL ES，它说的是44.1kHz，而不是44.1Hz

提前谢谢

//Buffer:
#define DEFAULT_FRAMES 1000
for (i = 0; i < DEFAULT_FRAMES; ++i) {
    defaultSineBuffer[i] = (sin((2 * 3.14 ) * (i%1000)*0.001))*(32767) ; // 1000 samples
}

// Call back buffer
void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
    nextBuffer = defaultSineBuffer;
    nextSize = sizeof(defaultSineBuffer);

    result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
}

// Create Engine
JNIEXPORT jboolean JNICALL Java_com_droid_Inspector_createEngine
        (JNIEnv *env, jobject jObject) {

    SLresult result;

    // create engine
    result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
    if(SL_RESULT_SUCCESS != result){
        return JNI_FALSE;
    }

    // realize the engine
    result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
    if(SL_RESULT_SUCCESS != result) {
        return JNI_FALSE;
    }

    // get the engine interface, which is needed in order to create other objects
    result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
    if(SL_RESULT_SUCCESS != result) {
        return JNI_FALSE;
    }


    // create output mix, with environmental reverb specified as a non-required interface
    const SLInterfaceID ids[1] = {SL_IID_ENVIRONMENTALREVERB};
    const SLboolean req[1] = {SL_BOOLEAN_FALSE};
    result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 1, ids, req);
    if(SL_RESULT_SUCCESS != result) {
        return JNI_FALSE;
    }


    // realize the output mix
    result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
    if(SL_RESULT_SUCCESS != result) {
        return JNI_FALSE;
    }


    // get the environmental reverb interface
    // this could fail if the environmental reverb effect is not available,
    // either because the feature is not present, excessive CPU load, or
    // the required MODIFY_AUDIO_SETTINGS permission was not requested and granted
    result = (*outputMixObject)->GetInterface(outputMixObject, SL_IID_ENVIRONMENTALREVERB,
                                              &outputMixEnvironmentalReverb);
    if (SL_RESULT_SUCCESS == result) {
        result = (*outputMixEnvironmentalReverb)->SetEnvironmentalReverbProperties(
                outputMixEnvironmentalReverb, &reverbSettings);
    }

    return JNI_TRUE;
}

// Create buffer player with 44.1kHz
JNIEXPORT jboolean JNICALL Java_com_droid_Inspector_createBufferQueueAudioPlayer
        (JNIEnv *env, jobject jObect, jint jInt) {
    SLresult result;

    // configure audio source
    SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};


    SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, SL_SAMPLINGRATE_44_1,
                        SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
                        SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};

    SLDataSource audioSrc = {&loc_bufq, &format_pcm};

    // configure audio sink
    SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
    SLDataSink audioSnk = {&loc_outmix, NULL};

    // create audio player
    const SLInterfaceID ids[3] = {SL_IID_BUFFERQUEUE, SL_IID_EFFECTSEND, SL_IID_VOLUME};
    const SLboolean req[3] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
    result = (*engineEngine)->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 3, ids, req);
    if(SL_RESULT_SUCCESS != result) {
        return JNI_FALSE;
    }
}


// Play it
JNIEXPORT jboolean JNICALL Java_com_droid_Inspector_playWave {
    result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
}

//缓冲区：
#定义默认的_帧1000
对于（i=0；i排队（bqPlayerBufferQueue，nextBuffer，nextSize）；
}
//创建引擎
JNIEXPORT jboolean JNICALL Java_com_droid_Inspector_createEngine
（JNIEnv*env，jobject-jobject）{
结果；
//创建引擎
结果=slCreateEngine（&engineObject，0，NULL，0，NULL，NULL）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
//实现引擎
结果=（*engineObject）->实现（engineObject，SL_BOOLEAN_FALSE）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
//获取引擎接口，这是创建其他对象所需的
结果=（*engineObject）->GetInterface（engineObject、SL_IID_ENGINE和EngineeEngine）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
//创建输出混音，将环境混响指定为非必需接口
const SLInterfaceID id[1]={SL_IID_ENVIRONMENTALREVERB}；
const SLboolean req[1]={SL_BOOLEAN_FALSE}；
结果=（*EngineeEngine）->CreateOutputMix（EngineeEngine和outputMixObject，1，ids，req）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
//实现输出混合
结果=（*outputMixObject）->实现（outputMixObject，SL_BOOLEAN_FALSE）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
//获取环境混响接口
//如果环境混响效果不可用，则可能会失败，
//可能是因为该功能不存在，CPU负载过大，或者
//未请求并授予所需的“修改音频设置”权限
结果=（*outputMixObject）->GetInterface（outputMixObject，SL_IID_环境混响，
&输出混合环境混响）；
if（SL_RESULT_SUCCESS==结果）{
结果=（*outputMixEnvironmentalReverb）->SetEnvironmentalReverbProperties(
输出混合环境混响和混响设置）；
}
返回JNI_TRUE；
}
//创建44.1kHz的缓冲播放器
JNIEXPORT jboolean JNICALL Java_com_droid_Inspector_createBufferQueueAudioPlayer
（JNIEnv*env、jobject、jObect、jint jint）{
结果；
//配置音频源
SLDataLocator_AndroidSimpleBufferQueue loc_bufq={SL_DATALOCATOR_AndroidSimpleBufferQueue，2}；
SLDataFormat_PCM format_PCM={SL_DATAFORMAT_PCM，1，SL_SAMPLINGRATE_44_1，
SL_PCMSAMPLEFORMAT_FIXED_16，SL_PCMSAMPLEFORMAT_FIXED_16，
SL_扬声器_前部_中心，SL_字节顺序_LITTLEENDIAN}；
SLDataSource audioSrc={&loc_bufq，&format_pcm}；
//配置音频接收器
SLDataLocator_OutputMix loc_outmix={SL_DATALOCATOR_OutputMix，outputMixObject}；
SLDataSink audioSnk={&loc_outmix，NULL}；
//创建音频播放器
const SLInterfaceID id[3]={SL_IID_BUFFERQUEUE，SL_IID_EFFECTSEND，SL_IID_VOLUME}；
const SLboolean req[3]={SL_BOOLEAN_TRUE，SL_BOOLEAN_TRUE，SL_BOOLEAN_TRUE}；
结果=（*EngineeEngine）->CreateAudioPlayer（EngineeEngine，&bqPlayerObject，&audioSrc，&audioSnk，3，ids，req）；
if（SL_RESULT_SUCCESS！=结果）{
返回JNI_FALSE；
}
}
//玩它
JNIEXPORT jboolean JNICALL Java\u com\u droid\u Inspector\u playWave{
结果=（*bqPlayerBufferQueue）->排队（bqPlayerBufferQueue，nextBuffer，nextSize）；
}

生成正弦的正确方法如下：

44.1 kHz的采样率为44100个采样/秒

44100 kHz波为44100个周期/秒

正弦函数的周期为2*PI

现在让我们来编写代码：

#define DEFAULT_FRAMES 1000

    for(i = 0; i < DEFAULT_FRAMES ; i++)
{
  // i is the sample index
  // Straight sine function means one cycle every 2*pi samples:
  // defaultSineBuffer[i] = sin(i); 
  // Multiply by 2*pi--now it's one cycle per sample:
  // defaultSineBuffer[i] = sin((2 * pi) * i); 
  // Multiply by 44,100 samples per second--now it's 44,100 cycles per second:
  // defaultSineBuffer[i] = sin(44100* (2 * pi) * i);
  // Divide by 44,100 samples per second--now it's 44,100 cycles per 44,100
  // samples, which is just what we needed:
  //defaultSineBuffer[i] = sin(44100 * (2 * pi) * i / 44100);
    defaultSineBuffer[i] = sin(2 * pi * i) * (32767);
}

#定义默认帧1000
对于（i=0；i