void RDHPIRecordStream::tickClock()
{
HPI_InStreamGetInfoEx(hpi_subsys,hpi_stream,
&state,&buffer_size,&data_recorded,
&samples_recorded,&reserved);
if((!record_started)&&(is_recording)) {
if(samples_recorded>0) {
if(record_length>0) {
length_timer->start(record_length,true);
}
emit recordStart();
emit stateChanged(card_number,stream_number,4); // RecordStarted
if(debug) {
printf("RDHPIRecordStream: emitted recordStart()\n");
printf("RDHPIRecordStream: emitted stateChanged(%d,%d,RDHPIRecordStream::RecordStarted)\n",card_number,stream_number);
}
record_started=true;
}
}
while(data_recorded>fragment_size) {
#if HPI_VER > 0x00030500
HPI_InStreamReadBuf(hpi_subsys,hpi_stream,pdata,fragment_size);
#else
HPI_InStreamRead(hpi_subsys,hpi_stream,&hpi_data);
#endif
if(is_recording) {
writeWave(pdata,fragment_size);
}
HPI_InStreamGetInfoEx(hpi_subsys,hpi_stream,
&state,&buffer_size,&data_recorded,
&samples_recorded,&reserved);
}
if(state==HPI_STATE_STOPPED) {
#if HPI_VER > 0x00030500
HPI_InStreamReadBuf(hpi_subsys,hpi_stream,pdata,data_recorded);
#else
HPI_DataCreate(&hpi_data,&format,pdata,data_recorded);
HPI_InStreamRead(hpi_subsys,hpi_stream,&hpi_data);
#endif
if(is_recording) {
writeWave(pdata,data_recorded);
}
}
emit position(samples_recorded);
if(debug) {
printf("RDHPIRecordStream: emitted position(%u)\n",
(unsigned)samples_recorded);
}
}
void AsiHpiDevice::readData()
{
#ifdef ASIHPI
uint16_t state=0;
uint32_t buffer_size=0;
uint32_t data_recorded=0;
uint32_t samples_recorded=0;
uint32_t aux_data_recorded=0;
HpiLog(HPI_InStreamGetInfoEx(NULL,asihpi_input_stream,&state,&buffer_size,
&data_recorded,&samples_recorded,
&aux_data_recorded));
if(state==HPI_STATE_RECORDING) {
if(HpiLog(HPI_InStreamReadBuf(NULL,asihpi_input_stream,asihpi_pcm_buffer,
data_recorded))==0) {
for(unsigned i=0; i<ringBufferQuantity(); i++) {
ringBuffer(i)->write((float *)asihpi_pcm_buffer,
data_recorded/(sizeof(float)*channels()));
}
}
}
else {
Log(LOG_WARNING,"not in recording state"+
QString().sprintf(" [state: %u]",state));
}
#endif // ASIHPI
}
void RDHPIRecordStream::pause()
{
if(debug) {
printf("RDHPIRecordStream: received pause()\n");
}
if(!is_recording) {
return;
}
HPI_InStreamStop(hpi_subsys,hpi_stream);
tickClock();
HPI_InStreamGetInfoEx(hpi_subsys,hpi_stream,
&state,&buffer_size,&data_recorded,
&samples_recorded,&reserved);
is_recording=false;
is_paused=true;
HPI_InStreamStart(hpi_subsys,hpi_stream);
emit paused();
emit stateChanged(card_number,stream_number,2); // Paused
if(debug) {
printf("RDHPIRecordStream: emitted paused()\n");
printf("RDHPIRecordStream: emitted stateChanged(%d,%d,RDHPIRecordStream::Paused)\n",card_number,stream_number);
}
}
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 AsiHpiDevice::start(QString *err)
{
#ifdef ASIHPI
hpi_err_t herr;
struct hpi_format fmt;
uint16_t state=0;
uint32_t buffer_size=0;
uint32_t data_recorded=0;
uint32_t samples_recorded=0;
uint32_t aux_data_recorded=0;
hpi_handle_t handle;
short lvls[HPI_MAX_CHANNELS];
//
// Open Mixer
//
if(HpiLog(HPI_MixerOpen(NULL,asihpi_adapter_index,&asihpi_mixer))==0) {
//
// Input Gain
//
if(HPI_MixerGetControl(NULL,asihpi_mixer,
HPI_SOURCENODE_LINEIN,asihpi_input_index,
HPI_DESTNODE_NONE,0,HPI_CONTROL_VOLUME,
&handle)==0) {
for(unsigned i=0; i<HPI_MAX_CHANNELS; i++) {
lvls[i]=asihpi_input_gain*100;
}
HpiLog(HPI_VolumeSetGain(NULL,handle,lvls));
}
//
// Input Source
//
if(HpiLog(HPI_MixerGetControl(NULL,asihpi_mixer,0,0,
HPI_DESTNODE_ISTREAM,asihpi_input_index,
HPI_CONTROL_MULTIPLEXER,&handle))==0) {
HpiLog(HPI_Multiplexer_SetSource(NULL,handle,asihpi_input_source,
asihpi_input_index));
}
//
// Input Type
//
if((HpiLog(HPI_MixerGetControl(NULL,asihpi_mixer,
HPI_SOURCENODE_LINEIN,asihpi_input_index,
HPI_DESTNODE_NONE,0,
HPI_CONTROL_MULTIPLEXER,&handle)))==0) {
HpiLog(HPI_Multiplexer_SetSource(NULL,handle,asihpi_input_type,
asihpi_input_index));
}
//
// Channel Mode
//
if((HpiLog(HPI_MixerGetControl(NULL,asihpi_mixer,0,0,
HPI_DESTNODE_ISTREAM,asihpi_input_index,
HPI_CONTROL_CHANNEL_MODE,
&handle)))==0) {
HpiLog(HPI_ChannelModeSet(NULL,handle,asihpi_channel_mode));
}
//
// Input Meter
//
if((HpiLog(HPI_MixerGetControl(NULL,asihpi_mixer,0,0,HPI_DESTNODE_ISTREAM,
asihpi_input_index,HPI_CONTROL_METER,&asihpi_input_meter)))==0) {
asihpi_meter_timer->start(100);
}
}
//
// Open Input Stream
//
if((herr=HPI_InStreamOpen(NULL,asihpi_adapter_index,asihpi_input_index,&asihpi_input_stream))!=0) {
*err=tr("HPI error")+": "+hpi_strerror(herr);
return false;
}
//
// Find Supported Format
//
MakeFormat(&fmt,HPI_FORMAT_PCM32_FLOAT);
if((herr=HPI_InStreamQueryFormat(NULL,asihpi_input_stream,&fmt))!=0) {
*err=tr("HPI error")+": "+hpi_strerror(herr);
return false;
}
//
// Set Format
//
if((herr=HPI_InStreamSetFormat(NULL,asihpi_input_stream,&fmt))!=0) {
*err=tr("HPI error")+": "+hpi_strerror(herr);
return false;
}
//
// Start input stream
//
if((herr=HPI_InStreamStart(NULL,asihpi_input_stream))!=0) {
*err=tr("HPI error")+": "+hpi_strerror(herr);
return false;
}
//
// Create PCM buffer
//
if((herr=HPI_InStreamGetInfoEx(NULL,asihpi_input_stream,&state,&buffer_size,
&data_recorded,&samples_recorded,
&aux_data_recorded))!=0) {
*err=tr("HPI error")+": "+hpi_strerror(herr);
return false;
}
asihpi_pcm_buffer=new uint8_t[buffer_size];
asihpi_read_timer->start(ASIHPI_READ_INTERVAL);
return true;
#else
return false;
#endif // ASIHPI
}
