25 #include "include/media/lirc.h"
26 #include "lirc/driver.h"
27 #include "lirc/lirc_log.h"
28 #include "lirc/receive.h"
29 #include "lirc/ir_remote.h"
39 lirc_t data[RBUF_SIZE];
48 struct timeval last_signal_time;
57 static struct rbuf rec_buffer;
58 static int update_mode = 0;
67 static lirc_t readdata(lirc_t timeout)
72 rec_buffer.at_eof = data &
LIRC_EOF ? 1 : 0;
73 if (rec_buffer.at_eof)
74 logprintf(LIRC_DEBUG,
"receive: Got EOF");
79 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
84 static void set_pending_pulse(lirc_t deltap)
86 LOGPRINTF(5,
"pending pulse: %lu", deltap);
87 rec_buffer.pendingp = deltap;
90 static void set_pending_space(lirc_t deltas)
92 LOGPRINTF(5,
"pending space: %lu", deltas);
93 rec_buffer.pendings = deltas;
97 static void log_input(lirc_t data)
99 fprintf(rec_buffer.input_log,
"%s %u\n",
100 data & PULSE_BIT ?
"pulse" :
"space", data & PULSE_MASK);
101 fflush(rec_buffer.input_log);
105 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
107 if (rec_buffer.rptr < rec_buffer.wptr) {
108 LOGPRINTF(3,
"<%c%lu", rec_buffer.data[rec_buffer.rptr] & PULSE_BIT ?
'p' :
's', (__u32)
109 rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK));
110 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
111 return rec_buffer.data[rec_buffer.rptr++];
113 if (rec_buffer.wptr < RBUF_SIZE) {
115 unsigned long elapsed = 0;
117 if (timerisset(&rec_buffer.last_signal_time)) {
118 struct timeval current;
120 gettimeofday(¤t, NULL);
121 elapsed = time_elapsed(&rec_buffer.last_signal_time, ¤t);
123 if (elapsed < maxusec)
124 data = readdata(maxusec - elapsed);
130 logprintf(LIRC_DEBUG,
"Receive: returning EOF");
133 if (LIRC_IS_TIMEOUT(data)) {
134 LOGPRINTF(1,
"timeout received: %lu", (__u32)LIRC_VALUE(data));
135 if (LIRC_VALUE(data) < maxusec)
136 return get_next_rec_buffer_internal(maxusec - LIRC_VALUE(data));
140 rec_buffer.data[rec_buffer.wptr] = data;
141 if (rec_buffer.input_log != NULL)
143 if (rec_buffer.data[rec_buffer.wptr] == 0)
145 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
149 LOGPRINTF(3,
"+%c%lu", rec_buffer.data[rec_buffer.rptr - 1] & PULSE_BIT ?
'p' :
's', (__u32)
150 rec_buffer.data[rec_buffer.rptr - 1]
152 return rec_buffer.data[rec_buffer.rptr - 1];
154 rec_buffer.too_long = 1;
161 struct pollfd pfd = {
167 ret = poll(&pfd, 1, (maxusec > 0) ? (maxusec / 1000) : -1);
168 if (maxusec > 0 && ret == 0)
170 }
while (ret == -1 && errno == EINTR);
177 if (pfd.revents & POLLIN)
186 if (rec_buffer.input_log != NULL)
187 fclose(rec_buffer.input_log);
188 rec_buffer.input_log = f;
192 static lirc_t get_next_rec_buffer(lirc_t maxusec)
194 return get_next_rec_buffer_internal(receive_timeout(maxusec));
199 memset(&rec_buffer, 0,
sizeof(rec_buffer));
205 rec_buffer.too_long = 0;
206 set_pending_pulse(0);
207 set_pending_space(0);
209 rec_buffer.at_eof = 0;
221 timerclear(&rec_buffer.last_signal_time);
223 unsigned char buffer[
sizeof(
ir_code)];
231 logprintf(LIRC_ERROR,
"reading in mode LIRC_MODE_LIRCCODE failed");
234 for (i = 0, rec_buffer.decoded = 0; i < count; i++)
235 rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((
ir_code)buffer[i]);
239 move = rec_buffer.wptr - rec_buffer.rptr;
240 if (move > 0 && rec_buffer.rptr > 0) {
241 memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
242 sizeof(rec_buffer.data[0]) * move);
243 rec_buffer.wptr -= rec_buffer.rptr;
248 LOGPRINTF(3,
"c%lu", (__u32)data & (PULSE_MASK));
250 rec_buffer.data[rec_buffer.wptr] = data;
256 rec_buffer.is_biphase = 0;
261 static void unget_rec_buffer(
int count)
264 if (count == 1 || count == 2) {
265 rec_buffer.rptr -= count;
266 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
268 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
273 static void unget_rec_buffer_delta(lirc_t delta)
276 rec_buffer.sum -= delta & (PULSE_MASK);
277 rec_buffer.data[rec_buffer.rptr] = delta;
280 static lirc_t get_next_pulse(lirc_t maxusec)
284 data = get_next_rec_buffer(maxusec);
287 if (!is_pulse(data)) {
291 return data & (PULSE_MASK);
294 static lirc_t get_next_space(lirc_t maxusec)
298 data = get_next_rec_buffer(maxusec);
301 if (!is_space(data)) {
308 static int sync_pending_pulse(
struct ir_remote* remote)
310 if (rec_buffer.pendingp > 0) {
313 deltap = get_next_pulse(rec_buffer.pendingp);
316 if (!expect(remote, deltap, rec_buffer.pendingp))
318 set_pending_pulse(0);
323 static int sync_pending_space(
struct ir_remote* remote)
325 if (rec_buffer.pendings > 0) {
328 deltas = get_next_space(rec_buffer.pendings);
331 if (!expect(remote, deltas, rec_buffer.pendings))
333 set_pending_space(0);
338 static int expectpulse(
struct ir_remote* remote,
int exdelta)
343 LOGPRINTF(5,
"expecting pulse: %lu", exdelta);
344 if (!sync_pending_space(remote))
347 deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
350 if (rec_buffer.pendingp > 0) {
351 if (rec_buffer.pendingp > deltap)
353 retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
356 set_pending_pulse(0);
358 retval = expect(remote, deltap, exdelta);
363 static int expectspace(
struct ir_remote* remote,
int exdelta)
368 LOGPRINTF(5,
"expecting space: %lu", exdelta);
369 if (!sync_pending_pulse(remote))
372 deltas = get_next_space(rec_buffer.pendings + exdelta);
375 if (rec_buffer.pendings > 0) {
376 if (rec_buffer.pendings > deltas)
378 retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
381 set_pending_space(0);
383 retval = expect(remote, deltas, exdelta);
388 static int expectone(
struct ir_remote* remote,
int bit)
390 if (is_biphase(remote)) {
391 int all_bits = bit_count(remote);
394 mask = ((
ir_code)1) << (all_bits - 1 - bit);
396 if (remote->
sone > 0 && !expectspace(remote, 2 * remote->
sone)) {
400 set_pending_pulse(2 * remote->pone);
402 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
406 set_pending_pulse(remote->pone);
408 }
else if (is_space_first(remote)) {
409 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
413 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
418 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
423 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
428 set_pending_space(remote->
sone);
434 static int expectzero(
struct ir_remote* remote,
int bit)
436 if (is_biphase(remote)) {
437 int all_bits = bit_count(remote);
440 mask = ((
ir_code)1) << (all_bits - 1 - bit);
442 if (!expectpulse(remote, 2 * remote->pzero)) {
446 set_pending_space(2 * remote->
szero);
448 if (!expectpulse(remote, remote->pzero)) {
452 set_pending_space(remote->
szero);
454 }
else if (is_space_first(remote)) {
455 if (remote->
szero > 0 && !expectspace(remote, remote->
szero)) {
459 if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
464 if (!expectpulse(remote, remote->pzero)) {
469 if (!expectspace(remote, remote->
szero)) {
474 set_pending_space(remote->
szero);
480 static lirc_t sync_rec_buffer(
struct ir_remote* remote)
483 lirc_t deltas, deltap;
486 deltas = get_next_space(1000000);
492 deltap = get_next_pulse(1000000);
495 deltas = get_next_space(1000000);
499 if (count > REC_SYNC)
503 if (has_toggle_mask(remote)) {
505 remote->toggle_mask_state = 0;
514 static int get_header(
struct ir_remote* remote)
516 if (is_rcmm(remote)) {
517 lirc_t deltap, deltas, sum;
519 deltap = get_next_pulse(remote->phead);
524 deltas = get_next_space(remote->
shead);
529 sum = deltap + deltas;
530 if (expect(remote, sum, remote->phead + remote->
shead))
534 }
else if (is_bo(remote)) {
535 if (expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
536 && expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
537 && expectpulse(remote, remote->phead) && expectspace(remote, remote->
shead))
541 if (remote->
shead == 0) {
542 if (!sync_pending_space(remote))
544 set_pending_pulse(remote->phead);
547 if (!expectpulse(remote, remote->phead)) {
556 deltas = get_next_space(remote->
shead);
558 if (expect(remote, remote->
shead, deltas))
565 set_pending_space(remote->
shead);
569 static int get_foot(
struct ir_remote* remote)
571 if (!expectspace(remote, remote->
sfoot))
573 if (!expectpulse(remote, remote->pfoot))
578 static int get_lead(
struct ir_remote* remote)
580 if (remote->
plead == 0)
582 if (!sync_pending_space(remote))
584 set_pending_pulse(remote->
plead);
588 static int get_trail(
struct ir_remote* remote)
591 if (!expectpulse(remote, remote->
ptrail))
593 if (rec_buffer.pendingp > 0)
594 if (!sync_pending_pulse(remote))
599 static int get_gap(
struct ir_remote* remote, lirc_t gap)
604 data = get_next_rec_buffer(gap - gap * remote->
eps / 100);
607 if (!is_space(data)) {
612 if (!expect_at_least(remote, data, gap)) {
619 static int get_repeat(
struct ir_remote* remote)
621 if (!get_lead(remote))
623 if (is_biphase(remote)) {
624 if (!expectspace(remote, remote->
srepeat))
626 if (!expectpulse(remote, remote->prepeat))
629 if (!expectpulse(remote, remote->prepeat))
631 set_pending_space(remote->
srepeat);
633 if (!get_trail(remote))
637 is_const(remote) ? (min_gap(remote) >
639 min_gap(remote) - rec_buffer.sum : 0) :
640 (has_repeat_gap(remote) ? remote->
repeat_gap : min_gap(remote))
653 if (is_rcmm(remote)) {
654 lirc_t deltap, deltas, sum;
656 if (bits % 2 || done % 2) {
657 logprintf(LIRC_ERROR,
"invalid bit number.");
660 if (!sync_pending_space(remote))
662 for (i = 0; i < bits; i += 2) {
664 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
666 if (deltap == 0 || deltas == 0) {
667 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
670 sum = deltap + deltas;
671 LOGPRINTF(3,
"rcmm: sum %ld", (__u32)sum);
672 if (expect(remote, sum, remote->pzero + remote->
szero)) {
675 }
else if (expect(remote, sum, remote->pone + remote->
sone)) {
678 }
else if (expect(remote, sum, remote->ptwo + remote->
stwo)) {
681 }
else if (expect(remote, sum, remote->pthree + remote->
sthree)) {
685 LOGPRINTF(2,
"no match for %d+%d=%d", deltap, deltas, sum);
690 }
else if (is_grundig(remote)) {
691 lirc_t deltap, deltas, sum;
692 int state, laststate;
694 if (bits % 2 || done % 2) {
695 logprintf(LIRC_ERROR,
"invalid bit number.");
698 if (!sync_pending_pulse(remote))
700 for (laststate = state = -1, i = 0; i < bits; ) {
702 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
703 if (deltas == 0 || deltap == 0) {
704 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
707 sum = deltas + deltap;
708 LOGPRINTF(3,
"grundig: sum %ld", (__u32)sum);
709 if (expect(remote, sum, remote->
szero + remote->pzero)) {
712 }
else if (expect(remote, sum, remote->
sone + remote->pone)) {
715 }
else if (expect(remote, sum, remote->
stwo + remote->ptwo)) {
718 }
else if (expect(remote, sum, remote->
sthree + remote->pthree)) {
722 LOGPRINTF(2,
"no match for %d+%d=%d", deltas, deltap, sum);
730 }
else if (laststate == 2 && state == 0) {
735 }
else if (laststate == 1 && state == 1) {
740 }
else if (laststate == 0 && state == 2) {
745 }
else if (laststate == -1) {
748 logprintf(LIRC_ERROR,
"invalid state %d:%d", laststate, state);
754 }
else if (is_serial(remote)) {
756 int space, stop_bit, parity_bit;
758 lirc_t delta, origdelta, pending, expecting, gap_delta;
760 lirc_t max_space, max_pulse;
762 base = 1000000 / remote->
baud;
765 set_pending_pulse(base);
768 space = (rec_buffer.pendingp == 0);
771 delta = origdelta = 0;
778 if (remote->
parity != IR_PARITY_NONE) {
780 max_space += remote->
sone;
781 max_pulse += remote->pzero;
785 while (received < bits || stop_bit) {
787 delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
788 if (delta == 0 && space && received + remote->
bits_in_byte + parity_bit >= bits)
794 LOGPRINTF(1,
"failed before bit %d", received + 1);
797 pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
798 if (expect(remote, delta, pending)) {
800 }
else if (delta > pending) {
803 LOGPRINTF(1,
"failed before bit %d", received + 1);
811 set_pending_pulse(base);
812 set_pending_space(0);
818 set_pending_pulse(0);
819 set_pending_space(0);
821 space = (space ? 0 : 1);
825 expecting = (space ? remote->
sone : remote->pzero);
826 if (delta > expecting || expect(remote, delta, expecting)) {
827 delta -= (expecting > delta ? delta : expecting);
833 if (received % (remote->
bits_in_byte + parity_bit) == 0) {
836 if ((remote->
parity == IR_PARITY_EVEN && parity)
837 || (remote->
parity == IR_PARITY_ODD && !parity)) {
838 LOGPRINTF(1,
"parity error after %d bits", received + 1);
846 temp << remote->
bits_in_byte | reverse(code >> parity_bit,
849 if (space && delta == 0) {
850 LOGPRINTF(1,
"failed at stop bit after %d bits", received + 1);
854 set_pending_space(stop);
858 if (delta == origdelta) {
859 LOGPRINTF(1,
"framing error after %d bits", received + 1);
865 space = (space ? 0 : 1);
868 unget_rec_buffer_delta(gap_delta);
869 set_pending_pulse(0);
870 set_pending_space(0);
872 }
else if (is_bo(remote)) {
874 lirc_t deltap, deltas;
878 for (i = 0; i < bits; i++) {
880 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
882 if (deltap == 0 || deltas == 0) {
883 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
887 pzero = remote->pone;
888 szero = remote->
sone;
892 pzero = remote->ptwo;
893 szero = remote->
stwo;
894 pone = remote->pthree;
897 LOGPRINTF(5,
"%lu %lu %lu %lu", pzero, szero, pone, sone);
898 if (expect(remote, deltap, pzero)) {
899 if (expect(remote, deltas, szero)) {
907 if (expect(remote, deltap, pone)) {
908 if (expect(remote, deltas, sone)) {
915 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
919 }
else if (is_xmp(remote)) {
920 lirc_t deltap, deltas, sum;
923 if (bits % 4 || done % 4) {
924 logprintf(LIRC_ERROR,
"invalid bit number.");
927 if (!sync_pending_space(remote))
929 for (i = 0; i < bits; i += 4) {
931 deltap = get_next_pulse(remote->pzero);
932 deltas = get_next_space(remote->
szero + 16 * remote->
sone);
933 if (deltap == 0 || deltas == 0) {
934 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
937 sum = deltap + deltas;
939 sum -= remote->pzero + remote->
szero;
940 n = (sum + remote->
sone / 2) / remote->
sone;
942 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
951 for (i = 0; i < bits; i++) {
953 if (is_goldstar(remote)) {
954 if ((done + i) % 2) {
956 remote->pone = remote->ptwo;
960 remote->pone = remote->pthree;
965 if (expectone(remote, done + i)) {
968 }
else if (expectzero(remote, done + i)) {
972 LOGPRINTF(1,
"failed on bit %d", done + i + 1);
989 LOGPRINTF(1,
"Failed on pre_data: cannot get it");
1000 remote_pre = remote->
pre_data & ~toggle_mask;
1001 match_pre = pre & ~toggle_mask;
1002 if (remote->
pre_data != 0 && remote_pre != match_pre) {
1003 LOGPRINTF(1,
"Failed on pre_data: bad data: %x", pre);
1007 if (remote->pre_p > 0 && remote->
pre_s > 0) {
1008 if (!expectpulse(remote, remote->pre_p))
1010 set_pending_space(remote->
pre_s);
1019 if (remote->post_p > 0 && remote->
post_s > 0) {
1020 if (!expectpulse(remote, remote->post_p))
1022 set_pending_space(remote->
post_s);
1038 struct timeval current;
1045 if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
1046 logprintf(LIRC_DEBUG,
"Decode: found EOF");
1048 rec_buffer.at_eof = 0;
1055 rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
1058 sync = sync_rec_buffer(remote);
1065 if (has_repeat(remote) &&
last_remote == remote) {
1067 if (!get_header(remote)) {
1068 LOGPRINTF(1,
"failed on repeat header");
1073 if (get_repeat(remote)) {
1075 logprintf(LIRC_NOTICE,
"repeat code without last_code received");
1085 is_const(remote) ? (min_gap(remote) >
1086 rec_buffer.sum ? min_gap(remote) -
1087 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1088 repeat_gap : min_gap(remote));
1090 is_const(remote) ? (max_gap(remote) >
1091 rec_buffer.sum ? max_gap(remote) -
1092 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1093 repeat_gap : max_gap(remote));
1098 sync_rec_buffer(remote);
1101 if (has_header(remote)) {
1103 if (!get_header(remote)) {
1105 if (!(remote->
flags &
NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
1114 if (is_raw(remote)) {
1122 codes = remote->codes;
1124 while (codes->
name != NULL && found == NULL) {
1126 for (i = 0; i < codes->
length; ) {
1127 if (!expectpulse(remote, codes->
signals[i++])) {
1130 sync_rec_buffer(remote);
1133 if (i < codes->
length && !expectspace(remote, codes->
signals[i++])) {
1136 sync_rec_buffer(remote);
1141 if (found != NULL) {
1143 (remote, is_const(remote) ?
1144 min_gap(remote) - rec_buffer.sum :
1155 ir_code decoded = rec_buffer.decoded;
1164 ctx->
code = decoded & gen_mask(remote->
bits);
1165 ctx->
pre = decoded >> remote->
bits;
1167 gettimeofday(¤t, NULL);
1168 sum = remote->phead + remote->
shead +
1169 lirc_t_max(remote->pone + remote->
sone,
1170 remote->pzero + remote->
szero) * bit_count(remote) + remote->
plead +
1171 remote->
ptrail + remote->pfoot + remote->
sfoot + remote->pre_p + remote->
pre_s +
1172 remote->post_p + remote->
post_s;
1174 rec_buffer.sum = sum >= remote->
gap ? remote->
gap - 1 : sum;
1175 sync = time_elapsed(&remote->
last_send, ¤t) - rec_buffer.sum;
1177 if (!get_lead(remote)) {
1178 LOGPRINTF(1,
"failed on leading pulse");
1182 if (has_pre(remote)) {
1183 ctx->
pre = get_pre(remote);
1198 if (has_post(remote)) {
1199 ctx->
post = get_post(remote);
1206 if (!get_trail(remote)) {
1207 LOGPRINTF(1,
"failed on trailing pulse");
1210 if (has_foot(remote)) {
1211 if (!get_foot(remote)) {
1217 rec_buffer.sum -= remote->phead + remote->
shead;
1218 if (is_rcmm(remote)) {
1219 if (!get_gap(remote, 1000))
1221 }
else if (is_const(remote)) {
1222 if (!get_gap(remote, min_gap(remote) > rec_buffer.sum ?
1223 min_gap(remote) - rec_buffer.sum :
1227 if (!get_gap(remote, min_gap(remote)))
1241 if (time_elapsed(&remote->
last_send, ¤t) < 325000)
1244 if (is_const(remote)) {
1245 ctx->
min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
1246 ctx->
max_remaining_gap = max_gap(remote) > rec_buffer.sum ? max_gap(remote) - rec_buffer.sum : 0;
void rec_buffer_init(void)
struct ir_remote * last_remote
void rec_buffer_set_logfile(FILE *f)
int waitfordata(__u32 maxusec)
struct ir_ncode * toggle_code
void rec_buffer_rewind(void)
struct ir_ncode * last_code
int receive_decode(struct ir_remote *remote, struct decode_ctx_t *ctx)
void rec_buffer_reset_wptr(void)
lirc_t(*const readdata)(lirc_t timeout)
#define LOGPRINTF(level, fmt, args...)
void logperror(loglevel_t prio, const char *fmt,...)
void rec_set_update_mode(int mode)
unsigned int min_code_repeat
const struct driver const * curr_driver
int rec_buffer_clear(void)
unsigned int bits_in_byte