lirc-0.8.4a/daemons/transmit.c

   1 /*      $Id: transmit.c,v 5.28 2008/05/11 13:29:47 lirc Exp $      */
   2
   3 /****************************************************************************
   4  ** transmit.c **************************************************************
   5  ****************************************************************************
   6  *
   7  * functions that prepare IR codes for transmitting
   8  *
   9  * Copyright (C) 1999-2004 Christoph Bartelmus <lirc@bartelmus.de>
  10  *
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 /* if the gap is lower than this value, we will concatenate the
  18    signals and send the signal chain at a single blow */
  19 #define LIRCD_EXACT_GAP_THRESHOLD 10000
  20
  21 #include "lircd.h"
  22 #include "transmit.h"
  23
  24 extern struct ir_remote *repeat_remote;
  25 struct sbuf send_buffer;
  26
  27 static void send_signals(lirc_t *signals, int n);
  28
  29 inline void set_bit(ir_code *code,int bit,int data)
  30 {
  31         (*code)&=~((((ir_code) 1)<<bit));
  32         (*code)|=((ir_code) (data ? 1:0)<<bit);
  33 }
  34
  35 /*
  36   sending stuff
  37 */
  38
  39 void init_send_buffer(void)
  40 {
  41         memset(&send_buffer,0,sizeof(send_buffer));
  42 }
  43
  44 inline void clear_send_buffer(void)
  45 {
  46         LOGPRINTF(3, "clearing transmit buffer");
  47         send_buffer.wptr=0;
  48         send_buffer.too_long=0;
  49         send_buffer.is_biphase=0;
  50         send_buffer.pendingp=0;
  51         send_buffer.pendings=0;
  52         send_buffer.sum=0;
  53 }
  54
  55 inline void add_send_buffer(lirc_t data)
  56 {
  57         if(send_buffer.wptr<WBUF_SIZE)
  58         {
  59                 LOGPRINTF(3, "adding to transmit buffer: %u", data);
  60                 send_buffer.sum+=data;
  61                 send_buffer._data[send_buffer.wptr]=data;
  62                 send_buffer.wptr++;
  63         }
  64         else
  65         {
  66                 send_buffer.too_long=1;
  67         }
  68 }
  69
  70 inline void send_pulse(lirc_t data)
  71 {
  72         if(send_buffer.pendingp>0)
  73         {
  74                 send_buffer.pendingp+=data;
  75         }
  76         else
  77         {
  78                 if(send_buffer.pendings>0)
  79                 {
  80                         add_send_buffer(send_buffer.pendings);
  81                         send_buffer.pendings=0;
  82                 }
  83                 send_buffer.pendingp=data;
  84         }
  85 }
  86
  87 inline void send_space(lirc_t data)
  88 {
  89         if(send_buffer.wptr==0 && send_buffer.pendingp==0)
  90         {
  91                 LOGPRINTF(1,"first signal is a space!");
  92                 return;
  93         }
  94         if(send_buffer.pendings>0)
  95         {
  96                 send_buffer.pendings+=data;
  97         }
  98         else
  99         {
 100                 if(send_buffer.pendingp>0)
 101                 {
 102                         add_send_buffer(send_buffer.pendingp);
 103                         send_buffer.pendingp=0;
 104                 }
 105                 send_buffer.pendings=data;
 106         }
 107 }
 108
 109 static inline int bad_send_buffer(void)
 110 {
 111         if(send_buffer.too_long!=0) return(1);
 112         if(send_buffer.wptr==WBUF_SIZE && send_buffer.pendingp>0)
 113         {
 114                 return(1);
 115         }
 116         return(0);
 117 }
 118
 119 static int check_send_buffer(void)
 120 {
 121         int i;
 122
 123         if (send_buffer.wptr == 0)
 124         {
 125                 LOGPRINTF(1, "nothing to send");
 126                 return(0);
 127         }
 128         for (i = 0; i < send_buffer.wptr; i++)
 129         {
 130                 if(send_buffer.data[i] == 0)
 131                 {
 132                         if(i%2)
 133                         {
 134                                 LOGPRINTF(1, "invalid space: %d", i);
 135                         }
 136                         else
 137                         {
 138                                 LOGPRINTF(1, "invalid pulse: %d", i);
 139                         }
 140                         return 0;
 141                 }
 142         }
 143
 144         return 1;
 145 }
 146
 147 static inline void flush_send_buffer(void)
 148 {
 149         if(send_buffer.pendingp>0)
 150         {
 151                 add_send_buffer(send_buffer.pendingp);
 152                 send_buffer.pendingp=0;
 153         }
 154         if(send_buffer.pendings>0)
 155         {
 156                 add_send_buffer(send_buffer.pendings);
 157                 send_buffer.pendings=0;
 158         }
 159 }
 160
 161 static inline void sync_send_buffer(void)
 162 {
 163         if(send_buffer.pendingp>0)
 164         {
 165                 add_send_buffer(send_buffer.pendingp);
 166                 send_buffer.pendingp=0;
 167         }
 168         if(send_buffer.wptr>0 && send_buffer.wptr%2==0) send_buffer.wptr--;
 169 }
 170
 171 inline void send_header(struct ir_remote *remote)
 172 {
 173         if(has_header(remote))
 174         {
 175                 send_pulse(remote->phead);
 176                 send_space(remote->shead);
 177         }
 178 }
 179
 180 inline void send_foot(struct ir_remote *remote)
 181 {
 182         if(has_foot(remote))
 183         {
 184                 send_space(remote->sfoot);
 185                 send_pulse(remote->pfoot);
 186         }
 187 }
 188
 189 inline void send_lead(struct ir_remote *remote)
 190 {
 191         if(remote->plead!=0)
 192         {
 193                 send_pulse(remote->plead);
 194         }
 195 }
 196
 197 inline void send_trail(struct ir_remote *remote)
 198 {
 199         if(remote->ptrail!=0)
 200         {
 201                 send_pulse(remote->ptrail);
 202         }
 203 }
 204
 205 inline void send_data(struct ir_remote *remote,ir_code data,int bits,int done)
 206 {
 207         int i;
 208         int all_bits = bit_count(remote);
 209         ir_code mask;
 210         if(is_rcmm(remote))
 211         {
 212                 data=reverse(data,bits);
 213                 mask=1<<(all_bits-1-done);
 214                 if(bits%2 || done%2)
 215                 {
 216                         logprintf(LOG_ERR,"invalid bit number.");
 217                         return;
 218                 }
 219                 for(i=0;i<bits;i+=2,mask>>=2)
 220                 {
 221                         switch(data&3)
 222                         {
 223                         case 0:
 224                                 send_pulse(remote->pzero);
 225                                 send_space(remote->szero);
 226                                 break;
 227                         /* 2 and 1 swapped due to reverse() */
 228                         case 2:
 229                                 send_pulse(remote->pone);
 230                                 send_space(remote->sone);
 231                                 break;
 232                         case 1:
 233                                 send_pulse(remote->ptwo);
 234                                 send_space(remote->stwo);
 235                                 break;
 236                         case 3:
 237                                 send_pulse(remote->pthree);
 238                                 send_space(remote->sthree);
 239                                 break;
 240                         }
 241                         data=data>>2;
 242                 }
 243                 return;
 244         }
 245
 246         data=reverse(data,bits);
 247         mask=((ir_code) 1)<<(all_bits-1-done);
 248         for(i=0;i<bits;i++,mask>>=1)
 249         {
 250                 if(has_toggle_bit_mask(remote) && mask&remote->toggle_bit_mask)
 251                 {
 252                         data &= ~((ir_code) 1);
 253                         if(remote->toggle_bit_mask_state&mask)
 254                         {
 255                                 data |= (ir_code) 1;
 256                         }
 257
 258                 }
 259                 if(has_toggle_mask(remote) &&
 260                    mask&remote->toggle_mask &&
 261                    remote->toggle_mask_state%2)
 262                 {
 263                         data ^= 1;
 264                 }
 265                 if(data&1)
 266                 {
 267                         if(is_biphase(remote))
 268                         {
 269
 270                                 if(mask&remote->rc6_mask)
 271                                 {
 272                                         send_space(2*remote->sone);
 273                                         send_pulse(2*remote->pone);
 274                                 }
 275                                 else
 276                                 {
 277                                         send_space(remote->sone);
 278                                         send_pulse(remote->pone);
 279                                 }
 280                         }
 281                         else if(is_space_first(remote))
 282                         {
 283                                 send_space(remote->sone);
 284                                 send_pulse(remote->pone);
 285                         }
 286                         else
 287                         {
 288                                 send_pulse(remote->pone);
 289                                 send_space(remote->sone);
 290                         }
 291                 }
 292                 else
 293                 {
 294                         if(mask&remote->rc6_mask)
 295                         {
 296                                 send_pulse(2*remote->pzero);
 297                                 send_space(2*remote->szero);
 298                         }
 299                         else if(is_space_first(remote))
 300                         {
 301                                 send_space(remote->szero);
 302                                 send_pulse(remote->pzero);
 303                         }
 304                         else
 305                         {
 306                                 send_pulse(remote->pzero);
 307                                 send_space(remote->szero);
 308                         }
 309                 }
 310                 data=data>>1;
 311         }
 312 }
 313
 314 inline void send_pre(struct ir_remote *remote)
 315 {
 316         if(has_pre(remote))
 317         {
 318                 send_data(remote,remote->pre_data,remote->pre_data_bits,0);
 319                 if(remote->pre_p>0 && remote->pre_s>0)
 320                 {
 321                         send_pulse(remote->pre_p);
 322                         send_space(remote->pre_s);
 323                 }
 324         }
 325 }
 326
 327 inline void send_post(struct ir_remote *remote)
 328 {
 329         if(has_post(remote))
 330         {
 331                 if(remote->post_p>0 && remote->post_s>0)
 332                 {
 333                         send_pulse(remote->post_p);
 334                         send_space(remote->post_s);
 335                 }
 336                 send_data(remote,remote->post_data,remote->post_data_bits,
 337                           remote->pre_data_bits+remote->bits);
 338         }
 339 }
 340
 341 inline void send_repeat(struct ir_remote *remote)
 342 {
 343         send_lead(remote);
 344         send_pulse(remote->prepeat);
 345         send_space(remote->srepeat);
 346         send_trail(remote);
 347 }
 348
 349 inline void send_code(struct ir_remote *remote,ir_code code, int repeat)
 350 {
 351         if(!repeat || !(remote->flags&NO_HEAD_REP))
 352                 send_header(remote);
 353         send_lead(remote);
 354         send_pre(remote);
 355         send_data(remote,code,remote->bits,remote->pre_data_bits);
 356         send_post(remote);
 357         send_trail(remote);
 358         if(!repeat || !(remote->flags&NO_FOOT_REP))
 359                 send_foot(remote);
 360
 361         if(!repeat &&
 362            remote->flags&NO_HEAD_REP &&
 363            remote->flags&CONST_LENGTH)
 364         {
 365                 send_buffer.sum-=remote->phead+remote->shead;
 366         }
 367 }
 368
 369 static void send_signals(lirc_t *signals, int n)
 370 {
 371         int i;
 372
 373         for(i=0; i<n; i++)
 374         {
 375                 add_send_buffer(signals[i]);
 376         }
 377 }
 378
 379 int init_send(struct ir_remote *remote,struct ir_ncode *code)
 380 {
 381         int i, repeat=0;
 382
 383         if(is_grundig(remote) ||
 384            is_goldstar(remote) || is_serial(remote) || is_bo(remote))
 385         {
 386                 logprintf(LOG_ERR,"sorry, can't send this protocol yet");
 387                 return(0);
 388         }
 389         clear_send_buffer();
 390         if(is_biphase(remote))
 391         {
 392                 send_buffer.is_biphase=1;
 393         }
 394         if(repeat_remote==NULL)
 395         {
 396                 remote->repeat_countdown=remote->min_repeat;
 397         }
 398         else
 399         {
 400                 repeat = 1;
 401         }
 402
 403  init_send_loop:
 404         if(repeat && has_repeat(remote))
 405         {
 406                 if(remote->flags&REPEAT_HEADER && has_header(remote))
 407                 {
 408                         send_header(remote);
 409                 }
 410                 send_repeat(remote);
 411         }
 412         else
 413         {
 414                 if(!is_raw(remote))
 415                 {
 416                         ir_code next_code;
 417
 418                         if(code->transmit_state == NULL)
 419                         {
 420                                 next_code = code->code;
 421                         }
 422                         else
 423                         {
 424                                 next_code = code->transmit_state->code;
 425                         }
 426                         send_code(remote, next_code, repeat);
 427                         if(has_toggle_mask(remote))
 428                         {
 429                                 remote->toggle_mask_state++;
 430                                 if(remote->toggle_mask_state==4)
 431                                 {
 432                                         remote->toggle_mask_state=2;
 433                                 }
 434                         }
 435                         send_buffer.data=send_buffer._data;
 436                 }
 437                 else
 438                 {
 439                         if(code->signals==NULL)
 440                         {
 441                                 logprintf(LOG_ERR, "no signals for raw send");
 442                                 return 0;
 443                         }
 444                         if(send_buffer.wptr>0)
 445                         {
 446                                 send_signals(code->signals, code->length);
 447                         }
 448                         else
 449                         {
 450                                 send_buffer.data=code->signals;
 451                                 send_buffer.wptr=code->length;
 452                                 for(i=0; i<code->length; i++)
 453                                 {
 454                                         send_buffer.sum+=code->signals[i];
 455                                 }
 456                         }
 457                 }
 458         }
 459         sync_send_buffer();
 460         if(bad_send_buffer())
 461         {
 462                 logprintf(LOG_ERR,"buffer too small");
 463                 return(0);
 464         }
 465         if(has_repeat_gap(remote) && repeat && has_repeat(remote))
 466         {
 467                 remote->min_remaining_gap=remote->repeat_gap;
 468                 remote->max_remaining_gap=remote->repeat_gap;
 469         }
 470         else if(is_const(remote))
 471         {
 472                 if(min_gap(remote)>send_buffer.sum)
 473                 {
 474                         remote->min_remaining_gap=min_gap(remote)-send_buffer.sum;
 475                         remote->max_remaining_gap=max_gap(remote)-send_buffer.sum;
 476                 }
 477                 else
 478                 {
 479                         logprintf(LOG_ERR,"too short gap: %u",remote->gap);
 480                         remote->min_remaining_gap=min_gap(remote);
 481                         remote->max_remaining_gap=max_gap(remote);
 482                         return(0);
 483                 }
 484         }
 485         else
 486         {
 487                 remote->min_remaining_gap=min_gap(remote);
 488                 remote->max_remaining_gap=max_gap(remote);
 489         }
 490         /* update transmit state */
 491         if(code->next != NULL)
 492         {
 493                 if(code->transmit_state == NULL)
 494                 {
 495                         code->transmit_state = code->next;
 496                 }
 497                 else
 498                 {
 499                         code->transmit_state = code->transmit_state->next;
 500                 }
 501         }
 502         if((remote->repeat_countdown>0 || code->transmit_state != NULL) &&
 503            remote->min_remaining_gap<LIRCD_EXACT_GAP_THRESHOLD)
 504         {
 505                 if(send_buffer.data!=send_buffer._data)
 506                 {
 507                         lirc_t *signals;
 508                         int n;
 509
 510                         LOGPRINTF(1, "unrolling raw signal optimisation");
 511                         signals=send_buffer.data;
 512                         n=send_buffer.wptr;
 513                         send_buffer.data=send_buffer._data;
 514                         send_buffer.wptr=0;
 515
 516                         send_signals(signals, n);
 517                 }
 518                 LOGPRINTF(1, "concatenating low gap signals");
 519                 if(code->next == NULL || code->transmit_state == NULL)
 520                 {
 521                         remote->repeat_countdown--;
 522                 }
 523                 send_space(remote->min_remaining_gap);
 524                 flush_send_buffer();
 525                 send_buffer.sum=0;
 526
 527                 repeat = 1;
 528                 goto init_send_loop;
 529         }
 530         LOGPRINTF(3, "transmit buffer ready");
 531         if(!check_send_buffer())
 532         {
 533                 logprintf(LOG_ERR, "invalid send buffer");
 534                 logprintf(LOG_ERR,
 535                           "this remote configuration cannot be used "
 536                           "to transmit");
 537                 return 0;
 538         }
 539         return 1;
 540 }