24 #include <sys/types.h> 
   68         if (ncode->
next && node != NULL)
 
   74 get_next_ir_code_node(
const struct ir_ncode*            ncode,
 
   82 static inline int bit_count(
const struct ir_remote* remote)
 
   87 static inline int bits_set(
ir_code data)
 
  105         for (i = 0; i < bits; i++)
 
  111 static inline int is_pulse(lirc_t data)
 
  113         return ((data & LIRC_MODE2_MASK)==LIRC_MODE2_PULSE) ? 1 : 0;
 
  116 static inline int is_space(lirc_t data)
 
  118         return ((data & LIRC_MODE2_MASK)==LIRC_MODE2_SPACE) ? 1 : 0;
 
  121 static inline int is_timeout(lirc_t data)
 
  123         return ((data & LIRC_MODE2_MASK)==LIRC_MODE2_TIMEOUT) ? 1 : 0;
 
  126 static inline int is_overflow(lirc_t data)
 
  128         return ((data & LIRC_MODE2_MASK)==LIRC_MODE2_OVERFLOW) ? 1 : 0;
 
  131 static inline int has_repeat(
const struct ir_remote* remote)
 
  133         if (remote->prepeat > 0 && remote->
srepeat > 0)
 
  139 static inline void set_protocol(
struct ir_remote* remote, 
int protocol)
 
  141         remote->
flags &= ~(IR_PROTOCOL_MASK);
 
  142         remote->
flags |= protocol;
 
  145 static inline int is_raw(
const struct ir_remote* remote)
 
  153 static inline int is_space_enc(
const struct ir_remote* remote)
 
  161 static inline int is_space_first(
const struct ir_remote* remote)
 
  169 static inline int is_rc5(
const struct ir_remote* remote)
 
  171         if ((remote->
flags & IR_PROTOCOL_MASK) == 
RC5)
 
  177 static inline int is_rc6(
const struct ir_remote* remote)
 
  185 static inline int is_biphase(
const struct ir_remote* remote)
 
  187         if (is_rc5(remote) || is_rc6(remote))
 
  193 static inline int is_rcmm(
const struct ir_remote* remote)
 
  195         if ((remote->
flags & IR_PROTOCOL_MASK) == 
RCMM)
 
  201 static inline int is_grundig(
const struct ir_remote* remote)
 
  209 static inline int is_bo(
const struct ir_remote* remote)
 
  211         if ((remote->
flags & IR_PROTOCOL_MASK) == 
BO)
 
  217 static inline int is_serial(
const struct ir_remote* remote)
 
  225 static inline int is_xmp(
const struct ir_remote* remote)
 
  227         if ((remote->
flags & IR_PROTOCOL_MASK) == 
XMP)
 
  233 static inline int is_const(
const struct ir_remote* remote)
 
  241 static inline int has_repeat_gap(
const struct ir_remote* remote)
 
  249 static inline int has_pre(
const struct ir_remote* remote)
 
  257 static inline int has_post(
const struct ir_remote* remote)
 
  265 static inline int has_header(
const struct ir_remote* remote)
 
  267         if (remote->phead > 0 && remote->
shead > 0)
 
  273 static inline int has_foot(
const struct ir_remote* remote)
 
  275         if (remote->pfoot > 0 && remote->
sfoot > 0)
 
  281 static inline int has_toggle_bit_mask(
const struct ir_remote* remote)
 
  289 static inline int has_ignore_mask(
const struct ir_remote* remote)
 
  297 static inline int has_repeat_mask(
struct ir_remote* remote)
 
  305 static inline int has_toggle_mask(
const struct ir_remote* remote)
 
  313 static inline lirc_t min_gap(
const struct ir_remote* remote)
 
  315         if (remote->
gap2 != 0 && remote->
gap2 < remote->
gap)
 
  321 static inline lirc_t max_gap(
const struct ir_remote* remote)
 
  323         if (remote->
gap2 > remote->
gap)
 
  329 static inline unsigned int get_duty_cycle(
const struct ir_remote* remote)
 
  343 static inline int expect(
const struct ir_remote*        remote,
 
  350         if (abs(exdelta - delta) <= exdelta * remote->
eps / 100
 
  351             || abs(exdelta - delta) <= 
aeps)
 
  356 static inline int expect_at_least(
const struct ir_remote*       remote,
 
  363         if (delta + exdelta * remote->
eps / 100 >= exdelta
 
  364             || delta + 
aeps >= exdelta)
 
  369 static inline int expect_at_most(
const struct ir_remote*        remote,
 
  376         if (delta <= exdelta + exdelta * remote->
eps / 100
 
  377             || delta <= exdelta + 
aeps)
 
  382 static inline lirc_t upper_limit(
const struct ir_remote* remote, lirc_t val)
 
  386         lirc_t eps_val = val * (100 + remote->
eps) / 100;
 
  387         lirc_t aeps_val = val + 
aeps;
 
  389         return eps_val > aeps_val ? eps_val : aeps_val;
 
  392 static inline lirc_t lower_limit(
const struct ir_remote* remote, lirc_t val)
 
  396         lirc_t eps_val = val * (100 - remote->
eps) / 100;
 
  397         lirc_t aeps_val = val - 
aeps;
 
  404         return eps_val < aeps_val ? eps_val : aeps_val;
 
  408 static inline unsigned long time_elapsed(
const struct timeval*  last,
 
  409                                          const struct timeval*  current)
 
  411         unsigned long secs, diff;
 
  413         secs = current->tv_sec - last->tv_sec;
 
  415         diff = 1000000 * secs + current->tv_usec - last->tv_usec;
 
  420 static inline ir_code gen_mask(
int bits)
 
  426         for (i = 0; i < bits; i++) {
 
  441         all <<= remote->
bits;
 
  442         all |= is_raw(remote) ? code : (code & gen_mask(remote->
bits));
 
  464                          unsigned int*                  min_freq,
 
  465                          unsigned int*                  max_freq);
 
  468                            lirc_t*                      max_gap_lengthp,
 
  469                            lirc_t*                      min_pulse_lengthp,
 
  470                            lirc_t*                      min_space_lengthp,
 
  471                            lirc_t*                      max_pulse_lengthp,
 
  472                            lirc_t*                      max_space_lengthp);
 
  485              const struct timeval*      start,
 
  486              const struct timeval*      last,
 
  487              lirc_t                     signal_length);
 
  495                   const char*   remote_name,
 
  496                   const char*   button_name,
 
  497                   const char*   button_suffix,
 
const struct driver *const curr_driver
Read-only access to drv for client code.
Interface to the userspace drivers.
int write_message(char *buffer, size_t size, const char *remote_name, const char *button_name, const char *button_suffix, ir_code code, int reps)
Formats the arguments into a readable string.
void get_frequency_range(const struct ir_remote *remotes, unsigned int *min_freq, unsigned int *max_freq)
void get_filter_parameters(const struct ir_remote *remotes, lirc_t *max_gap_lengthp, lirc_t *min_pulse_lengthp, lirc_t *min_space_lengthp, lirc_t *max_pulse_lengthp, lirc_t *max_space_lengthp)
struct ir_remote * get_ir_remote(const struct ir_remote *remotes, const char *name)
Return ir_remote with given name in remotes list, or NULL if not found.
struct ir_ncode * repeat_code
Global pointer to the code currently repeating.
void ncode_free(struct ir_ncode *ncode)
Dispose an ir_ncode instance obtained from ncode_dup().
struct ir_remote * last_remote
TODO.
int send_ir_ncode(struct ir_remote *remote, struct ir_ncode *code, int delay)
Transmits the actual code in the second argument by calling the current hardware driver.
struct ir_remote * repeat_remote
Global pointer to the remote that contains the code currently repeating.
void ir_remote_init(int use_dyncodes)
Initiate: define if dynamic codes should be used.
const struct ir_remote * is_in_remotes(const struct ir_remote *remotes, const struct ir_remote *remote)
Test if a given remote is in a list of remotes.
int map_code(const struct ir_remote *remote, struct decode_ctx_t *ctx, int pre_bits, ir_code pre, int bits, ir_code code, int post_bits, ir_code post)
struct ir_ncode * ncode_dup(struct ir_ncode *ncode)
Create a malloc'd, deep copy of ncode.
void map_gap(const struct ir_remote *remote, struct decode_ctx_t *ctx, const struct timeval *start, const struct timeval *last, lirc_t signal_length)
char * decode_all(struct ir_remote *remotes)
Tries to decode current signal trying all known remotes.
const struct ir_remote * get_decoding(void)
Return pointer to currently decoded remote.
struct ir_ncode * get_code_by_name(const struct ir_remote *remote, const char *name)
Return code with given name in remote's list of codes or NULL.
Describes and decodes the signals from IR remotes.
#define RAW_CODES
for internal use only
#define RC6
IR data follows RC6 protocol.
#define GRUNDIG
encoding found on Grundig remote
#define BO
encoding found on Bang & Olufsen remote
uint64_t ir_code
Denotes an internal coded representation for an IR transmission.
#define SPACE_FIRST
bits are encoded as space+pulse
#define SPACE_ENC
IR data is space encoded.
#define RC5
IR data follows RC5 protocol.
#define SERIAL
serial protocol
#define CONST_LENGTH
signal length+gap is always constant
#define RCMM
IR data follows RC-MM protocol.
unsigned int eps
Shared list of remotes.
lirc_t aeps
Error tolerance in per cent.
State describing code, pre, post + gap and repeat state.
unsigned int resolution
The resolution in microseconds of the recorded durations when reading signals.
An ir_code for entering into (singly) linked lists, i.e.
IR Command, corresponding to one (command defining) line of the configuration file.
struct ir_code_node * next
Linked list of the subsequent ir_code's, after the first one.
ir_code code
The first code of the command.
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
unsigned int aeps
detecting very short pulses is difficult with relative tolerance for some remotes,...
uint32_t gap2
time between signals in usecs
ir_code rc6_mask
RC-6 doubles signal length of some bits.
unsigned int duty_cycle
0<duty cycle<=100 default: 50
ir_code repeat_mask
mask defines which bits are inverted for repeats
lirc_t srepeat
indicate repeating
int bits
bits (length of code)
int post_data_bits
length of post_data
ir_code ignore_mask
mask defines which bits can be ignored when matching a code
ir_code toggle_mask
Sharp (?) error detection scheme.
uint32_t gap
time between signals in usecs
int eps
eps (relative tolerance)
const char * name
name of remote control
ir_code toggle_bit_mask
previously only one bit called toggle_bit
int pre_data_bits
length of pre_data