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