inline lirc_t sync_rec_buffer(struct ir_remote * remote)
{
int count;
lirc_t deltas, deltap;
count = 0;
deltas = get_next_space(1000000);
if (deltas == 0)
return (0);
if (last_remote != NULL && !is_rcmm(remote)) {
while (!expect_at_least(last_remote, deltas, last_remote->min_remaining_gap)) {
deltap = get_next_pulse(1000000);
if (deltap == 0)
return (0);
deltas = get_next_space(1000000);
if (deltas == 0)
return (0);
count++;
if (count > REC_SYNC) { /* no sync found,
let's try a diffrent remote */
return (0);
}
}
if (has_toggle_mask(remote)) {
if (!expect_at_most(last_remote, deltas, last_remote->max_remaining_gap)) {
remote->toggle_mask_state = 0;
remote->toggle_code = NULL;
}
}
}
rec_buffer.sum = 0;
return (deltas);
}
void fprint_remote_head(FILE *f, struct ir_remote *rem)
{
fprintf(f, "begin remote\n\n");
if(!is_raw(rem)){
fprintf(f, " name %s\n",rem->name);
fprintf(f, " bits %5d\n",rem->bits);
fprint_flags(f,rem->flags);
fprintf(f, " eps %5d\n",rem->eps);
fprintf(f, " aeps %5d\n\n",rem->aeps);
if(has_header(rem))
{
fprintf(f, " header %5lu %5lu\n",
(unsigned long) rem->phead,
(unsigned long) rem->shead);
}
if(rem->pthree!=0 || rem->sthree!=0)
fprintf(f, " three %5lu %5lu\n",
(unsigned long) rem->pthree,
(unsigned long) rem->sthree);
if(rem->ptwo!=0 || rem->stwo!=0)
fprintf(f, " two %5lu %5lu\n",
(unsigned long) rem->ptwo,
(unsigned long) rem->stwo);
fprintf(f, " one %5lu %5lu\n",
(unsigned long) rem->pone,
(unsigned long) rem->sone);
fprintf(f, " zero %5lu %5lu\n",
(unsigned long) rem->pzero,
(unsigned long) rem->szero);
if(rem->ptrail!=0)
{
fprintf(f, " ptrail %5lu\n",
(unsigned long) rem->ptrail);
}
if(rem->plead!=0)
{
fprintf(f, " plead %5lu\n",
(unsigned long) rem->plead);
}
if(has_foot(rem))
{
fprintf(f, " foot %5lu %5lu\n",
(unsigned long) rem->pfoot,
(unsigned long) rem->sfoot);
}
if(has_repeat(rem))
{
fprintf(f, " repeat %5lu %5lu\n",
(unsigned long) rem->prepeat,
(unsigned long) rem->srepeat);
}
if(rem->pre_data_bits>0)
{
fprintf(f, " pre_data_bits %d\n",rem->pre_data_bits);
# ifdef LONG_IR_CODE
fprintf(f, " pre_data 0x%llX\n",rem->pre_data);
# else
fprintf(f, " pre_data 0x%lX\n",rem->pre_data);
# endif
}
if(rem->post_data_bits>0)
{
fprintf(f, " post_data_bits %d\n",rem->post_data_bits);
# ifdef LONG_IR_CODE
fprintf(f, " post_data 0x%llX\n",rem->post_data);
# else
fprintf(f, " post_data 0x%lX\n",rem->post_data);
# endif
}
if(rem->pre_p!=0 && rem->pre_s!=0)
{
fprintf(f, " pre %5lu %5lu\n",
(unsigned long) rem->pre_p,
(unsigned long) rem->pre_s);
}
if(rem->post_p!=0 && rem->post_s!=0)
{
fprintf(f, " post %5lu %5lu\n",
(unsigned long) rem->post_p,
(unsigned long) rem->post_s);
}
fprintf(f, " gap %lu\n",
(unsigned long) rem->gap);
if(has_repeat_gap(rem))
{
fprintf(f, " repeat_gap %lu\n",
(unsigned long) rem->repeat_gap);
}
if(rem->min_repeat>0)
{
fprintf(f, " min_repeat %d\n",rem->min_repeat);
}
if(rem->min_code_repeat>0)
{
fprintf(f, " min_code_repeat %d\n",
rem->min_code_repeat);
}
# ifdef LONG_IR_CODE
fprintf(f, " toggle_bit_mask 0x%llX\n",
rem->toggle_bit_mask);
# else
fprintf(f, " toggle_bit_mask 0x%lX\n",
rem->toggle_bit_mask);
# endif
if(has_toggle_mask(rem))
{
# ifdef LONG_IR_CODE
fprintf(f, " toggle_mask 0x%llX\n",
rem->toggle_mask);
# else
fprintf(f, " toggle_mask 0x%lX\n",
rem->toggle_mask);
# endif
}
if(rem->rc6_mask!=0)
{
# ifdef LONG_IR_CODE
fprintf(f, " rc6_mask 0x%llX\n",
rem->rc6_mask);
# else
fprintf(f, " rc6_mask 0x%lX\n",
rem->rc6_mask);
# endif
}
if(is_serial(rem))
{
fprintf(f, " baud %d\n",rem->baud);
fprintf(f, " serial_mode %dN%d%s\n",
rem->bits_in_byte,
rem->stop_bits/2,
rem->stop_bits%2 ? ".5":"");
}
}
else
{
fprintf(f, " name %s\n",rem->name);
fprint_flags(f,rem->flags);
fprintf(f, " eps %5d\n",rem->eps);
fprintf(f, " aeps %5d\n\n",rem->aeps);
fprintf(f, " ptrail %5lu\n",(unsigned long) rem->ptrail);
fprintf(f, " repeat %5lu %5lu\n",
(unsigned long) rem->prepeat,
(unsigned long) rem->srepeat);
fprintf(f, " gap %lu\n",(unsigned long) rem->gap);
}
if(rem->freq!=0)
{
fprintf(f, " frequency %u\n",rem->freq);
}
if(rem->duty_cycle!=0)
{
fprintf(f, " duty_cycle %u\n",rem->duty_cycle);
}
fprintf(f,"\n");
}
void fprint_remote_head(FILE* f, const struct ir_remote* rem)
{
fprintf(f, "begin remote\n\n");
fprintf(f, " name %s\n", rem->name);
if (rem->manual_sort)
fprintf(f, " manual_sort %d\n", rem->manual_sort);
if (rem->driver)
fprintf(f, " driver %s\n", rem->driver);
if (!is_raw(rem))
fprintf(f, " bits %5d\n", rem->bits);
fprint_flags(f, rem->flags);
fprintf(f, " eps %5d\n", rem->eps);
fprintf(f, " aeps %5d\n\n", rem->aeps);
if (!is_raw(rem)) {
if (has_header(rem))
fprintf(f, " header %5u %5u\n", (__u32)rem->phead, (__u32)rem->shead);
if (rem->pthree != 0 || rem->sthree != 0)
fprintf(f, " three %5u %5u\n", (__u32)rem->pthree, (__u32)rem->sthree);
if (rem->ptwo != 0 || rem->stwo != 0)
fprintf(f, " two %5u %5u\n", (__u32)rem->ptwo, (__u32)rem->stwo);
fprintf(f, " one %5u %5u\n", (__u32)rem->pone, (__u32)rem->sone);
fprintf(f, " zero %5u %5u\n", (__u32)rem->pzero, (__u32)rem->szero);
}
if (rem->ptrail != 0)
fprintf(f, " ptrail %5u\n", (__u32)rem->ptrail);
if (!is_raw(rem)) {
if (rem->plead != 0)
fprintf(f, " plead %5u\n", (__u32)rem->plead);
if (has_foot(rem))
fprintf(f, " foot %5u %5u\n", (__u32)rem->pfoot, (__u32)rem->sfoot);
}
if (has_repeat(rem))
fprintf(f, " repeat %5u %5u\n", (__u32)rem->prepeat, (__u32)rem->srepeat);
if (!is_raw(rem)) {
if (rem->pre_data_bits > 0) {
fprintf(f, " pre_data_bits %d\n", rem->pre_data_bits);
fprintf(f, " pre_data 0x%llX\n", (unsigned long long)rem->pre_data);
}
if (rem->post_data_bits > 0) {
fprintf(f, " post_data_bits %d\n", rem->post_data_bits);
fprintf(f, " post_data 0x%llX\n", (unsigned long long)rem->post_data);
}
if (rem->pre_p != 0 && rem->pre_s != 0)
fprintf(f, " pre %5u %5u\n", (__u32)rem->pre_p, (__u32)rem->pre_s);
if (rem->post_p != 0 && rem->post_s != 0)
fprintf(f, " post %5u %5u\n", (__u32)rem->post_p, (__u32)rem->post_s);
}
fprint_remote_gap(f, rem);
if (has_repeat_gap(rem))
fprintf(f, " repeat_gap %u\n", (__u32)rem->repeat_gap);
if (rem->suppress_repeat > 0)
fprintf(f, " suppress_repeat %d\n", rem->suppress_repeat);
if (rem->min_repeat > 0) {
fprintf(f, " min_repeat %d\n", rem->min_repeat);
if (rem->suppress_repeat == 0) {
fprintf(f, "# suppress_repeat %d\n", rem->min_repeat);
fprintf(f, "# uncomment to suppress unwanted repeats\n");
}
}
if (!is_raw(rem)) {
if (rem->min_code_repeat > 0)
fprintf(f, " min_code_repeat %d\n", rem->min_code_repeat);
fprintf(f, " toggle_bit_mask 0x%llX\n", (unsigned long long)rem->toggle_bit_mask);
if (has_toggle_mask(rem))
fprintf(f, " toggle_mask 0x%llX\n", (unsigned long long)rem->toggle_mask);
if (rem->repeat_mask != 0)
fprintf(f, " repeat_mask 0x%llX\n", (unsigned long long)rem->repeat_mask);
if (rem->rc6_mask != 0)
fprintf(f, " rc6_mask 0x%llX\n", (unsigned long long)rem->rc6_mask);
if (has_ignore_mask(rem))
fprintf(f, " ignore_mask 0x%llX\n", (unsigned long long)rem->ignore_mask);
if (is_serial(rem)) {
fprintf(f, " baud %d\n", rem->baud);
fprintf(f, " serial_mode %dN%d%s\n", rem->bits_in_byte, rem->stop_bits / 2,
rem->stop_bits % 2 ? ".5" : "");
}
}
if (rem->freq != 0)
fprintf(f, " frequency %u\n", rem->freq);
if (rem->duty_cycle != 0)
fprintf(f, " duty_cycle %u\n", rem->duty_cycle);
fprintf(f, "\n");
}
int init_send(struct ir_remote *remote,struct ir_ncode *code)
{
int i, repeat=0;
if(is_grundig(remote) ||
is_goldstar(remote) || is_serial(remote) || is_bo(remote))
{
logprintf(LOG_ERR,"sorry, can't send this protocol yet");
return(0);
}
clear_send_buffer();
if(is_biphase(remote))
{
send_buffer.is_biphase=1;
}
if(repeat_remote==NULL)
{
remote->repeat_countdown=remote->min_repeat;
}
else
{
repeat = 1;
}
init_send_loop:
if(repeat && has_repeat(remote))
{
if(remote->flags&REPEAT_HEADER && has_header(remote))
{
send_header(remote);
}
send_repeat(remote);
}
else
{
if(!is_raw(remote))
{
ir_code next_code;
if(code->transmit_state == NULL)
{
next_code = code->code;
}
else
{
next_code = code->transmit_state->code;
}
send_code(remote, next_code, repeat);
if(has_toggle_mask(remote))
{
remote->toggle_mask_state++;
if(remote->toggle_mask_state==4)
{
remote->toggle_mask_state=2;
}
}
send_buffer.data=send_buffer._data;
}
else
{
if(code->signals==NULL)
{
logprintf(LOG_ERR, "no signals for raw send");
return 0;
}
if(send_buffer.wptr>0)
{
send_signals(code->signals, code->length);
}
else
{
send_buffer.data=code->signals;
send_buffer.wptr=code->length;
for(i=0; i<code->length; i++)
{
send_buffer.sum+=code->signals[i];
}
}
}
}
sync_send_buffer();
if(bad_send_buffer())
{
logprintf(LOG_ERR,"buffer too small");
return(0);
}
if(has_repeat_gap(remote) && repeat && has_repeat(remote))
{
remote->min_remaining_gap=remote->repeat_gap;
remote->max_remaining_gap=remote->repeat_gap;
}
else if(is_const(remote))
{
if(min_gap(remote)>send_buffer.sum)
{
remote->min_remaining_gap=min_gap(remote)-send_buffer.sum;
remote->max_remaining_gap=max_gap(remote)-send_buffer.sum;
}
else
{
logprintf(LOG_ERR,"too short gap: %u",remote->gap);
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
return(0);
}
}
else
{
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
}
/* update transmit state */
if(code->next != NULL)
{
if(code->transmit_state == NULL)
{
code->transmit_state = code->next;
}
else
{
code->transmit_state = code->transmit_state->next;
}
}
if((remote->repeat_countdown>0 || code->transmit_state != NULL) &&
remote->min_remaining_gap<LIRCD_EXACT_GAP_THRESHOLD)
{
if(send_buffer.data!=send_buffer._data)
{
lirc_t *signals;
int n;
LOGPRINTF(1, "unrolling raw signal optimisation");
signals=send_buffer.data;
n=send_buffer.wptr;
send_buffer.data=send_buffer._data;
send_buffer.wptr=0;
send_signals(signals, n);
}
LOGPRINTF(1, "concatenating low gap signals");
if(code->next == NULL || code->transmit_state == NULL)
{
remote->repeat_countdown--;
}
send_space(remote->min_remaining_gap);
flush_send_buffer();
send_buffer.sum=0;
repeat = 1;
goto init_send_loop;
}
LOGPRINTF(3, "transmit buffer ready");
return(1);
}
inline void send_data(struct ir_remote *remote,ir_code data,int bits,int done)
{
int i;
int all_bits = bit_count(remote);
ir_code mask;
if(is_rcmm(remote))
{
data=reverse(data,bits);
mask=1<<(all_bits-1-done);
if(bits%2 || done%2)
{
logprintf(LOG_ERR,"invalid bit number.");
return;
}
for(i=0;i<bits;i+=2,mask>>=2)
{
switch(data&3)
{
case 0:
send_pulse(remote->pzero);
send_space(remote->szero);
break;
/* 2 and 1 swapped due to reverse() */
case 2:
send_pulse(remote->pone);
send_space(remote->sone);
break;
case 1:
send_pulse(remote->ptwo);
send_space(remote->stwo);
break;
case 3:
send_pulse(remote->pthree);
send_space(remote->sthree);
break;
}
data=data>>2;
}
return;
}
data=reverse(data,bits);
mask=((ir_code) 1)<<(all_bits-1-done);
for(i=0;i<bits;i++,mask>>=1)
{
if(has_toggle_bit_mask(remote) && mask&remote->toggle_bit_mask)
{
data &= ~((ir_code) 1);
if(remote->toggle_bit_mask_state&mask)
{
data |= (ir_code) 1;
}
}
if(has_toggle_mask(remote) &&
mask&remote->toggle_mask &&
remote->toggle_mask_state%2)
{
data ^= 1;
}
if(data&1)
{
if(is_biphase(remote))
{
if(mask&remote->rc6_mask)
{
send_space(2*remote->sone);
send_pulse(2*remote->pone);
}
else
{
send_space(remote->sone);
send_pulse(remote->pone);
}
}
else if(is_space_first(remote))
{
send_space(remote->sone);
send_pulse(remote->pone);
}
else
{
send_pulse(remote->pone);
send_space(remote->sone);
}
}
else
{
if(mask&remote->rc6_mask)
{
send_pulse(2*remote->pzero);
send_space(2*remote->szero);
}
else if(is_space_first(remote))
{
send_space(remote->szero);
send_pulse(remote->pzero);
}
else
{
send_pulse(remote->pzero);
send_space(remote->szero);
}
}
data=data>>1;
}
}
struct ir_ncode *get_code(struct ir_remote *remote,
ir_code pre,ir_code code,ir_code post,
int *repeat_statep)
{
ir_code pre_mask,code_mask,post_mask;
int repeat_state;
struct ir_ncode *codes,*found;
pre_mask=code_mask=post_mask=0;
repeat_state=0;
if(remote->toggle_bit>0)
{
if(remote->toggle_bit<=remote->pre_data_bits)
{
repeat_state=
pre&(1<<(remote->pre_data_bits
-remote->toggle_bit)) ? 1:0;
pre_mask=1<<(remote->pre_data_bits
-remote->toggle_bit);
}
else if(remote->toggle_bit<=remote->pre_data_bits
+remote->bits)
{
repeat_state=
code&(1<<(remote->pre_data_bits
+remote->bits
-remote->toggle_bit)) ? 1:0;
code_mask=1<<(remote->pre_data_bits
+remote->bits
-remote->toggle_bit);
}
else if(remote->toggle_bit<=remote->pre_data_bits
+remote->bits
+remote->post_data_bits)
{
repeat_state=
post&(1<<(remote->pre_data_bits
+remote->bits
+remote->post_data_bits
-remote->toggle_bit)) ? 1:0;
post_mask=1<<(remote->pre_data_bits
+remote->bits
+remote->post_data_bits
-remote->toggle_bit);
}
else
{
logprintf(LOG_ERR,"bad toggle_bit");
}
}
if(has_toggle_mask(remote) && remote->toggle_mask_state%2)
{
ir_code *affected,mask,mask_bit;
int bit,current_bit;
affected=&post;
mask=remote->toggle_mask;
for(bit=current_bit=0;bit<remote->pre_data_bits+
remote->bits+
remote->post_data_bits;bit++,current_bit++)
{
if(bit==remote->post_data_bits)
{
affected=&code;
current_bit=0;
}
if(bit==remote->post_data_bits+remote->bits)
{
affected=&post;
current_bit=0;
}
mask_bit=mask&1;
(*affected)^=(mask_bit<<current_bit);
mask>>=1;
}
}
