int clear_rec_buffer(void)
{
int move, i;
timerclear(&rec_buffer.last_signal_time);
if (hw.rec_mode == LIRC_MODE_LIRCCODE) {
unsigned char buffer[sizeof(ir_code)];
size_t count;
count = hw.code_length / CHAR_BIT;
if (hw.code_length % CHAR_BIT)
count++;
if (read(hw.fd, buffer, count) != count) {
logprintf(LOG_ERR, "reading in mode LIRC_MODE_LIRCCODE failed");
return (0);
}
for (i = 0, rec_buffer.decoded = 0; i < count; i++) {
rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((ir_code) buffer[i]);
}
} else {
lirc_t data;
move = rec_buffer.wptr - rec_buffer.rptr;
if (move > 0 && rec_buffer.rptr > 0) {
memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
sizeof(rec_buffer.data[0]) * move);
rec_buffer.wptr -= rec_buffer.rptr;
} else {
rec_buffer.wptr = 0;
data = hw.readdata(0);
logprintf(3, "c%lu", (__u32) data & (PULSE_MASK));
rec_buffer.data[rec_buffer.wptr] = data;
rec_buffer.wptr++;
}
}
rewind_rec_buffer();
rec_buffer.is_biphase = 0;
return (1);
}
int clear_rec_buffer(void) {
if(hw.rec_mode==LIRC_MODE_LIRCCODE || hw.rec_mode==LIRC_MODE_CODE) {
rec_buffer.decoded = hw.get_ir_code();
}
else {
//===========
lirc_t data;
int move;
//===========
move=rec_buffer.wptr-rec_buffer.rptr;
if(move>0 && rec_buffer.rptr>0)
{
memmove(&rec_buffer.data[0],
&rec_buffer.data[rec_buffer.rptr],
sizeof(rec_buffer.data[0])*move);
rec_buffer.wptr-=rec_buffer.rptr;
}
else
{
rec_buffer.wptr=0;
data=emulation_readdata(0);
rec_buffer.data[rec_buffer.wptr]=data;
rec_buffer.wptr++;
}
}
rewind_rec_buffer();
rec_buffer.is_biphase=0;
return(1);
}
int audio_init()
{
PaStreamParameters inputParameters;
PaStreamParameters outputParameters;
PaError err;
int flags;
struct termios t;
char api[1024];
char device[1024];
double latency;
LOGPRINTF(1, "hw_audio_init()");
//
logprintf(LOG_INFO, "Initializing %s...", hw.device);
init_rec_buffer();
rewind_rec_buffer();
/* new */
data.lastFrames[0] = 128;
data.lastFrames[1] = 128;
data.lastFrames[2] = 128;
data.lastSign = 0;
data.lastCount = 0;
data.pulseSign = 0;
data.carrierPos = 0.0;
data.remainingSignal = 0.0;
data.signalPhase = 0;
data.signaledDone = 1;
data.samplesToIgnore = 0;
data.carrierFreq = DEFAULT_FREQ;
err = Pa_Initialize();
if (err != paNoError)
goto error;
audio_parsedevicestr(api, device, &data.samplerate, &latency);
logprintf(LOG_INFO, "Using samplerate %i", data.samplerate);
/* choose input device */
audio_choosedevice(&inputParameters, 1, api, device, latency);
if (inputParameters.device == paNoDevice) {
logprintf(LOG_ERR, "No input device found");
goto error;
}
inputParameters.channelCount = NUM_CHANNELS; /* stereo input */
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.hostApiSpecificStreamInfo = NULL;
/* choose output device */
audio_choosedevice(&outputParameters, 0, api, device, latency);
if (outputParameters.device == paNoDevice) {
logprintf(LOG_ERR, "No output device found");
goto error;
}
outputParameters.channelCount = NUM_CHANNELS; /* stereo output */
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.hostApiSpecificStreamInfo = NULL;
outputLatency = outputParameters.suggestedLatency * 1000000;
/* Record some audio. -------------------------------------------- */
err = Pa_OpenStream(&stream, &inputParameters, &outputParameters, data.samplerate, 512, /* frames per buffer */
paPrimeOutputBuffersUsingStreamCallback, recordCallback, &data);
if (err != paNoError)
goto error;
/* open pty */
if (openpty(&master, &ptyfd, ptyName, 0, 0) == -1) {
logprintf(LOG_ERR, "openpty failed");
logperror(LOG_ERR, "openpty()");
goto error;
}
/* regular device file */
if (tcgetattr(master, &t) < 0) {
logprintf(LOG_ERR, "tcgetattr failed");
logperror(LOG_ERR, "tcgetattr()");
}
cfmakeraw(&t);
/* apply file descriptor options */
if (tcsetattr(master, TCSANOW, &t) < 0) {
logprintf(LOG_ERR, "tcsetattr failed");
logperror(LOG_ERR, "tcsetattr()");
}
flags = fcntl(ptyfd, F_GETFL, 0);
if (flags != -1) {
fcntl(ptyfd, F_SETFL, flags | O_NONBLOCK);
}
LOGPRINTF(LOG_INFO, "PTY name: %s", ptyName);
hw.fd = ptyfd;
/* make a pipe for sending signals to the callback */
/* make a pipe for signaling from the callback that everything
was sent */
if (pipe(sendPipe) == -1 || pipe(completedPipe) == -1) {
logprintf(LOG_ERR, "pipe failed");
logperror(LOG_ERR, "pipe()");
}
/* make the readable end non-blocking */
flags = fcntl(sendPipe[0], F_GETFL, 0);
if (flags != -1) {
fcntl(sendPipe[0], F_SETFL, flags | O_NONBLOCK);
} else {
logprintf(LOG_ERR, "fcntl failed");
logperror(LOG_ERR, "fcntl()");
}
err = Pa_StartStream(stream);
if (err != paNoError)
goto error;
/* wait for portaudio to settle */
usleep(50000);
return (1);
error:
Pa_Terminate();
logprintf(LOG_ERR, "an error occured while using the portaudio stream");
logprintf(LOG_ERR, "error number: %d", err);
logprintf(LOG_ERR, "error message: %s", Pa_GetErrorText(err));
return (0);
}
int receive_decode(struct ir_remote *remote,
ir_code *prep,ir_code *codep,ir_code *postp,
int *repeat_flagp,lirc_t *remaining_gapp)
{
ir_code pre,code,post,code_mask=0,post_mask=0;
lirc_t sync;
int header;
struct timeval current;
sync=0; /* make compiler happy */
code=pre=post=0;
header=0;
if(hw.rec_mode==LIRC_MODE_MODE2 ||
hw.rec_mode==LIRC_MODE_PULSE ||
hw.rec_mode==LIRC_MODE_RAW)
{
rewind_rec_buffer();
rec_buffer.is_biphase=is_biphase(remote) ? 1:0;
/* we should get a long space first */
if(!(sync=sync_rec_buffer(remote)))
{
LOGPRINTF(1,"failed on sync");
return(0);
}
LOGPRINTF(1,"sync");
if(has_repeat(remote) && last_remote==remote)
{
if(remote->flags&REPEAT_HEADER && has_header(remote))
{
if(!get_header(remote))
{
LOGPRINTF(1,"failed on repeat "
"header");
return(0);
}
LOGPRINTF(1,"repeat header");
}
if(get_repeat(remote))
{
if(remote->last_code==NULL)
{
logprintf(LOG_NOTICE,"repeat code "
"without last_code "
"received");
return(0);
}
*prep=remote->pre_data;
*codep=remote->last_code->code;
*postp=remote->post_data;
*repeat_flagp=1;
*remaining_gapp=
is_const(remote) ?
(remote->gap>rec_buffer.sum ?
remote->gap-rec_buffer.sum:0):
(has_repeat_gap(remote) ?
remote->repeat_gap:remote->gap);
return(1);
}
else
{
LOGPRINTF(1,"no repeat");
rewind_rec_buffer();
sync_rec_buffer(remote);
}
}
if(has_header(remote))
{
header=1;
if(!get_header(remote))
{
header=0;
if(!(remote->flags&NO_HEAD_REP &&
(sync<=remote->gap+remote->gap*remote->eps/100
|| sync<=remote->gap+remote->aeps)))
{
LOGPRINTF(1,"failed on header");
return(0);
}
}
LOGPRINTF(1,"header");
}
}
if(is_raw(remote))
{
struct ir_ncode *codes,*found;
int i;
if(hw.rec_mode==LIRC_MODE_CODE ||
hw.rec_mode==LIRC_MODE_LIRCCODE)
return(0);
codes=remote->codes;
found=NULL;
while(codes->name!=NULL && found==NULL)
{
found=codes;
for(i=0;i<codes->length;)
{
if(!expectpulse(remote,codes->signals[i++]))
{
found=NULL;
rewind_rec_buffer();
sync_rec_buffer(remote);
break;
}
if(i<codes->length &&
!expectspace(remote,codes->signals[i++]))
{
found=NULL;
rewind_rec_buffer();
sync_rec_buffer(remote);
break;
}
}
codes++;
}
if(found!=NULL)
{
if(!get_gap(remote,
is_const(remote) ?
remote->gap-rec_buffer.sum:
remote->gap))
found=NULL;
}
if(found==NULL) return(0);
code=found->code;
}
else
{
if(hw.rec_mode==LIRC_MODE_CODE ||
hw.rec_mode==LIRC_MODE_LIRCCODE)
{
int i;
lirc_t sum;
# ifdef LONG_IR_CODE
LOGPRINTF(1,"decoded: %llx",rec_buffer.decoded);
# else
LOGPRINTF(1,"decoded: %lx",rec_buffer.decoded);
# endif
if((hw.rec_mode==LIRC_MODE_CODE &&
hw.code_length<remote->pre_data_bits
+remote->bits+remote->post_data_bits)
||
(hw.rec_mode==LIRC_MODE_LIRCCODE &&
hw.code_length!=remote->pre_data_bits
+remote->bits+remote->post_data_bits))
{
return(0);
}
for(i=0;i<remote->post_data_bits;i++)
{
post_mask=(post_mask<<1)+1;
}
post=rec_buffer.decoded&post_mask;
post_mask=0;
rec_buffer.decoded=
rec_buffer.decoded>>remote->post_data_bits;
for(i=0;i<remote->bits;i++)
{
code_mask=(code_mask<<1)+1;
}
code=rec_buffer.decoded&code_mask;
code_mask=0;
pre=rec_buffer.decoded>>remote->bits;
gettimeofday(¤t,NULL);
sum=remote->phead+remote->shead+
lirc_t_max(remote->pone+remote->sone,
remote->pzero+remote->szero)*
(remote->bits+
remote->pre_data_bits+
remote->post_data_bits)+
remote->plead+
remote->ptrail+
remote->pfoot+remote->sfoot+
remote->pre_p+remote->pre_s+
remote->post_p+remote->post_s;
rec_buffer.sum=sum>=remote->gap ? remote->gap-1:sum;
sync=time_elapsed(&remote->last_send,¤t)-
rec_buffer.sum;
}
else
{
if(!get_lead(remote))
