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; }