24 #define LIRCD_EXACT_GAP_THRESHOLD 10000
26 #include "include/media/lirc.h"
27 #include "lirc/lirc_log.h"
28 #include "lirc/transmit.h"
36 lirc_t _data[WBUF_SIZE];
46 static void send_signals(lirc_t * signals,
int n);
47 static int init_send_or_sim(
struct ir_remote *remote,
struct ir_ncode *code,
int sim,
int repeat_preset);
58 memset(&send_buffer, 0,
sizeof(send_buffer));
61 static void clear_send_buffer(
void)
65 send_buffer.too_long = 0;
66 send_buffer.is_biphase = 0;
67 send_buffer.pendingp = 0;
68 send_buffer.pendings = 0;
72 static void add_send_buffer(lirc_t data)
74 if (send_buffer.wptr < WBUF_SIZE) {
75 LOGPRINTF(3,
"adding to transmit buffer: %u", data);
76 send_buffer.sum += data;
77 send_buffer._data[send_buffer.wptr] = data;
80 send_buffer.too_long = 1;
84 static void send_pulse(lirc_t data)
86 if (send_buffer.pendingp > 0) {
87 send_buffer.pendingp += data;
89 if (send_buffer.pendings > 0) {
90 add_send_buffer(send_buffer.pendings);
91 send_buffer.pendings = 0;
93 send_buffer.pendingp = data;
97 static void send_space(lirc_t data)
99 if (send_buffer.wptr == 0 && send_buffer.pendingp == 0) {
100 LOGPRINTF(1,
"first signal is a space!");
103 if (send_buffer.pendings > 0) {
104 send_buffer.pendings += data;
106 if (send_buffer.pendingp > 0) {
107 add_send_buffer(send_buffer.pendingp);
108 send_buffer.pendingp = 0;
110 send_buffer.pendings = data;
114 static int bad_send_buffer(
void)
116 if (send_buffer.too_long != 0)
118 if (send_buffer.wptr == WBUF_SIZE && send_buffer.pendingp > 0) {
124 static int check_send_buffer(
void)
128 if (send_buffer.wptr == 0) {
132 for (i = 0; i < send_buffer.wptr; i++) {
133 if (send_buffer.data[i] == 0) {
146 static void flush_send_buffer(
void)
148 if (send_buffer.pendingp > 0) {
149 add_send_buffer(send_buffer.pendingp);
150 send_buffer.pendingp = 0;
152 if (send_buffer.pendings > 0) {
153 add_send_buffer(send_buffer.pendings);
154 send_buffer.pendings = 0;
158 static void sync_send_buffer(
void)
160 if (send_buffer.pendingp > 0) {
161 add_send_buffer(send_buffer.pendingp);
162 send_buffer.pendingp = 0;
164 if (send_buffer.wptr > 0 && send_buffer.wptr % 2 == 0)
168 static void send_header(
struct ir_remote *remote)
170 if (has_header(remote)) {
171 send_pulse(remote->phead);
172 send_space(remote->
shead);
176 static void send_foot(
struct ir_remote *remote)
178 if (has_foot(remote)) {
179 send_space(remote->
sfoot);
180 send_pulse(remote->pfoot);
184 static void send_lead(
struct ir_remote *remote)
186 if (remote->
plead != 0) {
187 send_pulse(remote->
plead);
191 static void send_trail(
struct ir_remote *remote)
193 if (remote->
ptrail != 0) {
194 send_pulse(remote->
ptrail);
198 static void send_data(
struct ir_remote *remote,
ir_code data,
int bits,
int done)
201 int all_bits = bit_count(remote);
205 data = reverse(data, bits);
206 if (is_rcmm(remote)) {
207 mask = 1 << (all_bits - 1 - done);
208 if (bits % 2 || done % 2) {
209 logprintf(LIRC_ERROR,
"invalid bit number.");
212 for (i = 0; i < bits; i += 2, mask >>= 2) {
215 send_pulse(remote->pzero);
216 send_space(remote->
szero);
220 send_pulse(remote->pone);
221 send_space(remote->
sone);
224 send_pulse(remote->ptwo);
225 send_space(remote->
stwo);
228 send_pulse(remote->pthree);
229 send_space(remote->
sthree);
235 }
else if (is_xmp(remote)) {
236 if (bits % 4 || done % 4) {
237 logprintf(LIRC_ERROR,
"invalid bit number.");
240 for (i = 0; i < bits; i += 4) {
243 nibble = reverse(data & 0xf, 4);
244 send_pulse(remote->pzero);
245 send_space(remote->
szero + nibble * remote->
sone);
251 mask = ((
ir_code) 1) << (all_bits - 1 - done);
252 for (i = 0; i < bits; i++, mask >>= 1) {
254 if (toggle_bit_mask_bits == 1) {
257 if (remote->toggle_bit_mask_state & mask) {
261 if (remote->toggle_bit_mask_state & mask) {
266 if (has_toggle_mask(remote) && mask & remote->
toggle_mask && remote->toggle_mask_state % 2) {
270 if (is_biphase(remote)) {
273 send_space(2 * remote->
sone);
274 send_pulse(2 * remote->pone);
276 send_space(remote->
sone);
277 send_pulse(remote->pone);
279 }
else if (is_space_first(remote)) {
280 send_space(remote->
sone);
281 send_pulse(remote->pone);
283 send_pulse(remote->pone);
284 send_space(remote->
sone);
288 send_pulse(2 * remote->pzero);
289 send_space(2 * remote->
szero);
290 }
else if (is_space_first(remote)) {
291 send_space(remote->
szero);
292 send_pulse(remote->pzero);
294 send_pulse(remote->pzero);
295 send_space(remote->
szero);
302 static void send_pre(
struct ir_remote *remote)
304 if (has_pre(remote)) {
306 if (remote->pre_p > 0 && remote->
pre_s > 0) {
307 send_pulse(remote->pre_p);
308 send_space(remote->
pre_s);
313 static void send_post(
struct ir_remote *remote)
315 if (has_post(remote)) {
316 if (remote->post_p > 0 && remote->
post_s > 0) {
317 send_pulse(remote->post_p);
318 send_space(remote->
post_s);
324 static void send_repeat(
struct ir_remote *remote)
327 send_pulse(remote->prepeat);
345 send_buffer.sum -= remote->phead + remote->
shead;
349 static void send_signals(lirc_t * signals,
int n)
353 for (i = 0; i < n; i++) {
354 add_send_buffer(signals[i]);
366 return init_send_or_sim(remote, code, 0, 0);
374 return init_send_or_sim(remote, code, 1, repeat_preset);
381 return send_buffer.wptr;
387 return send_buffer.data;
392 return send_buffer.sum;
395 static int init_send_or_sim(
struct ir_remote *remote,
struct ir_ncode *code,
int sim,
int repeat_preset)
397 int i, repeat = repeat_preset;
399 if (is_grundig(remote) || is_goldstar(remote) || is_serial(remote) || is_bo(remote)) {
401 logprintf(LIRC_ERROR,
"sorry, can't send this protocol yet");
406 if (strcmp(remote->
name,
"lirc") == 0) {
407 send_buffer.data[send_buffer.wptr] =
LIRC_EOF | 1;
408 send_buffer.wptr += 1;
412 if (is_biphase(remote)) {
413 send_buffer.is_biphase = 1;
417 remote->repeat_countdown = remote->
min_repeat;
424 if (repeat && has_repeat(remote)) {
430 if (!is_raw(remote)) {
434 next_code = code->
code;
439 if (repeat && has_repeat_mask(remote)) {
443 send_code(remote, next_code, repeat);
444 if (!sim && has_toggle_mask(remote)) {
445 remote->toggle_mask_state++;
446 if (remote->toggle_mask_state == 4) {
447 remote->toggle_mask_state = 2;
450 send_buffer.data = send_buffer._data;
454 logprintf(LIRC_ERROR,
"no signals for raw send");
458 if (send_buffer.wptr > 0) {
461 send_buffer.data = code->
signals;
462 send_buffer.wptr = code->
length;
463 for (i = 0; i < code->
length; i++) {
464 send_buffer.sum += code->
signals[i];
470 if (bad_send_buffer()) {
472 logprintf(LIRC_ERROR,
"buffer too small");
478 if (has_repeat_gap(remote) && repeat && has_repeat(remote)) {
481 }
else if (is_const(remote)) {
482 if (min_gap(remote) > send_buffer.sum) {
486 logprintf(LIRC_ERROR,
"too short gap: %u", remote->
gap);
496 if (code->
next != NULL) {
506 if ((remote->repeat_countdown > 0 || code->
transmit_state != NULL)
508 if (send_buffer.data != send_buffer._data) {
512 LOGPRINTF(1,
"unrolling raw signal optimisation");
513 signals = send_buffer.data;
514 n = send_buffer.wptr;
515 send_buffer.data = send_buffer._data;
516 send_buffer.wptr = 0;
518 send_signals(signals, n);
520 LOGPRINTF(1,
"concatenating low gap signals");
522 remote->repeat_countdown--;
534 if (!check_send_buffer()) {
536 logprintf(LIRC_ERROR,
"invalid send buffer");
537 logprintf(LIRC_ERROR,
"this remote configuration cannot be used to transmit");
struct ir_code_node * next
void send_buffer_init(void)
int send_buffer_put(struct ir_remote *remote, struct ir_ncode *code)
const lirc_t * send_buffer_data()
#define LOGPRINTF(level, fmt, args...)
struct ir_code_node * transmit_state
struct ir_remote * repeat_remote