25 #ifdef HAVE_KERNEL_LIRC_H 26 #include <linux/lirc.h> 28 #include "include/media/lirc.h" 31 #include "lirc/driver.h" 32 #include "lirc/lirc_log.h" 33 #include "lirc/receive.h" 34 #include "lirc/ir_remote.h" 46 lirc_t data[RBUF_SIZE];
55 struct timeval last_signal_time;
64 static struct rbuf rec_buffer;
65 static int update_mode = 0;
74 static lirc_t readdata(lirc_t timeout)
79 rec_buffer.at_eof = data &
LIRC_EOF ? 1 : 0;
80 if (rec_buffer.at_eof)
86 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
91 static void set_pending_pulse(lirc_t deltap)
94 rec_buffer.pendingp = deltap;
97 static void set_pending_space(lirc_t deltas)
100 rec_buffer.pendings = deltas;
104 static void log_input(lirc_t data)
106 fprintf(rec_buffer.input_log,
"%s %u\n",
107 data & PULSE_BIT ?
"pulse" :
"space", data & PULSE_MASK);
108 fflush(rec_buffer.input_log);
112 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
114 if (rec_buffer.rptr < rec_buffer.wptr) {
115 log_trace2(
"<%c%lu", rec_buffer.data[rec_buffer.rptr] & PULSE_BIT ?
'p' :
's', (__u32)
116 rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK));
117 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
118 return rec_buffer.data[rec_buffer.rptr++];
120 if (rec_buffer.wptr < RBUF_SIZE) {
122 unsigned long elapsed = 0;
124 if (timerisset(&rec_buffer.last_signal_time)) {
125 struct timeval current;
127 gettimeofday(¤t, NULL);
128 elapsed = time_elapsed(&rec_buffer.last_signal_time, ¤t);
130 if (elapsed < maxusec)
131 data = readdata(maxusec - elapsed);
140 if (LIRC_IS_TIMEOUT(data)) {
141 log_trace(
"timeout received: %lu", (__u32)LIRC_VALUE(data));
142 if (LIRC_VALUE(data) < maxusec)
143 return get_next_rec_buffer_internal(maxusec - LIRC_VALUE(data));
147 rec_buffer.data[rec_buffer.wptr] = data;
148 if (rec_buffer.input_log != NULL)
150 if (rec_buffer.data[rec_buffer.wptr] == 0)
152 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
156 log_trace2(
"+%c%lu", rec_buffer.data[rec_buffer.rptr - 1] & PULSE_BIT ?
'p' :
's', (__u32)
157 rec_buffer.data[rec_buffer.rptr - 1]
159 return rec_buffer.data[rec_buffer.rptr - 1];
161 rec_buffer.too_long = 1;
168 struct pollfd pfd = {
174 ret = curl_poll(&pfd, 1, (maxusec > 0) ? (maxusec / 1000) : -1);
175 if (maxusec > 0 && ret == 0)
177 }
while (ret == -1 && errno == EINTR);
184 if (pfd.revents & POLLIN)
193 if (rec_buffer.input_log != NULL)
194 fclose(rec_buffer.input_log);
195 rec_buffer.input_log = f;
199 static lirc_t get_next_rec_buffer(lirc_t maxusec)
201 return get_next_rec_buffer_internal(receive_timeout(maxusec));
206 memset(&rec_buffer, 0,
sizeof(rec_buffer));
212 rec_buffer.too_long = 0;
213 set_pending_pulse(0);
214 set_pending_space(0);
216 rec_buffer.at_eof = 0;
228 timerclear(&rec_buffer.last_signal_time);
230 unsigned char buffer[
sizeof(
ir_code)];
238 log_error(
"reading in mode LIRC_MODE_LIRCCODE failed");
241 for (i = 0, rec_buffer.decoded = 0; i < count; i++)
242 rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((
ir_code)buffer[i]);
246 move = rec_buffer.wptr - rec_buffer.rptr;
247 if (move > 0 && rec_buffer.rptr > 0) {
248 memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
249 sizeof(rec_buffer.data[0]) * move);
250 rec_buffer.wptr -= rec_buffer.rptr;
255 log_trace2(
"c%lu", (__u32)data & (PULSE_MASK));
257 rec_buffer.data[rec_buffer.wptr] = data;
263 rec_buffer.is_biphase = 0;
268 static void unget_rec_buffer(
int count)
271 if (count == 1 || count == 2) {
272 rec_buffer.rptr -= count;
273 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
275 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
280 static void unget_rec_buffer_delta(lirc_t delta)
283 rec_buffer.sum -= delta & (PULSE_MASK);
284 rec_buffer.data[rec_buffer.rptr] = delta;
287 static lirc_t get_next_pulse(lirc_t maxusec)
291 data = get_next_rec_buffer(maxusec);
294 if (!is_pulse(data)) {
298 return data & (PULSE_MASK);
301 static lirc_t get_next_space(lirc_t maxusec)
305 data = get_next_rec_buffer(maxusec);
308 if (!is_space(data)) {
315 static int sync_pending_pulse(
struct ir_remote* remote)
317 if (rec_buffer.pendingp > 0) {
320 deltap = get_next_pulse(rec_buffer.pendingp);
323 if (!expect(remote, deltap, rec_buffer.pendingp))
325 set_pending_pulse(0);
330 static int sync_pending_space(
struct ir_remote* remote)
332 if (rec_buffer.pendings > 0) {
335 deltas = get_next_space(rec_buffer.pendings);
338 if (!expect(remote, deltas, rec_buffer.pendings))
340 set_pending_space(0);
345 static int expectpulse(
struct ir_remote* remote,
int exdelta)
351 if (!sync_pending_space(remote))
354 deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
357 if (rec_buffer.pendingp > 0) {
358 if (rec_buffer.pendingp > deltap)
360 retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
363 set_pending_pulse(0);
365 retval = expect(remote, deltap, exdelta);
370 static int expectspace(
struct ir_remote* remote,
int exdelta)
376 if (!sync_pending_pulse(remote))
379 deltas = get_next_space(rec_buffer.pendings + exdelta);
382 if (rec_buffer.pendings > 0) {
383 if (rec_buffer.pendings > deltas)
385 retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
388 set_pending_space(0);
390 retval = expect(remote, deltas, exdelta);
395 static int expectone(
struct ir_remote* remote,
int bit)
397 if (is_biphase(remote)) {
398 int all_bits = bit_count(remote);
401 mask = ((
ir_code)1) << (all_bits - 1 - bit);
403 if (remote->
sone > 0 && !expectspace(remote, 2 * remote->
sone)) {
407 set_pending_pulse(2 * remote->pone);
409 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
413 set_pending_pulse(remote->pone);
415 }
else if (is_space_first(remote)) {
416 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
420 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
425 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
430 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
435 set_pending_space(remote->
sone);
441 static int expectzero(
struct ir_remote* remote,
int bit)
443 if (is_biphase(remote)) {
444 int all_bits = bit_count(remote);
447 mask = ((
ir_code)1) << (all_bits - 1 - bit);
449 if (!expectpulse(remote, 2 * remote->pzero)) {
453 set_pending_space(2 * remote->
szero);
455 if (!expectpulse(remote, remote->pzero)) {
459 set_pending_space(remote->
szero);
461 }
else if (is_space_first(remote)) {
462 if (remote->
szero > 0 && !expectspace(remote, remote->
szero)) {
466 if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
471 if (!expectpulse(remote, remote->pzero)) {
476 if (!expectspace(remote, remote->
szero)) {
481 set_pending_space(remote->
szero);
487 static lirc_t sync_rec_buffer(
struct ir_remote* remote)
490 lirc_t deltas, deltap;
493 deltas = get_next_space(1000000);
499 deltap = get_next_pulse(1000000);
502 deltas = get_next_space(1000000);
506 if (count > REC_SYNC)
510 if (has_toggle_mask(remote)) {
512 remote->toggle_mask_state = 0;
521 static int get_header(
struct ir_remote* remote)
523 if (is_rcmm(remote)) {
524 lirc_t deltap, deltas, sum;
526 deltap = get_next_pulse(remote->phead);
531 deltas = get_next_space(remote->
shead);
536 sum = deltap + deltas;
537 if (expect(remote, sum, remote->phead + remote->
shead))
541 }
else if (is_bo(remote)) {
542 if (expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
543 && expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
544 && expectpulse(remote, remote->phead) && expectspace(remote, remote->
shead))
548 if (remote->
shead == 0) {
549 if (!sync_pending_space(remote))
551 set_pending_pulse(remote->phead);
554 if (!expectpulse(remote, remote->phead)) {
563 deltas = get_next_space(remote->
shead);
565 if (expect(remote, remote->
shead, deltas))
572 set_pending_space(remote->
shead);
576 static int get_foot(
struct ir_remote* remote)
578 if (!expectspace(remote, remote->
sfoot))
580 if (!expectpulse(remote, remote->pfoot))
585 static int get_lead(
struct ir_remote* remote)
587 if (remote->
plead == 0)
589 if (!sync_pending_space(remote))
591 set_pending_pulse(remote->
plead);
595 static int get_trail(
struct ir_remote* remote)
598 if (!expectpulse(remote, remote->
ptrail))
600 if (rec_buffer.pendingp > 0)
601 if (!sync_pending_pulse(remote))
606 static int get_gap(
struct ir_remote* remote, lirc_t gap)
611 data = get_next_rec_buffer(gap - gap * remote->
eps / 100);
614 if (!is_space(data)) {
619 if (!expect_at_least(remote, data, gap)) {
626 static int get_repeat(
struct ir_remote* remote)
628 if (!get_lead(remote))
630 if (is_biphase(remote)) {
631 if (!expectspace(remote, remote->
srepeat))
633 if (!expectpulse(remote, remote->prepeat))
636 if (!expectpulse(remote, remote->prepeat))
638 set_pending_space(remote->
srepeat);
640 if (!get_trail(remote))
644 is_const(remote) ? (min_gap(remote) >
646 min_gap(remote) - rec_buffer.sum : 0) :
647 (has_repeat_gap(remote) ? remote->
repeat_gap : min_gap(remote))
660 if (is_rcmm(remote)) {
661 lirc_t deltap, deltas, sum;
663 if (bits % 2 || done % 2) {
667 if (!sync_pending_space(remote))
669 for (i = 0; i < bits; i += 2) {
671 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
673 if (deltap == 0 || deltas == 0) {
674 log_error(
"failed on bit %d", done + i + 1);
677 sum = deltap + deltas;
679 if (expect(remote, sum, remote->pzero + remote->
szero)) {
682 }
else if (expect(remote, sum, remote->pone + remote->
sone)) {
685 }
else if (expect(remote, sum, remote->ptwo + remote->
stwo)) {
688 }
else if (expect(remote, sum, remote->pthree + remote->
sthree)) {
692 log_trace1(
"no match for %d+%d=%d", deltap, deltas, sum);
697 }
else if (is_grundig(remote)) {
698 lirc_t deltap, deltas, sum;
699 int state, laststate;
701 if (bits % 2 || done % 2) {
705 if (!sync_pending_pulse(remote))
707 for (laststate = state = -1, i = 0; i < bits; ) {
709 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
710 if (deltas == 0 || deltap == 0) {
711 log_error(
"failed on bit %d", done + i + 1);
714 sum = deltas + deltap;
716 if (expect(remote, sum, remote->
szero + remote->pzero)) {
719 }
else if (expect(remote, sum, remote->
sone + remote->pone)) {
722 }
else if (expect(remote, sum, remote->
stwo + remote->ptwo)) {
725 }
else if (expect(remote, sum, remote->
sthree + remote->pthree)) {
729 log_trace1(
"no match for %d+%d=%d", deltas, deltap, sum);
737 }
else if (laststate == 2 && state == 0) {
742 }
else if (laststate == 1 && state == 1) {
747 }
else if (laststate == 0 && state == 2) {
752 }
else if (laststate == -1) {
755 log_error(
"invalid state %d:%d", laststate, state);
761 }
else if (is_serial(remote)) {
763 int space, stop_bit, parity_bit;
765 lirc_t delta, origdelta, pending, expecting, gap_delta;
767 lirc_t max_space, max_pulse;
769 base = 1000000 / remote->
baud;
772 set_pending_pulse(base);
775 space = (rec_buffer.pendingp == 0);
778 delta = origdelta = 0;
785 if (remote->
parity != IR_PARITY_NONE) {
787 max_space += remote->
sone;
788 max_pulse += remote->pzero;
792 while (received < bits || stop_bit) {
794 delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
795 if (delta == 0 && space && received + remote->
bits_in_byte + parity_bit >= bits)
801 log_trace(
"failed before bit %d", received + 1);
804 pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
805 if (expect(remote, delta, pending)) {
807 }
else if (delta > pending) {
810 log_trace(
"failed before bit %d", received + 1);
818 set_pending_pulse(base);
819 set_pending_space(0);
825 set_pending_pulse(0);
826 set_pending_space(0);
828 space = (space ? 0 : 1);
832 expecting = (space ? remote->
sone : remote->pzero);
833 if (delta > expecting || expect(remote, delta, expecting)) {
834 delta -= (expecting > delta ? delta : expecting);
840 if (received % (remote->
bits_in_byte + parity_bit) == 0) {
843 if ((remote->
parity == IR_PARITY_EVEN && parity)
844 || (remote->
parity == IR_PARITY_ODD && !parity)) {
845 log_trace(
"parity error after %d bits", received + 1);
853 temp << remote->
bits_in_byte | reverse(code >> parity_bit,
856 if (space && delta == 0) {
857 log_trace(
"failed at stop bit after %d bits", received + 1);
861 set_pending_space(stop);
865 if (delta == origdelta) {
866 log_trace(
"framing error after %d bits", received + 1);
872 space = (space ? 0 : 1);
875 unget_rec_buffer_delta(gap_delta);
876 set_pending_pulse(0);
877 set_pending_space(0);
879 }
else if (is_bo(remote)) {
881 lirc_t deltap, deltas;
885 for (i = 0; i < bits; i++) {
887 deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
889 if (deltap == 0 || deltas == 0) {
890 log_error(
"failed on bit %d", done + i + 1);
894 pzero = remote->pone;
895 szero = remote->
sone;
899 pzero = remote->ptwo;
900 szero = remote->
stwo;
901 pone = remote->pthree;
904 log_trace2(
"%lu %lu %lu %lu", pzero, szero, pone, sone);
905 if (expect(remote, deltap, pzero)) {
906 if (expect(remote, deltas, szero)) {
914 if (expect(remote, deltap, pone)) {
915 if (expect(remote, deltas, sone)) {
922 log_error(
"failed on bit %d", done + i + 1);
926 }
else if (is_xmp(remote)) {
927 lirc_t deltap, deltas, sum;
930 if (bits % 4 || done % 4) {
934 if (!sync_pending_space(remote))
936 for (i = 0; i < bits; i += 4) {
938 deltap = get_next_pulse(remote->pzero);
939 deltas = get_next_space(remote->
szero + 16 * remote->
sone);
940 if (deltap == 0 || deltas == 0) {
941 log_error(
"failed on bit %d", done + i + 1);
944 sum = deltap + deltas;
946 sum -= remote->pzero + remote->
szero;
947 n = (sum + remote->
sone / 2) / remote->
sone;
949 log_error(
"failed on bit %d", done + i + 1);
958 for (i = 0; i < bits; i++) {
960 if (is_goldstar(remote)) {
961 if ((done + i) % 2) {
963 remote->pone = remote->ptwo;
967 remote->pone = remote->pthree;
972 if (expectone(remote, done + i)) {
975 }
else if (expectzero(remote, done + i)) {
979 log_trace(
"failed on bit %d", done + i + 1);
996 log_trace(
"Failed on pre_data: cannot get it");
1007 remote_pre = remote->
pre_data & ~toggle_mask;
1008 match_pre = pre & ~toggle_mask;
1009 if (remote->
pre_data != 0 && remote_pre != match_pre) {
1010 log_trace(
"Failed on pre_data: bad data: %x", pre);
1014 if (remote->pre_p > 0 && remote->
pre_s > 0) {
1015 if (!expectpulse(remote, remote->pre_p))
1017 set_pending_space(remote->
pre_s);
1026 if (remote->post_p > 0 && remote->
post_s > 0) {
1027 if (!expectpulse(remote, remote->post_p))
1029 set_pending_space(remote->
post_s);
1045 struct timeval current;
1052 if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
1055 rec_buffer.at_eof = 0;
1062 rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
1065 sync = sync_rec_buffer(remote);
1072 if (has_repeat(remote) &&
last_remote == remote) {
1074 if (!get_header(remote)) {
1080 if (get_repeat(remote)) {
1082 log_notice(
"repeat code without last_code received");
1092 is_const(remote) ? (min_gap(remote) >
1093 rec_buffer.sum ? min_gap(remote) -
1094 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1095 repeat_gap : min_gap(remote));
1097 is_const(remote) ? (max_gap(remote) >
1098 rec_buffer.sum ? max_gap(remote) -
1099 rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1100 repeat_gap : max_gap(remote));
1105 sync_rec_buffer(remote);
1108 if (has_header(remote)) {
1110 if (!get_header(remote)) {
1112 if (!(remote->
flags &
NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
1121 if (is_raw(remote)) {
1129 codes = remote->codes;
1131 while (codes->
name != NULL && found == NULL) {
1133 for (i = 0; i < codes->
length; ) {
1134 if (!expectpulse(remote, codes->
signals[i++])) {
1137 sync_rec_buffer(remote);
1140 if (i < codes->
length && !expectspace(remote, codes->
signals[i++])) {
1143 sync_rec_buffer(remote);
1148 if (found != NULL) {
1150 (remote, is_const(remote) ?
1151 min_gap(remote) - rec_buffer.sum :
1162 ir_code decoded = rec_buffer.decoded;
1171 ctx->
code = decoded & gen_mask(remote->
bits);
1172 ctx->
pre = decoded >> remote->
bits;
1174 gettimeofday(¤t, NULL);
1175 sum = remote->phead + remote->
shead +
1176 lirc_t_max(remote->pone + remote->
sone,
1177 remote->pzero + remote->
szero) * bit_count(remote) + remote->
plead +
1178 remote->
ptrail + remote->pfoot + remote->
sfoot + remote->pre_p + remote->
pre_s +
1179 remote->post_p + remote->
post_s;
1181 rec_buffer.sum = sum >= remote->
gap ? remote->
gap - 1 : sum;
1182 sync = time_elapsed(&remote->
last_send, ¤t) - rec_buffer.sum;
1184 if (!get_lead(remote)) {
1189 if (has_pre(remote)) {
1190 ctx->
pre = get_pre(remote);
1205 if (has_post(remote)) {
1206 ctx->
post = get_post(remote);
1213 if (!get_trail(remote)) {
1217 if (has_foot(remote)) {
1218 if (!get_foot(remote)) {
1224 rec_buffer.sum -= remote->phead + remote->
shead;
1225 if (is_rcmm(remote)) {
1226 if (!get_gap(remote, 1000))
1228 }
else if (is_const(remote)) {
1229 if (!get_gap(remote, min_gap(remote) > rec_buffer.sum ?
1230 min_gap(remote) - rec_buffer.sum :
1234 if (!get_gap(remote, min_gap(remote)))
1248 if (time_elapsed(&remote->
last_send, ¤t) < 325000)
1251 if (is_const(remote)) {
1252 ctx->
min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
1253 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)
const struct driver *const curr_driver
struct ir_ncode * toggle_code
void rec_buffer_rewind(void)
#define log_debug(fmt,...)
struct ir_ncode * last_code
int receive_decode(struct ir_remote *remote, struct decode_ctx_t *ctx)
void rec_buffer_reset_wptr(void)
#define log_trace2(fmt,...)
#define log_trace1(fmt,...)
#define log_error(fmt,...)
#define log_trace(fmt,...)
#define log_perror_err(fmt,...)
lirc_t(*const readdata)(lirc_t timeout)
void rec_set_update_mode(int mode)
unsigned int min_code_repeat
int rec_buffer_clear(void)
#define log_notice(fmt,...)
unsigned int bits_in_byte