void MprRecorder::progressReport(Completion code)
{
void* ud;
mStatus = code;
{
OsLock lock(mMutex);
if (NULL != mpEvent)
{
mpEvent->getUserData(ud);
OsSysLog::add(FAC_MP, PRI_DEBUG, "MprRecorder::progressReport(%d), event=0x%p, &data=0x%p\n",
code, mpEvent, ud);
if (0 != ud)
{
MprRecorderStats *rs = (MprRecorderStats*) ud;
//report current stats
rs->mTotalBytesWritten = mTotalBytesWritten;
rs->mTotalSamplesWritten = mTotalSamplesWritten;
rs->mFinalStatus = code;
int sps = getSamplesPerSec();
rs->mDuration = (1000 * mTotalSamplesWritten) / sps;
rs->mDtmfTerm = mTermKey;
OsSysLog::add(FAC_MP, PRI_DEBUG, "MprRecorder::progressReport mTotalSamplesWritten(%d), sample per second(%d) duration (%d)\n", (int)mTotalSamplesWritten, (int)sps, (int)rs->mDuration);
//now trigger the event...and pass back our struct
OsStatus ret;
if (OS_SUCCESS != (ret = mpEvent->signal(code)))
{
OsSysLog::add(FAC_MP, PRI_WARNING, "MprRecorder::progressReport signal failed, returned %d, try again", (int)ret);
// the event was probably just reset, try again after waiting for 10 ms.
OsTask::delay(10);
void* userdata;
mpEvent->getUserData(userdata);
OsSysLog::add(FAC_MP, PRI_WARNING, "user data - old (0x%p), new (0x%p), event (0x%p) ",
ud, userdata, mpEvent);
// Comment out the assert for production system
// assert(userdata == ud);
if (userdata)
{
ret = mpEvent->signal(code);
OsSysLog::add(FAC_MP, PRI_WARNING, "MprRecorder::progressReport signal again, returned %d ", (int)ret);
}
}
}
else
{
OsSysLog::add(FAC_MP, PRI_WARNING, "MprRecorder::progressReport did not signal user data is 0 for event 0x%p", mpEvent);
}
}
else
{
OsSysLog::add(FAC_MP, PRI_DEBUG, "MprRecorder::progressReport(%d) (No event)\n", code);
}
}
}
void MprSimpleDtmfDetector::calcCoeffs()
{
int n;
for(n = 0; n < ms_nFreqsToDetect; n++)
{
m_coefs[n] = 2.0 * cos(2.0 * 3.141592654 * ms_freqs_to_detect[n] / getSamplesPerSec());
}
}
bool PlayStream::setPosition(unsigned samples)
{
#ifdef RPLAYSTREAM_SHOW_SLOTS
printf("setPosition(%d) -- Card: %d Stream: %d\n",samples,
card_number,stream_number);
#endif // RPLAYSTREAM_SHOW_SLOTS
if((samples<0)||(samples>getSampleLength())) {
return false;
}
if(playing&&((unsigned)samples!=(samples_skipped+samples_played))) {
restart_transport=true;
pause();
}
if(!playing) {
if(is_paused) {
is_paused=false;
repositioned=true;
}
HPICall(HPI_OutStreamReset(NULL,hpi_stream));
samples_played=0;
switch(getFormatTag()) {
case WAVE_FORMAT_PCM:
case WAVE_FORMAT_VORBIS:
samples_skipped=
(unsigned)((double)getBlockAlign()*
((double)samples/(double)getBlockAlign()));
seekWave((int)((double)samples_skipped*(double)getBlockAlign()),
SEEK_SET);
break;
case WAVE_FORMAT_MPEG:
samples_skipped=
(unsigned)((double)getBlockAlign()*
((double)samples/(double)getBlockAlign()));
seekWave((int)((double)(getAvgBytesPerSec())*
((double)(samples_skipped)/
((double)getSamplesPerSec()))),
SEEK_SET);
break;
}
emit position(samples);
}
if(restart_transport) {
play();
restart_transport=false;
}
return true;
}
void PlayStream::pause()
{
#ifdef RPLAYSTREAM_SHOW_SLOTS
printf("pause() -- Card: %d Stream: %d\n",card_number,stream_number);
#endif // RPLAYSTREAM_SHOW_SLOTS
uint16_t state;
uint32_t buffer_size;
uint32_t data_to_play;
uint32_t reserved;
if(!is_open) {
return;
}
if(playing) {
HPICall(HPI_OutStreamStop(NULL,hpi_stream));
clock->stop();
HPICall(HPI_OutStreamGetInfoEx(NULL,hpi_stream,&state,&buffer_size,
&data_to_play,&samples_played,&reserved));
switch(getFormatTag()) {
case WAVE_FORMAT_PCM:
samples_pending=data_to_play/(getChannels()*getBitsPerSample()/8);
break;
case WAVE_FORMAT_MPEG:
samples_pending=
1152*data_to_play/(144*getHeadBitRate()/getSamplesPerSec());
break;
}
playing=false;
is_paused=true;
stream_state=PlayStream::Paused;
if(!restart_transport) {
emit paused();
emit stateChanged(card_number,stream_number,(int)stream_state);
}
}
}
// Handle messages for this resource.
UtlBoolean MprRecorder::handleSetup(int file, int timeMS, int silenceLength, OsProtectedEvent* event)
{
int iMsPerFrame = (1000 * getSamplesPerFrame()) / getSamplesPerSec();
if (isEnabled()) {
OsSysLog::add(FAC_MP, PRI_DEBUG, "MprRecorder::handleSetup"
" -- attempt to setup while enabled!!\n");
return TRUE;
}
if (timeMS > 0) {
mFramesToRecord = timeMS / iMsPerFrame;
} else {
mFramesToRecord = 2000000000;
}
if (silenceLength > 0) {
mSilenceLength = 1000 * silenceLength / iMsPerFrame;
} else {
mSilenceLength = 5000 / iMsPerFrame; /*5 seconds */
}
unsigned long prevValue = MpBuf_setMVE(MIN_SPEECH_ENERGY_THRESHOLD); // any energy lower than this will be regarded as silence
OsSysLog::add(FAC_MP, PRI_INFO, "MprRecorder::handleSetup, set MinVoiceEnergy to %d, was %lu\n", MIN_SPEECH_ENERGY_THRESHOLD, prevValue);
{
OsLock lock(mMutex);
mFileDescriptor = file;
mpEvent = event;
}
mStatus = RECORD_IDLE;
OsSysLog::add(FAC_MP, PRI_DEBUG, "MprRecorder::handleSetup(%d, %d, 0x%p)... #frames=%d\n",
file, timeMS, event, mFramesToRecord);
return TRUE;
}
bool PlayStream::play()
{
#ifdef RPLAYSTREAM_SHOW_SLOTS
printf("play() -- Card: %d Stream: %d\n",card_number,stream_number);
#endif // RPLAYSTREAM_SHOW_SLOTS
if(!is_open) {
printf("FAIL1\n");
return false;
}
if((!playing)&&(!is_paused)) {
HPICall(HPI_OutStreamSetTimeScale(NULL,hpi_stream,
(uint16_t)((1000.0/(double)play_speed)*
HPI_OSTREAM_TIMESCALE_UNITS)));
if(!HPICall(HPI_OutStreamGetInfoEx(NULL,hpi_stream,
&state,&buffer_size,&data_to_play,
&samples_played,&reserved))) {
printf("FAIL3\n");
return false;
}
fragment_size=buffer_size/4;
if(fragment_size>MAX_FRAGMENT_SIZE) {
fragment_size=MAX_FRAGMENT_SIZE;
}
if(pdata!=NULL) {
delete pdata;
}
pdata=(uint8_t *)malloc(fragment_size);
if(pdata==NULL) {
printf("FAIL4\n");
return false;
}
switch(getFormatTag()) {
case WAVE_FORMAT_PCM:
case WAVE_FORMAT_VORBIS:
switch(getBitsPerSample()) {
case 8:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM8_UNSIGNED,
getSamplesPerSec(),0,0));
break;
case 16:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM16_SIGNED,
getSamplesPerSec(),0,0));
break;
case 32:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM32_SIGNED,
getSamplesPerSec(),0,0));
break;
default:
HPICall(HPI_AdapterClose(NULL,card_number));
return false;
break;
}
break;
case WAVE_FORMAT_MPEG:
switch(getHeadLayer()) {
case 1:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L1,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags()));
break;
case 2:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L2,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags()));
break;
case 3:
HPICall(HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L3,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags()));
break;
default:
HPI_AdapterClose(NULL,card_number);
return false;
}
break;
default:
return false;
}
#if HPI_VER < 0x00030500
if(HPI_DataCreate(&hpi_data,&format,pdata,fragment_size)!=0) {
return false;
}
#endif
}
if(!is_paused) {
memset(pdata,0,fragment_size);
left_to_write=getDataLength()-seekWave(0,SEEK_CUR);
if(left_to_write<fragment_size) {
read_bytes = left_to_write;
left_to_write=0;
stopping=true;
}
else {
read_bytes=fragment_size;
left_to_write-=fragment_size;
}
readWave(pdata,read_bytes);
#if HPI_VER > 0x00030500
HPICall(HPI_OutStreamWriteBuf(NULL,hpi_stream,pdata,read_bytes,&format));
#else
HPICall(HPI_DataCreate(&hpi_data,&format,pdata,read_bytes));
HPICall(HPI_OutStreamWrite(NULL,hpi_stream,&hpi_data));
#endif
if(HPI_OutStreamStart(NULL,hpi_stream)!=0) {
printf("FAIL11\n");
return false;
}
clock->start(50);
clock->start(FRAGMENT_TIME);
playing=true;
is_paused=false;
stopping=false;
if(play_length>0) {
play_timer->start(play_length,true);
start_time=QTime::currentTime();
}
stream_state=PlayStream::Playing;
if(!restart_transport) {
emit isStopped(false);
emit played();
emit stateChanged(card_number,stream_number,(int)stream_state);
}
}
if((!playing)&(is_paused|repositioned)) {
HPICall(HPI_OutStreamStart(NULL,hpi_stream));
clock->start(FRAGMENT_TIME);
playing=true;
stopping=false;
is_paused=false;
stream_state=PlayStream::Playing;
if(!restart_transport) {
emit isStopped(false);
emit played();
emit stateChanged(card_number,stream_number,(int)stream_state);
}
}
return true;
}
bool PlayStream::formatSupported(WaveFile::Format format)
{
uint16_t hpi_error;
#if HPI_VER < 0x30A00
HPI_FORMAT hpi_format;
#else
struct hpi_format hpi_format;
#endif
hpi_handle_t hostream;
bool found=false;
if(card_number<0) {
return false;
}
if(format==WaveFile::Vorbis) {
#ifdef HAVE_VORBIS
return true;
#endif // HAVE_VORBIS
return false;
}
if(!is_open) {
for(int i=0;i<sound_card->getCardOutputStreams(card_number);i++) {
if((hpi_error=HPI_OutStreamOpen(NULL,card_number,i,
&hostream))==0) {
found=true;
break;
}
}
if(!found) {
return false;
}
}
else {
hostream=hpi_stream;
}
switch(format) {
case WaveFile::Pcm16:
HPICall(HPI_FormatCreate(&hpi_format,getChannels(),
HPI_FORMAT_PCM16_SIGNED,
getSamplesPerSec(),getHeadBitRate(),0));
state=HPI_OutStreamQueryFormat(NULL,hostream,&hpi_format);
break;
case WaveFile::MpegL1:
HPICall(HPI_FormatCreate(&hpi_format,getChannels(),HPI_FORMAT_MPEG_L1,
getSamplesPerSec(),getHeadBitRate(),0));
state=HPI_OutStreamQueryFormat(NULL,hostream,&hpi_format);
break;
case WaveFile::MpegL2:
HPICall(HPI_FormatCreate(&hpi_format,getChannels(),HPI_FORMAT_MPEG_L2,
getSamplesPerSec(),getHeadBitRate(),0));
state=HPI_OutStreamQueryFormat(NULL,hostream,&hpi_format);
break;;
case WaveFile::MpegL3:
HPICall(HPI_FormatCreate(&hpi_format,getChannels(),HPI_FORMAT_MPEG_L3,
getSamplesPerSec(),getHeadBitRate(),0));
state=HPI_OutStreamQueryFormat(NULL,hostream,&hpi_format);
break;
default:
state=1;
break;
}
if(!is_open) {
HPICall(HPI_OutStreamClose(NULL,hostream));
}
if(state!=0) {
return false;
}
return true;
}
bool RDHPIRecordStream::recordReady()
{
HW16 hpi_error=0;
char hpi_text[200];
if(debug) {
printf("RDHPIRecordStream: received recordReady()\n");
}
if(!is_open) {
return false;
}
if((!is_recording)&&(!is_paused)) {
resetWave();
if(HPI_InStreamGetInfoEx(hpi_subsys,hpi_stream,
&state,&buffer_size,&data_recorded,
&samples_recorded,&reserved)!=0) {
if(debug) {
printf("RDHPIRecordStream: HPI_InStreamGetInfoEx() failed\n");
}
return false;
}
fragment_size=buffer_size/4;
if(fragment_size>192000) { // ALSA Compatibility Limitation
fragment_size=192000;
}
fragment_time=(1000*fragment_size)/(getAvgBytesPerSec());
if(pdata!=NULL) {
delete pdata;
}
pdata=(HW8 *)malloc(fragment_size);
if(pdata==NULL) {
if(debug) {
printf("RDHPIRecordStream: couldn't allocate buffer\n");
}
return false;
}
switch(getFormatTag()) {
case WAVE_FORMAT_PCM:
if(debug) {
printf("RDHPIRecordStream: using PCM%d format\n",
getBitsPerSample());
}
switch(getBitsPerSample()) {
case 8:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM8_UNSIGNED,getSamplesPerSec(),
0,0);
break;
case 16:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM16_SIGNED,getSamplesPerSec(),
0,0);
break;
case 32:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM32_SIGNED,getSamplesPerSec(),
0,0);
break;
default:
if(debug) {
printf("RDHPIRecordStream: unsupported sample size\n");
}
return false;
}
break;
case WAVE_FORMAT_MPEG:
if(debug) {
printf("RDHPIRecordStream: using MPEG-1 Layer %d\n",getHeadLayer());
}
switch(getHeadLayer()) {
case 1:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L1,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags());
break;
case 2:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L2,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags());
break;
case 3:
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_MPEG_L3,getSamplesPerSec(),
getHeadBitRate(),getHeadFlags());
break;
default:
HPI_AdapterClose(hpi_subsys,card_number);
if(debug) {
printf("RDHPIRecordStream: invalid MPEG-1 layer\n");
}
return false;
}
if(getMextChunk()) {
setMextHomogenous(true);
setMextPaddingUsed(false);
setMextHackedBitRate(true);
setMextFreeFormat(false);
setMextFrameSize(144*getHeadBitRate()/getSamplesPerSec());
setMextAncillaryLength(5);
setMextLeftEnergyPresent(true);
if(getChannels()>1) {
setMextRightEnergyPresent(true);
}
else {
setMextRightEnergyPresent(false);
}
setMextPrivateDataPresent(false);
}
break;
case WAVE_FORMAT_VORBIS:
if(debug) {
printf("RDHPIRecordStream: using OggVorbis\n");
}
HPI_FormatCreate(&format,getChannels(),
HPI_FORMAT_PCM16_SIGNED,getSamplesPerSec(),
0,0);
break;
default:
if(debug) {
printf("RDHPIRecordStream: invalid format tag\n");
}
return false;
break;
}
if((hpi_error=HPI_InStreamQueryFormat(hpi_subsys,hpi_stream,
&format))!=0) {
if(debug) {
HPI_GetErrorText(hpi_error,hpi_text);
printf("Num: %d\n",hpi_error);
printf("RDHPIRecordStream: %s\n",hpi_text);
}
return false;
}
}
#if HPI_VER < 0x00030500
HPI_DataCreate(&hpi_data,&format,pdata,fragment_size);
#endif
HPI_InStreamSetFormat(hpi_subsys,hpi_stream,&format);
HPI_InStreamStart(hpi_subsys,hpi_stream);
// clock->start(2*fragment_time/3);
clock->start(100);
is_ready=true;
is_recording=false;
is_paused=false;
stopping=false;
emit isStopped(false);
emit ready();
emit stateChanged(card_number,stream_number,1); // RecordReady
if(debug) {
printf("RDHPIRecordStream: emitted isStopped(false)\n");
printf("RDHPIRecordStream: emitted ready()\n");
printf("RDHPIRecordStream: emitted stateChanged(%d,%d,RDHPIRecordStream::RecordReady)\n",card_number,stream_number);
}
return true;
}
bool RDHPIRecordStream::formatSupported(RDWaveFile::Format format)
{
HPI_FORMAT hformat;
HPI_HISTREAM histream;
bool found=false;
if(card_number<0) {
return false;
}
if(format==RDWaveFile::Vorbis) {
#ifdef HAVE_VORBIS
return true;
#endif // HAVE_VORBIS
return false;
}
if(!is_open) {
for(int i=0;i<sound_card->getCardInputStreams(card_number);i++) {
if(HPI_InStreamOpen(hpi_subsys,card_number,i,&histream)==0) {
found=true;
break;
}
}
if(!found) {
return false;
}
}
else {
histream=hpi_stream;
}
switch(format) {
case RDWaveFile::Pcm8:
HPI_FormatCreate(&hformat,getChannels(),HPI_FORMAT_PCM8_UNSIGNED,
getSamplesPerSec(),getHeadBitRate(),0);
state=HPI_InStreamQueryFormat(hpi_subsys,histream,&hformat);
break;
case RDWaveFile::Pcm16:
HPI_FormatCreate(&hformat,getChannels(),HPI_FORMAT_PCM16_SIGNED,
getSamplesPerSec(),getHeadBitRate(),0);
state=HPI_InStreamQueryFormat(hpi_subsys,histream,&hformat);
break;
case RDWaveFile::MpegL1:
HPI_FormatCreate(&hformat,getChannels(),HPI_FORMAT_MPEG_L1,
getSamplesPerSec(),getHeadBitRate(),0);
state=HPI_InStreamQueryFormat(hpi_subsys,histream,&hformat);
break;
case RDWaveFile::MpegL2:
HPI_FormatCreate(&hformat,getChannels(),HPI_FORMAT_MPEG_L2,
getSamplesPerSec(),getHeadBitRate(),0);
state=HPI_InStreamQueryFormat(hpi_subsys,histream,&hformat);
break;
case RDWaveFile::MpegL3:
HPI_FormatCreate(&hformat,getChannels(),HPI_FORMAT_MPEG_L3,
getSamplesPerSec(),getHeadBitRate(),0);
state=HPI_InStreamQueryFormat(hpi_subsys,histream,&hformat);
break;
default:
state=1;
break;
}
if(!is_open) {
HPI_InStreamClose(hpi_subsys,histream);
}
if(state!=0) {
return false;
}
return true;
}
