/*override*/void* operator()( void* item ) {
Harness::ConcurrencyTracker ct;
if( is_serial() )
ASSERT( !my_is_running, "premature entry to serial stage" );
my_is_running = true;
Buffer* b = get_buffer(item);
if( b ) {
if( is_ordered() ) {
if( b->sequence_number == Buffer::unused )
b->sequence_number = current_token-1;
else
ASSERT( b->sequence_number==current_token-1, "item arrived out of order" );
} else if( is_serial() ) {
if( b->sequence_number != current_token-1 && b->sequence_number != Buffer::unused )
out_of_order_count++;
}
ASSERT( b->id < StreamSize, NULL );
ASSERT( !my_done[b->id], "duplicate processing of token?" );
ASSERT( b->is_busy, NULL );
my_done[b->id] = true;
if( my_is_last ) {
b->id = Buffer::unused;
b->sequence_number = Buffer::unused;
__TBB_store_with_release(b->is_busy, false);
}
}
my_is_running = false;
return b;
}
/*override*/Buffer* get_buffer( void* ) {
unsigned long next_input;
unsigned free_buffer = 0;
{ // lock protected scope
tbb::spin_mutex::scoped_lock lock(input_lock);
if( current_token>=StreamSize )
return NULL;
next_input = current_token++;
// once in a while, emulate waiting for input; this only makes sense for serial input
if( is_serial() && WaitTest.required() )
WaitTest.probe( );
while( free_buffer<MaxBuffer )
if( __TBB_load_with_acquire(buffer[free_buffer].is_busy) )
++free_buffer;
else {
buffer[free_buffer].is_busy = true;
break;
}
}
ASSERT( free_buffer<my_number_of_tokens, "premature reuse of buffer" );
Buffer* b = &buffer[free_buffer];
ASSERT( &buffer[0] <= b, NULL );
ASSERT( b <= &buffer[MaxBuffer-1], NULL );
ASSERT( b->id == Buffer::unused, NULL);
b->id = next_input;
ASSERT( b->sequence_number == Buffer::unused, NULL);
return b;
}
static struct ir_remote * read_config_recursive(FILE *f, const char *name, int depth)
{
char buf[LINE_LEN+1], *key, *val, *val2;
int len,argc;
struct ir_remote *top_rem=NULL,*rem=NULL;
struct void_array codes_list,raw_codes,signals;
struct ir_ncode raw_code={NULL,0,0,NULL};
struct ir_ncode name_code={NULL,0,0,NULL};
struct ir_ncode *code;
int mode=ID_none;
line=0;
parse_error=0;
LOGPRINTF(2, "parsing '%s'", name);
while(fgets(buf,LINE_LEN,f)!=NULL)
{
line++;
len=strlen(buf);
if(len==LINE_LEN && buf[len-1]!='\n')
{
logprintf(LOG_ERR,"line %d too long in config file",
line);
parse_error=1;
break;
}
if(len>0)
{
len--;
if(buf[len]=='\n') buf[len]=0;
}
if(len>0)
{
len--;
if(buf[len]=='\r') buf[len]=0;
}
/* ignore comments */
if(buf[0]=='#'){
continue;
}
key=strtok(buf, whitespace);
/* ignore empty lines */
if(key==NULL) continue;
val=strtok(NULL, whitespace);
if(val!=NULL){
val2=strtok(NULL, whitespace);
LOGPRINTF(3,"\"%s\" \"%s\"",key,val);
if (strcasecmp("include",key)==0){
FILE* childFile;
const char *childName;
const char *fullPath;
char result[FILENAME_MAX+1];
if (depth > MAX_INCLUDES) {
logprintf(LOG_ERR,"error opening child file defined at %s:%d",name,line);
logprintf(LOG_ERR,"too many files included");
parse_error=-1;
break;
}
childName = lirc_parse_include(val);
if (!childName){
logprintf(LOG_ERR,"error parsing child file value defined at line %d:",line);
logprintf(LOG_ERR,"invalid quoting");
parse_error=-1;
break;
}
fullPath = lirc_parse_relative(result, sizeof(result), childName, name);
if (!fullPath) {
logprintf(LOG_ERR,"error composing relative file path defined at line %d:",line);
logprintf(LOG_ERR,"resulting path too long");
parse_error=-1;
break;
}
childFile = fopen(fullPath, "r");
if (childFile == NULL){
logprintf(LOG_ERR,"error opening child file '%s' defined at line %d:",fullPath, line);
logprintf(LOG_ERR,"ignoring this child file for now.");
}
else{
int save_line = line;
if (!top_rem){
/* create first remote */
LOGPRINTF(2,"creating first remote");
rem = read_config_recursive(childFile, fullPath, depth + 1);
if(rem != (void *) -1 && rem != NULL) {
top_rem = rem;
} else {
rem = NULL;
}
}else{
/* create new remote */
LOGPRINTF(2,"creating next remote");
rem->next=read_config_recursive(childFile, fullPath, depth + 1);
if(rem->next != (void *) -1 && rem->next != NULL) {
rem=rem->next;
} else {
rem->next = NULL;
}
}
fclose(childFile);
line = save_line;
}
}else if (strcasecmp("begin",key)==0){
if (strcasecmp("codes", val)==0){
/* init codes mode */
LOGPRINTF(2," begin codes");
if (!checkMode(mode, ID_remote,
"begin codes")) break;
if (rem->codes){
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"codes are already defined");
parse_error=1;
break;
}
init_void_array(&codes_list,30, sizeof(struct ir_ncode));
mode=ID_codes;
}else if(strcasecmp("raw_codes",val)==0){
/* init raw_codes mode */
LOGPRINTF(2," begin raw_codes");
if(!checkMode(mode, ID_remote,
"begin raw_codes")) break;
if (rem->codes){
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"codes are already defined");
parse_error=1;
break;
}
set_protocol(rem, RAW_CODES);
raw_code.code=0;
init_void_array(&raw_codes,30, sizeof(struct ir_ncode));
mode=ID_raw_codes;
}else if(strcasecmp("remote",val)==0){
/* create new remote */
LOGPRINTF(1,"parsing remote");
if(!checkMode(mode, ID_none,
"begin remote")) break;
mode=ID_remote;
if (!top_rem){
/* create first remote */
LOGPRINTF(2,"creating first remote");
rem=top_rem=s_malloc(sizeof(struct ir_remote));
}else{
/* create new remote */
LOGPRINTF(2,"creating next remote");
rem->next=s_malloc(sizeof(struct ir_remote));;
rem=rem->next;
}
}else if(mode==ID_codes){
code=defineCode(key, val, &name_code);
while(!parse_error && val2!=NULL)
{
struct ir_code_node *node;
if(val2[0]=='#') break; /* comment */
node=defineNode(code, val2);
val2=strtok(NULL, whitespace);
}
code->current=NULL;
add_void_array(&codes_list, code);
}else{
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"unknown section \"%s\"",val);
parse_error=1;
}
if(!parse_error && val2!=NULL)
{
logprintf(LOG_WARNING,"garbage after "
"'%s' token in line %d ignored",
val,line);
}
}else if (strcasecmp("end",key)==0){
if (strcasecmp("codes", val)==0){
/* end Codes mode */
LOGPRINTF(2," end codes");
if (!checkMode(mode, ID_codes,
"end codes")) break;
rem->codes=get_void_array(&codes_list);
mode=ID_remote; /* switch back */
}else if(strcasecmp("raw_codes",val)==0){
/* end raw codes mode */
LOGPRINTF(2," end raw_codes");
if(mode==ID_raw_name){
raw_code.signals=get_void_array(&signals);
raw_code.length=signals.nr_items;
if(raw_code.length%2==0)
{
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"bad signal length");
parse_error=1;
}
if(!add_void_array(&raw_codes, &raw_code))
break;
mode=ID_raw_codes;
}
if(!checkMode(mode,ID_raw_codes,
"end raw_codes")) break;
rem->codes=get_void_array(&raw_codes);
mode=ID_remote; /* switch back */
}else if(strcasecmp("remote",val)==0){
/* end remote mode */
LOGPRINTF(2,"end remote");
/* print_remote(rem); */
if (!checkMode(mode,ID_remote,
"end remote")) break;
if(!sanityChecks(rem)) {
parse_error=1;
break;
}
# ifdef DYNCODES
if(rem->dyncodes_name==NULL)
{
rem->dyncodes_name=s_strdup("unknown");
}
rem->dyncodes[0].name=rem->dyncodes_name;
rem->dyncodes[1].name=rem->dyncodes_name;
# endif
/* not really necessary because we
clear the alloced memory */
rem->next=NULL;
rem->last_code=NULL;
mode=ID_none; /* switch back */
}else if(mode==ID_codes){
code=defineCode(key, val, &name_code);
while(!parse_error && val2!=NULL)
{
struct ir_code_node *node;
if(val2[0]=='#') break; /* comment */
node=defineNode(code, val2);
val2=strtok(NULL, whitespace);
}
code->current=NULL;
add_void_array(&codes_list, code);
}else{
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"unknown section %s",val);
parse_error=1;
}
if(!parse_error && val2!=NULL)
{
logprintf(LOG_WARNING,"garbage after '%s'"
" token in line %d ignored",
val,line);
}
} else {
switch (mode){
case ID_remote:
argc=defineRemote(key, val, val2, rem);
if(!parse_error && ((argc==1 && val2!=NULL) ||
(argc==2 && val2!=NULL && strtok(NULL, whitespace)!=NULL)))
{
logprintf(LOG_WARNING,"garbage after '%s'"
" token in line %d ignored",
key,line);
}
break;
case ID_codes:
code=defineCode(key, val, &name_code);
while(!parse_error && val2!=NULL)
{
struct ir_code_node *node;
if(val2[0]=='#') break; /* comment */
node=defineNode(code, val2);
val2=strtok(NULL, whitespace);
}
code->current=NULL;
add_void_array(&codes_list, code);
break;
case ID_raw_codes:
case ID_raw_name:
if(strcasecmp("name",key)==0){
LOGPRINTF(3,"Button: \"%s\"",val);
if(mode==ID_raw_name)
{
raw_code.signals=get_void_array(&signals);
raw_code.length=signals.nr_items;
if(raw_code.length%2==0)
{
logprintf(LOG_ERR,"error in configfile line %d:",line);
logprintf(LOG_ERR,"bad signal length");
parse_error=1;
}
if(!add_void_array(&raw_codes, &raw_code))
break;
}
if(!(raw_code.name=s_strdup(val))){
break;
}
raw_code.code++;
init_void_array(&signals,50,sizeof(lirc_t));
mode=ID_raw_name;
if(!parse_error && val2!=NULL)
{
logprintf(LOG_WARNING,"garbage after '%s'"
" token in line %d ignored",
key,line);
}
}else{
if(mode==ID_raw_codes)
{
logprintf(LOG_ERR,"no name for signal defined at line %d",line);
parse_error=1;
break;
}
if(!addSignal(&signals, key)) break;
if(!addSignal(&signals, val)) break;
if (val2){
if (!addSignal(&signals, val2)){
break;
}
}
while ((val=strtok(NULL, whitespace))){
if (!addSignal(&signals, val)) break;
}
}
break;
}
}
}else if(mode==ID_raw_name){
if(!addSignal(&signals, key)){
break;
}
}else{
logprintf(LOG_ERR,"error in configfile line %d", line);
parse_error=1;
break;
}
if (parse_error){
break;
}
}
if(mode!=ID_none)
{
switch(mode)
{
case ID_raw_name:
if(raw_code.name!=NULL)
{
free(raw_code.name);
if(get_void_array(&signals)!=NULL)
free(get_void_array(&signals));
}
case ID_raw_codes:
rem->codes=get_void_array(&raw_codes);
break;
case ID_codes:
rem->codes=get_void_array(&codes_list);
break;
}
if(!parse_error)
{
logprintf(LOG_ERR,"unexpected end of file");
parse_error=1;
}
}
if (parse_error){
static int print_error = 1;
if(print_error) {
logprintf(LOG_ERR, "reading of file '%s' failed",
name);
print_error = 0;
}
free_config(top_rem);
if(depth == 0) print_error = 1;
return((void *) -1);
}
/* kick reverse flag */
/* handle RC6 flag to be backwards compatible: previous RC-6
config files did not set rc6_mask */
rem=top_rem;
while(rem!=NULL)
{
if((!is_raw(rem)) && rem->flags&REVERSE)
{
struct ir_ncode *codes;
if(has_pre(rem))
{
rem->pre_data=reverse(rem->pre_data,
rem->pre_data_bits);
}
if(has_post(rem))
{
rem->post_data=reverse(rem->post_data,
rem->post_data_bits);
}
codes=rem->codes;
while(codes->name!=NULL)
{
codes->code=reverse(codes->code,rem->bits);
codes++;
}
rem->flags=rem->flags&(~REVERSE);
rem->flags=rem->flags|COMPAT_REVERSE;
/* don't delete the flag because we still need
it to remain compatible with older versions
*/
}
if(rem->flags&RC6 && rem->rc6_mask==0 && rem->toggle_bit>0)
{
int all_bits=bit_count(rem);
rem->rc6_mask=((ir_code) 1)<<(all_bits-rem->toggle_bit);
}
if(rem->toggle_bit > 0)
{
int all_bits=bit_count(rem);
if(has_toggle_bit_mask(rem))
{
logprintf(LOG_WARNING,
"%s uses both toggle_bit and "
"toggle_bit_mask", rem->name);
}
else
{
rem->toggle_bit_mask=((ir_code) 1)<<(all_bits-rem->toggle_bit);
}
rem->toggle_bit = 0;
}
if(has_toggle_bit_mask(rem))
{
if(!is_raw(rem) && rem->codes)
{
rem->toggle_bit_mask_state = (rem->codes->code & rem->toggle_bit_mask);
if(rem->toggle_bit_mask_state)
{
/* start with state set to 0 for backwards compatibility */
rem->toggle_bit_mask_state ^= rem->toggle_bit_mask;
}
}
}
if(is_serial(rem))
{
lirc_t base;
if(rem->baud>0)
{
base=1000000/rem->baud;
if(rem->pzero==0 && rem->szero==0)
{
rem->pzero=base;
}
if(rem->pone==0 && rem->sone==0)
{
rem->sone=base;
}
}
if(rem->bits_in_byte==0)
{
rem->bits_in_byte=8;
}
}
if(rem->min_code_repeat>0)
{
if(!has_repeat(rem) ||
rem->min_code_repeat>rem->min_repeat)
{
logprintf(LOG_WARNING,
"invalid min_code_repeat value");
rem->min_code_repeat = 0;
}
}
calculate_signal_lengths(rem);
rem=rem->next;
}
top_rem = sort_by_bit_count(top_rem);
# if defined(DEBUG) && !defined(DAEMONIZE)
/*fprint_remotes(stderr, top_rem);*/
# endif
return (top_rem);
}
void fprint_remote_head(FILE *f, struct ir_remote *rem)
{
fprintf(f, "begin remote\n\n");
if(!is_raw(rem)){
fprintf(f, " name %s\n",rem->name);
fprintf(f, " bits %5d\n",rem->bits);
fprint_flags(f,rem->flags);
fprintf(f, " eps %5d\n",rem->eps);
fprintf(f, " aeps %5d\n\n",rem->aeps);
if(has_header(rem))
{
fprintf(f, " header %5lu %5lu\n",
(unsigned long) rem->phead,
(unsigned long) rem->shead);
}
if(rem->pthree!=0 || rem->sthree!=0)
fprintf(f, " three %5lu %5lu\n",
(unsigned long) rem->pthree,
(unsigned long) rem->sthree);
if(rem->ptwo!=0 || rem->stwo!=0)
fprintf(f, " two %5lu %5lu\n",
(unsigned long) rem->ptwo,
(unsigned long) rem->stwo);
fprintf(f, " one %5lu %5lu\n",
(unsigned long) rem->pone,
(unsigned long) rem->sone);
fprintf(f, " zero %5lu %5lu\n",
(unsigned long) rem->pzero,
(unsigned long) rem->szero);
if(rem->ptrail!=0)
{
fprintf(f, " ptrail %5lu\n",
(unsigned long) rem->ptrail);
}
if(rem->plead!=0)
{
fprintf(f, " plead %5lu\n",
(unsigned long) rem->plead);
}
if(has_foot(rem))
{
fprintf(f, " foot %5lu %5lu\n",
(unsigned long) rem->pfoot,
(unsigned long) rem->sfoot);
}
if(has_repeat(rem))
{
fprintf(f, " repeat %5lu %5lu\n",
(unsigned long) rem->prepeat,
(unsigned long) rem->srepeat);
}
if(rem->pre_data_bits>0)
{
fprintf(f, " pre_data_bits %d\n",rem->pre_data_bits);
# ifdef LONG_IR_CODE
fprintf(f, " pre_data 0x%llX\n",rem->pre_data);
# else
fprintf(f, " pre_data 0x%lX\n",rem->pre_data);
# endif
}
if(rem->post_data_bits>0)
{
fprintf(f, " post_data_bits %d\n",rem->post_data_bits);
# ifdef LONG_IR_CODE
fprintf(f, " post_data 0x%llX\n",rem->post_data);
# else
fprintf(f, " post_data 0x%lX\n",rem->post_data);
# endif
}
if(rem->pre_p!=0 && rem->pre_s!=0)
{
fprintf(f, " pre %5lu %5lu\n",
(unsigned long) rem->pre_p,
(unsigned long) rem->pre_s);
}
if(rem->post_p!=0 && rem->post_s!=0)
{
fprintf(f, " post %5lu %5lu\n",
(unsigned long) rem->post_p,
(unsigned long) rem->post_s);
}
fprintf(f, " gap %lu\n",
(unsigned long) rem->gap);
if(has_repeat_gap(rem))
{
fprintf(f, " repeat_gap %lu\n",
(unsigned long) rem->repeat_gap);
}
if(rem->min_repeat>0)
{
fprintf(f, " min_repeat %d\n",rem->min_repeat);
}
if(rem->min_code_repeat>0)
{
fprintf(f, " min_code_repeat %d\n",
rem->min_code_repeat);
}
# ifdef LONG_IR_CODE
fprintf(f, " toggle_bit_mask 0x%llX\n",
rem->toggle_bit_mask);
# else
fprintf(f, " toggle_bit_mask 0x%lX\n",
rem->toggle_bit_mask);
# endif
if(has_toggle_mask(rem))
{
# ifdef LONG_IR_CODE
fprintf(f, " toggle_mask 0x%llX\n",
rem->toggle_mask);
# else
fprintf(f, " toggle_mask 0x%lX\n",
rem->toggle_mask);
# endif
}
if(rem->rc6_mask!=0)
{
# ifdef LONG_IR_CODE
fprintf(f, " rc6_mask 0x%llX\n",
rem->rc6_mask);
# else
fprintf(f, " rc6_mask 0x%lX\n",
rem->rc6_mask);
# endif
}
if(is_serial(rem))
{
fprintf(f, " baud %d\n",rem->baud);
fprintf(f, " serial_mode %dN%d%s\n",
rem->bits_in_byte,
rem->stop_bits/2,
rem->stop_bits%2 ? ".5":"");
}
}
else
{
fprintf(f, " name %s\n",rem->name);
fprint_flags(f,rem->flags);
fprintf(f, " eps %5d\n",rem->eps);
fprintf(f, " aeps %5d\n\n",rem->aeps);
fprintf(f, " ptrail %5lu\n",(unsigned long) rem->ptrail);
fprintf(f, " repeat %5lu %5lu\n",
(unsigned long) rem->prepeat,
(unsigned long) rem->srepeat);
fprintf(f, " gap %lu\n",(unsigned long) rem->gap);
}
if(rem->freq!=0)
{
fprintf(f, " frequency %u\n",rem->freq);
}
if(rem->duty_cycle!=0)
{
fprintf(f, " duty_cycle %u\n",rem->duty_cycle);
}
fprintf(f,"\n");
}
void
print_line(int fd, struct cl_t *line, unsigned char *details, pid_t pid, int index,
time_t until)
/* print some basic fields of a line, and some more if details == 1 */
{
char buf[TERM_LEN];
int len = 0;
struct tm *ftime;
len = snprintf(buf, sizeof(buf), "%-5ld", line->cl_id);
if ( bit_test(details, FIELD_USER) )
len += snprintf(buf+len, sizeof(buf)-len, " %-6s", line->cl_file->cf_user);
if ( bit_test(details, FIELD_PID) )
len += snprintf(buf+len, sizeof(buf)-len, " %-7d", pid);
if ( bit_test(details, FIELD_INDEX) )
len += snprintf(buf+len, sizeof(buf)-len, " %-5d", index);
if ( bit_test(details, FIELD_RQ) )
len += snprintf(buf+len, sizeof(buf)-len, " %-4d", line->cl_numexe);
if ( bit_test(details, FIELD_OPTIONS) ) {
char opt[9];
int i = 0;
opt[0] = '\0';
if ( is_lavg(line->cl_option) )
i += snprintf(opt+i, sizeof(opt)-i, "L%.*s",
(is_lavg_sev(line->cl_option)) ? 0:1, "O");
if ( is_serial(line->cl_option) )
i += snprintf(opt+i, sizeof(opt)-i, "%.*sS%.*s", i, ",",
(is_serial_sev(line->cl_option)) ? 0:1, "O");
if ( is_exe_sev(line->cl_option) )
i += snprintf(opt+i, sizeof(opt)-i, "%.*sES", i, ",");
len += snprintf(buf+len, sizeof(buf)-len, " %-9s", opt);
}
if ( bit_test(details, FIELD_LAVG) ) {
len += snprintf(buf+len, sizeof(buf)-len, " %.1f,%.1f,%.1f",
((double)((line->cl_lavg)[0]))/10,
((double)((line->cl_lavg)[1]))/10,
((double)((line->cl_lavg)[2]))/10);
if ( until > 0 ) {
ftime = localtime( &until );
len += snprintf(buf+len, sizeof(buf)-len, " %02d/%02d/%d %02d:%02d %s",
(ftime->tm_mon + 1), ftime->tm_mday, (ftime->tm_year + 1900),
ftime->tm_hour, ftime->tm_min,
(is_strict(line->cl_option)) ? "Y":"N");
}
else
len += snprintf(buf+len, sizeof(buf)-len, " %18s", " (no until set) ");
}
if ( bit_test(details, FIELD_SCHEDULE) ) {
ftime = localtime( &(line->cl_nextexe) );
len += snprintf(buf+len, sizeof(buf)-len, " %02d/%02d/%d %02d:%02d",
(ftime->tm_mon + 1), ftime->tm_mday, (ftime->tm_year + 1900),
ftime->tm_hour, ftime->tm_min );
}
len += snprintf(buf+len, sizeof(buf)-len, " %s\n", line->cl_shell);
if ( send(fd, buf, (len < sizeof(buf)) ? len : sizeof(buf), 0) < 0 )
error_e("error in send()");
}
void fprint_remote_head(FILE* f, const struct ir_remote* rem)
{
fprintf(f, "begin remote\n\n");
fprintf(f, " name %s\n", rem->name);
if (rem->manual_sort)
fprintf(f, " manual_sort %d\n", rem->manual_sort);
if (rem->driver)
fprintf(f, " driver %s\n", rem->driver);
if (!is_raw(rem))
fprintf(f, " bits %5d\n", rem->bits);
fprint_flags(f, rem->flags);
fprintf(f, " eps %5d\n", rem->eps);
fprintf(f, " aeps %5d\n\n", rem->aeps);
if (!is_raw(rem)) {
if (has_header(rem))
fprintf(f, " header %5u %5u\n", (__u32)rem->phead, (__u32)rem->shead);
if (rem->pthree != 0 || rem->sthree != 0)
fprintf(f, " three %5u %5u\n", (__u32)rem->pthree, (__u32)rem->sthree);
if (rem->ptwo != 0 || rem->stwo != 0)
fprintf(f, " two %5u %5u\n", (__u32)rem->ptwo, (__u32)rem->stwo);
fprintf(f, " one %5u %5u\n", (__u32)rem->pone, (__u32)rem->sone);
fprintf(f, " zero %5u %5u\n", (__u32)rem->pzero, (__u32)rem->szero);
}
if (rem->ptrail != 0)
fprintf(f, " ptrail %5u\n", (__u32)rem->ptrail);
if (!is_raw(rem)) {
if (rem->plead != 0)
fprintf(f, " plead %5u\n", (__u32)rem->plead);
if (has_foot(rem))
fprintf(f, " foot %5u %5u\n", (__u32)rem->pfoot, (__u32)rem->sfoot);
}
if (has_repeat(rem))
fprintf(f, " repeat %5u %5u\n", (__u32)rem->prepeat, (__u32)rem->srepeat);
if (!is_raw(rem)) {
if (rem->pre_data_bits > 0) {
fprintf(f, " pre_data_bits %d\n", rem->pre_data_bits);
fprintf(f, " pre_data 0x%llX\n", (unsigned long long)rem->pre_data);
}
if (rem->post_data_bits > 0) {
fprintf(f, " post_data_bits %d\n", rem->post_data_bits);
fprintf(f, " post_data 0x%llX\n", (unsigned long long)rem->post_data);
}
if (rem->pre_p != 0 && rem->pre_s != 0)
fprintf(f, " pre %5u %5u\n", (__u32)rem->pre_p, (__u32)rem->pre_s);
if (rem->post_p != 0 && rem->post_s != 0)
fprintf(f, " post %5u %5u\n", (__u32)rem->post_p, (__u32)rem->post_s);
}
fprint_remote_gap(f, rem);
if (has_repeat_gap(rem))
fprintf(f, " repeat_gap %u\n", (__u32)rem->repeat_gap);
if (rem->suppress_repeat > 0)
fprintf(f, " suppress_repeat %d\n", rem->suppress_repeat);
if (rem->min_repeat > 0) {
fprintf(f, " min_repeat %d\n", rem->min_repeat);
if (rem->suppress_repeat == 0) {
fprintf(f, "# suppress_repeat %d\n", rem->min_repeat);
fprintf(f, "# uncomment to suppress unwanted repeats\n");
}
}
if (!is_raw(rem)) {
if (rem->min_code_repeat > 0)
fprintf(f, " min_code_repeat %d\n", rem->min_code_repeat);
fprintf(f, " toggle_bit_mask 0x%llX\n", (unsigned long long)rem->toggle_bit_mask);
if (has_toggle_mask(rem))
fprintf(f, " toggle_mask 0x%llX\n", (unsigned long long)rem->toggle_mask);
if (rem->repeat_mask != 0)
fprintf(f, " repeat_mask 0x%llX\n", (unsigned long long)rem->repeat_mask);
if (rem->rc6_mask != 0)
fprintf(f, " rc6_mask 0x%llX\n", (unsigned long long)rem->rc6_mask);
if (has_ignore_mask(rem))
fprintf(f, " ignore_mask 0x%llX\n", (unsigned long long)rem->ignore_mask);
if (is_serial(rem)) {
fprintf(f, " baud %d\n", rem->baud);
fprintf(f, " serial_mode %dN%d%s\n", rem->bits_in_byte, rem->stop_bits / 2,
rem->stop_bits % 2 ? ".5" : "");
}
}
if (rem->freq != 0)
fprintf(f, " frequency %u\n", rem->freq);
if (rem->duty_cycle != 0)
fprintf(f, " duty_cycle %u\n", rem->duty_cycle);
fprintf(f, "\n");
}
int init_send(struct ir_remote *remote,struct ir_ncode *code)
{
int i, repeat=0;
if(is_grundig(remote) ||
is_goldstar(remote) || is_serial(remote) || is_bo(remote))
{
logprintf(LOG_ERR,"sorry, can't send this protocol yet");
return(0);
}
clear_send_buffer();
if(is_biphase(remote))
{
send_buffer.is_biphase=1;
}
if(repeat_remote==NULL)
{
remote->repeat_countdown=remote->min_repeat;
}
else
{
repeat = 1;
}
init_send_loop:
if(repeat && has_repeat(remote))
{
if(remote->flags&REPEAT_HEADER && has_header(remote))
{
send_header(remote);
}
send_repeat(remote);
}
else
{
if(!is_raw(remote))
{
ir_code next_code;
if(code->transmit_state == NULL)
{
next_code = code->code;
}
else
{
next_code = code->transmit_state->code;
}
send_code(remote, next_code, repeat);
if(has_toggle_mask(remote))
{
remote->toggle_mask_state++;
if(remote->toggle_mask_state==4)
{
remote->toggle_mask_state=2;
}
}
send_buffer.data=send_buffer._data;
}
else
{
if(code->signals==NULL)
{
logprintf(LOG_ERR, "no signals for raw send");
return 0;
}
if(send_buffer.wptr>0)
{
send_signals(code->signals, code->length);
}
else
{
send_buffer.data=code->signals;
send_buffer.wptr=code->length;
for(i=0; i<code->length; i++)
{
send_buffer.sum+=code->signals[i];
}
}
}
}
sync_send_buffer();
if(bad_send_buffer())
{
logprintf(LOG_ERR,"buffer too small");
return(0);
}
if(has_repeat_gap(remote) && repeat && has_repeat(remote))
{
remote->min_remaining_gap=remote->repeat_gap;
remote->max_remaining_gap=remote->repeat_gap;
}
else if(is_const(remote))
{
if(min_gap(remote)>send_buffer.sum)
{
remote->min_remaining_gap=min_gap(remote)-send_buffer.sum;
remote->max_remaining_gap=max_gap(remote)-send_buffer.sum;
}
else
{
logprintf(LOG_ERR,"too short gap: %u",remote->gap);
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
return(0);
}
}
else
{
remote->min_remaining_gap=min_gap(remote);
remote->max_remaining_gap=max_gap(remote);
}
/* update transmit state */
if(code->next != NULL)
{
if(code->transmit_state == NULL)
{
code->transmit_state = code->next;
}
else
{
code->transmit_state = code->transmit_state->next;
}
}
if((remote->repeat_countdown>0 || code->transmit_state != NULL) &&
remote->min_remaining_gap<LIRCD_EXACT_GAP_THRESHOLD)
{
if(send_buffer.data!=send_buffer._data)
{
lirc_t *signals;
int n;
LOGPRINTF(1, "unrolling raw signal optimisation");
signals=send_buffer.data;
n=send_buffer.wptr;
send_buffer.data=send_buffer._data;
send_buffer.wptr=0;
send_signals(signals, n);
}
LOGPRINTF(1, "concatenating low gap signals");
if(code->next == NULL || code->transmit_state == NULL)
{
remote->repeat_countdown--;
}
send_space(remote->min_remaining_gap);
flush_send_buffer();
send_buffer.sum=0;
repeat = 1;
goto init_send_loop;
}
LOGPRINTF(3, "transmit buffer ready");
return(1);
}