status_t TinyAudioStreamOut::standby()
{
if (pcm_stop(mPcm) != 0)
LOGE("standby() failed: %s\n",
::pcm_get_error(mPcm));
return NO_ERROR;
}
static gboolean
gst_tinyalsa_sink_unprepare (GstAudioSink * asink)
{
GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
if (pcm_stop (sink->pcm) < 0) {
GST_ERROR_OBJECT (sink, "Could not stop device: %s",
pcm_get_error (sink->pcm));
}
/* mutex with getcaps */
GST_OBJECT_LOCK (sink);
if (pcm_close (sink->pcm)) {
GST_ERROR_OBJECT (sink, "Could not close device: %s",
pcm_get_error (sink->pcm));
return FALSE;
}
sink->pcm = NULL;
gst_caps_replace (&sink->cached_caps, NULL);
GST_OBJECT_UNLOCK (sink);
GST_DEBUG_OBJECT (sink, "Device unprepared");
return TRUE;
}
int plan_two_stop_bt_voice(void)
{
g_bt_upload_voice.voice_thread_run_flag = 0;
g_bt_download_voice.voice_thread_run_flag = 0;
if(g_bt_upload_voice.stream_sender->dev)
pcm_stop(g_bt_upload_voice.stream_sender->dev);
if(g_bt_upload_voice.stream_receiver->dev)
pcm_stop(g_bt_upload_voice.stream_receiver->dev);
if(g_bt_download_voice.stream_sender->dev)
pcm_stop(g_bt_download_voice.stream_sender->dev);
if(g_bt_download_voice.stream_receiver->dev)
pcm_stop(g_bt_download_voice.stream_receiver->dev);
while(!(g_bt_download_voice.voice_thread_exit_flag && g_bt_upload_voice.voice_thread_exit_flag )){
ALOGD("plan_two_stop_bt_voice: wait bt voice ending");
usleep(1000);
}
return 0;
}
void AudioPlaybackLocal::doStop()
{
// TODO: remove when pcm_stop does pcm_drain
// hack to have snd_pcm_drain equivalent
struct pcm_ {
int fd;
};
pcm_* pcm = (pcm_*)mPcmHandle;
ioctl(pcm->fd, SNDRV_PCM_IOCTL_DRAIN);
pcm_stop(mPcmHandle);
}
status_t AudioALSALoopbackController::close()
{
ALOGD("+%s()", __FUNCTION__);
AudioAutoTimeoutLock _l(mLock);
AudioAutoTimeoutLock _l2(*AudioALSADriverUtility::getInstance()->getStreamSramDramLock());
mHardwareResourceManager->stopOutputDevice();
pcm_stop(mPcmDL);
pcm_stop(mPcmUL);
pcm_close(mPcmDL);
pcm_close(mPcmUL);
mPcmDL = NULL;
mPcmUL = NULL;
mHardwareResourceManager->stopInputDevice(mHardwareResourceManager->getInputDevice());
ALOGD("-%s()", __FUNCTION__);
return NO_ERROR;
}
void AudioALSAPlaybackHandlerNormal::CloseHpImpeDancePcm(void)
{
ALOGD("CloseHpImpeDancePcm");
// Don't lock Sram/Dram lock here, it would be locked by caller function
if (mHpImpeDancePcm != NULL)
{
pcm_stop(mHpImpeDancePcm);
pcm_close(mHpImpeDancePcm);
mHpImpeDancePcm = NULL;
}
}
status_t AudioALSACaptureDataProviderBase::closePcmDriver()
{
ALOGD("+%s(), mPcm = %p", __FUNCTION__, mPcm);
if (mPcm != NULL)
{
pcm_stop(mPcm);
pcm_close(mPcm);
mPcm = NULL;
}
ALOGD("-%s(), mPcm = %p", __FUNCTION__, mPcm);
return NO_ERROR;
}
static void
gst_tinyalsa_sink_reset (GstAudioSink * asink)
{
GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
if (pcm_stop (sink->pcm) < 0) {
GST_ERROR_OBJECT (sink, "Could not stop device: %s",
pcm_get_error (sink->pcm));
}
if (pcm_prepare (sink->pcm) < 0) {
GST_ERROR_OBJECT (sink, "Could not prepare device: %s",
pcm_get_error (sink->pcm));
}
}
status_t AudioALSACaptureDataProviderBTSCO::close()
{
ALOGD("%s()", __FUNCTION__);
ASSERT(mClientLock.tryLock() != 0); // lock by base class detach
mEnable = false;
AudioAutoTimeoutLock _l(mEnableLock);
ClosePCMDump();
pcm_stop(mPcm);
pcm_close(mPcm);
mPcm = NULL;
return NO_ERROR;
}
status_t AudioALSACaptureDataProviderTDM::close()
{
ALOGD("%s()", __FUNCTION__);
ASSERT(mClientLock.tryLock() != 0); // lock by base class detach
mEnable = false;
AudioAutoTimeoutLock _l(mEnableLock);
AudioAutoTimeoutLock _l2(*AudioALSADriverUtility::getInstance()->getStreamSramDramLock());
ClosePCMDump();
pcm_stop(mPcm);
pcm_close(mPcm);
mPcm = NULL;
return NO_ERROR;
}
status_t AudioALSACaptureDataProviderEchoRefExt::close()
{
ALOGD("%s()", __FUNCTION__);
ASSERT(mClientLock.tryLock() != 0); // lock by base class detach
mEnable = false;
AudioAutoTimeoutLock _l(mEnableLock);
ClosePCMDump();
pcm_stop(mPcm);
pcm_close(mPcm);
mPcm = NULL;
AudioALSASampleRateController *pAudioALSASampleRateController = AudioALSASampleRateController::getInstance();
pAudioALSASampleRateController->resetScenarioStatus(PLAYBACK_SCENARIO_ECHO_REF_EXT);
return NO_ERROR;
}
status_t AudioALSAFMController::setFmDirectConnection(const bool enable, const bool bforce)
{
ALOGD("+%s(), enable = %d, bforce = %d", __FUNCTION__, enable, bforce);
// Check Current Status
if (mIsFmDirectConnectionMode == enable && bforce == false)
{
ALOGW("-%s(), enable = %d, bforce = %d", __FUNCTION__, enable, bforce);
return INVALID_OPERATION;
}
// Apply
if (enable == true)
{
mConfig.channels = 2;
mConfig.rate = getFmDownlinkSamplingRate();
mConfig.period_size = 3072;
mConfig.period_count = 2;
mConfig.format = PCM_FORMAT_S16_LE;
mConfig.start_threshold = 0;
mConfig.stop_threshold = 0;
mConfig.silence_threshold = 0;
if (mPcm == NULL)
{
// Get pcm open Info
int card_index = -1;
int pcm_index = -1;
if (WCNChipController::GetInstance()->IsFMMergeInterfaceSupported() == true)
{
card_index = AudioALSADeviceParser::getInstance()->GetCardIndexByString(keypcmMRGrxPlayback);
pcm_index = AudioALSADeviceParser::getInstance()->GetPcmIndexByString(keypcmMRGrxPlayback);
}
else
{
card_index = AudioALSADeviceParser::getInstance()->GetCardIndexByString(keypcmFMI2SPlayback);
pcm_index = AudioALSADeviceParser::getInstance()->GetPcmIndexByString(keypcmFMI2SPlayback);
}
ALOGD("%s(), card_index = %d, pcm_index = %d", __FUNCTION__, card_index, pcm_index);
mPcm = pcm_open(card_index, pcm_index , PCM_OUT, &mConfig);
ALOGD("%s(), pcm_open mPcm = %p", __FUNCTION__, mPcm);
}
if (mPcm == NULL || pcm_is_ready(mPcm) == false)
{
ALOGE("%s(), Unable to open mPcm device %u (%s)", __FUNCTION__, 6 , pcm_get_error(mPcm));
}
pcm_start(mPcm);
}
else
{
if (mPcm != NULL)
{
pcm_stop(mPcm);
pcm_close(mPcm);
mPcm = NULL;
}
}
// Update Direct Mode Status
mIsFmDirectConnectionMode = enable;
// Update (HW_GAIN2) Volume for Direct Mode Only
if (mIsFmDirectConnectionMode == true)
{
setFmVolume(mFmVolume);
}
ALOGD("-%s(), enable = %d, bforce = %d", __FUNCTION__, enable, bforce);
return NO_ERROR;
}
static int stream_transfer(struct stream_transfer *stream_transfer)
{
struct dev_stream *stream_sender;
struct dev_stream *stream_receiver;
short* Srcptr;
short* Drcptr;
int size_transfer = 0;
int ret =0;
int exit_flag =0;
int i=0;
stream_sender = stream_transfer->stream_sender;
stream_receiver = stream_transfer->stream_receiver;
size_transfer = stream_sender->buf_size;
#ifdef START_ZERO_BUFFER
/* 消除开头杂音 */
memset(stream_sender->buf, 0, stream_sender->buf_size);
pcm_write(stream_receiver->dev, stream_sender->buf, stream_sender->buf_size);
#endif
ret =pcm_wait(stream_sender->dev, 0);
ret =pcm_wait(stream_receiver->dev, 0);
pcm_stop(stream_receiver->dev);
pcm_start(stream_receiver->dev);
/* 消除开头pa音 */
memset(stream_sender->buf, 0, stream_sender->buf_size);
pcm_write(stream_receiver->dev, stream_sender->buf, stream_sender->buf_size);
while( 1 ){
if ( (!stream_transfer->voice_thread_run_flag)){
break;
}
#if 0
if (SNDRV_PCM_STATE_XRUN == get_pcm_state(stream_sender->dev) ){
//ALOGD("read SNDRV_PCM_STATE_XRUN ");
if(ioctl(stream_sender->dev->fd, SNDRV_PCM_IOCTL_PREPARE)){
ALOGE("in read, fail to prepare SNDRV_PCM_STATE_XRUN ");
}
//usleep(3 * 1000);
ret =pcm_wait(stream_sender->dev, 0);
//ALOGD("pcm_read, pcm_wait ret=%d", ret);
//ALOGD("read after prepare state:%d ",get_pcm_state(stream_sender->dev));
}
#endif
ret = pcm_read(stream_sender->dev, stream_sender->buf, size_transfer);
if (ret != 0) {
//exit_flag = 1;
ALOGE("err: read codec err:%s, ret=%d", strerror(errno), ret);
//break;
}
if ( (!stream_transfer->voice_thread_run_flag)){
break;
}
#if 0
if (SNDRV_PCM_STATE_XRUN == get_pcm_state(stream_receiver->dev) ){
//ALOGD("write SNDRV_PCM_STATE_XRUN ");
pcm_stop(stream_receiver->dev);
usleep(3 * 1000);
//ALOGD("write after stop state:%d ",get_pcm_state(stream_receiver->dev));
pcm_start(stream_receiver->dev);
ret =pcm_wait(stream_receiver->dev, 0);
//ALOGD("pcm_write, pcm_wait ret=%d", ret);
//usleep(3 * 1000);
//ALOGD("write after prepare state:%d ",get_pcm_state(stream_receiver->dev));
}
#endif
ret = pcm_write(stream_receiver->dev, stream_sender->buf, size_transfer);
if (ret != 0) {
//exit_flag = 1;
ALOGE("err: write pcm err:%s, ret=%d", strerror(errno), ret);
}
if ( (!stream_transfer->voice_thread_run_flag)){
break;
}
if (stream_transfer->record_flag == 1){
//是上行,还是下行.
if (stream_transfer->voice_direction == UPSTREAM){
Srcptr = (short*)(stream_sender->buf);
Drcptr = (short*)(record_data.record_buf + (record_data.lenwriteup%record_data.record_lenth));
if(record_data.lenwriteup >= record_data.lenwritedown)
{
memcpy(Drcptr,Srcptr,size_transfer);
}
else
{
int i;
for(i=0;i<size_transfer/2;i++,Drcptr++)
{
*Drcptr = (*Drcptr + *Srcptr++)/2;
}
record_data.lenwrite += size_transfer;
}
record_data.lenwriteup += size_transfer;
//ALOGD("stream is upload");
} else {
Srcptr = (short*)(stream_sender->buf);
Drcptr = (short*)(record_data.record_buf + (record_data.lenwritedown%record_data.record_lenth));
if(record_data.lenwritedown >= record_data.lenwriteup)
{
memcpy(Drcptr,Srcptr,size_transfer);
}
else
{
for(i=0;i<size_transfer/2;i++,Drcptr++)
{
*Drcptr = ((int)*Drcptr + (int)(*Srcptr++))/2;
}
record_data.lenwrite += size_transfer;
}
record_data.lenwritedown += size_transfer;
}
sem_post(&g_sem_record);
}
if ( (!stream_transfer->voice_thread_run_flag)){
break;
}
}
return 0;
}
void AudioRecordingLocal::doStop()
{
pcm_stop(mPcmHandle);
}
void *SpeechANCController::readThread_ANCLog_ADC2(void *arg)
{
prctl(PR_SET_NAME, (unsigned long)__FUNCTION__, 0, 0, 0);
SpeechANCController *pSpeechANCController = (SpeechANCController *)arg;
// force to set priority
struct sched_param sched_p;
sched_getparam(0, &sched_p);
sched_p.sched_priority = RTPM_PRIO_AUDIO_RECORD + 1;
if (0 != sched_setscheduler(0, SCHED_RR, &sched_p))
{
ALOGE("[%s] failed, errno: %d", __FUNCTION__, errno);
}
else
{
sched_p.sched_priority = RTPM_PRIO_AUDIO_CCCI_THREAD;
sched_getparam(0, &sched_p);
ALOGD("sched_setscheduler ok, priority: %d", sched_p.sched_priority);
}
ALOGD("+%s(), pid: %d, tid: %d", __FUNCTION__, getpid(), gettid());
ssize_t buffer_size, write_bytes = 0;
pSpeechANCController->mIndexPcmIn_ADC2 = pSpeechANCController->ConfigPCM(keypcmADC2AWB, &buffer_size);
// config attribute
memset(&pSpeechANCController->mConfig_ADC2, 0, sizeof(pSpeechANCController->mConfig_ADC2));
pSpeechANCController->mConfig_ADC2.channels = 2;
//pSpeechANCController->mConfig_ADC2.rate = 192000;
pSpeechANCController->mConfig_ADC2.rate = 48000;//actural samplerate 26000
// Buffer size: 2048(period_size) * 2(ch) * 2(byte) * 8(period_count) = 64 kb
pSpeechANCController->mConfig_ADC2.period_count = 4;
pSpeechANCController->mConfig_ADC2.format = PCM_FORMAT_S16_LE;
pSpeechANCController->mConfig_ADC2.start_threshold = 0;
pSpeechANCController->mConfig_ADC2.stop_threshold = 0;
pSpeechANCController->mConfig_ADC2.silence_threshold = 0;
pSpeechANCController->mConfig_ADC2.period_size = (buffer_size / (pSpeechANCController->mConfig_ADC2.channels * pSpeechANCController->mConfig_ADC2.period_count)) / ((pSpeechANCController->mConfig_ADC2.format == PCM_FORMAT_S16_LE) ? 2 : 4);
pSpeechANCController->StartPCMIn(2, pSpeechANCController->mIndexPcmIn_ADC2, pSpeechANCController->mConfig_ADC2);
// read raw data from stream manager
char *buffer = new char[kReadBufferSize];
memset(buffer, 0, sizeof(char)*kReadBufferSize);
while (pSpeechANCController->mEnable_ANCLog_ADC2 == true)
{
if (pSpeechANCController->mEnable_ANCLog_ADC2 == false)
{
break;
}
//pcm read
// bytes_read = StreamInANCLog1->read(buffer, bytes);
ASSERT(pSpeechANCController->mPcmIn_ADC2 != NULL);
int retval = pcm_read(pSpeechANCController->mPcmIn_ADC2, buffer, kReadBufferSize);
if (mDumpFile_ADC2 != NULL)
{
// ALOGD("%s(),fwrite file=0x%x, kReadBufferSize=%d", __FUNCTION__, mDumpFile_ADC2, kReadBufferSize);
// write data to sd card
write_bytes += fwrite((void *)buffer, sizeof(char), kReadBufferSize, mDumpFile_ADC2);
}
else
{
ALOGE("%s(), mDumpFile_ADC2 == NULL!!!!!!!!!!!!!!!!!!!!!!!!", __FUNCTION__);
}
if (retval != 0)
{
ALOGE("%s(), pcm_read() error, retval = %d", __FUNCTION__, retval);
}
}
// close file
if (mDumpFile_ADC2 != NULL)
{
fflush(mDumpFile_ADC2);
fclose(mDumpFile_ADC2);
mDumpFile_ADC2 = NULL;
}
pcm_stop(pSpeechANCController->mPcmIn_ADC2);
pcm_close(pSpeechANCController->mPcmIn_ADC2);
pSpeechANCController->mPcmIn_ADC2 = NULL;
ALOGD("-%s(), pid: %d, tid: %d", __FUNCTION__, getpid(), gettid());
pthread_exit(NULL);
return NULL;
}
