/*
* FFT128
* Input in [-128,383]
* Outut in [-128,128]
*
*/
static inline void fft128(void *a) {
int i;
// Temp space to help for interleaving in the end
v16 B[8];
v16 *A = (v16*) a;
// v16 *Twiddle = (v16*)FFT128_Twiddle;
/* Size-2 butterflies */
for (i = 0; i<8; i++) {
B[i] = v16_add(A[i], A[i+8]);
A[i+8] = v16_sub(A[i], A[i+8]);
A[i+8] = REDUCE_FULL_S(A[i+8]);
A[i+8] = v16_mul(A[i+8], FFT128_Twiddle[i].v16);
A[i+8] = REDUCE(A[i+8]);
}
B[3] = REDUCE(B[3]);
B[7] = REDUCE(B[7]);
fft64(B);
fft64(A+8);
/* Transpose (i.e. interleave) */
#ifdef v16_interleave_inplace
v16 *A1=A+8, *B1=B;
for (i=0; i<8; i++) {
A[2*i] = *(B1++);
A[2*i+1] = *(A1++);
v16_interleave_inplace(A[2*i],A[2*i+1]);
}
#else
for (i=0; i<8; i++) {
A[2*i] = v16_interleavel (B[i], A[i+8]);
A[2*i+1] = v16_interleaveh (B[i], A[i+8]);
}
#endif
}
static void add_to_history(pa_smoother *s, uint64_t x, uint64_t y) {
unsigned j, i;
pa_assert(s);
/* First try to update an existing history entry */
i = s->history_idx;
for (j = s->n_history; j > 0; j--) {
if (s->history_x[i] == x) {
s->history_y[i] = y;
return;
}
REDUCE_INC(i);
}
/* Drop old entries */
drop_old(s, x);
/* Calculate position for new entry */
j = s->history_idx + s->n_history;
REDUCE(j);
/* Fill in entry */
s->history_x[j] = x;
s->history_y[j] = y;
/* Adjust counter */
s->n_history ++;
/* And make sure we don't store more entries than fit in */
if (s->n_history > HISTORY_MAX) {
s->history_idx += s->n_history - HISTORY_MAX;
REDUCE(s->history_idx);
s->n_history = HISTORY_MAX;
}
}
void
mainwin_update_background(MainWin *mw)
{
Pixmap dummy = wm_get_root_pmap(mw->dpy);
Window dummy_root;
int x, y;
unsigned int root_w, root_h, border_width, depth;
XGetGeometry(mw->dpy, mw->root, &dummy_root, &x, &y, &root_w, &root_h, &border_width, &depth);
if(mw->background != 0)
{
imlib_context_set_image(mw->background);
imlib_free_image();
}
if(dummy != None)
{
unsigned int width, height;
mw->background = imlib_create_image(root_w, root_h);
imlib_context_set_image(mw->background);
XGetGeometry(mw->dpy, dummy, &dummy_root, &x, &y, &width, &height, &border_width, &depth);
imlib_context_set_drawable(dummy);
imlib_copy_drawable_to_image(0, 0, 0, width, height, 0, 0, 1);
for(x = 1; x < (int)ceil((double)root_w / width); ++x)
imlib_image_copy_rect(0, 0, width, height, x * width, 0);
for(y = 1; y < (int)ceil((double)root_h / height); ++y)
imlib_image_copy_rect(0, 0, root_w, height, 0, y * height);
}
else
{
mw->background = imlib_create_image(root_w, root_h);
imlib_context_set_image(mw->background);
imlib_image_clear();
}
mainwin_update_bg_pixmap(mw);
REDUCE(clientwin_render((ClientWin*)iter->data), mw->cod);
}
void fb_mulm_low(dig_t *c, dig_t *a, dig_t *b) {
__m128i ma0, ma1, mb0, mb1, m0, m1, m2, m3, m4, m5, m8, m9, t0, t1, t2, t3;
ma0 = _mm_load_si128((__m128i *)a);
mb0 = _mm_load_si128((__m128i *)b);
MUL(ma0, mb0);
m0 = t0;
m1 = t1;
ma1 = _mm_load_si128((__m128i *)a + 1);
mb1 = _mm_load_si128((__m128i *)b + 1);
MUL(ma1, mb1);
m2 = t0;
m3 = t1;
ma0 = XOR(ma0, ma1);
mb0 = XOR(mb0, mb1);
MUL(ma0, mb0);
m4 = t0;
m5 = t1;
m4 = _mm_xor_si128(m4, m0);
m5 = _mm_xor_si128(m5, m1);
m4 = _mm_xor_si128(m4, m2);
m5 = _mm_xor_si128(m5, m3);
m1 = XOR(m1, m4);
m2 = XOR(m2, m5);
align dig_t _x[2];
REDUCE();
_mm_store_si128((__m128i *) c + 0, m0);
_mm_store_si128((__m128i *) _x, m1);
c[2] = _x[0];
c[3] = _x[1] & 0x07FFFFFFFFFFFFFF;
return;
}
void fb_sqrm_low(dig_t *c, const dig_t *a) {
__m128i t0, t1, m0, m1, m2, m3, m4, m5, m6, m8, m9, mask;
align dig_t x[2];
t0 = _mm_set_epi32(0x55545150, 0x45444140, 0x15141110, 0x05040100);
mask = _mm_set_epi32(0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F);
m0 = _mm_load_si128((__m128i *)(a));
m1 = _mm_and_si128(m0, mask);
m1 = _mm_shuffle_epi8(t0, m1);
m2 = _mm_srli_epi64(m0, 4);
m2 = _mm_and_si128(m2, mask);
m2 = _mm_shuffle_epi8(t0, m2);
m3 = _mm_unpacklo_epi8(m1, m2);
m4 = _mm_unpackhi_epi8(m1, m2);
m0 = _mm_load_si128((__m128i *)(a+2));
m1 = _mm_and_si128(m0, mask);
m1 = _mm_shuffle_epi8(t0, m1);
m2 = _mm_srli_epi64(m0, 4);
m2 = _mm_and_si128(m2, mask);
m2 = _mm_shuffle_epi8(t0, m2);
m5 = _mm_unpacklo_epi8(m1, m2);
m6 = _mm_unpackhi_epi8(m1, m2);
m0 = m3;
m1 = m4;
m2 = m5;
m3 = m6;
REDUCE();
_mm_store_si128((__m128i *) c + 0, m0);
_mm_store_si128((__m128i *) x, m1);
c[2] = x[0];
c[3] = x[1] & 0x07FFFFFFFFFFFFFF;
}
}
static TSStateId ts_lex_states[STATE_COUNT] = {
[0] = 1,
[1] = 12,
[2] = 12,
};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym_program] = ACTIONS(SHIFT(1)),
[anon_sym_LF] = ACTIONS(SHIFT(2)),
[anon_sym_CR] = ACTIONS(SHIFT(2)),
[aux_sym_SLASH_BSLASHd_SLASH] = ACTIONS(SHIFT(2)),
[anon_sym_DQUOTEhello_DQUOTE] = ACTIONS(SHIFT(2)),
},
[1] = {
[ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
},
};
#pragma GCC diagnostic pop
EXPORT_LANGUAGE(ts_language_anonymous_tokens);
static dlist *
skippy_run(MainWin *mw, dlist *clients, int force, Window focus, Window leader, Bool all_xin)
{
unsigned int width, height, tree_count, u;
float factor;
int xoff, yoff;
XEvent ev;
int die = 0;
dlist *iter, *tmp;
Window dummy_w, *tree_windows;
CARD32 desktop = wm_get_current_desktop(mw->dpy);
Bool refocus = False;
/* Update the main window's geometry (and Xinerama info if applicable) */
mainwin_update(mw);
#ifdef XINERAMA
if(all_xin)
mw->xin_active = 0;
#else /* ! XINERAMA */
if(all_xin);
#endif /* XINERAMA */
/* Update the client table, pick the ones we want and sort them */
clients = update_clients(mw, clients);
tmp = dlist_first(dlist_find_all(clients, (dlist_match_func)clientwin_validate_func, &desktop));
if(leader != None)
{
mw->cod = dlist_first(dlist_find_all(tmp, clientwin_check_group_leader_func, (void*)&leader));
dlist_free(tmp);
} else
mw->cod = tmp;
if(! mw->cod)
return clients;
dlist_sort(mw->cod, clientwin_sort_func, 0);
/* Move the mini windows around */
layout_run(mw, mw->cod, &width, &height);
factor = (float)(mw->width - 100) / width;
if(factor * height > mw->height - 100)
factor = (float)(mw->height - 100) / height;
xoff = (mw->width - (float)width * factor) / 2;
yoff = (mw->height - (float)height * factor) / 2;
for(iter = mw->cod; iter; iter = iter->next)
clientwin_move((ClientWin*)iter->data, factor, xoff, yoff);
/* Get the currently focused window and select which mini-window to focus */
iter = dlist_find(mw->cod, clientwin_cmp_func, (void *)focus);
if(! iter)
iter = mw->cod;
mw->focus = (ClientWin*)iter->data;
mw->focus->focused = 1;
/* Save the stacking tree */
XQueryTree(mw->dpy, mw->root, &dummy_w, &dummy_w, &tree_windows, &tree_count);
mw->stack_touched = False;
/* Map the client windows */
for(iter = mw->cod; iter; iter = iter->next)
clientwin_map((ClientWin*)iter->data, force);
XWarpPointer(mw->dpy, None, mw->focus->mini.window, 0, 0, 0, 0, mw->focus->mini.width / 2, mw->focus->mini.height / 2);
/* Restore the stacking order (using XRestackWindows seems like a bad idea) */
if(mw->stack_touched)
for(u = 0; u < tree_count; ++u)
XRaiseWindow(mw->dpy, tree_windows[u]);
XFree(tree_windows);
/* Map the main window and run our event loop */
mainwin_map(mw);
while(! die) {
XNextEvent(mw->dpy, &ev);
if(ev.type == KeyRelease && ev.xkey.keycode == mw->key_q) {
DIE_NOW = 1;
break;
}
else if(ev.type == DestroyNotify || ev.type == UnmapNotify) {
dlist *iter = dlist_find(clients, clientwin_cmp_func, (void *)ev.xany.window);
if(iter)
{
ClientWin *cw = (ClientWin *)iter->data;
clients = dlist_first(dlist_remove(iter));
iter = dlist_find(mw->cod, clientwin_cmp_func, (void *)ev.xany.window);
if(iter)
mw->cod = dlist_first(dlist_remove(iter));
clientwin_destroy(cw);
if(! mw->cod)
{
die = 1;
break;
}
}
}
else if(ev.xany.window == mw->window)
die = mainwin_handle(mw, &ev);
else if(ev.type == PropertyNotify && (ev.xproperty.atom == ESETROOT_PMAP_ID || ev.xproperty.atom == _XROOTPMAP_ID))
mainwin_update_background(mw);
else if(mw->tooltip && ev.xany.window == mw->tooltip->window)
tooltip_handle(mw->tooltip, &ev);
else if(ev.type == KeyRelease && ev.xkey.keycode == mw->key_escape)
{
refocus = True;
break;
}
else
{
dlist *iter;
for(iter = mw->cod; iter; iter = iter->next)
{
ClientWin *cw = (ClientWin *)iter->data;
if(cw->mini.window == ev.xany.window)
{
die = clientwin_handle(cw, &ev);
break;
}
}
}
}
/* Unmap the main window and clean up */
mainwin_unmap(mw);
XFlush(mw->dpy);
REDUCE(clientwin_unmap((ClientWin*)iter->data), mw->cod);
dlist_free(mw->cod);
mw->cod = 0;
if(die == 2)
DIE_NOW = 1;
if(refocus)
XSetInputFocus(mw->dpy, focus, RevertToPointerRoot, CurrentTime);
return clients;
}
static void
parse_main(struct cparse_params *v, VALUE tok, VALUE val, int resume)
{
long i; /* table index */
long act; /* action type */
VALUE act_value; /* action type, VALUE version */
int read_next = 1; /* true if we need to read next token */
VALUE tmp;
if (resume)
goto resume;
while (1) {
D_puts("");
D_puts("---- enter new loop ----");
D_puts("");
D_printf("(act) k1=%ld\n", v->curstate);
tmp = AREF(v->action_pointer, v->curstate);
if (NIL_P(tmp)) goto notfound;
D_puts("(act) pointer[k1] ok");
i = NUM2LONG(tmp);
D_printf("read_next=%d\n", read_next);
if (read_next && (v->t != vFINAL_TOKEN)) {
if (v->lex_is_iterator) {
D_puts("resuming...");
if (v->fin) rb_raise(rb_eArgError, "token given after EOF");
v->i = i; /* save i */
return;
resume:
D_puts("resumed");
i = v->i; /* load i */
}
else {
D_puts("next_token");
tmp = rb_funcall(v->parser, id_nexttoken, 0);
extract_user_token(v, tmp, &tok, &val);
}
/* convert token */
v->t = rb_hash_aref(v->token_table, tok);
if (NIL_P(v->t)) {
v->t = vERROR_TOKEN;
}
D_printf("(act) t(k2)=%ld\n", NUM2LONG(v->t));
if (v->debug) {
rb_funcall(v->parser, id_d_read_token,
3, v->t, tok, val);
}
}
read_next = 0;
i += NUM2LONG(v->t);
D_printf("(act) i=%ld\n", i);
if (i < 0) goto notfound;
act_value = AREF(v->action_table, i);
if (NIL_P(act_value)) goto notfound;
act = NUM2LONG(act_value);
D_printf("(act) table[i]=%ld\n", act);
tmp = AREF(v->action_check, i);
if (NIL_P(tmp)) goto notfound;
if (NUM2LONG(tmp) != v->curstate) goto notfound;
D_printf("(act) check[i]=%ld\n", NUM2LONG(tmp));
D_puts("(act) found");
act_fixed:
D_printf("act=%ld\n", act);
goto handle_act;
notfound:
D_puts("(act) not found: use default");
act_value = AREF(v->action_default, v->curstate);
act = NUM2LONG(act_value);
goto act_fixed;
handle_act:
if (act > 0 && act < v->shift_n) {
D_puts("shift");
if (v->errstatus > 0) {
v->errstatus--;
rb_ivar_set(v->parser, id_errstatus, LONG2NUM(v->errstatus));
}
SHIFT(v, act, v->t, val);
read_next = 1;
}
else if (act < 0 && act > -(v->reduce_n)) {
D_puts("reduce");
REDUCE(v, act);
}
else if (act == -(v->reduce_n)) {
goto error;
error_recovered:
; /* goto label requires stmt */
}
else if (act == v->shift_n) {
D_puts("accept");
goto accept;
}
else {
rb_raise(RaccBug, "[Racc Bug] unknown act value %ld", act);
}
if (v->debug) {
rb_funcall(v->parser, id_d_next_state,
2, LONG2NUM(v->curstate), v->state);
}
}
/* not reach */
accept:
if (v->debug) rb_funcall(v->parser, id_d_accept, 0);
v->retval = RARRAY_PTR(v->vstack)[0];
v->fin = CP_FIN_ACCEPT;
return;
error:
D_printf("error detected, status=%ld\n", v->errstatus);
if (v->errstatus == 0) {
v->nerr++;
rb_funcall(v->parser, id_onerror,
3, v->t, val, v->vstack);
}
user_yyerror:
if (v->errstatus == 3) {
if (v->t == vFINAL_TOKEN) {
v->retval = Qfalse;
v->fin = CP_FIN_EOT;
return;
}
read_next = 1;
}
v->errstatus = 3;
rb_ivar_set(v->parser, id_errstatus, LONG2NUM(v->errstatus));
/* check if we can shift/reduce error token */
D_printf("(err) k1=%ld\n", v->curstate);
D_printf("(err) k2=%d (error)\n", ERROR_TOKEN);
while (1) {
tmp = AREF(v->action_pointer, v->curstate);
if (NIL_P(tmp)) goto error_pop;
D_puts("(err) pointer[k1] ok");
i = NUM2LONG(tmp) + ERROR_TOKEN;
D_printf("(err) i=%ld\n", i);
if (i < 0) goto error_pop;
act_value = AREF(v->action_table, i);
if (NIL_P(act_value)) {
D_puts("(err) table[i] == nil");
goto error_pop;
}
act = NUM2LONG(act_value);
D_printf("(err) table[i]=%ld\n", act);
tmp = AREF(v->action_check, i);
if (NIL_P(tmp)) {
D_puts("(err) check[i] == nil");
goto error_pop;
}
if (NUM2LONG(tmp) != v->curstate) {
D_puts("(err) check[i] != k1");
goto error_pop;
}
D_puts("(err) found: can handle error token");
break;
error_pop:
D_puts("(err) act not found: can't handle error token; pop");
if (RARRAY_LEN(v->state) <= 1) {
v->retval = Qnil;
v->fin = CP_FIN_CANTPOP;
return;
}
POP(v->state);
POP(v->vstack);
v->curstate = num_to_long(LAST_I(v->state));
if (v->debug) {
POP(v->tstack);
rb_funcall(v->parser, id_d_e_pop,
3, v->state, v->tstack, v->vstack);
}
}
/* shift/reduce error token */
if (act > 0 && act < v->shift_n) {
D_puts("e shift");
SHIFT(v, act, ERROR_TOKEN, val);
}
else if (act < 0 && act > -(v->reduce_n)) {
D_puts("e reduce");
REDUCE(v, act);
}
else if (act == v->shift_n) {
D_puts("e accept");
goto accept;
}
else {
rb_raise(RaccBug, "[Racc Bug] unknown act value %ld", act);
}
goto error_recovered;
}
static dlist *
skippy_run(MainWin *mw, dlist *clients, Window focus, Window leader, Bool all_xin)
{
XEvent ev;
int die = 0;
Bool refocus = False;
int last_rendered;
/* Update the main window's geometry (and Xinerama info if applicable) */
mainwin_update(mw);
#ifdef XINERAMA
if(all_xin)
mw->xin_active = 0;
#else /* ! XINERAMA */
if(all_xin);
#endif /* XINERAMA */
/* Map the main window and run our event loop */
if(mw->lazy_trans)
{
mainwin_map(mw);
XFlush(mw->dpy);
}
clients = do_layout(mw, clients, focus, leader);
if(! mw->cod)
return clients;
/* Map the main window and run our event loop */
if(! mw->lazy_trans)
mainwin_map(mw);
last_rendered = time_in_millis();
while(! die) {
int i, j, now, timeout;
int move_x = -1, move_y = -1;
struct pollfd r_fd;
XFlush(mw->dpy);
r_fd.fd = ConnectionNumber(mw->dpy);
r_fd.events = POLLIN;
if(mw->poll_time > 0)
timeout = MAX(0, mw->poll_time + last_rendered - time_in_millis());
else
timeout = -1;
i = poll(&r_fd, 1, timeout);
now = time_in_millis();
if(now >= last_rendered + mw->poll_time)
{
REDUCE(if( ((ClientWin*)iter->data)->damaged ) clientwin_repair(iter->data), mw->cod);
last_rendered = now;
}
i = XPending(mw->dpy);
for(j = 0; j < i; ++j)
{
XNextEvent(mw->dpy, &ev);
if (ev.type == MotionNotify)
{
move_x = ev.xmotion.x_root;
move_y = ev.xmotion.y_root;
}
else if(ev.type == DestroyNotify || ev.type == UnmapNotify) {
dlist *iter = dlist_find(clients, clientwin_cmp_func, (void *)ev.xany.window);
if(iter)
{
ClientWin *cw = (ClientWin *)iter->data;
clients = dlist_first(dlist_remove(iter));
iter = dlist_find(mw->cod, clientwin_cmp_func, (void *)ev.xany.window);
if(iter)
mw->cod = dlist_first(dlist_remove(iter));
clientwin_destroy(cw, True);
if(! mw->cod)
{
die = 1;
break;
}
}
}
else if (mw->poll_time >= 0 && ev.type == mw->damage_event_base + XDamageNotify)
{
XDamageNotifyEvent *d_ev = (XDamageNotifyEvent *)&ev;
dlist *iter = dlist_find(mw->cod, clientwin_cmp_func, (void *)d_ev->drawable);
if(iter)
{
if(mw->poll_time == 0)
clientwin_repair((ClientWin *)iter->data);
else
((ClientWin *)iter->data)->damaged = True;
}
}
else if(ev.type == KeyRelease && ev.xkey.keycode == mw->key_q)
{
DIE_NOW = 1;
die = 1;
break;
}
else if(ev.type == KeyRelease && ev.xkey.keycode == mw->key_escape)
{
refocus = True;
die = 1;
break;
}
else if(ev.xany.window == mw->window)
die = mainwin_handle(mw, &ev);
else if(ev.type == PropertyNotify)
{
if(ev.xproperty.atom == ESETROOT_PMAP_ID || ev.xproperty.atom == _XROOTPMAP_ID)
{
mainwin_update_background(mw);
REDUCE(clientwin_render((ClientWin *)iter->data), mw->cod);
}
}
else if(mw->tooltip && ev.xany.window == mw->tooltip->window)
tooltip_handle(mw->tooltip, &ev);
else
{
dlist *iter;
for(iter = mw->cod; iter; iter = iter->next)
{
ClientWin *cw = (ClientWin *)iter->data;
if(cw->mini.window == ev.xany.window)
{
die = clientwin_handle(cw, &ev);
if(die)
break;
}
}
if(die)
break;
}
}
if(mw->tooltip && move_x != -1)
tooltip_move(mw->tooltip, move_x + 20, move_y + 20);
}
