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;
}
