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