inline int get_repeat(struct ir_remote *remote) { if (!get_lead(remote)) return (0); if (is_biphase(remote)) { if (!expectspace(remote, remote->srepeat)) return (0); if (!expectpulse(remote, remote->prepeat)) return (0); } else { if (!expectpulse(remote, remote->prepeat)) return (0); set_pending_space(remote->srepeat); } if (!get_trail(remote)) return (0); if (!get_gap (remote, is_const(remote) ? (min_gap(remote) > rec_buffer.sum ? min_gap(remote) - rec_buffer.sum : 0) : (has_repeat_gap(remote) ? remote->repeat_gap : min_gap(remote)) )) return (0); return (1); }
/** * \brief Add bridge visual on a line. * \param visuals (out) The visuals. * \param left_pos Left position. * \param right_pos Right position. */ void bear::bridge::add_bridge_visual ( std::list<engine::scene_visual>& visuals, const universe::position_type& left_pos, const universe::position_type& right_pos ) const { visual::sprite s(get_sprite()); visual::position_type p ( ( left_pos + right_pos - s.get_size() ) / 2 + get_gap() ); claw::math::line_2d<universe::coordinate_type> line ( left_pos, right_pos - left_pos ); double angle = std::atan(line.direction.y / line.direction.x); s.set_angle(angle); visuals.push_front ( engine::scene_visual( p, s, get_z_position() ) ); } // bridge::add_bridge_visual()
/** * \brief Get the sprites representing the item. * \param visuals (out) The sprites of the item, and their positions. */ void bear::reflecting_decoration::get_visual ( std::list<engine::scene_visual>& visuals ) const { items_list::const_iterator it; items_list item_list(m_items_list); item_list.sort( reflecting_decoration::z_item_position_compare() ); for ( it = item_list.begin(); it != item_list.end(); ++it ) if ( it->get_item() != NULL ) { std::list<engine::scene_visual> scenes; (*it)->get_visual(scenes); scenes.sort(engine::scene_visual::z_position_compare()); if ( !scenes.empty() ) { visual::scene_element_sequence e; visual::position_type origin ( scenes.front().scene_element.get_position() ); e.set_position( origin + get_gap() ); for ( ; !scenes.empty() ; scenes.pop_front() ) { visual::scene_element elem( scenes.front().scene_element ); elem.set_position( elem.get_position() - origin ); e.push_back( elem ); } e.get_rendering_attributes().combine( get_rendering_attributes() ); visuals.push_back( engine::scene_visual(e, get_z_position()) ); } } } // reflecting_decoration::get_visual()
int receive_decode(struct ir_remote *remote, ir_code *prep,ir_code *codep,ir_code *postp, int *repeat_flagp,lirc_t *remaining_gapp) { ir_code pre,code,post,code_mask=0,post_mask=0; lirc_t sync; int header; struct timeval current; sync=0; /* make compiler happy */ code=pre=post=0; header=0; if(hw.rec_mode==LIRC_MODE_MODE2 || hw.rec_mode==LIRC_MODE_PULSE || hw.rec_mode==LIRC_MODE_RAW) { rewind_rec_buffer(); rec_buffer.is_biphase=is_biphase(remote) ? 1:0; /* we should get a long space first */ if(!(sync=sync_rec_buffer(remote))) { LOGPRINTF(1,"failed on sync"); return(0); } LOGPRINTF(1,"sync"); if(has_repeat(remote) && last_remote==remote) { if(remote->flags&REPEAT_HEADER && has_header(remote)) { if(!get_header(remote)) { LOGPRINTF(1,"failed on repeat " "header"); return(0); } LOGPRINTF(1,"repeat header"); } if(get_repeat(remote)) { if(remote->last_code==NULL) { logprintf(LOG_NOTICE,"repeat code " "without last_code " "received"); return(0); } *prep=remote->pre_data; *codep=remote->last_code->code; *postp=remote->post_data; *repeat_flagp=1; *remaining_gapp= is_const(remote) ? (remote->gap>rec_buffer.sum ? remote->gap-rec_buffer.sum:0): (has_repeat_gap(remote) ? remote->repeat_gap:remote->gap); return(1); } else { LOGPRINTF(1,"no repeat"); rewind_rec_buffer(); sync_rec_buffer(remote); } } if(has_header(remote)) { header=1; if(!get_header(remote)) { header=0; if(!(remote->flags&NO_HEAD_REP && (sync<=remote->gap+remote->gap*remote->eps/100 || sync<=remote->gap+remote->aeps))) { LOGPRINTF(1,"failed on header"); return(0); } } LOGPRINTF(1,"header"); } } if(is_raw(remote)) { struct ir_ncode *codes,*found; int i; if(hw.rec_mode==LIRC_MODE_CODE || hw.rec_mode==LIRC_MODE_LIRCCODE) return(0); codes=remote->codes; found=NULL; while(codes->name!=NULL && found==NULL) { found=codes; for(i=0;i<codes->length;) { if(!expectpulse(remote,codes->signals[i++])) { found=NULL; rewind_rec_buffer(); sync_rec_buffer(remote); break; } if(i<codes->length && !expectspace(remote,codes->signals[i++])) { found=NULL; rewind_rec_buffer(); sync_rec_buffer(remote); break; } } codes++; } if(found!=NULL) { if(!get_gap(remote, is_const(remote) ? remote->gap-rec_buffer.sum: remote->gap)) found=NULL; } if(found==NULL) return(0); code=found->code; } else { if(hw.rec_mode==LIRC_MODE_CODE || hw.rec_mode==LIRC_MODE_LIRCCODE) { int i; lirc_t sum; # ifdef LONG_IR_CODE LOGPRINTF(1,"decoded: %llx",rec_buffer.decoded); # else LOGPRINTF(1,"decoded: %lx",rec_buffer.decoded); # endif if((hw.rec_mode==LIRC_MODE_CODE && hw.code_length<remote->pre_data_bits +remote->bits+remote->post_data_bits) || (hw.rec_mode==LIRC_MODE_LIRCCODE && hw.code_length!=remote->pre_data_bits +remote->bits+remote->post_data_bits)) { return(0); } for(i=0;i<remote->post_data_bits;i++) { post_mask=(post_mask<<1)+1; } post=rec_buffer.decoded&post_mask; post_mask=0; rec_buffer.decoded= rec_buffer.decoded>>remote->post_data_bits; for(i=0;i<remote->bits;i++) { code_mask=(code_mask<<1)+1; } code=rec_buffer.decoded&code_mask; code_mask=0; pre=rec_buffer.decoded>>remote->bits; gettimeofday(¤t,NULL); sum=remote->phead+remote->shead+ lirc_t_max(remote->pone+remote->sone, remote->pzero+remote->szero)* (remote->bits+ remote->pre_data_bits+ remote->post_data_bits)+ remote->plead+ remote->ptrail+ remote->pfoot+remote->sfoot+ remote->pre_p+remote->pre_s+ remote->post_p+remote->post_s; rec_buffer.sum=sum>=remote->gap ? remote->gap-1:sum; sync=time_elapsed(&remote->last_send,¤t)- rec_buffer.sum; } else { if(!get_lead(remote))
static int run(struct bladerf *dev, struct app_params *p, int16_t *samples, const struct test_case *t) { int status, status_out; struct bladerf_metadata meta; uint64_t timestamp; unsigned int gap; uint32_t counter; uint64_t tscount_diff; unsigned int i; bool suppress_overrun_msg = false; unsigned int overruns = 0; bool prev_iter_overrun = false; /* Clear out metadata and request that we just received any available * samples, with the timestamp filled in for us */ memset(&meta, 0, sizeof(meta)); meta.flags = BLADERF_META_FLAG_RX_NOW; status = enable_counter_mode(dev, true); if (status != 0) { goto out; } status = perform_sync_init(dev, BLADERF_MODULE_RX, 0, p); if (status != 0) { goto out; } /* Initial read to get a starting timestamp, and counter value */ gap = get_gap(p, t); status = bladerf_sync_rx(dev, samples, gap, &meta, p->timeout_ms); if (status != 0) { fprintf(stderr, "Intial RX failed: %s\n", bladerf_strerror(status)); goto out; } counter = extract_counter_val((uint8_t*) samples); timestamp = meta.timestamp; assert(timestamp >= (uint64_t) counter); tscount_diff = timestamp - (uint64_t) counter; if (t->gap != 0) { printf("\nTest Case: Read size=%"PRIu64" samples, %u iterations\n", t->gap, t->iterations); } else { printf("\nTest Case: Random read size, %u iterations\n", t->iterations); } printf("--------------------------------------------------------\n"); assert((timestamp - tscount_diff) <= UINT32_MAX); status = check_data(samples, &meta, UINT64_MAX, (uint32_t) (timestamp - tscount_diff), meta.actual_count, &suppress_overrun_msg); if (status == DETECTED_OVERRUN) { overruns++; status = 0; } printf("Timestamp-counter diff: %"PRIu64"\n", tscount_diff); printf("Initial timestamp: 0x%016"PRIx64"\n", meta.timestamp); printf("Intital counter value: 0x%08"PRIx32"\n", counter); printf("Initial status: 0x%08"PRIu32"\n", meta.status); for (i = 0; i < t->iterations && status == 0; i++) { timestamp = meta.timestamp + gap; gap = get_gap(p, t); status = bladerf_sync_rx(dev, samples, gap, &meta, p->timeout_ms); if (status != 0) { fprintf(stderr, "RX %u failed: %s\n", i, bladerf_strerror(status)); goto out; } /* If an overrun occured on the previous iteration, we don't know what * the timestamp will actually be on this iteration. */ if (prev_iter_overrun) { timestamp = meta.timestamp; } status = check_data(samples, &meta, timestamp, (uint32_t) (timestamp - tscount_diff), gap, &suppress_overrun_msg); if (status == DETECTED_OVERRUN) { overruns++; status = 0; prev_iter_overrun = true; } } if (status != 0) { printf("Test failed due to errors.\n"); } else if (overruns != 0) { printf("Test failed due to %u overruns.\n", overruns); status = -1; } else { printf("Test passed.\n"); } out: status_out = bladerf_enable_module(dev, BLADERF_MODULE_RX, false); if (status_out != 0) { fprintf(stderr, "Failed to disable RX module: %s\n", bladerf_strerror(status)); } status = first_error(status, status_out); status_out = enable_counter_mode(dev, false); status = first_error(status, status_out); return status; }