25 #include "include/media/lirc.h"
26 #include "lirc/driver.h"
27 #include "lirc/lirc_log.h"
28 #include "lirc/receive.h"
41 lirc_t data[RBUF_SIZE];
50 struct timeval last_signal_time;
59 static struct rbuf rec_buffer;
62 static lirc_t readdata(lirc_t timeout)
67 rec_buffer.at_eof = data &
LIRC_EOF ? 1 : 0;
68 if (rec_buffer.at_eof){
69 logprintf(LIRC_DEBUG,
"receive: Got EOF");
75 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
77 return (a > b ? a : b);
80 static void set_pending_pulse(lirc_t deltap)
82 LOGPRINTF(5,
"pending pulse: %lu", deltap);
83 rec_buffer.pendingp = deltap;
86 static void set_pending_space(lirc_t deltas)
88 LOGPRINTF(5,
"pending space: %lu", deltas);
89 rec_buffer.pendings = deltas;
93 static void log_input(lirc_t data)
95 fprintf(rec_buffer.input_log,
"%s %u\n",
96 data & PULSE_BIT ?
"pulse" :
"space", data & PULSE_MASK);
97 fflush(rec_buffer.input_log);
101 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
103 if (rec_buffer.rptr < rec_buffer.wptr) {
104 LOGPRINTF(3,
"<%c%lu", rec_buffer.data[rec_buffer.rptr] & PULSE_BIT ?
'p' :
's', (__u32)
105 rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK));
106 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
107 return (rec_buffer.data[rec_buffer.rptr++]);
109 if (rec_buffer.wptr < RBUF_SIZE) {
111 unsigned long elapsed = 0;
113 if (timerisset(&rec_buffer.last_signal_time)) {
114 struct timeval current;
116 gettimeofday(¤t, NULL);
117 elapsed = time_elapsed(&rec_buffer.last_signal_time, ¤t);
119 if (elapsed < maxusec) {
120 data = readdata(maxusec - elapsed);
127 logprintf(LIRC_DEBUG,
"Receive: returning EOF");
130 if (LIRC_IS_TIMEOUT(data)) {
131 LOGPRINTF(1,
"timeout received: %lu", (__u32) LIRC_VALUE(data));
132 if (LIRC_VALUE(data) < maxusec) {
133 return get_next_rec_buffer_internal(maxusec - LIRC_VALUE(data));
138 rec_buffer.data[rec_buffer.wptr] = data;
139 if (rec_buffer.input_log != NULL){
142 if (rec_buffer.data[rec_buffer.wptr] == 0)
144 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
148 LOGPRINTF(3,
"+%c%lu", rec_buffer.data[rec_buffer.rptr - 1] & PULSE_BIT ?
'p' :
's', (__u32)
149 rec_buffer.data[rec_buffer.rptr - 1]
151 return (rec_buffer.data[rec_buffer.rptr - 1]);
153 rec_buffer.too_long = 1;
180 tv.tv_sec = maxusec / 1000000;
181 tv.tv_usec = maxusec % 1000000;
189 while (ret == -1 && errno == EINTR);
191 logperror(LIRC_ERROR,
"select() failed");
207 if (rec_buffer.input_log != NULL) {
208 fclose(rec_buffer.input_log);
210 rec_buffer.input_log = f;
214 static lirc_t get_next_rec_buffer(lirc_t maxusec)
216 return get_next_rec_buffer_internal(receive_timeout(maxusec));
221 memset(&rec_buffer, 0,
sizeof(rec_buffer));
227 rec_buffer.too_long = 0;
228 set_pending_pulse(0);
229 set_pending_space(0);
231 rec_buffer.at_eof = 0;
243 timerclear(&rec_buffer.last_signal_time);
245 unsigned char buffer[
sizeof(
ir_code)];
253 logprintf(LIRC_ERROR,
"reading in mode LIRC_MODE_LIRCCODE failed");
256 for (i = 0, rec_buffer.decoded = 0; i < count; i++) {
257 rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((
ir_code) buffer[i]);
262 move = rec_buffer.wptr - rec_buffer.rptr;
263 if (move > 0 && rec_buffer.rptr > 0) {
264 memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
265 sizeof(rec_buffer.data[0]) * move);
266 rec_buffer.wptr -= rec_buffer.rptr;
271 LOGPRINTF(3,
"c%lu", (__u32) data & (PULSE_MASK));
273 rec_buffer.data[rec_buffer.wptr] = data;
279 rec_buffer.is_biphase = 0;
284 static void unget_rec_buffer(
int count)
287 if (count == 1 || count == 2) {
288 rec_buffer.rptr -= count;
289 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
291 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
297 static void unget_rec_buffer_delta(lirc_t delta)
300 rec_buffer.sum -= delta & (PULSE_MASK);
301 rec_buffer.data[rec_buffer.rptr] = delta;
304 static lirc_t get_next_pulse(lirc_t maxusec)
308 data = get_next_rec_buffer(maxusec);
311 if (!is_pulse(data)) {
315 return (data & (PULSE_MASK));
318 static lirc_t get_next_space(lirc_t maxusec)
322 data = get_next_rec_buffer(maxusec);
325 if (!is_space(data)) {
332 static int sync_pending_pulse(
struct ir_remote *remote)
334 if (rec_buffer.pendingp > 0) {
337 deltap = get_next_pulse(rec_buffer.pendingp);
340 if (!expect(remote, deltap, rec_buffer.pendingp))
342 set_pending_pulse(0);
347 static int sync_pending_space(
struct ir_remote *remote)
349 if (rec_buffer.pendings > 0) {
352 deltas = get_next_space(rec_buffer.pendings);
355 if (!expect(remote, deltas, rec_buffer.pendings))
357 set_pending_space(0);
362 static int expectpulse(
struct ir_remote *remote,
int exdelta)
367 LOGPRINTF(5,
"expecting pulse: %lu", exdelta);
368 if (!sync_pending_space(remote))
371 deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
374 if (rec_buffer.pendingp > 0) {
375 if (rec_buffer.pendingp > deltap)
377 retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
380 set_pending_pulse(0);
382 retval = expect(remote, deltap, exdelta);
387 static int expectspace(
struct ir_remote *remote,
int exdelta)
392 LOGPRINTF(5,
"expecting space: %lu", exdelta);
393 if (!sync_pending_pulse(remote))
396 deltas = get_next_space(rec_buffer.pendings + exdelta);
399 if (rec_buffer.pendings > 0) {
400 if (rec_buffer.pendings > deltas)
402 retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
405 set_pending_space(0);
407 retval = expect(remote, deltas, exdelta);
412 static int expectone(
struct ir_remote *remote,
int bit)
414 if (is_biphase(remote)) {
415 int all_bits = bit_count(remote);
418 mask = ((
ir_code) 1) << (all_bits - 1 - bit);
420 if (remote->
sone > 0 && !expectspace(remote, 2 * remote->
sone)) {
424 set_pending_pulse(2 * remote->pone);
426 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
430 set_pending_pulse(remote->pone);
432 }
else if (is_space_first(remote)) {
433 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
437 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
442 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
447 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
452 set_pending_space(remote->
sone);
458 static int expectzero(
struct ir_remote *remote,
int bit)
460 if (is_biphase(remote)) {
461 int all_bits = bit_count(remote);
464 mask = ((
ir_code) 1) << (all_bits - 1 - bit);
466 if (!expectpulse(remote, 2 * remote->pzero)) {
470 set_pending_space(2 * remote->
szero);
472 if (!expectpulse(remote, remote->pzero)) {
476 set_pending_space(remote->
szero);
478 }
else if (is_space_first(remote)) {
479 if (remote->
szero > 0 && !expectspace(remote, remote->
szero)) {
483 if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
488 if (!expectpulse(remote, remote->pzero)) {
493 if (!expectspace(remote, remote->
szero)) {
498 set_pending_space(remote->
szero);
504 static lirc_t sync_rec_buffer(
struct ir_remote * remote)
507 lirc_t deltas, deltap;
510 deltas = get_next_space(1000000);
514 if (last_remote != NULL && !is_rcmm(remote)) {
516 deltap = get_next_pulse(1000000);
519 deltas = get_next_space(1000000);
523 if (count > REC_SYNC) {
528 if (has_toggle_mask(remote)) {
530 remote->toggle_mask_state = 0;
540 static int get_header(
struct ir_remote *remote)
542 if (is_rcmm(remote)) {
543 lirc_t deltap, deltas, sum;
545 deltap = get_next_pulse(remote->phead);
550 deltas = get_next_space(remote->
shead);
555 sum = deltap + deltas;
556 if (expect(remote, sum, remote->phead + remote->
shead)) {
561 }
else if (is_bo(remote)) {
562 if (expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
563 && expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
564 && expectpulse(remote, remote->phead) && expectspace(remote, remote->
shead)) {
569 if (remote->
shead == 0) {
570 if (!sync_pending_space(remote))
572 set_pending_pulse(remote->phead);
575 if (!expectpulse(remote, remote->phead)) {
584 deltas = get_next_space(remote->
shead);
586 if (expect(remote, remote->
shead, deltas)) {
594 set_pending_space(remote->
shead);
598 static int get_foot(
struct ir_remote *remote)
600 if (!expectspace(remote, remote->
sfoot))
602 if (!expectpulse(remote, remote->pfoot))
607 static int get_lead(
struct ir_remote *remote)
609 if (remote->
plead == 0)
611 if (!sync_pending_space(remote))
613 set_pending_pulse(remote->
plead);
617 static int get_trail(
struct ir_remote *remote)
619 if (remote->
ptrail != 0) {
620 if (!expectpulse(remote, remote->
ptrail))
623 if (rec_buffer.pendingp > 0) {
624 if (!sync_pending_pulse(remote))
630 static int get_gap(
struct ir_remote *remote, lirc_t gap)
635 data = get_next_rec_buffer(gap - gap * remote->
eps / 100);
638 if (!is_space(data)) {
643 if (!expect_at_least(remote, data, gap)) {
650 static int get_repeat(
struct ir_remote *remote)
652 if (!get_lead(remote))
654 if (is_biphase(remote)) {
655 if (!expectspace(remote, remote->
srepeat))
657 if (!expectpulse(remote, remote->prepeat))
660 if (!expectpulse(remote, remote->prepeat))
662 set_pending_space(remote->
srepeat);
664 if (!get_trail(remote))
668 is_const(remote) ? (min_gap(remote) >
669 rec_buffer.sum ? min_gap(remote) -
670 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
repeat_gap : min_gap(remote))
683 if (is_rcmm(remote)) {
684 lirc_t deltap, deltas, sum;
686 if (bits % 2 || done % 2) {
687 logprintf(LIRC_ERROR,
"invalid bit number.");
690 if (!sync_pending_space(remote))
692 for (i = 0; i < bits; i += 2) {
694 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
696 if (deltap == 0 || deltas == 0) {
697 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
700 sum = deltap + deltas;
701 LOGPRINTF(3,
"rcmm: sum %ld", (__u32) sum);
702 if (expect(remote, sum, remote->pzero + remote->
szero)) {
705 }
else if (expect(remote, sum, remote->pone + remote->
sone)) {
708 }
else if (expect(remote, sum, remote->ptwo + remote->
stwo)) {
711 }
else if (expect(remote, sum, remote->pthree + remote->
sthree)) {
715 LOGPRINTF(2,
"no match for %d+%d=%d", deltap, deltas, sum);
720 }
else if (is_grundig(remote)) {
721 lirc_t deltap, deltas, sum;
722 int state, laststate;
724 if (bits % 2 || done % 2) {
725 logprintf(LIRC_ERROR,
"invalid bit number.");
728 if (!sync_pending_pulse(remote))
730 for (laststate = state = -1, i = 0; i < bits;) {
732 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
733 if (deltas == 0 || deltap == 0) {
734 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
737 sum = deltas + deltap;
738 LOGPRINTF(3,
"grundig: sum %ld", (__u32) sum);
739 if (expect(remote, sum, remote->
szero + remote->pzero)) {
742 }
else if (expect(remote, sum, remote->
sone + remote->pone)) {
745 }
else if (expect(remote, sum, remote->
stwo + remote->ptwo)) {
748 }
else if (expect(remote, sum, remote->
sthree + remote->pthree)) {
752 LOGPRINTF(2,
"no match for %d+%d=%d", deltas, deltap, sum);
760 }
else if (laststate == 2 && state == 0) {
765 }
else if (laststate == 1 && state == 1) {
770 }
else if (laststate == 0 && state == 2) {
775 }
else if (laststate == -1) {
778 logprintf(LIRC_ERROR,
"invalid state %d:%d", laststate, state);
784 }
else if (is_serial(remote)) {
786 int space, stop_bit, parity_bit;
788 lirc_t delta, origdelta, pending, expecting, gap_delta;
790 lirc_t max_space, max_pulse;
792 base = 1000000 / remote->
baud;
795 set_pending_pulse(base);
798 space = (rec_buffer.pendingp == 0);
801 delta = origdelta = 0;
808 if (remote->
parity != IR_PARITY_NONE) {
810 max_space += remote->
sone;
811 max_pulse += remote->pzero;
815 while (received < bits || stop_bit) {
817 delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
818 if (delta == 0 && space && received + remote->
bits_in_byte + parity_bit >= bits) {
825 LOGPRINTF(1,
"failed before bit %d", received + 1);
828 pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
829 if (expect(remote, delta, pending)) {
831 }
else if (delta > pending) {
834 LOGPRINTF(1,
"failed before bit %d", received + 1);
842 set_pending_pulse(base);
843 set_pending_space(0);
849 set_pending_pulse(0);
850 set_pending_space(0);
852 space = (space ? 0 : 1);
857 expecting = (space ? remote->
sone : remote->pzero);
858 if (delta > expecting || expect(remote, delta, expecting)) {
859 delta -= (expecting > delta ? delta : expecting);
865 if (received % (remote->
bits_in_byte + parity_bit) == 0) {
868 if ((remote->
parity == IR_PARITY_EVEN && parity)
869 || (remote->
parity == IR_PARITY_ODD && !parity)) {
870 LOGPRINTF(1,
"parity error after %d bits", received + 1);
878 temp << remote->
bits_in_byte | reverse(code >> parity_bit,
881 if (space && delta == 0) {
882 LOGPRINTF(1,
"failed at stop bit after %d bits", received + 1);
886 set_pending_space(stop);
890 if (delta == origdelta) {
891 LOGPRINTF(1,
"framing error after %d bits", received + 1);
897 space = (space ? 0 : 1);
901 unget_rec_buffer_delta(gap_delta);
902 set_pending_pulse(0);
903 set_pending_space(0);
905 }
else if (is_bo(remote)) {
907 lirc_t deltap, deltas;
911 for (i = 0; i < bits; i++) {
913 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
915 if (deltap == 0 || deltas == 0) {
916 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
920 pzero = remote->pone;
921 szero = remote->
sone;
925 pzero = remote->ptwo;
926 szero = remote->
stwo;
927 pone = remote->pthree;
930 LOGPRINTF(5,
"%lu %lu %lu %lu", pzero, szero, pone, sone);
931 if (expect(remote, deltap, pzero)) {
932 if (expect(remote, deltas, szero)) {
940 if (expect(remote, deltap, pone)) {
941 if (expect(remote, deltas, sone)) {
948 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
952 }
else if (is_xmp(remote)) {
953 lirc_t deltap, deltas, sum;
956 if (bits % 4 || done % 4) {
957 logprintf(LIRC_ERROR,
"invalid bit number.");
960 if (!sync_pending_space(remote))
962 for (i = 0; i < bits; i += 4) {
964 deltap = get_next_pulse(remote->pzero);
965 deltas = get_next_space(remote->
szero + 16 * remote->
sone);
966 if (deltap == 0 || deltas == 0) {
967 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
970 sum = deltap + deltas;
972 sum -= remote->pzero + remote->
szero;
973 n = (sum + remote->
sone / 2) / remote->
sone;
975 logprintf(LIRC_ERROR,
"failed on bit %d", done + i + 1);
985 for (i = 0; i < bits; i++) {
987 if (is_goldstar(remote)) {
988 if ((done + i) % 2) {
990 remote->pone = remote->ptwo;
994 remote->pone = remote->pthree;
999 if (expectone(remote, done + i)) {
1002 }
else if (expectzero(remote, done + i)) {
1006 LOGPRINTF(1,
"failed on bit %d", done + i + 1);
1023 if (remote->pre_p > 0 && remote->
pre_s > 0) {
1024 if (!expectpulse(remote, remote->pre_p))
1026 set_pending_space(remote->
pre_s);
1035 if (remote->post_p > 0 && remote->
post_s > 0) {
1036 if (!expectpulse(remote, remote->post_p))
1038 set_pending_space(remote->
post_s);
1054 struct timeval current;
1061 if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
1062 logprintf(LIRC_DEBUG,
"Decode: found EOF");
1064 rec_buffer.at_eof = 0;
1072 rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
1075 if (!(sync = sync_rec_buffer(remote))) {
1082 if (has_repeat(remote) && last_remote == remote) {
1084 if (!get_header(remote)) {
1085 LOGPRINTF(1,
"failed on repeat header");
1090 if (get_repeat(remote)) {
1092 logprintf(LIRC_NOTICE,
"repeat code without last_code received");
1102 is_const(remote) ? (min_gap(remote) >
1103 rec_buffer.sum ? min_gap(remote) -
1104 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1105 repeat_gap : min_gap(remote));
1107 is_const(remote) ? (max_gap(remote) >
1108 rec_buffer.sum ? max_gap(remote) -
1109 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1110 repeat_gap : max_gap(remote));
1115 sync_rec_buffer(remote);
1120 if (has_header(remote)) {
1122 if (!get_header(remote)) {
1124 if (!(remote->
flags &
NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
1133 if (is_raw(remote)) {
1140 codes = remote->codes;
1142 while (codes->
name != NULL && found == NULL) {
1144 for (i = 0; i < codes->
length;) {
1145 if (!expectpulse(remote, codes->
signals[i++])) {
1148 sync_rec_buffer(remote);
1151 if (i < codes->
length && !expectspace(remote, codes->
signals[i++])) {
1154 sync_rec_buffer(remote);
1159 if (found != NULL) {
1161 (remote, is_const(remote) ? min_gap(remote) - rec_buffer.sum : min_gap(remote)))
1171 ir_code decoded = rec_buffer.decoded;
1180 ctx->
code = decoded & gen_mask(remote->
bits);
1181 ctx->
pre = decoded >> remote->
bits;
1183 gettimeofday(¤t, NULL);
1184 sum = remote->phead + remote->
shead +
1185 lirc_t_max(remote->pone + remote->
sone,
1186 remote->pzero + remote->
szero) * bit_count(remote) + remote->
plead +
1187 remote->
ptrail + remote->pfoot + remote->
sfoot + remote->pre_p + remote->
pre_s +
1188 remote->post_p + remote->
post_s;
1190 rec_buffer.sum = sum >= remote->
gap ? remote->
gap - 1 : sum;
1191 sync = time_elapsed(&remote->
last_send, ¤t) - rec_buffer.sum;
1193 if (!get_lead(remote)) {
1194 LOGPRINTF(1,
"failed on leading pulse");
1198 if (has_pre(remote)) {
1199 ctx->
pre = get_pre(remote);
1214 if (has_post(remote)) {
1215 ctx->
post = get_post(remote);
1222 if (!get_trail(remote)) {
1223 LOGPRINTF(1,
"failed on trailing pulse");
1226 if (has_foot(remote)) {
1227 if (!get_foot(remote)) {
1233 rec_buffer.sum -= remote->phead + remote->
shead;
1235 if (is_rcmm(remote)) {
1236 if (!get_gap(remote, 1000))
1238 }
else if (is_const(remote)) {
1240 (remote, min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0))
1243 if (!get_gap(remote, min_gap(remote)))
1257 if (time_elapsed(&remote->
last_send, ¤t) < 325000) {
1261 if (is_const(remote)) {
1262 ctx->
min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
1263 ctx->
max_remaining_gap = max_gap(remote) > rec_buffer.sum ? max_gap(remote) - rec_buffer.sum : 0;
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)
void rec_buffer_init(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,...)
unsigned int min_code_repeat
const struct driver const * curr_driver
int rec_buffer_clear(void)
unsigned int bits_in_byte