/** @method union( rect ) -> [x, y, w, h] @method union!( rect ) -> self Returns a new rectangle that completely covers the given rectangle(s). There may be an area inside the new rectangle that is not covered by the inputs. Rectangles are pre-normalized. */ static VALUE rb_array_union_bang(VALUE self, VALUE other_rect) { normalize(self); normalize(other_rect); { GET_X(); GET_Y(); GET_W(); GET_H(); double other_x=array_get_x(other_rect); double other_y=array_get_y(other_rect); double other_w=array_get_w(other_rect); double other_h=array_get_h(other_rect); double new_x=RUDL_MIN(x, other_x); double new_y=RUDL_MIN(y, other_y); SET_X( new_x ); SET_Y( new_y ); SET_W( RUDL_MAX(x+w, other_x+other_w)-new_x ); SET_H( RUDL_MAX(y+h, other_y+other_h)-new_y ); } return self; }
/** @method contains?( thing ) -> boolean Returns whether thing ([x, y, w, h] or [x, y]) fits completely within the rectangle. */ static VALUE rb_array_contains(VALUE self, VALUE thing) { GET_X(); GET_Y(); GET_W(); GET_H(); double x2,y2,w2,h2; Check_Type(thing, T_ARRAY); x2=array_get_x(thing); y2=array_get_y(thing); if(RARRAY(thing)->len>3){ // It's a rectangle w2=array_get_w(thing); h2=array_get_h(thing); return INT2BOOL((x <= x2) && (y <= y2) && (x + w >= x2 + w2) && (y + h >= y2 + h2) && (x + w > x2) && (y + h > y2)); }else{ // It's a point return INT2BOOL((x2>=x && x2<x+w && y2>=y && y2<y+h)); } return Qfalse; }
void dsim_reg_set_porch(struct decon_lcd *lcd) { u32 val, mask, width, height; if (lcd->mode == VIDEO_MODE) { val = DSIM_MVPORCH_CMD_ALLOW(DSIM_CMD_ALLOW_VALUE) | DSIM_MVPORCH_STABLE_VFP(DSIM_STABLE_VFP_VALUE) | DSIM_MVPORCH_VBP(lcd->vbp); mask = DSIM_MVPORCH_CMD_ALLOW_MASK | DSIM_MVPORCH_VBP_MASK | DSIM_MVPORCH_STABLE_VFP_MASK; dsim_write_mask(DSIM_MVPORCH, val, mask); val = DSIM_MHPORCH_HFP(lcd->hfp) | DSIM_MHPORCH_HBP(lcd->hbp); dsim_write(DSIM_MHPORCH, val); val = DSIM_MSYNC_VSA(lcd->vsa) | DSIM_MSYNC_HSA(lcd->hsa); mask = DSIM_MSYNC_VSA_MASK | DSIM_MSYNC_HSA_MASK; dsim_write_mask(DSIM_MSYNC, val, mask); } width = GET_W(lcd->hsync_2h_cycle, lcd->xres); height = GET_H(lcd->hsync_2h_cycle, lcd->yres); val = DSIM_MDRESOL_VRESOL(height) | DSIM_MDRESOL_HRESOL(width); mask = DSIM_MDRESOL_VRESOL_MASK | DSIM_MDRESOL_HRESOL_MASK; dsim_write_mask(DSIM_MDRESOL, val, mask); }
point transform(point v, float A[4][4]) { float v_f[] = {GET_X(v), GET_Y(v), GET_Z(v), GET_W(v)}; return std::make_tuple(dot_product(v_f, A[0]), dot_product(v_f, A[1]), dot_product(v_f, A[2]), dot_product(v_f, A[3])); }
/** @method same_size?( rect ) Returns whether @rect is the same area as @self. */ static VALUE rb_array_same_size(VALUE self, VALUE rect) { GET_X(); GET_Y(); GET_W(); GET_H(); if(self==rect){ return Qtrue; } Check_Type(rect, T_ARRAY); return(x==array_get_x(rect) && y==array_get_y(rect) && w==array_get_w(rect) && h==array_get_h(rect)); }
static VALUE rb_array_inflate_bang(VALUE self, VALUE size) { normalize(self); { GET_X(); GET_Y(); GET_W(); GET_H(); double dx=array_get_x(size); double dy=array_get_y(size); SET_X(x-dx/2); SET_Y(y-dy/2); SET_W(w+dx); SET_H(h+dy); } return self; }
__inline__ static void normalize(VALUE self) { GET_W(); GET_H(); if(w<0){ GET_X(); x=x+w; w=-w; SET_X(x); SET_W(w); } if(h<0){ GET_Y(); y=y+h; h=-h; SET_Y(y); SET_H(h); } }
/* * dsim main display configuration for window partial update * - w : width for partial update * - h : height for partial update * - mic_on : MIC_ENABLE (1) / MIC_DISABLE (0) */ void dsim_reg_set_win_update_conf(int w, int h, struct decon_lcd *lcd) { u32 val; u32 mask; w = GET_W(lcd->hsync_2h_cycle, w); h = GET_H(lcd->hsync_2h_cycle, h); /* Before setting config. disable standby */ mask = DSIM_MDRESOL_STAND_BY; val = 0; dsim_write_mask(DSIM_MDRESOL, val, mask); val = DSIM_MDRESOL_VRESOL(h) | DSIM_MDRESOL_HRESOL(w) | DSIM_MDRESOL_STAND_BY; mask = DSIM_MDRESOL_STAND_BY | DSIM_MDRESOL_VRESOL_MASK | DSIM_MDRESOL_HRESOL_MASK; dsim_write_mask(DSIM_MDRESOL, val, mask); }
void adns__procdgram(adns_state ads, const byte * dgram, int dglen, int serv, int viatcp, struct timeval now) { int cbyte, rrstart, wantedrrs, rri, foundsoa, foundns, cname_here; int id, f1, f2, qdcount, ancount, nscount, arcount; int flg_ra, flg_rd, flg_tc, flg_qr, opcode; int rrtype, rrclass, rdlength, rdstart; int anstart, nsstart, arstart; int ownermatched, l, nrrs; unsigned long ttl, soattl; const typeinfo *typei; adns_query qu, nqu; dns_rcode rcode; adns_status st; vbuf tempvb; byte *newquery, *rrsdata; parseinfo pai; if (dglen < DNS_HDRSIZE) { adns__diag(ads, serv, 0, "received datagram too short for message header (%d)", dglen); return; } cbyte = 0; GET_W(cbyte, id); GET_B(cbyte, f1); GET_B(cbyte, f2); GET_W(cbyte, qdcount); GET_W(cbyte, ancount); GET_W(cbyte, nscount); GET_W(cbyte, arcount); assert(cbyte == DNS_HDRSIZE); flg_qr = f1 & 0x80; opcode = (f1 & 0x78) >> 3; flg_tc = f1 & 0x02; flg_rd = f1 & 0x01; flg_ra = f2 & 0x80; rcode = (f2 & 0x0f); cname_here = 0; if (!flg_qr) { adns__diag(ads, serv, 0, "server sent us a query, not a response"); return; } if (opcode) { adns__diag(ads, serv, 0, "server sent us unknown opcode %d (wanted 0=QUERY)", opcode); return; } qu = 0; /* See if we can find the relevant query, or leave qu=0 otherwise ... */ if (qdcount == 1) { for (qu = viatcp ? ads->tcpw.head : ads->udpw.head; qu; qu = nqu) { nqu = qu->next; if (qu->id != id) continue; if (dglen < qu->query_dglen) continue; if (memcmp(qu->query_dgram + DNS_HDRSIZE, dgram + DNS_HDRSIZE, qu->query_dglen - DNS_HDRSIZE)) continue; if (viatcp) { assert(qu->state == query_tcpw); } else { assert(qu->state == query_tosend); if (!(qu->udpsent & (1 << serv))) continue; } break; } if (qu) { /* We're definitely going to do something with this query now */ if (viatcp) ALIST_UNLINK(ads->tcpw, qu); else ALIST_UNLINK(ads->udpw, qu); } } /* If we're going to ignore the packet, we return as soon as we have * failed the query (if any) and printed the warning message (if * any). */ switch (rcode) { case rcode_noerror: case rcode_nxdomain: break; case rcode_formaterror: adns__warn(ads, serv, qu, "server cannot understand our query (Format Error)"); if (qu) adns__query_fail(qu, adns_s_rcodeformaterror); return; case rcode_servfail: if (qu) adns__query_fail(qu, adns_s_rcodeservfail); else adns__debug(ads, serv, qu, "server failure on unidentifiable query"); return; case rcode_notimp: adns__warn(ads, serv, qu, "server claims not to implement our query"); if (qu) adns__query_fail(qu, adns_s_rcodenotimplemented); return; case rcode_refused: adns__debug(ads, serv, qu, "server refused our query"); if (qu) adns__query_fail(qu, adns_s_rcoderefused); return; default: adns__warn(ads, serv, qu, "server gave unknown response code %d", rcode); if (qu) adns__query_fail(qu, adns_s_rcodeunknown); return; } if (!qu) { if (!qdcount) { adns__diag(ads, serv, 0, "server sent reply without quoting our question"); } else if (qdcount > 1) { adns__diag(ads, serv, 0, "server claimed to answer %d questions with one message", qdcount); } else if (ads->iflags & adns_if_debug) { adns__vbuf_init(&tempvb); adns__debug(ads, serv, 0, "reply not found, id %02x, query owner %s", id, adns__diag_domain(ads, serv, 0, &tempvb, dgram, dglen, DNS_HDRSIZE)); adns__vbuf_free(&tempvb); } return; } /* We're definitely going to do something with this packet and this query now. */ anstart = qu->query_dglen; arstart = -1; /* Now, take a look at the answer section, and see if it is complete. * If it has any CNAMEs we stuff them in the answer. */ wantedrrs = 0; cbyte = anstart; for (rri = 0; rri < ancount; rri++) { rrstart = cbyte; st = adns__findrr(qu, serv, dgram, dglen, &cbyte, &rrtype, &rrclass, &ttl, &rdlength, &rdstart, &ownermatched); if (st) { adns__query_fail(qu, st); return; } if (rrtype == -1) goto x_truncated; if (rrclass != DNS_CLASS_IN) { adns__diag(ads, serv, qu, "ignoring answer RR with wrong class %d (expected IN=%d)", rrclass, DNS_CLASS_IN); continue; } if (!ownermatched) { if (ads->iflags & adns_if_debug) { adns__debug(ads, serv, qu, "ignoring RR with an unexpected owner %s", adns__diag_domain(ads, serv, qu, &qu->vb, dgram, dglen, rrstart)); } continue; } if (rrtype == adns_r_cname && (qu->typei->type & adns__rrt_typemask) != adns_r_cname) { if (qu->flags & adns_qf_cname_forbid) { adns__query_fail(qu, adns_s_prohibitedcname); return; } else if (qu->cname_dgram) { /* Ignore second and subsequent CNAME(s) */ adns__debug(ads, serv, qu, "allegedly canonical name %s is actually alias for %s", qu->answer->cname, adns__diag_domain(ads, serv, qu, &qu->vb, dgram, dglen, rdstart)); adns__query_fail(qu, adns_s_prohibitedcname); return; } else if (wantedrrs) { /* Ignore CNAME(s) after RR(s). */ adns__debug(ads, serv, qu, "ignoring CNAME (to %s) coexisting with RR", adns__diag_domain(ads, serv, qu, &qu->vb, dgram, dglen, rdstart)); } else { qu->cname_begin = rdstart; qu->cname_dglen = dglen; st = adns__parse_domain(ads, serv, qu, &qu->vb, qu-> flags & adns_qf_quotefail_cname ? 0 : pdf_quoteok, dgram, dglen, &rdstart, rdstart + rdlength); if (!qu->vb.used) goto x_truncated; if (st) { adns__query_fail(qu, st); return; } l = strlen((char *)qu->vb.buf) + 1; qu->answer->cname = adns__alloc_preserved(qu, l); if (!qu->answer->cname) { adns__query_fail(qu, adns_s_nomemory); return; } qu->cname_dgram = adns__alloc_mine(qu, dglen); os_memcpy(qu->cname_dgram, dgram, dglen); os_memcpy(qu->answer->cname, qu->vb.buf, l); cname_here = 1; adns__update_expires(qu, ttl, now); /* If we find the answer section truncated after this point we restart * the query at the CNAME; if beforehand then we obviously have to use * TCP. If there is no truncation we can use the whole answer if * it contains the relevant info. */ } } else if (rrtype == (qu->typei->type & adns__rrt_typemask)) { wantedrrs++; } else { adns__debug(ads, serv, qu, "ignoring answer RR with irrelevant type %d", rrtype); } } /* We defer handling truncated responses here, in case there was a CNAME * which we could use. */ if (flg_tc) goto x_truncated; nsstart = cbyte; if (!wantedrrs) { /* Oops, NODATA or NXDOMAIN or perhaps a referral (which would be a problem) */ /* RFC2308: NODATA has _either_ a SOA _or_ _no_ NS records in authority section */ foundsoa = 0; soattl = 0; foundns = 0; for (rri = 0; rri < nscount; rri++) { rrstart = cbyte; st = adns__findrr(qu, serv, dgram, dglen, &cbyte, &rrtype, &rrclass, &ttl, &rdlength, &rdstart, 0); if (st) { adns__query_fail(qu, st); return; } if (rrtype == -1) goto x_truncated; if (rrclass != DNS_CLASS_IN) { adns__diag(ads, serv, qu, "ignoring authority RR with wrong class %d (expected IN=%d)", rrclass, DNS_CLASS_IN); continue; } if (rrtype == adns_r_soa_raw) { foundsoa = 1; soattl = ttl; break; } else if (rrtype == adns_r_ns_raw) { foundns = 1; } } if (rcode == rcode_nxdomain) { /* We still wanted to look for the SOA so we could find the TTL. */ adns__update_expires(qu, soattl, now); if (qu->flags & adns_qf_search) { adns__search_next(ads, qu, now); } else { adns__query_fail(qu, adns_s_nxdomain); } return; } if (foundsoa || !foundns) { /* Aha ! A NODATA response, good. */ adns__update_expires(qu, soattl, now); adns__query_fail(qu, adns_s_nodata); return; } /* Now what ? No relevant answers, no SOA, and at least some NS's. * Looks like a referral. Just one last chance ... if we came across * a CNAME in this datagram then we should probably do our own CNAME * lookup now in the hope that we won't get a referral again. */ if (cname_here) goto x_restartquery; /* Bloody hell, I thought we asked for recursion ? */ if (!flg_ra) { adns__diag(ads, serv, qu, "server is not willing to do recursive lookups for us"); adns__query_fail(qu, adns_s_norecurse); } else { if (!flg_rd) adns__diag(ads, serv, qu, "server thinks we didn't ask for recursive lookup"); else adns__debug(ads, serv, qu, "server claims to do recursion, but gave us a referral"); adns__query_fail(qu, adns_s_invalidresponse); } return; } /* Now, we have some RRs which we wanted. */ qu->answer->rrs.untyped = adns__alloc_interim(qu, qu->typei->rrsz * wantedrrs); if (!qu->answer->rrs.untyped) { adns__query_fail(qu, adns_s_nomemory); return; } typei = qu->typei; cbyte = anstart; rrsdata = qu->answer->rrs.bytes; pai.ads = qu->ads; pai.qu = qu; pai.serv = serv; pai.dgram = dgram; pai.dglen = dglen; pai.nsstart = nsstart; pai.nscount = nscount; pai.arcount = arcount; pai.now = now; for (rri = 0, nrrs = 0; rri < ancount; rri++) { st = adns__findrr(qu, serv, dgram, dglen, &cbyte, &rrtype, &rrclass, &ttl, &rdlength, &rdstart, &ownermatched); assert(!st); assert(rrtype != -1); if (rrclass != DNS_CLASS_IN || rrtype != (qu->typei->type & adns__rrt_typemask) || !ownermatched) continue; adns__update_expires(qu, ttl, now); st = typei->parse(&pai, rdstart, rdstart + rdlength, rrsdata + nrrs * typei->rrsz); if (st) { adns__query_fail(qu, st); return; } if (rdstart == -1) goto x_truncated; nrrs++; } assert(nrrs == wantedrrs); qu->answer->nrrs = nrrs; /* This may have generated some child queries ... */ if (qu->children.head) { qu->state = query_childw; ALIST_LINK_TAIL(ads->childw, qu); return; } adns__query_done(qu); return; x_truncated: if (!flg_tc) { adns__diag(ads, serv, qu, "server sent datagram which points outside itself"); adns__query_fail(qu, adns_s_invalidresponse); return; } qu->flags |= adns_qf_usevc; x_restartquery: if (qu->cname_dgram) { st = adns__mkquery_frdgram(qu->ads, &qu->vb, &qu->id, qu->cname_dgram, qu->cname_dglen, qu->cname_begin, qu->typei->type, qu->flags); if (st) { adns__query_fail(qu, st); return; } newquery = ns_realloc(qu->query_dgram, qu->vb.used); if (!newquery) { adns__query_fail(qu, adns_s_nomemory); return; } qu->query_dgram = newquery; qu->query_dglen = qu->vb.used; os_memcpy(newquery, qu->vb.buf, qu->vb.used); } if (qu->state == query_tcpw) qu->state = query_tosend; qu->retries = 0; adns__reset_preserved(qu); adns__query_send(qu, now); }
adns_status adns__findrr_anychk(adns_query qu, int serv, const byte *dgram, int dglen, int *cbyte_io, int *type_r, int *class_r, unsigned long *ttl_r, int *rdlen_r, int *rdstart_r, const byte *eo_dgram, int eo_dglen, int eo_cbyte, int *eo_matched_r) { findlabel_state fls, eo_fls; int cbyte; int tmp, rdlen, mismatch; unsigned long ttl; int lablen, labstart, ch; int eo_lablen, eo_labstart, eo_ch; adns_status st; cbyte= *cbyte_io; adns__findlabel_start(&fls,qu->ads, serv,qu, dgram,dglen,dglen,cbyte,&cbyte); if (eo_dgram) { adns__findlabel_start(&eo_fls,qu->ads, -1,0, eo_dgram,eo_dglen,eo_dglen,eo_cbyte,0); mismatch= 0; } else { mismatch= 1; } for (;;) { st= adns__findlabel_next(&fls,&lablen,&labstart); if (st) return st; if (lablen<0) goto x_truncated; if (!mismatch) { st= adns__findlabel_next(&eo_fls,&eo_lablen,&eo_labstart); assert(!st); assert(eo_lablen>=0); if (lablen != eo_lablen) mismatch= 1; while (!mismatch && eo_lablen-- > 0) { ch= dgram[labstart++]; if (ctype_alpha(ch)) ch &= ~32; eo_ch= eo_dgram[eo_labstart++]; if (ctype_alpha(eo_ch)) eo_ch &= ~32; if (ch != eo_ch) mismatch= 1; } } if (!lablen) break; } if (eo_matched_r) *eo_matched_r= !mismatch; if (cbyte+10>dglen) goto x_truncated; GET_W(cbyte,tmp); *type_r= tmp; GET_W(cbyte,tmp); *class_r= tmp; GET_L(cbyte,ttl); if (ttl > MAXTTLBELIEVE) ttl= MAXTTLBELIEVE; *ttl_r= ttl; GET_W(cbyte,rdlen); if (rdlen_r) *rdlen_r= rdlen; if (rdstart_r) *rdstart_r= cbyte; cbyte+= rdlen; if (cbyte>dglen) goto x_truncated; *cbyte_io= cbyte; return adns_s_ok; x_truncated: *type_r= -1; return 0; }