void
GestureRecognizer::start(int x, int y)
{
ILOG_TRACE_F(ILX_GESTURE);
_moves.clear();
_path.clear();
_lastMove = -1;
_lastMoveTS = direct_clock_get_millis();
_preX = x;
_preY = y;
}
long long
fusion_get_millis()
{
struct timeval tv;
if (!_fusion_shared)
return direct_clock_get_millis();
gettimeofday( &tv, NULL );
return (tv.tv_sec - _fusion_shared->start_time.tv_sec) * 1000LL +
(tv.tv_usec - _fusion_shared->start_time.tv_usec) / 1000LL;
}
bool
FPSCalculator::funck()
{
long long diff;
long long now = direct_clock_get_millis();
_frames++;
diff = now - _fpsTime;
if (diff >= 1000)
{
_fps = _frames * 1000 / (float) (diff);
_fpsTime = now;
_frames = 0;
sigUpdated(_fps);
}
return true;
}
static void
handle_disconnect( VoodooManager *manager )
{
D_MAGIC_ASSERT( manager, VoodooManager );
if (0) {
int num;
long long millis = direct_clock_get_millis();
long long diff = millis - manager->millis;
num = manager->msg_count * 1000LL / diff;
D_INFO( "Voodoo/Manager: Average number of messages: %d.%03d k/sec\n", num / 1000, num % 1000 );
}
D_DEBUG( "Voodoo/Manager: Remote site disconnected from manager at %p!\n", manager );
voodoo_manager_quit( manager );
}
DFBResult
sawman_get_performance( SaWMan *sawman,
DFBWindowStackingClass stacking,
bool reset,
unsigned int *ret_updates,
unsigned long long *ret_pixels,
long long *ret_duration )
{
SaWManTier *tier;
long long now = direct_clock_get_millis();
sawman_lock( sawman );
tier = sawman_tier_by_class( sawman, stacking );
if (!tier) {
sawman_unlock( sawman );
return DFB_BUG;
}
if (ret_updates)
*ret_updates = tier->performance.updates;
if (ret_pixels)
*ret_pixels = tier->performance.pixels;
if (ret_duration)
*ret_duration = now - tier->performance.stamp;
if (reset) {
tier->performance.stamp = now;
tier->performance.updates = 0;
tier->performance.pixels = 0;
}
sawman_unlock( sawman );
return DFB_OK;
}
DirectResult
fusion_call_execute3(FusionCall *call,
FusionCallExecFlags flags,
int call_arg,
void *ptr,
unsigned int length,
void *ret_ptr,
unsigned int ret_size,
unsigned int *ret_length)
{
FusionWorld *world;
CallTLS *call_tls;
D_DEBUG_AT( Fusion_Call, "%s( %p, flags 0x%x, arg %d, ptr %p, length %u, ret_ptr %p, ret_size %u )\n",
__FUNCTION__, call, flags, call_arg, ptr, length, ret_ptr, ret_size );
if (ret_size > FUSION_CALL_RETURN_DATA_MAX)
return DR_LIMITEXCEEDED;
D_ASSERT( call != NULL );
// if (!call->handler)
// return DR_DESTROYED;
#if D_DEBUG_ENABLED
if (direct_log_domain_check( &Fusion_Call )) // avoid call to direct_trace_lookup_symbol_at
D_DEBUG_AT( Fusion_Call, " -> %s\n", direct_trace_lookup_symbol_at( call->handler3 ) );
#endif
world = _fusion_world( call->shared );
call_tls = Call_GetTLS( world );
if (call->fusion_id == fusion_id( world ) &&
(!(flags & FCEF_NODIRECT) || (call_tls->dispatcher)))
{
FusionCallHandlerResult result;
unsigned int execute_length;
D_ASSERT( call->handler3 != NULL );
result = call->handler3( call->fusion_id, call_arg, ptr, length, call->ctx, 0, ret_ptr, ret_size, &execute_length );
if (result != FCHR_RETURN)
D_WARN( "local call handler returned FCHR_RETAIN, need FCEF_NODIRECT" );
if (ret_length)
*ret_length = execute_length;
}
else {
FusionCallExecute3 execute;
DirectResult ret = DR_OK;
// check whether we can cache this call
if (flags & FCEF_QUEUE && fusion_config->call_bin_max_num > 0) {
D_ASSERT( flags & FCEF_ONEWAY );
if (call_tls->bins_data_len + length > fusion_config->call_bin_max_data) {
ret = fusion_world_flush_calls( world, 0 );
if (ret)
return ret;
}
call_tls->bins[call_tls->bins_num].call_id = call->call_id;
call_tls->bins[call_tls->bins_num].call_arg = call_arg;
call_tls->bins[call_tls->bins_num].ptr = NULL;
call_tls->bins[call_tls->bins_num].length = length;
call_tls->bins[call_tls->bins_num].ret_ptr = ret_ptr;
call_tls->bins[call_tls->bins_num].ret_length = ret_size;
call_tls->bins[call_tls->bins_num].flags = flags | FCEF_FOLLOW;
if (length > 0) {
call_tls->bins[call_tls->bins_num].ptr = &call_tls->bins_data[call_tls->bins_data_len];
direct_memcpy( &call_tls->bins_data[call_tls->bins_data_len], ptr, length );
call_tls->bins_data_len += length;
}
call_tls->bins_num++;
if (call_tls->bins_num == 1)
call_tls->bins_create_ts = direct_clock_get_millis();
else if (call_tls->bins_num >= fusion_config->call_bin_max_num || direct_clock_get_millis() - call_tls->bins_create_ts >= EXECUTE3_BIN_FLUSH_MILLIS)
ret = fusion_world_flush_calls( world, 0 );
return ret;
}
ret = fusion_world_flush_calls( world, 1 );
execute.call_id = call->call_id;
execute.call_arg = call_arg;
execute.ptr = ptr;
execute.length = length;
execute.ret_ptr = ret_ptr;
execute.ret_length = ret_size;
execute.flags = flags | FCEF_RESUMABLE;
execute.serial = 0;
D_DEBUG_AT( Fusion_Call, " -> ptr %p, length %u\n", ptr, length );
while (ioctl( world->fusion_fd, FUSION_CALL_EXECUTE3, &execute )) {
switch (errno) {
case EINTR:
continue;
case EINVAL:
D_ERROR ("Fusion/Call: invalid call (id 0x%08x)\n", call->call_id);
return DR_INVARG;
case EIDRM:
return DR_DESTROYED;
default:
break;
}
D_PERROR ("FUSION_CALL_EXECUTE3 (call id 0x%08x, creator %lu)", call->call_id, call->fusion_id );
return DR_FAILURE;
}
if (ret_length)
*ret_length = execute.ret_length;
}
return DR_OK;
}
FPSCalculator::FPSCalculator()
: _frames(0),
_fps(0),
_fpsTime(direct_clock_get_millis())
{
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
bool quit = false;
Test test;
memset( &test, 0, sizeof(test) );
ret = Initialize( &test, &argc, &argv );
if (ret)
goto error;
ret = InitGL( &test );
if (ret)
goto error;
/*
* Main Loop
*/
while (!quit) {
static int frames = 0;
static double tRot0 = -1.0, tRate0 = -1.0;
double dt, t = direct_clock_get_millis() / 1000.0;
if (tRot0 < 0.0)
tRot0 = t;
dt = t - tRot0;
tRot0 = t;
/* advance rotation for next frame */
angle += 70.0 * dt; /* 70 degrees per second */
if (angle > 3600.0)
angle -= 3600.0;
ret = RenderGL( &test );
if (ret)
goto error;
/*
* Show the rendered buffer
*/
test.primary->Flip( test.primary, NULL, DSFLIP_ONSYNC );
frames++;
if (tRate0 < 0.0)
tRate0 = t;
if (t - tRate0 >= 5.0) {
GLfloat seconds = t - tRate0;
GLfloat fps = frames / seconds;
printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
fps);
tRate0 = t;
frames = 0;
}
DFBInputEvent evt;
/*
* Process events
*/
while (test.events->GetEvent( test.events, DFB_EVENT(&evt) ) == DFB_OK) {
switch (evt.type) {
case DIET_KEYPRESS:
switch (evt.key_symbol) {
case DIKS_ESCAPE:
quit = true;
break;
case DIKS_CURSOR_UP:
inc_rotx = 5.0;
break;
case DIKS_CURSOR_DOWN:
inc_rotx = -5.0;
break;
case DIKS_CURSOR_LEFT:
inc_roty = 5.0;
break;
case DIKS_CURSOR_RIGHT:
inc_roty = -5.0;
break;
case DIKS_PAGE_UP:
inc_rotz = 5.0;
break;
case DIKS_PAGE_DOWN:
inc_rotz = -5.0;
break;
default:
;
}
break;
case DIET_KEYRELEASE:
switch (evt.key_symbol) {
case DIKS_CURSOR_UP:
inc_rotx = 0;
break;
case DIKS_CURSOR_DOWN:
inc_rotx = 0;
break;
case DIKS_CURSOR_LEFT:
inc_roty = 0;
break;
case DIKS_CURSOR_RIGHT:
inc_roty = 0;
break;
case DIKS_PAGE_UP:
inc_rotz = 0;
break;
case DIKS_PAGE_DOWN:
inc_rotz = 0;
break;
default:
;
}
break;
case DIET_AXISMOTION:
if (evt.flags & DIEF_AXISREL) {
switch (evt.axis) {
case DIAI_X:
view_rot[1] += evt.axisrel / 2.0;
break;
case DIAI_Y:
view_rot[0] += evt.axisrel / 2.0;
break;
case DIAI_Z:
view_rot[2] += evt.axisrel / 2.0;
break;
default:
;
}
}
break;
default:
;
}
}
view_rot[0] += inc_rotx;
view_rot[1] += inc_roty;
view_rot[2] += inc_rotz;
}
error:
Shutdown( &test );
return ret;
}
long long
fusion_get_millis()
{
return direct_clock_get_millis();
}
static void *
manager_input_loop( DirectThread *thread, void *arg )
{
int len;
struct pollfd pf;
VoodooManager *manager = arg;
manager->millis = direct_clock_get_millis();
while (!manager->quit) {
D_MAGIC_ASSERT( manager, VoodooManager );
pf.fd = manager->fd;
pf.events = POLLIN;
switch (poll( &pf, 1, 100 )) {
case -1:
if (errno != EINTR) {
D_PERROR( "Voodoo/Input: Could not poll() the socket!\n" );
usleep( 200000 );
}
/* fall through */
case 0:
continue;
}
pthread_mutex_lock( &manager->input.lock );
while (manager->input.end == manager->input.max) {
pthread_cond_wait( &manager->input.wait, &manager->input.lock );
if (manager->quit)
break;
}
if (!manager->quit) {
len = recv( manager->fd, manager->input.buffer + manager->input.end,
manager->input.max - manager->input.end, MSG_DONTWAIT );
if (len < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
break;
default:
D_PERROR( "Voodoo/Input: Could not recv() data!\n" );
usleep( 200000 );
}
}
else if (len > 0) {
D_DEBUG( "Voodoo/Input: Received %d bytes...\n", len );
manager->input.end += len;
pthread_cond_broadcast( &manager->input.wait );
}
else
handle_disconnect( manager );
}
pthread_mutex_unlock( &manager->input.lock );
}
return NULL;
}
