LIRC libraries
LinuxInfraredRemoteControl
 All Data Structures Files Functions Variables Typedefs Enumerations Macros Groups Pages
receive.c
Go to the documentation of this file.
1 /****************************************************************************
2  * receive.c ***************************************************************
3  ****************************************************************************
4  *
5  * functions that decode IR codes
6  *
7  * Copyright (C) 1999 Christoph Bartelmus <lirc@bartelmus.de>
8  *
9  */
10 
17 #ifdef HAVE_CONFIG_H
18 # include <config.h>
19 #endif
20 
21 #include <limits.h>
22 #include <errno.h>
23 #include <poll.h>
24 
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"
30 
31 #define RBUF_SIZE 512
32 
33 #define REC_SYNC 8
34 
38 struct rbuf {
39  lirc_t data[RBUF_SIZE];
40  ir_code decoded;
41  int rptr;
42  int wptr;
43  int too_long;
44  int is_biphase;
45  lirc_t pendingp;
46  lirc_t pendings;
47  lirc_t sum;
48  struct timeval last_signal_time;
49  int at_eof;
50  FILE* input_log;
51 };
52 
53 
57 static struct rbuf rec_buffer;
58 static int update_mode = 0;
59 
60 
61 void rec_set_update_mode(int mode)
62 {
63  update_mode = mode;
64 }
65 
66 
67 static lirc_t readdata(lirc_t timeout)
68 {
69  lirc_t data;
70 
71  data = curr_driver->readdata(timeout);
72  rec_buffer.at_eof = data & LIRC_EOF ? 1 : 0;
73  if (rec_buffer.at_eof)
74  logprintf(LIRC_DEBUG, "receive: Got EOF");
75  return data;
76 }
77 
78 
79 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
80 {
81  return a > b ? a : b;
82 }
83 
84 static void set_pending_pulse(lirc_t deltap)
85 {
86  LOGPRINTF(5, "pending pulse: %lu", deltap);
87  rec_buffer.pendingp = deltap;
88 }
89 
90 static void set_pending_space(lirc_t deltas)
91 {
92  LOGPRINTF(5, "pending space: %lu", deltas);
93  rec_buffer.pendings = deltas;
94 }
95 
96 
97 static void log_input(lirc_t data)
98 {
99  fprintf(rec_buffer.input_log, "%s %u\n",
100  data & PULSE_BIT ? "pulse" : "space", data & PULSE_MASK);
101  fflush(rec_buffer.input_log);
102 }
103 
104 
105 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
106 {
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++];
112  }
113  if (rec_buffer.wptr < RBUF_SIZE) {
114  lirc_t data = 0;
115  unsigned long elapsed = 0;
116 
117  if (timerisset(&rec_buffer.last_signal_time)) {
118  struct timeval current;
119 
120  gettimeofday(&current, NULL);
121  elapsed = time_elapsed(&rec_buffer.last_signal_time, &current);
122  }
123  if (elapsed < maxusec)
124  data = readdata(maxusec - elapsed);
125  if (!data) {
126  LOGPRINTF(3, "timeout: %u", maxusec);
127  return 0;
128  }
129  if (data & LIRC_EOF) {
130  logprintf(LIRC_DEBUG, "Receive: returning EOF");
131  return data;
132  }
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));
137  return 0;
138  }
139 
140  rec_buffer.data[rec_buffer.wptr] = data;
141  if (rec_buffer.input_log != NULL)
142  log_input(data);
143  if (rec_buffer.data[rec_buffer.wptr] == 0)
144  return 0;
145  rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
146  & (PULSE_MASK);
147  rec_buffer.wptr++;
148  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]
151  & (PULSE_MASK));
152  return rec_buffer.data[rec_buffer.rptr - 1];
153  }
154  rec_buffer.too_long = 1;
155  return 0;
156 }
157 
158 int waitfordata(__u32 maxusec)
159 {
160  int ret;
161  struct pollfd pfd = {
162  .fd = curr_driver->fd, .events = POLLIN, .revents = 0 };
163 
164  while (1) {
165  do {
166  do {
167  ret = poll(&pfd, 1, maxusec * 1000);
168  } while (ret == -1 && errno == EINTR);
169  if (ret == -1) {
170  logperror(LIRC_ERROR, "poll() failed");
171  continue;
172  }
173  } while (ret == -1);
174 
175  if (pfd.revents & POLLIN)
176  /* we will read later */
177  return 1;
178  }
179 }
180 
181 
182 void rec_buffer_set_logfile(FILE* f)
183 {
184  if (rec_buffer.input_log != NULL)
185  fclose(rec_buffer.input_log);
186  rec_buffer.input_log = f;
187 }
188 
189 
190 static lirc_t get_next_rec_buffer(lirc_t maxusec)
191 {
192  return get_next_rec_buffer_internal(receive_timeout(maxusec));
193 }
194 
195 void rec_buffer_init(void)
196 {
197  memset(&rec_buffer, 0, sizeof(rec_buffer));
198 }
199 
200 void rec_buffer_rewind(void)
201 {
202  rec_buffer.rptr = 0;
203  rec_buffer.too_long = 0;
204  set_pending_pulse(0);
205  set_pending_space(0);
206  rec_buffer.sum = 0;
207  rec_buffer.at_eof = 0;
208 }
209 
210 void rec_buffer_reset_wptr(void)
211 {
212  rec_buffer.wptr = 0;
213 }
214 
215 int rec_buffer_clear(void)
216 {
217  int move, i;
218 
219  timerclear(&rec_buffer.last_signal_time);
220  if (curr_driver->rec_mode == LIRC_MODE_LIRCCODE) {
221  unsigned char buffer[sizeof(ir_code)];
222  size_t count;
223 
224  count = curr_driver->code_length / CHAR_BIT;
225  if (curr_driver->code_length % CHAR_BIT)
226  count++;
227 
228  if (read(curr_driver->fd, buffer, count) != count) {
229  logprintf(LIRC_ERROR, "reading in mode LIRC_MODE_LIRCCODE failed");
230  return 0;
231  }
232  for (i = 0, rec_buffer.decoded = 0; i < count; i++)
233  rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((ir_code)buffer[i]);
234  } else {
235  lirc_t data;
236 
237  move = rec_buffer.wptr - rec_buffer.rptr;
238  if (move > 0 && rec_buffer.rptr > 0) {
239  memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
240  sizeof(rec_buffer.data[0]) * move);
241  rec_buffer.wptr -= rec_buffer.rptr;
242  } else {
243  rec_buffer.wptr = 0;
244  data = readdata(0);
245 
246  LOGPRINTF(3, "c%lu", (__u32)data & (PULSE_MASK));
247 
248  rec_buffer.data[rec_buffer.wptr] = data;
249  rec_buffer.wptr++;
250  }
251  }
252 
253  rec_buffer_rewind();
254  rec_buffer.is_biphase = 0;
255 
256  return 1;
257 }
258 
259 static void unget_rec_buffer(int count)
260 {
261  LOGPRINTF(5, "unget: %d", count);
262  if (count == 1 || count == 2) {
263  rec_buffer.rptr -= count;
264  rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
265  if (count == 2)
266  rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
267  & (PULSE_MASK);
268  }
269 }
270 
271 static void unget_rec_buffer_delta(lirc_t delta)
272 {
273  rec_buffer.rptr--;
274  rec_buffer.sum -= delta & (PULSE_MASK);
275  rec_buffer.data[rec_buffer.rptr] = delta;
276 }
277 
278 static lirc_t get_next_pulse(lirc_t maxusec)
279 {
280  lirc_t data;
281 
282  data = get_next_rec_buffer(maxusec);
283  if (data == 0)
284  return 0;
285  if (!is_pulse(data)) {
286  LOGPRINTF(2, "pulse expected");
287  return 0;
288  }
289  return data & (PULSE_MASK);
290 }
291 
292 static lirc_t get_next_space(lirc_t maxusec)
293 {
294  lirc_t data;
295 
296  data = get_next_rec_buffer(maxusec);
297  if (data == 0)
298  return 0;
299  if (!is_space(data)) {
300  LOGPRINTF(2, "space expected");
301  return 0;
302  }
303  return data;
304 }
305 
306 static int sync_pending_pulse(struct ir_remote* remote)
307 {
308  if (rec_buffer.pendingp > 0) {
309  lirc_t deltap;
310 
311  deltap = get_next_pulse(rec_buffer.pendingp);
312  if (deltap == 0)
313  return 0;
314  if (!expect(remote, deltap, rec_buffer.pendingp))
315  return 0;
316  set_pending_pulse(0);
317  }
318  return 1;
319 }
320 
321 static int sync_pending_space(struct ir_remote* remote)
322 {
323  if (rec_buffer.pendings > 0) {
324  lirc_t deltas;
325 
326  deltas = get_next_space(rec_buffer.pendings);
327  if (deltas == 0)
328  return 0;
329  if (!expect(remote, deltas, rec_buffer.pendings))
330  return 0;
331  set_pending_space(0);
332  }
333  return 1;
334 }
335 
336 static int expectpulse(struct ir_remote* remote, int exdelta)
337 {
338  lirc_t deltap;
339  int retval;
340 
341  LOGPRINTF(5, "expecting pulse: %lu", exdelta);
342  if (!sync_pending_space(remote))
343  return 0;
344 
345  deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
346  if (deltap == 0)
347  return 0;
348  if (rec_buffer.pendingp > 0) {
349  if (rec_buffer.pendingp > deltap)
350  return 0;
351  retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
352  if (!retval)
353  return 0;
354  set_pending_pulse(0);
355  } else {
356  retval = expect(remote, deltap, exdelta);
357  }
358  return retval;
359 }
360 
361 static int expectspace(struct ir_remote* remote, int exdelta)
362 {
363  lirc_t deltas;
364  int retval;
365 
366  LOGPRINTF(5, "expecting space: %lu", exdelta);
367  if (!sync_pending_pulse(remote))
368  return 0;
369 
370  deltas = get_next_space(rec_buffer.pendings + exdelta);
371  if (deltas == 0)
372  return 0;
373  if (rec_buffer.pendings > 0) {
374  if (rec_buffer.pendings > deltas)
375  return 0;
376  retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
377  if (!retval)
378  return 0;
379  set_pending_space(0);
380  } else {
381  retval = expect(remote, deltas, exdelta);
382  }
383  return retval;
384 }
385 
386 static int expectone(struct ir_remote* remote, int bit)
387 {
388  if (is_biphase(remote)) {
389  int all_bits = bit_count(remote);
390  ir_code mask;
391 
392  mask = ((ir_code)1) << (all_bits - 1 - bit);
393  if (mask & remote->rc6_mask) {
394  if (remote->sone > 0 && !expectspace(remote, 2 * remote->sone)) {
395  unget_rec_buffer(1);
396  return 0;
397  }
398  set_pending_pulse(2 * remote->pone);
399  } else {
400  if (remote->sone > 0 && !expectspace(remote, remote->sone)) {
401  unget_rec_buffer(1);
402  return 0;
403  }
404  set_pending_pulse(remote->pone);
405  }
406  } else if (is_space_first(remote)) {
407  if (remote->sone > 0 && !expectspace(remote, remote->sone)) {
408  unget_rec_buffer(1);
409  return 0;
410  }
411  if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
412  unget_rec_buffer(2);
413  return 0;
414  }
415  } else {
416  if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
417  unget_rec_buffer(1);
418  return 0;
419  }
420  if (remote->ptrail > 0) {
421  if (remote->sone > 0 && !expectspace(remote, remote->sone)) {
422  unget_rec_buffer(2);
423  return 0;
424  }
425  } else {
426  set_pending_space(remote->sone);
427  }
428  }
429  return 1;
430 }
431 
432 static int expectzero(struct ir_remote* remote, int bit)
433 {
434  if (is_biphase(remote)) {
435  int all_bits = bit_count(remote);
436  ir_code mask;
437 
438  mask = ((ir_code)1) << (all_bits - 1 - bit);
439  if (mask & remote->rc6_mask) {
440  if (!expectpulse(remote, 2 * remote->pzero)) {
441  unget_rec_buffer(1);
442  return 0;
443  }
444  set_pending_space(2 * remote->szero);
445  } else {
446  if (!expectpulse(remote, remote->pzero)) {
447  unget_rec_buffer(1);
448  return 0;
449  }
450  set_pending_space(remote->szero);
451  }
452  } else if (is_space_first(remote)) {
453  if (remote->szero > 0 && !expectspace(remote, remote->szero)) {
454  unget_rec_buffer(1);
455  return 0;
456  }
457  if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
458  unget_rec_buffer(2);
459  return 0;
460  }
461  } else {
462  if (!expectpulse(remote, remote->pzero)) {
463  unget_rec_buffer(1);
464  return 0;
465  }
466  if (remote->ptrail > 0) {
467  if (!expectspace(remote, remote->szero)) {
468  unget_rec_buffer(2);
469  return 0;
470  }
471  } else {
472  set_pending_space(remote->szero);
473  }
474  }
475  return 1;
476 }
477 
478 static lirc_t sync_rec_buffer(struct ir_remote* remote)
479 {
480  int count;
481  lirc_t deltas, deltap;
482 
483  count = 0;
484  deltas = get_next_space(1000000);
485  if (deltas == 0)
486  return 0;
487 
488  if (last_remote != NULL && !is_rcmm(remote)) {
489  while (!expect_at_least(last_remote, deltas, last_remote->min_remaining_gap)) {
490  deltap = get_next_pulse(1000000);
491  if (deltap == 0)
492  return 0;
493  deltas = get_next_space(1000000);
494  if (deltas == 0)
495  return 0;
496  count++;
497  if (count > REC_SYNC) /* no sync found,
498  * let's try a diffrent remote */
499  return 0;
500  }
501  if (has_toggle_mask(remote)) {
502  if (!expect_at_most(last_remote, deltas, last_remote->max_remaining_gap)) {
503  remote->toggle_mask_state = 0;
504  remote->toggle_code = NULL;
505  }
506  }
507  }
508  rec_buffer.sum = 0;
509  return deltas;
510 }
511 
512 static int get_header(struct ir_remote* remote)
513 {
514  if (is_rcmm(remote)) {
515  lirc_t deltap, deltas, sum;
516 
517  deltap = get_next_pulse(remote->phead);
518  if (deltap == 0) {
519  unget_rec_buffer(1);
520  return 0;
521  }
522  deltas = get_next_space(remote->shead);
523  if (deltas == 0) {
524  unget_rec_buffer(2);
525  return 0;
526  }
527  sum = deltap + deltas;
528  if (expect(remote, sum, remote->phead + remote->shead))
529  return 1;
530  unget_rec_buffer(2);
531  return 0;
532  } else if (is_bo(remote)) {
533  if (expectpulse(remote, remote->pone) && expectspace(remote, remote->sone)
534  && expectpulse(remote, remote->pone) && expectspace(remote, remote->sone)
535  && expectpulse(remote, remote->phead) && expectspace(remote, remote->shead))
536  return 1;
537  return 0;
538  }
539  if (remote->shead == 0) {
540  if (!sync_pending_space(remote))
541  return 0;
542  set_pending_pulse(remote->phead);
543  return 1;
544  }
545  if (!expectpulse(remote, remote->phead)) {
546  unget_rec_buffer(1);
547  return 0;
548  }
549  /* if this flag is set I need a decision now if this is really
550  * a header */
551  if (remote->flags & NO_HEAD_REP) {
552  lirc_t deltas;
553 
554  deltas = get_next_space(remote->shead);
555  if (deltas != 0) {
556  if (expect(remote, remote->shead, deltas))
557  return 1;
558  unget_rec_buffer(2);
559  return 0;
560  }
561  }
562 
563  set_pending_space(remote->shead);
564  return 1;
565 }
566 
567 static int get_foot(struct ir_remote* remote)
568 {
569  if (!expectspace(remote, remote->sfoot))
570  return 0;
571  if (!expectpulse(remote, remote->pfoot))
572  return 0;
573  return 1;
574 }
575 
576 static int get_lead(struct ir_remote* remote)
577 {
578  if (remote->plead == 0)
579  return 1;
580  if (!sync_pending_space(remote))
581  return 0;
582  set_pending_pulse(remote->plead);
583  return 1;
584 }
585 
586 static int get_trail(struct ir_remote* remote)
587 {
588  if (remote->ptrail != 0)
589  if (!expectpulse(remote, remote->ptrail))
590  return 0;
591  if (rec_buffer.pendingp > 0)
592  if (!sync_pending_pulse(remote))
593  return 0;
594  return 1;
595 }
596 
597 static int get_gap(struct ir_remote* remote, lirc_t gap)
598 {
599  lirc_t data;
600 
601  LOGPRINTF(2, "sum: %d", rec_buffer.sum);
602  data = get_next_rec_buffer(gap - gap * remote->eps / 100);
603  if (data == 0)
604  return 1;
605  if (!is_space(data)) {
606  LOGPRINTF(2, "space expected");
607  return 0;
608  }
609  unget_rec_buffer(1);
610  if (!expect_at_least(remote, data, gap)) {
611  LOGPRINTF(1, "end of signal not found");
612  return 0;
613  }
614  return 1;
615 }
616 
617 static int get_repeat(struct ir_remote* remote)
618 {
619  if (!get_lead(remote))
620  return 0;
621  if (is_biphase(remote)) {
622  if (!expectspace(remote, remote->srepeat))
623  return 0;
624  if (!expectpulse(remote, remote->prepeat))
625  return 0;
626  } else {
627  if (!expectpulse(remote, remote->prepeat))
628  return 0;
629  set_pending_space(remote->srepeat);
630  }
631  if (!get_trail(remote))
632  return 0;
633  if (!get_gap
634  (remote,
635  is_const(remote) ? (min_gap(remote) >
636  rec_buffer.sum ?
637  min_gap(remote) - rec_buffer.sum : 0) :
638  (has_repeat_gap(remote) ? remote->repeat_gap : min_gap(remote))
639  ))
640  return 0;
641  return 1;
642 }
643 
644 static ir_code get_data(struct ir_remote* remote, int bits, int done)
645 {
646  ir_code code;
647  int i;
648 
649  code = 0;
650 
651  if (is_rcmm(remote)) {
652  lirc_t deltap, deltas, sum;
653 
654  if (bits % 2 || done % 2) {
655  logprintf(LIRC_ERROR, "invalid bit number.");
656  return (ir_code) -1;
657  }
658  if (!sync_pending_space(remote))
659  return 0;
660  for (i = 0; i < bits; i += 2) {
661  code <<= 2;
662  deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
663  deltas = get_next_space(remote->szero + remote->sone + remote->stwo + remote->sthree);
664  if (deltap == 0 || deltas == 0) {
665  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
666  return (ir_code) -1;
667  }
668  sum = deltap + deltas;
669  LOGPRINTF(3, "rcmm: sum %ld", (__u32)sum);
670  if (expect(remote, sum, remote->pzero + remote->szero)) {
671  code |= 0;
672  LOGPRINTF(2, "00");
673  } else if (expect(remote, sum, remote->pone + remote->sone)) {
674  code |= 1;
675  LOGPRINTF(2, "01");
676  } else if (expect(remote, sum, remote->ptwo + remote->stwo)) {
677  code |= 2;
678  LOGPRINTF(2, "10");
679  } else if (expect(remote, sum, remote->pthree + remote->sthree)) {
680  code |= 3;
681  LOGPRINTF(2, "11");
682  } else {
683  LOGPRINTF(2, "no match for %d+%d=%d", deltap, deltas, sum);
684  return (ir_code) -1;
685  }
686  }
687  return code;
688  } else if (is_grundig(remote)) {
689  lirc_t deltap, deltas, sum;
690  int state, laststate;
691 
692  if (bits % 2 || done % 2) {
693  logprintf(LIRC_ERROR, "invalid bit number.");
694  return (ir_code) -1;
695  }
696  if (!sync_pending_pulse(remote))
697  return (ir_code) -1;
698  for (laststate = state = -1, i = 0; i < bits; ) {
699  deltas = get_next_space(remote->szero + remote->sone + remote->stwo + remote->sthree);
700  deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
701  if (deltas == 0 || deltap == 0) {
702  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
703  return (ir_code) -1;
704  }
705  sum = deltas + deltap;
706  LOGPRINTF(3, "grundig: sum %ld", (__u32)sum);
707  if (expect(remote, sum, remote->szero + remote->pzero)) {
708  state = 0;
709  LOGPRINTF(2, "2T");
710  } else if (expect(remote, sum, remote->sone + remote->pone)) {
711  state = 1;
712  LOGPRINTF(2, "3T");
713  } else if (expect(remote, sum, remote->stwo + remote->ptwo)) {
714  state = 2;
715  LOGPRINTF(2, "4T");
716  } else if (expect(remote, sum, remote->sthree + remote->pthree)) {
717  state = 3;
718  LOGPRINTF(2, "6T");
719  } else {
720  LOGPRINTF(2, "no match for %d+%d=%d", deltas, deltap, sum);
721  return (ir_code) -1;
722  }
723  if (state == 3) { /* 6T */
724  i += 2;
725  code <<= 2;
726  state = -1;
727  code |= 0;
728  } else if (laststate == 2 && state == 0) { /* 4T2T */
729  i += 2;
730  code <<= 2;
731  state = -1;
732  code |= 1;
733  } else if (laststate == 1 && state == 1) { /* 3T3T */
734  i += 2;
735  code <<= 2;
736  state = -1;
737  code |= 2;
738  } else if (laststate == 0 && state == 2) { /* 2T4T */
739  i += 2;
740  code <<= 2;
741  state = -1;
742  code |= 3;
743  } else if (laststate == -1) {
744  /* 1st bit */
745  } else {
746  logprintf(LIRC_ERROR, "invalid state %d:%d", laststate, state);
747  return (ir_code) -1;
748  }
749  laststate = state;
750  }
751  return code;
752  } else if (is_serial(remote)) {
753  int received;
754  int space, stop_bit, parity_bit;
755  int parity;
756  lirc_t delta, origdelta, pending, expecting, gap_delta;
757  lirc_t base, stop;
758  lirc_t max_space, max_pulse;
759 
760  base = 1000000 / remote->baud;
761 
762  /* start bit */
763  set_pending_pulse(base);
764 
765  received = 0;
766  space = (rec_buffer.pendingp == 0); /* expecting space ? */
767  stop_bit = 0;
768  parity_bit = 0;
769  delta = origdelta = 0;
770  stop = base * remote->stop_bits / 2;
771  parity = 0;
772  gap_delta = 0;
773 
774  max_space = remote->sone * remote->bits_in_byte + stop;
775  max_pulse = remote->pzero * (1 + remote->bits_in_byte);
776  if (remote->parity != IR_PARITY_NONE) {
777  parity_bit = 1;
778  max_space += remote->sone;
779  max_pulse += remote->pzero;
780  bits += bits / remote->bits_in_byte;
781  }
782 
783  while (received < bits || stop_bit) {
784  if (delta == 0) {
785  delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
786  if (delta == 0 && space && received + remote->bits_in_byte + parity_bit >= bits)
787  /* open end */
788  delta = max_space;
789  origdelta = delta;
790  }
791  if (delta == 0) {
792  LOGPRINTF(1, "failed before bit %d", received + 1);
793  return (ir_code) -1;
794  }
795  pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
796  if (expect(remote, delta, pending)) {
797  delta = 0;
798  } else if (delta > pending) {
799  delta -= pending;
800  } else {
801  LOGPRINTF(1, "failed before bit %d", received + 1);
802  return (ir_code) -1;
803  }
804  if (pending > 0) {
805  if (stop_bit) {
806  LOGPRINTF(5, "delta: %lu", delta);
807  gap_delta = delta;
808  delta = 0;
809  set_pending_pulse(base);
810  set_pending_space(0);
811  stop_bit = 0;
812  space = 0;
813  LOGPRINTF(3, "stop bit found");
814  } else {
815  LOGPRINTF(3, "pending bit found");
816  set_pending_pulse(0);
817  set_pending_space(0);
818  if (delta == 0)
819  space = (space ? 0 : 1);
820  }
821  continue;
822  }
823  expecting = (space ? remote->sone : remote->pzero);
824  if (delta > expecting || expect(remote, delta, expecting)) {
825  delta -= (expecting > delta ? delta : expecting);
826  received++;
827  code <<= 1;
828  code |= space;
829  parity ^= space;
830  LOGPRINTF(2, "adding %d", space);
831  if (received % (remote->bits_in_byte + parity_bit) == 0) {
832  ir_code temp;
833 
834  if ((remote->parity == IR_PARITY_EVEN && parity)
835  || (remote->parity == IR_PARITY_ODD && !parity)) {
836  LOGPRINTF(1, "parity error after %d bits", received + 1);
837  return (ir_code) -1;
838  }
839  parity = 0;
840 
841  /* parity bit is filtered out */
842  temp = code >> (remote->bits_in_byte + parity_bit);
843  code =
844  temp << remote->bits_in_byte | reverse(code >> parity_bit,
845  remote->bits_in_byte);
846 
847  if (space && delta == 0) {
848  LOGPRINTF(1, "failed at stop bit after %d bits", received + 1);
849  return (ir_code) -1;
850  }
851  LOGPRINTF(3, "awaiting stop bit");
852  set_pending_space(stop);
853  stop_bit = 1;
854  }
855  } else {
856  if (delta == origdelta) {
857  LOGPRINTF(1, "framing error after %d bits", received + 1);
858  return (ir_code) -1;
859  }
860  delta = 0;
861  }
862  if (delta == 0)
863  space = (space ? 0 : 1);
864  }
865  if (gap_delta)
866  unget_rec_buffer_delta(gap_delta);
867  set_pending_pulse(0);
868  set_pending_space(0);
869  return code;
870  } else if (is_bo(remote)) {
871  int lastbit = 1;
872  lirc_t deltap, deltas;
873  lirc_t pzero, szero;
874  lirc_t pone, sone;
875 
876  for (i = 0; i < bits; i++) {
877  code <<= 1;
878  deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
879  deltas = get_next_space(remote->szero + remote->sone + remote->stwo + remote->sthree);
880  if (deltap == 0 || deltas == 0) {
881  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
882  return (ir_code) -1;
883  }
884  if (lastbit == 1) {
885  pzero = remote->pone;
886  szero = remote->sone;
887  pone = remote->ptwo;
888  sone = remote->stwo;
889  } else {
890  pzero = remote->ptwo;
891  szero = remote->stwo;
892  pone = remote->pthree;
893  sone = remote->sthree;
894  }
895  LOGPRINTF(5, "%lu %lu %lu %lu", pzero, szero, pone, sone);
896  if (expect(remote, deltap, pzero)) {
897  if (expect(remote, deltas, szero)) {
898  code |= 0;
899  lastbit = 0;
900  LOGPRINTF(2, "0");
901  continue;
902  }
903  }
904 
905  if (expect(remote, deltap, pone)) {
906  if (expect(remote, deltas, sone)) {
907  code |= 1;
908  lastbit = 1;
909  LOGPRINTF(2, "1");
910  continue;
911  }
912  }
913  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
914  return (ir_code) -1;
915  }
916  return code;
917  } else if (is_xmp(remote)) {
918  lirc_t deltap, deltas, sum;
919  ir_code n;
920 
921  if (bits % 4 || done % 4) {
922  logprintf(LIRC_ERROR, "invalid bit number.");
923  return (ir_code) -1;
924  }
925  if (!sync_pending_space(remote))
926  return 0;
927  for (i = 0; i < bits; i += 4) {
928  code <<= 4;
929  deltap = get_next_pulse(remote->pzero);
930  deltas = get_next_space(remote->szero + 16 * remote->sone);
931  if (deltap == 0 || deltas == 0) {
932  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
933  return (ir_code) -1;
934  }
935  sum = deltap + deltas;
936 
937  sum -= remote->pzero + remote->szero;
938  n = (sum + remote->sone / 2) / remote->sone;
939  if (n >= 16) {
940  logprintf(LIRC_ERROR, "failed on bit %d", done + i + 1);
941  return (ir_code) -1;
942  }
943  LOGPRINTF(1, "%d: %lx", i, n);
944  code |= n;
945  }
946  return code;
947  }
948 
949  for (i = 0; i < bits; i++) {
950  code = code << 1;
951  if (is_goldstar(remote)) {
952  if ((done + i) % 2) {
953  LOGPRINTF(2, "$1");
954  remote->pone = remote->ptwo;
955  remote->sone = remote->stwo;
956  } else {
957  LOGPRINTF(2, "$2");
958  remote->pone = remote->pthree;
959  remote->sone = remote->sthree;
960  }
961  }
962 
963  if (expectone(remote, done + i)) {
964  LOGPRINTF(2, "1");
965  code |= 1;
966  } else if (expectzero(remote, done + i)) {
967  LOGPRINTF(2, "0");
968  code |= 0;
969  } else {
970  LOGPRINTF(1, "failed on bit %d", done + i + 1);
971  return (ir_code) -1;
972  }
973  }
974  return code;
975 }
976 
977 static ir_code get_pre(struct ir_remote* remote)
978 {
979  ir_code pre;
980  ir_code remote_pre;
981  ir_code match_pre;
982  ir_code toggle_mask;
983 
984  pre = get_data(remote, remote->pre_data_bits, 0);
985 
986  if (pre == (ir_code) -1) {
987  LOGPRINTF(1, "Failed on pre_data: cannot get it");
988  return (ir_code) -1;
989  }
990  if (update_mode) {
991  /*
992  * toggle_bit_mask is applied to the concatenated
993  * pre_data - data - post_data. We dont check post data, but
994  * adjusts for the length.
995  */
996  toggle_mask =
997  remote->toggle_bit_mask >> remote->post_data_bits;
998  remote_pre = remote->pre_data & ~toggle_mask;
999  match_pre = pre & ~toggle_mask;
1000  if (remote->pre_data != 0 && remote_pre != match_pre) {
1001  LOGPRINTF(1, "Failed on pre_data: bad data: %x", pre);
1002  return (ir_code) -1;
1003  }
1004  }
1005  if (remote->pre_p > 0 && remote->pre_s > 0) {
1006  if (!expectpulse(remote, remote->pre_p))
1007  return (ir_code) -1;
1008  set_pending_space(remote->pre_s);
1009  }
1010  return pre;
1011 }
1012 
1013 static ir_code get_post(struct ir_remote* remote)
1014 {
1015  ir_code post;
1016 
1017  if (remote->post_p > 0 && remote->post_s > 0) {
1018  if (!expectpulse(remote, remote->post_p))
1019  return (ir_code) -1;
1020  set_pending_space(remote->post_s);
1021  }
1022 
1023  post = get_data(remote, remote->post_data_bits, remote->pre_data_bits + remote->bits);
1024 
1025  if (post == (ir_code) -1) {
1026  LOGPRINTF(1, "failed on post_data");
1027  return (ir_code) -1;
1028  }
1029  return post;
1030 }
1031 
1032 int receive_decode(struct ir_remote* remote, struct decode_ctx_t* ctx)
1033 {
1034  lirc_t sync;
1035  int header;
1036  struct timeval current;
1037 
1038  sync = 0; /* make compiler happy */
1039  memset(ctx, 0, sizeof(struct decode_ctx_t));
1040  ctx->code = ctx->pre = ctx->post = 0;
1041  header = 0;
1042 
1043  if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
1044  logprintf(LIRC_DEBUG, "Decode: found EOF");
1045  ctx->code = LIRC_EOF;
1046  rec_buffer.at_eof = 0;
1047  return 1;
1048  }
1049  if (curr_driver->rec_mode == LIRC_MODE_MODE2 ||
1050  curr_driver->rec_mode == LIRC_MODE_PULSE ||
1051  curr_driver->rec_mode == LIRC_MODE_RAW) {
1052  rec_buffer_rewind();
1053  rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
1054 
1055  /* we should get a long space first */
1056  sync = sync_rec_buffer(remote);
1057  if (!sync) {
1058  LOGPRINTF(1, "failed on sync");
1059  return 0;
1060  }
1061  LOGPRINTF(1, "sync");
1062 
1063  if (has_repeat(remote) && last_remote == remote) {
1064  if (remote->flags & REPEAT_HEADER && has_header(remote)) {
1065  if (!get_header(remote)) {
1066  LOGPRINTF(1, "failed on repeat header");
1067  return 0;
1068  }
1069  LOGPRINTF(1, "repeat header");
1070  }
1071  if (get_repeat(remote)) {
1072  if (remote->last_code == NULL) {
1073  logprintf(LIRC_NOTICE, "repeat code without last_code received");
1074  return 0;
1075  }
1076 
1077  ctx->pre = remote->pre_data;
1078  ctx->code = remote->last_code->code;
1079  ctx->post = remote->post_data;
1080  ctx->repeat_flag = 1;
1081 
1082  ctx->min_remaining_gap =
1083  is_const(remote) ? (min_gap(remote) >
1084  rec_buffer.sum ? min_gap(remote) -
1085  rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1086  repeat_gap : min_gap(remote));
1087  ctx->max_remaining_gap =
1088  is_const(remote) ? (max_gap(remote) >
1089  rec_buffer.sum ? max_gap(remote) -
1090  rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
1091  repeat_gap : max_gap(remote));
1092  return 1;
1093  }
1094  LOGPRINTF(1, "no repeat");
1095  rec_buffer_rewind();
1096  sync_rec_buffer(remote);
1097  }
1098 
1099  if (has_header(remote)) {
1100  header = 1;
1101  if (!get_header(remote)) {
1102  header = 0;
1103  if (!(remote->flags & NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
1104  LOGPRINTF(1, "failed on header");
1105  return 0;
1106  }
1107  }
1108  LOGPRINTF(1, "header");
1109  }
1110  }
1111 
1112  if (is_raw(remote)) {
1113  struct ir_ncode* codes;
1114  struct ir_ncode* found;
1115  int i;
1116 
1117  if (curr_driver->rec_mode == LIRC_MODE_LIRCCODE)
1118  return 0;
1119 
1120  codes = remote->codes;
1121  found = NULL;
1122  while (codes->name != NULL && found == NULL) {
1123  found = codes;
1124  for (i = 0; i < codes->length; ) {
1125  if (!expectpulse(remote, codes->signals[i++])) {
1126  found = NULL;
1127  rec_buffer_rewind();
1128  sync_rec_buffer(remote);
1129  break;
1130  }
1131  if (i < codes->length && !expectspace(remote, codes->signals[i++])) {
1132  found = NULL;
1133  rec_buffer_rewind();
1134  sync_rec_buffer(remote);
1135  break;
1136  }
1137  }
1138  codes++;
1139  if (found != NULL) {
1140  if (!get_gap
1141  (remote, is_const(remote) ?
1142  min_gap(remote) - rec_buffer.sum :
1143  min_gap(remote)))
1144  found = NULL;
1145  }
1146  }
1147  if (found == NULL)
1148  return 0;
1149  ctx->code = found->code;
1150  } else {
1151  if (curr_driver->rec_mode == LIRC_MODE_LIRCCODE) {
1152  lirc_t sum;
1153  ir_code decoded = rec_buffer.decoded;
1154 
1155  LOGPRINTF(1, "decoded: %llx", decoded);
1156  if (curr_driver->rec_mode == LIRC_MODE_LIRCCODE
1157  && curr_driver->code_length != bit_count(remote))
1158  return 0;
1159 
1160  ctx->post = decoded & gen_mask(remote->post_data_bits);
1161  decoded >>= remote->post_data_bits;
1162  ctx->code = decoded & gen_mask(remote->bits);
1163  ctx->pre = decoded >> remote->bits;
1164 
1165  gettimeofday(&current, NULL);
1166  sum = remote->phead + remote->shead +
1167  lirc_t_max(remote->pone + remote->sone,
1168  remote->pzero + remote->szero) * bit_count(remote) + remote->plead +
1169  remote->ptrail + remote->pfoot + remote->sfoot + remote->pre_p + remote->pre_s +
1170  remote->post_p + remote->post_s;
1171 
1172  rec_buffer.sum = sum >= remote->gap ? remote->gap - 1 : sum;
1173  sync = time_elapsed(&remote->last_send, &current) - rec_buffer.sum;
1174  } else {
1175  if (!get_lead(remote)) {
1176  LOGPRINTF(1, "failed on leading pulse");
1177  return 0;
1178  }
1179 
1180  if (has_pre(remote)) {
1181  ctx->pre = get_pre(remote);
1182  if (ctx->pre == (ir_code) -1) {
1183  LOGPRINTF(1, "failed on pre");
1184  return 0;
1185  }
1186  LOGPRINTF(1, "pre: %llx", ctx->pre);
1187  }
1188 
1189  ctx->code = get_data(remote, remote->bits, remote->pre_data_bits);
1190  if (ctx->code == (ir_code) -1) {
1191  LOGPRINTF(1, "failed on code");
1192  return 0;
1193  }
1194  LOGPRINTF(1, "code: %llx", ctx->code);
1195 
1196  if (has_post(remote)) {
1197  ctx->post = get_post(remote);
1198  if (ctx->post == (ir_code) -1) {
1199  LOGPRINTF(1, "failed on post");
1200  return 0;
1201  }
1202  LOGPRINTF(1, "post: %llx", ctx->post);
1203  }
1204  if (!get_trail(remote)) {
1205  LOGPRINTF(1, "failed on trailing pulse");
1206  return 0;
1207  }
1208  if (has_foot(remote)) {
1209  if (!get_foot(remote)) {
1210  LOGPRINTF(1, "failed on foot");
1211  return 0;
1212  }
1213  }
1214  if (header == 1 && is_const(remote) && (remote->flags & NO_HEAD_REP))
1215  rec_buffer.sum -= remote->phead + remote->shead;
1216  if (is_rcmm(remote)) {
1217  if (!get_gap(remote, 1000))
1218  return 0;
1219  } else if (is_const(remote)) {
1220  if (!get_gap(remote, min_gap(remote) > rec_buffer.sum ?
1221  min_gap(remote) - rec_buffer.sum :
1222  0))
1223  return 0;
1224  } else {
1225  if (!get_gap(remote, min_gap(remote)))
1226  return 0;
1227  }
1228  } /* end of mode specific code */
1229  }
1230  if ((!has_repeat(remote) || remote->reps < remote->min_code_repeat)
1231  && expect_at_most(remote, sync, remote->max_remaining_gap))
1232  ctx->repeat_flag = 1;
1233  else
1234  ctx->repeat_flag = 0;
1235  if (curr_driver->rec_mode == LIRC_MODE_LIRCCODE) {
1236  /* Most TV cards don't pass each signal to the
1237  * driver. This heuristic should fix repeat in such
1238  * cases. */
1239  if (time_elapsed(&remote->last_send, &current) < 325000)
1240  ctx->repeat_flag = 1;
1241  }
1242  if (is_const(remote)) {
1243  ctx->min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
1244  ctx->max_remaining_gap = max_gap(remote) > rec_buffer.sum ? max_gap(remote) - rec_buffer.sum : 0;
1245  } else {
1246  ctx->min_remaining_gap = min_gap(remote);
1247  ctx->max_remaining_gap = max_gap(remote);
1248  }
1249  return 1;
1250 }
ir_remote::min_remaining_gap
lirc_t min_remaining_gap
Definition: ir_remote_types.h:240
rec_buffer_init
void rec_buffer_init(void)
Definition: receive.c:195
last_remote
struct ir_remote * last_remote
Definition: ir_remote.c:51
rec_buffer_set_logfile
void rec_buffer_set_logfile(FILE *f)
Definition: receive.c:182
ir_remote
Definition: ir_remote_types.h:163
ir_remote::bits
int bits
Definition: ir_remote_types.h:167
waitfordata
int waitfordata(__u32 maxusec)
Definition: receive.c:158
driver::fd
int fd
Definition: driver.h:93
ir_remote::post_data
ir_code post_data
Definition: ir_remote_types.h:195
ir_remote::post_s
lirc_t post_s
Definition: ir_remote_types.h:197
ir_remote::plead
lirc_t plead
Definition: ir_remote_types.h:187
ir_remote::toggle_code
struct ir_ncode * toggle_code
Definition: ir_remote_types.h:237
rec_buffer_rewind
void rec_buffer_rewind(void)
Definition: receive.c:200
ir_remote::baud
unsigned int baud
Definition: ir_remote_types.h:222
ir_ncode::signals
lirc_t * signals
Definition: ir_remote_types.h:83
ir_remote::eps
int eps
Definition: ir_remote_types.h:169
ir_remote::last_code
struct ir_ncode * last_code
Definition: ir_remote_types.h:236
ir_remote::parity
unsigned int parity
Definition: ir_remote_types.h:224
decode_ctx_t::pre
ir_code pre
Definition: ir_remote_types.h:152
receive_decode
int receive_decode(struct ir_remote *remote, struct decode_ctx_t *ctx)
Definition: receive.c:1032
LIRC_EOF
#define LIRC_EOF
Definition: lirc_config.h:104
ir_code
__u64 ir_code
Definition: ir_remote_types.h:55
ir_remote::sfoot
lirc_t sfoot
Definition: ir_remote_types.h:189
ir_remote::ptrail
lirc_t ptrail
Definition: ir_remote_types.h:188
ir_remote::pre_data_bits
int pre_data_bits
Definition: ir_remote_types.h:192
rec_buffer_reset_wptr
void rec_buffer_reset_wptr(void)
Definition: receive.c:210
driver::code_length
const __u32 code_length
Definition: driver.h:111
ir_ncode::name
char * name
Definition: ir_remote_types.h:74
driver::readdata
lirc_t(*const readdata)(lirc_t timeout)
Definition: driver.h:169
ir_remote::last_send
struct timeval last_send
Definition: ir_remote_types.h:239
ir_remote::post_data_bits
int post_data_bits
Definition: ir_remote_types.h:194
ir_remote::sthree
lirc_t sthree
Definition: ir_remote_types.h:183
ir_remote::pre_data
ir_code pre_data
Definition: ir_remote_types.h:193
decode_ctx_t::post
ir_code post
Definition: ir_remote_types.h:153
ir_remote::sone
lirc_t sone
Definition: ir_remote_types.h:185
ir_remote::shead
lirc_t shead
Definition: ir_remote_types.h:182
REPEAT_HEADER
#define REPEAT_HEADER
Definition: ir_remote_types.h:134
decode_ctx_t::max_remaining_gap
lirc_t max_remaining_gap
Definition: ir_remote_types.h:155
decode_ctx_t::code
ir_code code
Definition: ir_remote_types.h:151
ir_remote::repeat_gap
__u32 repeat_gap
Definition: ir_remote_types.h:201
ir_remote::gap
__u32 gap
Definition: ir_remote_types.h:199
NO_HEAD_REP
#define NO_HEAD_REP
Definition: ir_remote_types.h:131
ir_remote::stop_bits
unsigned int stop_bits
Definition: ir_remote_types.h:225
ir_remote::pre_s
lirc_t pre_s
Definition: ir_remote_types.h:196
ir_remote::szero
lirc_t szero
Definition: ir_remote_types.h:186
LOGPRINTF
#define LOGPRINTF(level, fmt, args...)
Definition: lirc_log.h:75
ir_ncode
Definition: ir_remote_types.h:72
ir_remote::stwo
lirc_t stwo
Definition: ir_remote_types.h:184
ir_remote::flags
int flags
Definition: ir_remote_types.h:168
ir_remote::srepeat
lirc_t srepeat
Definition: ir_remote_types.h:190
decode_ctx_t
Definition: ir_remote_types.h:150
decode_ctx_t::min_remaining_gap
lirc_t min_remaining_gap
Definition: ir_remote_types.h:156
ir_remote::max_remaining_gap
lirc_t max_remaining_gap
Definition: ir_remote_types.h:241
logperror
void logperror(loglevel_t prio, const char *fmt,...)
Definition: lirc_log.c:288
ir_ncode::code
ir_code code
Definition: ir_remote_types.h:77
rec_set_update_mode
void rec_set_update_mode(int mode)
Definition: receive.c:61
ir_remote::min_code_repeat
unsigned int min_code_repeat
Definition: ir_remote_types.h:215
driver::rec_mode
__u32 rec_mode
Definition: driver.h:108
curr_driver
const struct driver const * curr_driver
Definition: driver.c:26
ir_remote::rc6_mask
ir_code rc6_mask
Definition: ir_remote_types.h:219
decode_ctx_t::repeat_flag
int repeat_flag
Definition: ir_remote_types.h:154
ir_remote::toggle_bit_mask
ir_code toggle_bit_mask
Definition: ir_remote_types.h:203
rec_buffer_clear
int rec_buffer_clear(void)
Definition: receive.c:215
ir_remote::bits_in_byte
unsigned int bits_in_byte
Definition: ir_remote_types.h:223
ir_ncode::length
int length
Definition: ir_remote_types.h:80