26 #include "media/lirc.h" 
   28 #include "lirc/driver.h" 
   29 #include "lirc/lirc_log.h" 
   30 #include "lirc/receive.h" 
   31 #include "lirc/ir_remote.h" 
   43         lirc_t          data[RBUF_SIZE];
 
   52         struct timeval  last_signal_time;
 
   61 static struct rbuf rec_buffer;
 
   62 static int update_mode = 0;
 
   70 int (*lircd_waitfordata)(uint32_t timeout) = NULL;
 
   73 static lirc_t readdata(lirc_t timeout)
 
   78         rec_buffer.at_eof = data & 
LIRC_EOF ? 1 : 0;
 
   79         if (rec_buffer.at_eof)
 
   85 static lirc_t lirc_t_max(lirc_t a, lirc_t b)
 
   90 static void set_pending_pulse(lirc_t deltap)
 
   93         rec_buffer.pendingp = deltap;
 
   96 static void set_pending_space(lirc_t deltas)
 
   99         rec_buffer.pendings = deltas;
 
  103 static void log_input(lirc_t data)
 
  105         fprintf(rec_buffer.input_log, 
"%s %u\n",
 
  106                 data & PULSE_BIT ? 
"pulse" : 
"space", data & PULSE_MASK);
 
  107         fflush(rec_buffer.input_log);
 
  111 static lirc_t get_next_rec_buffer_internal(lirc_t maxusec)
 
  113         if (rec_buffer.rptr < rec_buffer.wptr) {
 
  114                 log_trace2(
"<%c%lu", rec_buffer.data[rec_buffer.rptr] & PULSE_BIT ? 
'p' : 
's', (uint32_t)
 
  115                           rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK));
 
  116                 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
 
  117                 return rec_buffer.data[rec_buffer.rptr++];
 
  119         if (rec_buffer.wptr < RBUF_SIZE) {
 
  121                 unsigned long elapsed = 0;
 
  123                 if (timerisset(&rec_buffer.last_signal_time)) {
 
  124                         struct timeval current;
 
  126                         gettimeofday(¤t, NULL);
 
  127                         elapsed = time_elapsed(&rec_buffer.last_signal_time, ¤t);
 
  129                 if (elapsed < maxusec)
 
  130                         data = readdata(maxusec - elapsed);
 
  139                 if (LIRC_IS_TIMEOUT(data)) {
 
  140                         log_trace(
"timeout received: %lu", (uint32_t)LIRC_VALUE(data));
 
  141                         if (LIRC_VALUE(data) < maxusec)
 
  142                                 return get_next_rec_buffer_internal(maxusec - LIRC_VALUE(data));
 
  146                 rec_buffer.data[rec_buffer.wptr] = data;
 
  147                 if (rec_buffer.input_log != NULL)
 
  149                 if (rec_buffer.data[rec_buffer.wptr] == 0)
 
  151                 rec_buffer.sum += rec_buffer.data[rec_buffer.rptr]
 
  155                 log_trace2(
"+%c%lu", rec_buffer.data[rec_buffer.rptr - 1] & PULSE_BIT ? 
'p' : 
's', (uint32_t)
 
  156                           rec_buffer.data[rec_buffer.rptr - 1]
 
  158                 return rec_buffer.data[rec_buffer.rptr - 1];
 
  160         rec_buffer.too_long = 1;
 
  167         lircd_waitfordata = func;
 
  174         struct pollfd pfd = {
 
  177         if (lircd_waitfordata != NULL)
 
  178                 return lircd_waitfordata(maxusec);
 
  183                                 ret = curl_poll(&pfd, 1, (maxusec > 0) ? (maxusec / 1000) : -1);
 
  184                                 if (maxusec > 0 && ret == 0)
 
  186                         } 
while (ret == -1 && errno == EINTR);
 
  193                 if (pfd.revents & POLLIN)
 
  202         if (rec_buffer.input_log != NULL)
 
  203                 fclose(rec_buffer.input_log);
 
  204         rec_buffer.input_log = f;
 
  208 static lirc_t get_next_rec_buffer(lirc_t maxusec)
 
  210         return get_next_rec_buffer_internal(receive_timeout(maxusec));
 
  215         memset(&rec_buffer, 0, 
sizeof(rec_buffer));
 
  221         rec_buffer.too_long = 0;
 
  222         set_pending_pulse(0);
 
  223         set_pending_space(0);
 
  225         rec_buffer.at_eof = 0;
 
  237         timerclear(&rec_buffer.last_signal_time);
 
  247                         log_error(
"reading in mode LIRC_MODE_LIRCCODE failed");
 
  250                 for (i = 0, rec_buffer.decoded = 0; i < count; i++)
 
  251                         rec_buffer.decoded = (rec_buffer.decoded << CHAR_BIT) + ((
ir_code)buffer[i]);
 
  255                 move = rec_buffer.wptr - rec_buffer.rptr;
 
  256                 if (move > 0 && rec_buffer.rptr > 0) {
 
  257                         memmove(&rec_buffer.data[0], &rec_buffer.data[rec_buffer.rptr],
 
  258                                 sizeof(rec_buffer.data[0]) * move);
 
  259                         rec_buffer.wptr -= rec_buffer.rptr;
 
  264                         log_trace2(
"c%lu", (uint32_t)data & (PULSE_MASK));
 
  266                         rec_buffer.data[rec_buffer.wptr] = data;
 
  272         rec_buffer.is_biphase = 0;
 
  277 static void unget_rec_buffer(
int count)
 
  280         if (count == 1 || count == 2) {
 
  281                 rec_buffer.rptr -= count;
 
  282                 rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr] & (PULSE_MASK);
 
  284                         rec_buffer.sum -= rec_buffer.data[rec_buffer.rptr + 1]
 
  289 static void unget_rec_buffer_delta(lirc_t delta)
 
  292         rec_buffer.sum -= delta & (PULSE_MASK);
 
  293         rec_buffer.data[rec_buffer.rptr] = delta;
 
  296 static lirc_t get_next_pulse(lirc_t maxusec)
 
  300         data = get_next_rec_buffer(maxusec);
 
  303         if (!is_pulse(data)) {
 
  307         return data & (PULSE_MASK);
 
  310 static lirc_t get_next_space(lirc_t maxusec)
 
  314         data = get_next_rec_buffer(maxusec);
 
  317         if (!is_space(data)) {
 
  324 static int sync_pending_pulse(
struct ir_remote* remote)
 
  326         if (rec_buffer.pendingp > 0) {
 
  329                 deltap = get_next_pulse(rec_buffer.pendingp);
 
  332                 if (!expect(remote, deltap, rec_buffer.pendingp))
 
  334                 set_pending_pulse(0);
 
  339 static int sync_pending_space(
struct ir_remote* remote)
 
  341         if (rec_buffer.pendings > 0) {
 
  344                 deltas = get_next_space(rec_buffer.pendings);
 
  347                 if (!expect(remote, deltas, rec_buffer.pendings))
 
  349                 set_pending_space(0);
 
  354 static int expectpulse(
struct ir_remote* remote, 
int exdelta)
 
  360         if (!sync_pending_space(remote))
 
  363         deltap = get_next_pulse(rec_buffer.pendingp + exdelta);
 
  366         if (rec_buffer.pendingp > 0) {
 
  367                 if (rec_buffer.pendingp > deltap)
 
  369                 retval = expect(remote, deltap - rec_buffer.pendingp, exdelta);
 
  372                 set_pending_pulse(0);
 
  374                 retval = expect(remote, deltap, exdelta);
 
  379 static int expectspace(
struct ir_remote* remote, 
int exdelta)
 
  385         if (!sync_pending_pulse(remote))
 
  388         deltas = get_next_space(rec_buffer.pendings + exdelta);
 
  391         if (rec_buffer.pendings > 0) {
 
  392                 if (rec_buffer.pendings > deltas)
 
  394                 retval = expect(remote, deltas - rec_buffer.pendings, exdelta);
 
  397                 set_pending_space(0);
 
  399                 retval = expect(remote, deltas, exdelta);
 
  404 static int expectone(
struct ir_remote* remote, 
int bit)
 
  406         if (is_biphase(remote)) {
 
  407                 int all_bits = bit_count(remote);
 
  410                 mask = ((
ir_code)1) << (all_bits - 1 - bit);
 
  412                         if (remote->
sone > 0 && !expectspace(remote, 2 * remote->
sone)) {
 
  416                         set_pending_pulse(2 * remote->pone);
 
  418                         if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
 
  422                         set_pending_pulse(remote->pone);
 
  424         } 
else if (is_space_first(remote)) {
 
  425                 if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
 
  429                 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
 
  434                 if (remote->pone > 0 && !expectpulse(remote, remote->pone)) {
 
  439                         if (remote->
sone > 0 && !expectspace(remote, remote->
sone)) {
 
  444                         set_pending_space(remote->
sone);
 
  450 static int expectzero(
struct ir_remote* remote, 
int bit)
 
  452         if (is_biphase(remote)) {
 
  453                 int all_bits = bit_count(remote);
 
  456                 mask = ((
ir_code)1) << (all_bits - 1 - bit);
 
  458                         if (!expectpulse(remote, 2 * remote->pzero)) {
 
  462                         set_pending_space(2 * remote->
szero);
 
  464                         if (!expectpulse(remote, remote->pzero)) {
 
  468                         set_pending_space(remote->
szero);
 
  470         } 
else if (is_space_first(remote)) {
 
  471                 if (remote->
szero > 0 && !expectspace(remote, remote->
szero)) {
 
  475                 if (remote->pzero > 0 && !expectpulse(remote, remote->pzero)) {
 
  480                 if (!expectpulse(remote, remote->pzero)) {
 
  485                         if (!expectspace(remote, remote->
szero)) {
 
  490                         set_pending_space(remote->
szero);
 
  496 static lirc_t sync_rec_buffer(
struct ir_remote* remote)
 
  499         lirc_t deltas, deltap;
 
  502         deltas = get_next_space(1000000);
 
  508                         deltap = get_next_pulse(1000000);
 
  511                         deltas = get_next_space(1000000);
 
  515                         if (count > REC_SYNC)   
 
  519                 if (has_toggle_mask(remote)) {
 
  521                                 remote->toggle_mask_state = 0;
 
  530 static int get_header(
struct ir_remote* remote)
 
  532         if (is_rcmm(remote)) {
 
  533                 lirc_t deltap, deltas, sum;
 
  535                 deltap = get_next_pulse(remote->phead);
 
  540                 deltas = get_next_space(remote->
shead);
 
  545                 sum = deltap + deltas;
 
  546                 if (expect(remote, sum, remote->phead + remote->
shead))
 
  550         } 
else if (is_bo(remote)) {
 
  551                 if (expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
 
  552                     && expectpulse(remote, remote->pone) && expectspace(remote, remote->
sone)
 
  553                     && expectpulse(remote, remote->phead) && expectspace(remote, remote->
shead))
 
  557         if (remote->
shead == 0) {
 
  558                 if (!sync_pending_space(remote))
 
  560                 set_pending_pulse(remote->phead);
 
  563         if (!expectpulse(remote, remote->phead)) {
 
  572                 deltas = get_next_space(remote->
shead);
 
  574                         if (expect(remote, remote->
shead, deltas))
 
  581         set_pending_space(remote->
shead);
 
  585 static int get_foot(
struct ir_remote* remote)
 
  587         if (!expectspace(remote, remote->
sfoot))
 
  589         if (!expectpulse(remote, remote->pfoot))
 
  594 static int get_lead(
struct ir_remote* remote)
 
  596         if (remote->
plead == 0)
 
  598         if (!sync_pending_space(remote))
 
  600         set_pending_pulse(remote->
plead);
 
  604 static int get_trail(
struct ir_remote* remote)
 
  607                 if (!expectpulse(remote, remote->
ptrail))
 
  609         if (rec_buffer.pendingp > 0)
 
  610                 if (!sync_pending_pulse(remote))
 
  615 static int get_gap(
struct ir_remote* remote, lirc_t gap)
 
  620         data = get_next_rec_buffer(gap - gap * remote->
eps / 100);
 
  623         if (!is_space(data)) {
 
  628         if (!expect_at_least(remote, data, gap)) {
 
  635 static int get_repeat(
struct ir_remote* remote)
 
  637         if (!get_lead(remote))
 
  639         if (is_biphase(remote)) {
 
  640                 if (!expectspace(remote, remote->
srepeat))
 
  642                 if (!expectpulse(remote, remote->prepeat))
 
  645                 if (!expectpulse(remote, remote->prepeat))
 
  647                 set_pending_space(remote->
srepeat);
 
  649         if (!get_trail(remote))
 
  653                     is_const(remote) ? (min_gap(remote) >
 
  655                                         min_gap(remote) - rec_buffer.sum : 0) :
 
  656                     (has_repeat_gap(remote) ? remote->
repeat_gap : min_gap(remote))
 
  669         if (is_rcmm(remote)) {
 
  670                 lirc_t deltap, deltas, sum;
 
  672                 if (bits % 2 || done % 2) {
 
  676                 if (!sync_pending_space(remote))
 
  678                 for (i = 0; i < bits; i += 2) {
 
  680                         deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
 
  682                         if (deltap == 0 || deltas == 0) {
 
  683                                 log_error(
"failed on bit %d", done + i + 1);
 
  686                         sum = deltap + deltas;
 
  688                         if (expect(remote, sum, remote->pzero + remote->
szero)) {
 
  691                         } 
else if (expect(remote, sum, remote->pone + remote->
sone)) {
 
  694                         } 
else if (expect(remote, sum, remote->ptwo + remote->
stwo)) {
 
  697                         } 
else if (expect(remote, sum, remote->pthree + remote->
sthree)) {
 
  701                                 log_trace1(
"no match for %d+%d=%d", deltap, deltas, sum);
 
  706         } 
else if (is_grundig(remote)) {
 
  707                 lirc_t deltap, deltas, sum;
 
  708                 int state, laststate;
 
  710                 if (bits % 2 || done % 2) {
 
  714                 if (!sync_pending_pulse(remote))
 
  716                 for (laststate = state = -1, i = 0; i < bits; ) {
 
  718                         deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
 
  719                         if (deltas == 0 || deltap == 0) {
 
  720                                 log_error(
"failed on bit %d", done + i + 1);
 
  723                         sum = deltas + deltap;
 
  724                         log_trace2(
"grundig: sum %ld", (uint32_t)sum);
 
  725                         if (expect(remote, sum, remote->
szero + remote->pzero)) {
 
  728                         } 
else if (expect(remote, sum, remote->
sone + remote->pone)) {
 
  731                         } 
else if (expect(remote, sum, remote->
stwo + remote->ptwo)) {
 
  734                         } 
else if (expect(remote, sum, remote->
sthree + remote->pthree)) {
 
  738                                 log_trace1(
"no match for %d+%d=%d", deltas, deltap, sum);
 
  746                         } 
else if (laststate == 2 && state == 0) {      
 
  751                         } 
else if (laststate == 1 && state == 1) {      
 
  756                         } 
else if (laststate == 0 && state == 2) {      
 
  761                         } 
else if (laststate == -1) {
 
  764                                 log_error(
"invalid state %d:%d", laststate, state);
 
  770         } 
else if (is_serial(remote)) {
 
  772                 int space, stop_bit, parity_bit;
 
  774                 lirc_t delta, origdelta, pending, expecting, gap_delta;
 
  776                 lirc_t max_space, max_pulse;
 
  778                 base = 1000000 / remote->
baud;
 
  781                 set_pending_pulse(base);
 
  784                 space = (rec_buffer.pendingp == 0);     
 
  787                 delta = origdelta = 0;
 
  794                 if (remote->
parity != IR_PARITY_NONE) {
 
  796                         max_space += remote->
sone;
 
  797                         max_pulse += remote->pzero;
 
  801                 while (received < bits || stop_bit) {
 
  803                                 delta = space ? get_next_space(max_space) : get_next_pulse(max_pulse);
 
  804                                 if (delta == 0 && space && received + remote->
bits_in_byte + parity_bit >= bits)
 
  810                                 log_trace(
"failed before bit %d", received + 1);
 
  813                         pending = (space ? rec_buffer.pendings : rec_buffer.pendingp);
 
  814                         if (expect(remote, delta, pending)) {
 
  816                         } 
else if (delta > pending) {
 
  819                                 log_trace(
"failed before bit %d", received + 1);
 
  827                                         set_pending_pulse(base);
 
  828                                         set_pending_space(0);
 
  834                                         set_pending_pulse(0);
 
  835                                         set_pending_space(0);
 
  837                                                 space = (space ? 0 : 1);
 
  841                         expecting = (space ? remote->
sone : remote->pzero);
 
  842                         if (delta > expecting || expect(remote, delta, expecting)) {
 
  843                                 delta -= (expecting > delta ? delta : expecting);
 
  849                                 if (received % (remote->
bits_in_byte + parity_bit) == 0) {
 
  852                                         if ((remote->
parity == IR_PARITY_EVEN && parity)
 
  853                                             || (remote->
parity == IR_PARITY_ODD && !parity)) {
 
  854                                                 log_trace(
"parity error after %d bits", received + 1);
 
  862                                                 temp << remote->
bits_in_byte | reverse(code >> parity_bit,
 
  865                                         if (space && delta == 0) {
 
  866                                                 log_trace(
"failed at stop bit after %d bits", received + 1);
 
  870                                         set_pending_space(stop);
 
  874                                 if (delta == origdelta) {
 
  875                                         log_trace(
"framing error after %d bits", received + 1);
 
  881                                 space = (space ? 0 : 1);
 
  884                         unget_rec_buffer_delta(gap_delta);
 
  885                 set_pending_pulse(0);
 
  886                 set_pending_space(0);
 
  888         } 
else if (is_bo(remote)) {
 
  890                 lirc_t deltap, deltas;
 
  894                 for (i = 0; i < bits; i++) {
 
  896                         deltap = get_next_pulse(remote->pzero + remote->pone + remote->ptwo + remote->pthree);
 
  898                         if (deltap == 0 || deltas == 0) {
 
  899                                 log_error(
"failed on bit %d", done + i + 1);
 
  903                                 pzero = remote->pone;
 
  904                                 szero = remote->
sone;
 
  908                                 pzero = remote->ptwo;
 
  909                                 szero = remote->
stwo;
 
  910                                 pone = remote->pthree;
 
  913                         log_trace2(
"%lu %lu %lu %lu", pzero, szero, pone, sone);
 
  914                         if (expect(remote, deltap, pzero)) {
 
  915                                 if (expect(remote, deltas, szero)) {
 
  923                         if (expect(remote, deltap, pone)) {
 
  924                                 if (expect(remote, deltas, sone)) {
 
  931                         log_error(
"failed on bit %d", done + i + 1);
 
  935         } 
else if (is_xmp(remote)) {
 
  936                 lirc_t deltap, deltas, sum;
 
  939                 if (bits % 4 || done % 4) {
 
  943                 if (!sync_pending_space(remote))
 
  945                 for (i = 0; i < bits; i += 4) {
 
  947                         deltap = get_next_pulse(remote->pzero);
 
  948                         deltas = get_next_space(remote->
szero + 16 * remote->
sone);
 
  949                         if (deltap == 0 || deltas == 0) {
 
  950                                 log_error(
"failed on bit %d", done + i + 1);
 
  953                         sum = deltap + deltas;
 
  955                         sum -= remote->pzero + remote->
szero;
 
  956                         n = (sum + remote->
sone / 2) / remote->
sone;
 
  958                                 log_error(
"failed on bit %d", done + i + 1);
 
  967         for (i = 0; i < bits; i++) {
 
  969                 if (expectone(remote, done + i)) {
 
  972                 } 
else if (expectzero(remote, done + i)) {
 
  976                         log_trace(
"failed on bit %d", done + i + 1);
 
  993                 log_trace(
"Failed on pre_data: cannot get it");
 
 1004                 remote_pre = remote->
pre_data & ~toggle_mask;
 
 1005                 match_pre = pre & ~toggle_mask;
 
 1006                 if (remote->
pre_data != 0 && remote_pre != match_pre) {
 
 1007                         log_trace(
"Failed on pre_data: bad data: %x", pre);
 
 1011         if (remote->pre_p > 0 && remote->
pre_s > 0) {
 
 1012                 if (!expectpulse(remote, remote->pre_p))
 
 1014                 set_pending_space(remote->
pre_s);
 
 1023         if (remote->post_p > 0 && remote->
post_s > 0) {
 
 1024                 if (!expectpulse(remote, remote->post_p))
 
 1026                 set_pending_space(remote->
post_s);
 
 1042         struct timeval current;
 
 1049         if (rec_buffer.at_eof && rec_buffer.wptr - rec_buffer.rptr <= 1) {
 
 1052                 rec_buffer.at_eof = 0;
 
 1059                 rec_buffer.is_biphase = is_biphase(remote) ? 1 : 0;
 
 1062                 sync = sync_rec_buffer(remote);
 
 1069                 if (has_repeat(remote) && 
last_remote == remote) {
 
 1071                                 if (!get_header(remote)) {
 
 1077                         if (get_repeat(remote)) {
 
 1079                                         log_notice(
"repeat code without last_code received");
 
 1089                                         is_const(remote) ? (min_gap(remote) >
 
 1090                                                             rec_buffer.sum ? min_gap(remote) -
 
 1091                                                             rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
 
 1092                                                                                    repeat_gap : min_gap(remote));
 
 1094                                         is_const(remote) ? (max_gap(remote) >
 
 1095                                                             rec_buffer.sum ? max_gap(remote) -
 
 1096                                                             rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->
 
 1097                                                                                    repeat_gap : max_gap(remote));
 
 1102                         sync_rec_buffer(remote);
 
 1105                 if (has_header(remote)) {
 
 1107                         if (!get_header(remote)) {
 
 1109                                 if (!(remote->
flags & 
NO_HEAD_REP && expect_at_most(remote, sync, max_gap(remote)))) {
 
 1118         if (is_raw(remote)) {
 
 1126                 codes = remote->codes;
 
 1128                 while (codes->
name != NULL && found == NULL) {
 
 1130                         for (i = 0; i < codes->
length; ) {
 
 1131                                 if (!expectpulse(remote, codes->
signals[i++])) {
 
 1134                                         sync_rec_buffer(remote);
 
 1137                                 if (i < codes->
length && !expectspace(remote, codes->
signals[i++])) {
 
 1140                                         sync_rec_buffer(remote);
 
 1145                         if (found != NULL) {
 
 1147                                             (remote, is_const(remote) ?
 
 1148                                             min_gap(remote) - rec_buffer.sum :
 
 1159                         ir_code decoded = rec_buffer.decoded;
 
 1168                         ctx->
code = decoded & gen_mask(remote->
bits);
 
 1169                         ctx->
pre = decoded >> remote->
bits;
 
 1172                         sum = remote->phead + remote->
shead +
 
 1173                               lirc_t_max(remote->pone + remote->
sone,
 
 1174                                          remote->pzero + remote->
szero) * bit_count(remote) + remote->
plead +
 
 1175                               remote->
ptrail + remote->pfoot + remote->
sfoot + remote->pre_p + remote->
pre_s +
 
 1176                               remote->post_p + remote->
post_s;
 
 1178                         rec_buffer.sum = sum >= remote->
gap ? remote->
gap - 1 : sum;
 
 1181                         if (!get_lead(remote)) {
 
 1186                         if (has_pre(remote)) {
 
 1187                                 ctx->
pre = get_pre(remote);
 
 1202                         if (has_post(remote)) {
 
 1203                                 ctx->
post = get_post(remote);
 
 1210                         if (!get_trail(remote)) {
 
 1214                         if (has_foot(remote)) {
 
 1215                                 if (!get_foot(remote)) {
 
 1221                                 rec_buffer.sum -= remote->phead + remote->
shead;
 
 1222                         if (is_rcmm(remote)) {
 
 1223                                 if (!get_gap(remote, 1000))
 
 1225                         } 
else if (is_const(remote)) {
 
 1226                                 if (!get_gap(remote, min_gap(remote) > rec_buffer.sum ?
 
 1227                                              min_gap(remote) - rec_buffer.sum :
 
 1231                                 if (!get_gap(remote, min_gap(remote)))
 
 1248         if (is_const(remote)) {
 
 1249                 ctx->
min_remaining_gap = min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0;
 
 1250                 ctx->
max_remaining_gap = max_gap(remote) > rec_buffer.sum ? max_gap(remote) - rec_buffer.sum : 0;
 
const struct driver *const curr_driver
Read-only access to drv for client code.
void rec_buffer_set_logfile(FILE *f)
Set a file logging input from driver in same format as mode2(1).
int waitfordata(uint32_t maxusec)
If set_waitfordata(func) is called, invoke and return function set this way.
void set_waitfordata_func(int(*func)(uint32_t maxusec))
Set the function used by waitfordata().
void rec_buffer_rewind(void)
Reset the modules's internal fifo's read state to initial values where the nothing is read.
struct ir_remote * last_remote
TODO.
void rec_buffer_reset_wptr(void)
Reset internal fifo's write pointer.
void rec_set_update_mode(int mode)
Set update mode, where recorded pre_data is verified to match the template pre_data.
void rec_buffer_init(void)
Clear internal buffer to pristine state.
int receive_decode(struct ir_remote *remote, struct decode_ctx_t *ctx)
Decode data from remote.
int rec_buffer_clear(void)
Flush the internal fifo and store a single code read from the driver in it.
#define REPEAT_HEADER
header is also sent before repeat code
uint64_t ir_code
Denotes an internal coded representation for an IR transmission.
#define NO_HEAD_REP
no header for key repeats
#define LIRC_EOF
Bit manipulator in lirc_t, see lirc.h .
#define log_trace(fmt,...)
Log a trace message.
#define log_notice(fmt,...)
Log a notice message.
#define log_debug(fmt,...)
Log a debug message.
#define log_perror_err(fmt,...)
perror wrapper logging with level LIRC_ERROR.
#define log_trace2(fmt,...)
Log a trace2 message.
#define log_error(fmt,...)
Log an error message.
#define log_trace1(fmt,...)
Log a trace1 message.
logchannel_t
Log channels used to filter messages.
State describing code, pre, post + gap and repeat state.
ir_code code
Code part, matched to code defintion.
int repeat_flag
True if code is a repeated one.
ir_code post
post data, sent after code.
lirc_t min_remaining_gap
Estimated min time of trailing gap.
lirc_t max_remaining_gap
Estimated max time of trailing gap.
ir_code pre
pre data, before code.
int fd
Set by the driver after init().
const uint32_t code_length
Length in bits of the code.
lirc_t(*const readdata)(lirc_t timeout)
Get length of next pulse/space from hardware.
uint32_t rec_mode
Possible values are: LIRC_MODE_RAW, LIRC_MODE_PULSE, LIRC_MODE_MODE2, LIRC_MODE_LIRCCODE.
IR Command, corresponding to one (command defining) line of the configuration file.
ir_code code
The first code of the command.
lirc_t * signals
(private)
struct ir_code_node * current
Should point at the ir_code currently being transmitted, or NULL if none.
char * name
Name of command.
One remote as represented in the configuration file.
uint32_t repeat_gap
time between two repeat codes if different from gap
lirc_t stwo
2 (only used for RC-MM)
unsigned int stop_bits
mapping: 1->2 1.5->3 2->4
unsigned int bits_in_byte
default: 8
ir_code rc6_mask
RC-6 doubles signal length of some bits.
lirc_t max_remaining_gap
gap range
lirc_t ptrail
trailing pulse
lirc_t srepeat
indicate repeating
ir_code pre_data
data which the remote sends before actual keycode
int bits
bits (length of code)
int post_data_bits
length of post_data
lirc_t plead
leading pulse
lirc_t sthree
3 (only used for RC-MM)
struct timeval last_send
time last_code was received or sent
ir_code post_data
data which the remote sends after actual keycode
unsigned int baud
can be overridden by [p|s]zero, [p|s]one
lirc_t post_s
signal between keycode and post_code
lirc_t pre_s
signal between pre_data and keycode
uint32_t gap
time between signals in usecs
int eps
eps (relative tolerance)
struct ir_ncode * last_code
code received or sent last
struct ir_ncode * toggle_code
toggle code received or sent last
unsigned int min_code_repeat
meaningful only if remote sends a repeat code: in this case this value indicates how often the real c...
ir_code toggle_bit_mask
previously only one bit called toggle_bit
unsigned int parity
currently unsupported
int pre_data_bits
length of pre_data
lirc_t min_remaining_gap
remember gap for CONST_LENGTH remotes