void variable_intersection::populate_self(const app * a)
{
SASSERT(is_uninterp(a));
//TODO: optimize quadratic complexity
//TODO: optimize number of checks when variable occurs multiple times
unsigned arity = a->get_num_args();
for(unsigned i1=0; i1<arity; i1++) {
expr * e1=a->get_arg(i1);
if(is_var(e1)) {
var* v1=to_var(e1);
for(unsigned i2=i1+1; i2<arity; i2++) {
expr * e2=a->get_arg(i2);
if(!is_var(e2)) {
continue;
}
var* v2=to_var(e2);
if(v1->get_idx()==v2->get_idx()) {
add_pair(i1, i2);
}
}
}
else {
SASSERT(is_app(e1));
app * c1 = to_app(e1);
SASSERT(c1->get_num_args()==0); //c1 must be a constant
m_const_indexes.push_back(i1);
m_consts.push_back(c1);
SASSERT(m_const_indexes.size()==m_consts.size());
}
}
}
void StandardEstimator::correlate(ChainingMesh& mesh1, ChainingMesh& mesh2, array& paircount, double vmax) {
/* Iterate over cells in mesh 1... */
for(vector<Cell>::iterator c1 = mesh1.cells.begin(); c1 != mesh1.cells.end(); c1++) {
Particle* p1begin = &mesh1.particles[c1->start];
Particle* p1end = p1begin + c1->count;
if(p1begin == p1end)
continue;
/* ... and cells in mesh 2 */
for(vector<Cell>::iterator c2 = mesh2.cells.begin(); c2 != mesh2.cells.end(); c2++) {
Particle* p2begin = &mesh2.particles[c2->start];
Particle* p2end = p2begin + c2->count;
if(p2begin == p2end)
continue;
/* Check distance between cells, and compare it to the maximum
* separation that we actually care about */
if(cell_separation(*c1, *c2, L, L, inf) > smax + 2*vmax)
continue;
/* Correlate particles within these cells */
for(Particle* p1 = p1begin; p1 < p1end; p1++)
for(Particle* p2 = p2begin; p2 < p2end; p2++)
add_pair(*p1, *p2, paircount);
}
}
}
static void
fix_diff_singleton(struct saucy *s, int cf)
{
int r = s->right.lab[cf];
int l = s->left.lab[cf];
int rcfl;
if (!s->right.clen[cf] && r != l) {
/* Make sure diff is marked */
add_diff(s, r);
/* It is now undiffed since it is singleton */
++s->nundiffs;
remove_diffnon(s, r);
/* Mark the other if not singleton already */
rcfl = s->right.cfront[l];
if (s->right.clen[rcfl]) {
add_diff(s, l);
/* Check for pairs */
if (in_cell_range(&s->right, s->left.unlab[r], rcfl)) {
add_pair(s, l);
}
}
/* Otherwise we might be eating a pair */
else if (is_a_pair(s, r)) {
eat_pair(s, r);
}
}
}
int main(int argc, char * argv[]){
pair_t ** pairs = new_pairs(); //create a new pair array
add_pair(pairs, 2, 10); //assign a new pair
add_pair(pairs, 0, 3); //assign a new pair
add_pair(pairs, 13, 7);
print_pairs(pairs); //print pairs
rm_pair(pairs, 1); //remove pair at index 1
printf("------------\n");
print_pairs(pairs); //print pairs (again)
delete_pairs(pairs); //delete all pairs, no memleaks!
return 0;
}
static void tst18() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(2);
add_pair(m, d1, 1112, 1290, 1302, 1302);
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_swap(d1, d2, 0);
std::cout << "mk_swap 0:\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
void StandardEstimator::self_correlate(ChainingMesh& mesh, array& paircount, double vmax) {
/* Iterate over pairs of distinct cells within the ChainingMesh */
for(vector<Cell>::iterator c1 = mesh.cells.begin(); c1 != mesh.cells.end(); c1++) {
Particle* p1begin = &mesh.particles[c1->start];
Particle* p1end = p1begin + c1->count;
if(p1begin == p1end)
continue;
for(vector<Cell>::iterator c2 = c1+1; c2 != mesh.cells.end(); c2++) {
Particle* p2begin = &mesh.particles[c2->start];
Particle* p2end = p2begin + c2->count;
if(p2begin == p2end)
continue;
/* Check distance between cells, and compare it to the maximum
* r that we actually care about */
if(cell_separation(*c1, *c2, L, L, inf) > smax + 2*vmax)
continue;
/* Correlate particles within these cells */
for(Particle* p1 = p1begin; p1 < p1end; p1++)
for(Particle* p2 = p2begin; p2 < p2end; p2++)
add_pair(*p1, *p2, paircount);
}
}
/* Now count pairs of distinct particles from within the same cell */
for(vector<Cell>::iterator c = mesh.cells.begin(); c != mesh.cells.end(); c++) {
Particle* pbegin = &mesh.particles[c->start];
Particle* pend = pbegin + c->count;
if(pbegin == pend)
continue;
for(Particle* p1 = pbegin; p1 != pend; p1++)
for(Particle* p2 = p1+1; p2 != pend; p2++)
add_pair(*p1, *p2, paircount);
}
}
/**
* Set name => address hint.
*
* Input: { name, address }
* Output: { result: bool }
*
*/
static char* hint_set(void *env, struct kr_module *module, const char *args)
{
struct kr_zonecut *hints = module->data;
auto_free char *args_copy = strdup(args);
int ret = -1;
char *addr = strchr(args_copy, ' ');
if (addr) {
*addr = '\0';
ret = add_pair(hints, args_copy, addr + 1);
}
char *result = NULL;
asprintf(&result, "{ \"result\": %s", ret == 0 ? "true" : "false");
return result;
}
/**
* Get/set root hints set.
*
* Input: { name: [addr_list], ... }
* Output: current list
*
*/
static char* hint_root(void *env, struct kr_module *module, const char *args)
{
struct engine *engine = env;
struct kr_context *ctx = &engine->resolver;
/* Replace root hints if parameter is set */
if (args && strlen(args) > 0) {
JsonNode *node = NULL;
JsonNode *root_node = json_decode(args);
kr_zonecut_set(&ctx->root_hints, (const uint8_t *)"");
json_foreach(node, root_node) {
switch(node->tag) {
case JSON_STRING: add_pair(&ctx->root_hints, node->key, node->string_); break;
default: continue;
}
}
json_delete(root_node);
}
int ColInfo::add_joint_pair(Joint* j1, Joint* j2, SceneGraph* sg)
{
if(Pair(j1, j2)) return 0;
ColModel* m1, *m2;
m1 = Model(j1);
if(!m1)
{
m1 = new ColModel(j1, sg);
add_model(m1);
}
m2 = Model(j2);
if(!m2)
{
m2 = new ColModel(j2, sg);
add_model(m2);
}
if(m1->n_triangle == 0 || m2->n_triangle == 0) return -1;
if( (j1->parent == j2 && j1->n_dof == 0) || (j2->parent == j1 && j2->n_dof == 0) )
return 0;
cerr << "add joint pair: " << j1->name << ", " << j2->name << endl;
ColPair* p = new ColPair(m1, m2);
add_pair(p);
return 0;
}
static int load_map(struct kr_zonecut *hints, FILE *fp)
{
size_t line_len = 0;
size_t count = 0;
auto_free char *line = NULL;
while(getline(&line, &line_len, fp) > 0) {
char *saveptr = NULL;
char *tok = strtok_r(line, " \t\r", &saveptr);
if (tok == NULL || strchr(tok, '#') || strlen(tok) == 0) {
continue;
}
char *name_tok = strtok_r(NULL, " \t\n", &saveptr);
while (name_tok != NULL) {
if (add_pair(hints, name_tok, tok) == 0) {
count += 1;
}
name_tok = strtok_r(NULL, " \t\n", &saveptr);
}
}
DEBUG_MSG(NULL, "loaded %zu hints\n", count);
return kr_ok();
}
void build_verlet_lists()
{
int c, np1, n, np2, i ,j, j_start;
Cell *cell;
IA_Neighbor *neighbor;
Particle *p1, *p2;
PairList *pl;
double dist2;
#ifdef VERLET_DEBUG
double max_range_nonbonded2 = SQR(max_cut_nonbonded + skin);
int estimate, sum=0;
fprintf(stderr,"%d: build_verlet_list_and_force_calc:\n",this_node);
/* estimate number of interactions: (0.5*n_part*ia_volume*density)/n_nodes */
estimate = 0.5*n_part*(4.0/3.0*PI*pow(max_range_nonbonded2,1.5))*(n_part/(box_l[0]*box_l[1]*box_l[2]))/n_nodes;
if (!dd.use_vList) { fprintf(stderr, "%d: build_verlet_lists, but use_vList == 0\n", this_node); errexit(); }
#endif
/* Loop local cells */
for (c = 0; c < local_cells.n; c++) {
VERLET_TRACE(fprintf(stderr,"%d: cell %d with %d neighbors\n",this_node,c, dd.cell_inter[c].n_neighbors));
cell = local_cells.cell[c];
p1 = cell->part;
np1 = cell->n;
/* Loop cell neighbors */
for (n = 0; n < dd.cell_inter[c].n_neighbors; n++) {
neighbor = &dd.cell_inter[c].nList[n];
p2 = neighbor->pList->part;
np2 = neighbor->pList->n;
/* init pair list */
pl = &neighbor->vList;
pl->n = 0;
/* no interaction set, Verlet list stays empty */
if (max_cut_nonbonded == 0.0)
continue;
/* Loop cell particles */
for(i=0; i < np1; i++) {
j_start = 0;
/* Tasks within cell: store old position, avoid double counting */
if(n == 0) {
memcpy(p1[i].l.p_old, p1[i].r.p, 3*sizeof(double));
j_start = i+1;
}
/* Loop neighbor cell particles */
for(j = j_start; j < np2; j++) {
#ifdef EXCLUSIONS
if(do_nonbonded(&p1[i], &p2[j]))
#endif
{
dist2 = distance2(p1[i].r.p, p2[j].r.p);
if(dist2 <= SQR(get_ia_param(p1[i].p.type, p2[j].p.type)->max_cut + skin))
add_pair(pl, &p1[i], &p2[j]);
}
}
}
resize_verlet_list(pl);
VERLET_TRACE(fprintf(stderr,"%d: neighbor %d has %d particles\n",this_node,n,pl->n));
VERLET_TRACE(sum += pl->n);
}
}
rebuild_verletlist = 0;
VERLET_TRACE(fprintf(stderr,"%d: total number of interaction pairs: %d (should be around %d)\n",this_node,sum,estimate));
}
void build_verlet_lists_and_calc_verlet_ia()
{
int c, np1, n, np2, i ,j, j_start;
Cell *cell;
IA_Neighbor *neighbor;
Particle *p1, *p2;
PairList *pl;
double dist2, vec21[3];
#ifdef VERLET_DEBUG
int estimate, sum=0;
double max_range_nonbonded2 = SQR(max_cut_nonbonded + skin);
fprintf(stderr,"%d: build_verlet_list_and_calc_verlet_ia:\n",this_node);
/* estimate number of interactions: (0.5*n_part*ia_volume*density)/n_nodes */
estimate = 0.5*n_part*(4.0/3.0*PI*pow(max_range_nonbonded2,1.5))*(n_part/(box_l[0]*box_l[1]*box_l[2]))/n_nodes;
if (!dd.use_vList) { fprintf(stderr, "%d: build_verlet_lists, but use_vList == 0\n", this_node); errexit(); }
#endif
/* Loop local cells */
for (c = 0; c < local_cells.n; c++) {
VERLET_TRACE(fprintf(stderr,"%d: cell %d with %d neighbors\n",this_node,c, dd.cell_inter[c].n_neighbors));
cell = local_cells.cell[c];
p1 = cell->part;
np1 = cell->n;
/* Loop cell neighbors */
for (n = 0; n < dd.cell_inter[c].n_neighbors; n++) {
neighbor = &dd.cell_inter[c].nList[n];
p2 = neighbor->pList->part;
np2 = neighbor->pList->n;
VERLET_TRACE(fprintf(stderr,"%d: neighbor %d contains %d parts\n",this_node,n,np2));
/* init pair list */
pl = &neighbor->vList;
pl->n = 0;
/* Loop cell particles */
for(i=0; i < np1; i++) {
j_start = 0;
/* Tasks within cell: bonded forces, store old position, avoid double counting */
if(n == 0) {
#ifdef MULTI_TIMESTEP
if (p1[i].p.smaller_timestep==current_time_step_is_small || smaller_time_step < 0.)
#endif
{
add_bonded_force(&p1[i]);
#ifdef CONSTRAINTS
add_constraints_forces(&p1[i]);
#endif
add_external_potential_forces(&p1[i]);
memcpy(p1[i].l.p_old, p1[i].r.p, 3*sizeof(double));
j_start = i+1;
}
}
/* no interaction set, no need for particle pairs */
if (max_cut_nonbonded == 0.0)
continue;
/* Loop neighbor cell particles */
for(j = j_start; j < np2; j++) {
#ifdef EXCLUSIONS
if(do_nonbonded(&p1[i], &p2[j]))
#endif
{
dist2 = distance2vec(p1[i].r.p, p2[j].r.p, vec21);
VERLET_TRACE(fprintf(stderr,"%d: pair %d %d has distance %f\n",this_node,p1[i].p.identity,p2[j].p.identity,sqrt(dist2)));
if(dist2 <= SQR(get_ia_param(p1[i].p.type, p2[j].p.type)->max_cut + skin)) {
ONEPART_TRACE(if(p1[i].p.identity==check_id) fprintf(stderr,"%d: OPT: Verlet Pair %d %d (Cells %d,%d %d,%d dist %f)\n",this_node,p1[i].p.identity,p2[j].p.identity,c,i,n,j,sqrt(dist2)));
ONEPART_TRACE(if(p2[j].p.identity==check_id) fprintf(stderr,"%d: OPT: Verlet Pair %d %d (Cells %d %d dist %f)\n",this_node,p1[i].p.identity,p2[j].p.identity,c,n,sqrt(dist2)));
add_pair(pl, &p1[i], &p2[j]);
#ifdef MULTI_TIMESTEP
if (smaller_time_step < 0.
|| (p1[i].p.smaller_timestep==0 && p2[j].p.smaller_timestep==0 && current_time_step_is_small==0)
|| (!(p1[i].p.smaller_timestep==0 && p2[j].p.smaller_timestep==0) && current_time_step_is_small==1))
#endif
{
/* calc non bonded interactions */
add_non_bonded_pair_force(&(p1[i]), &(p2[j]), vec21, sqrt(dist2), dist2);
}
}
}
}
}
resize_verlet_list(pl);
VERLET_TRACE(fprintf(stderr,"%d: neighbor %d has %d pairs\n",this_node,n,pl->n));
VERLET_TRACE(sum += pl->n);
}
struct ini_file *ini_parse(const char *text, int *err, int *line) {
jmp_buf on_error;
int e_code;
struct ini_file *ini = NULL;
ini_section *cur_sec = NULL;
const char *tstart, *tend;
int t;
if(err) *err = SUCCESS;
if(line) *line = 1;
ini = make_ini();
if((e_code = setjmp(on_error)) != 0) {
if(err) *err = e_code;
ini_free(ini);
return NULL;
}
while((t = get_token(&text, &tstart, &tend, line, on_error)) != T_END) {
if(t == '[') {
char *section_name;
if(get_token(&text, &tstart, &tend, line, on_error) != T_VALUE) {
longjmp(on_error, EMPTY_SECTION);
}
section_name = get_string(tstart, tend, on_error);
cur_sec = add_section(&ini->sections, section_name);
if(!cur_sec)
longjmp(on_error, OUT_OF_MEMORY);
if(get_token(&text, &tstart, &tend, line, on_error) != ']') {
longjmp(on_error, MISSING_END_BRACE);
}
} else if (t == T_VALUE ) {
char *par, *val;
par = get_string(tstart, tend, on_error);
t = get_token(&text, &tstart, &tend, line, on_error);
if(t != '=' && t != ':') {
longjmp(on_error, EXPECTED_EQUALS);
}
if(get_token(&text, &tstart, &tend, line, on_error) != T_VALUE) {
longjmp(on_error, EXPECTED_VALUE);
}
val = get_string(tstart, tend, on_error);
if(cur_sec)
add_pair(cur_sec, par, val);
else {
/* Add the parameter and value to the INI file's globals */
ini_pair *pair;
if(!(pair = malloc(sizeof *pair)))
longjmp(on_error, OUT_OF_MEMORY);
pair->param = par;
pair->value = val;
pair->left = pair->right = NULL;
if(!ini->globals)
ini->globals = pair;
else
insert_pair(ini->globals, pair);
}
} else
longjmp(on_error, EXPECTED_PARAMETER);
}
return ini;
}
/* ----------------------------------------------------------------------------
FUNCTION
Name: Open
Prototype: struct confread_file* confread_open(char* path)
Developer: Andrew Burian
Created On: 2015-03-07
Parameters:
char* path
file path to the conf file to read
Return Values:
struct confread_file*
the newly creaded confread file
null on failure
Description:
Parses the given config file and loads it into the data structure for
processing
Revisions:
(none)
---------------------------------------------------------------------------- */
struct confread_file* confread_open(char* path){
// the actual configuration file
FILE* confDataFile = 0;
// temp pointers
struct confread_file* confFile = 0;
struct confread_section* thisSection = 0;
// the line from the conf file
char* line = 0;
size_t lineLen = 0;
// other char pointers for manipulation of the line
char* lineStart = 0;
char* lineEnd = 0;
char* keyStart = 0;
char* keyEnd = 0;
// open the data file
if(!(confDataFile = fopen(path, "r"))){
return 0;
}
// create the conf file
confFile = malloc(sizeof(struct confread_file));
confFile->count = 0;
confFile->name = malloc(strlen(path) + 1);
confFile->sections = 0;
memcpy(confFile->name, path, strlen(path) + 1);
// add the 'root section'
thisSection = add_section(confFile, "root");
// Read the file line by line until EOF
while(getline(&line, &lineLen, confDataFile) != -1){
// seek forward to the first non-space character
for(lineStart = line; *lineStart != 0; ++lineStart){
if(!isspace(*lineStart)){
break;
}
}
// omit if empty
if(*lineStart == 0){
continue;
}
// omit if comment '#'
if(*lineStart == '#'){
continue;
}
// see if this is a section header
if(*lineStart == '['){
// move lineStart off the header start
++lineStart;
// seek forward to the end of the header ']'
for(lineEnd = lineStart; *lineEnd != 0; ++lineEnd){
if(*lineEnd == ']'){
break;
}
}
// if it's anything other than the end of header, invalid line
if(*lineEnd != ']'){
continue;
}
// seek linestart forward to trim whitespace
for(lineStart = lineStart; lineStart != lineEnd; ++lineStart){
if(!isspace(*lineStart)){
break;
}
}
// omit zero size headers
if(lineStart == lineEnd){
continue;
}
// seek line end back to trim whitespace
for(lineEnd = lineEnd - 1; lineEnd != lineStart; --lineEnd){
if(!isspace(*lineEnd)){
break;
}
}
// set next char as null
lineEnd[1] = 0;
// create the new section
thisSection = add_section(confFile, lineStart);
continue;
}
// otherwise, key-value
else{
// seek line end forward to the separator '='
for(lineEnd = lineStart; *lineEnd != 0; ++lineEnd){
if(*lineEnd == '='){
break;
}
}
// discard if invalid
if(*lineEnd != '='){
continue;
}
// if key is zero length, discard
if(lineEnd == lineStart){
continue;
}
// set the key start
keyStart = lineEnd + 1;
// seek the line end backwards to trim whitespace
for(lineEnd = lineEnd - 1; lineEnd != lineStart; --lineEnd){
if(!isspace(*lineEnd)){
break;
}
}
// set the following char to null
lineEnd[1] = 0;
// seek the key end forward to the end of the line
for(keyEnd = keyStart; *keyEnd != 0; ++keyEnd){
if(*keyEnd == '\n'){
break;
}
}
// if the key is zero length, discard
if(keyEnd == keyStart){
continue;
}
// seek key end backwards to trim trailing whitespace
for(keyEnd = keyEnd; keyEnd != keyStart; --keyEnd){
if(!isspace(*keyEnd)){
break;
}
}
// seek the key start forward to trim leading whitespace
for(keyStart = keyStart; keyStart != keyEnd; ++keyStart){
if(!isspace(*keyStart)){
break;
}
}
// set the new line char to null
keyEnd[1] = 0;
// add the key-value pair
add_pair(thisSection, lineStart, keyStart);
}
}
free(line);
fclose(confDataFile);
return confFile;
}
sink_line_res sink_line(config *cfg, data_set *ds, char *line, size_t len, size_t row_count) {
size_t col = 0;
if (len == 0) { return SINK_LINE_EMPTY; }
if (line[len - 1] == '\n') { line[len - 1] = '\0'; len--; }
if (*line == '\0') { return SINK_LINE_EMPTY; }
LOG(3, "sink_line: %s\n", line);
float cur_x = row_count;
bool has_x = false;
// ignore comments
if (is_comment_marker(line[0])) { return SINK_LINE_COMMENT; }
size_t offset = 0;
while (offset < len && line[offset]) {
double v = 0;
if (offset >= len) { break; }
// ignore comment to EOL
if (is_comment_marker(line[offset])) { return SINK_LINE_OK; }
if (!number_head_char(line[offset])) {
if (offset == 0) {
v = EMPTY_VALUE;
} else {
offset++;
if (!number_head_char(line[offset])) {
v = EMPTY_VALUE;
}
}
}
char *cur_line = &line[offset];
char *out_line = NULL;
if (isnan(v)) {
offset++; // already got the value
} else {
v = strtod(cur_line, &out_line);
if (isinf(v)) { v = EMPTY_VALUE; }
}
if (out_line == cur_line) {
break;
} else {
// could do this in terms of *line == '\0' or line[offset] == len.
// strtod shifts &line.
while(&line[offset] < out_line) {
offset++;
}
}
if (cfg->x_column && !has_x) {
cur_x = v;
has_x = true;
} else {
point p = { .x = cur_x, .y = v };
add_pair(cfg, ds, row_count, col, &p);
col++;
if (col == MAX_COLUMNS) { break; }
}
}
// Fill remaining columns with EMPTY_VALUE
for (size_t c = col; c < ds->columns; c++) {
point p = { .x = cur_x, .y = EMPTY_VALUE };
add_pair(cfg, ds, row_count, c, &p);
}
return SINK_LINE_OK;
}
void IOUniformer::redirect(const char *orig_path, const char *new_path) {
LOGI("Start redirect : from %s to %s", orig_path, new_path);
add_pair(orig_path, new_path);
}
void PixmanBitmap::initialize_formats() {
if (formats_initialized)
return;
add_pair(PIXMAN_a8r8g8b8, DynamicFormat(32,8,16,8,8,8,0,8,24,PF::Alpha));
add_pair(PIXMAN_x8r8g8b8, DynamicFormat(32,8,16,8,8,8,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_a8b8g8r8, DynamicFormat(32,8,0,8,8,8,16,8,24,PF::Alpha));
add_pair(PIXMAN_x8b8g8r8, DynamicFormat(32,8,0,8,8,8,16,0,0,PF::NoAlpha));
add_pair(PIXMAN_b8g8r8a8, DynamicFormat(32,8,8,8,16,8,24,8,0,PF::Alpha));
add_pair(PIXMAN_b8g8r8x8, DynamicFormat(32,8,8,8,16,8,24,0,0,PF::NoAlpha));
add_pair(PIXMAN_x14r6g6b6, DynamicFormat(32,6,12,6,6,6,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_x2r10g10b10, DynamicFormat(32,10,20,10,10,10,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_a2r10g10b10, DynamicFormat(32,10,20,10,10,10,0,2,30,PF::Alpha));
add_pair(PIXMAN_x2b10g10r10, DynamicFormat(32,10,0,10,10,10,20,0,0,PF::NoAlpha));
add_pair(PIXMAN_a2b10g10r10, DynamicFormat(32,10,0,10,10,10,20,2,30,PF::Alpha));
add_pair(PIXMAN_r8g8b8, DynamicFormat(24,8,16,8,8,8,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_b8g8r8, DynamicFormat(24,8,0,8,8,8,16,0,0,PF::NoAlpha));
add_pair(PIXMAN_r5g6b5, DynamicFormat(16,5,11,6,5,5,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_b5g6r5, DynamicFormat(16,5,0,6,5,5,11,0,0,PF::NoAlpha));
add_pair(PIXMAN_a1r5g5b5, DynamicFormat(16,5,10,5,5,5,0,1,15,PF::Alpha));
add_pair(PIXMAN_x1r5g5b5, DynamicFormat(16,5,10,5,5,5,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_a1b5g5r5, DynamicFormat(16,5,0,5,5,5,10,1,15,PF::Alpha));
add_pair(PIXMAN_x1b5g5r5, DynamicFormat(16,5,0,5,5,5,10,0,0,PF::NoAlpha));
add_pair(PIXMAN_a4r4g4b4, DynamicFormat(16,4,8,4,4,4,0,4,12,PF::Alpha));
add_pair(PIXMAN_x4r4g4b4, DynamicFormat(16,4,8,4,4,4,0,0,0,PF::NoAlpha));
add_pair(PIXMAN_a4b4g4r4, DynamicFormat(16,4,0,4,4,4,8,4,12,PF::Alpha));
add_pair(PIXMAN_x4b4g4r4, DynamicFormat(16,4,0,4,4,4,8,0,0,PF::NoAlpha));
add_pair(PIXMAN_g8, DynamicFormat(8,8,0,8,0,8,0,8,0,PF::Alpha));
add_pair(PIXMAN_g8, DynamicFormat(8,8,0,8,0,8,0,0,0,PF::NoAlpha));
formats_initialized = true;
}
