ec2ff4d0471d2a04391c0f637112e580aaadc783
[mikachu/openbox.git] / render / imagecache.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    imagecache.c for the Openbox window manager
4    Copyright (c) 2008        Dana Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "render.h"
20 #include "imagecache.h"
21
22 static gboolean RrImagePicEqual(const RrImagePic *p1,
23                                 const RrImagePic *p2);
24
25 RrImageCache* RrImageCacheNew()
26 {
27     RrImageCache *self;
28
29     self = g_new(RrImageCache, 1);
30     self->ref = 1;
31     self->table = g_hash_table_new((GHashFunc)RrImagePicHash,
32                                    (GEqualFunc)RrImagePicEqual);
33     return self;
34 }
35
36 void RrImageCacheRef(RrImageCache *self)
37 {
38     ++self->ref;
39 }
40
41 void RrImageCacheUnref(RrImageCache *self)
42 {
43     if (self && --self->ref == 0) {
44         g_assert(g_hash_table_size(self->table) == 0);
45         g_hash_table_unref(self->table);
46
47         g_free(self);
48     }
49 }
50
51 /*! Finds an image in the cache, if it is already in there */
52 RrImage* RrImageCacheFind(RrImageCache *self,
53                           RrPixel32 *data, gint w, gint h)
54 {
55     RrImagePic pic;
56     pic.width = w;
57     pic.height = h;
58     pic.data = data;
59     return g_hash_table_lookup(self->table, &pic);
60 }
61
62 /* This is a fast, reversable hash function called "lookup3", found here:
63    http://burtleburtle.net/bob/c/lookup3.c
64 */
65 #define hashsize(n) ((RrPixel32)1<<(n))
66 #define hashmask(n) (hashsize(n)-1)
67 #define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
68 /* mix -- mix 3 32-bit values reversibly. */
69 #define mix(a,b,c) \
70 { \
71   a -= c;  a ^= rot(c, 4);  c += b; \
72   b -= a;  b ^= rot(a, 6);  a += c; \
73   c -= b;  c ^= rot(b, 8);  b += a; \
74   a -= c;  a ^= rot(c,16);  c += b; \
75   b -= a;  b ^= rot(a,19);  a += c; \
76   c -= b;  c ^= rot(b, 4);  b += a; \
77 }
78 /* final -- final mixing of 3 32-bit values (a,b,c) into c */
79 #define final(a,b,c) \
80 { \
81   c ^= b; c -= rot(b,14); \
82   a ^= c; a -= rot(c,11); \
83   b ^= a; b -= rot(a,25); \
84   c ^= b; c -= rot(b,16); \
85   a ^= c; a -= rot(c,4);  \
86   b ^= a; b -= rot(a,14); \
87   c ^= b; c -= rot(b,24); \
88 }
89
90 guint32 hashword(const guint32 *key, gint length, guint32 initval)
91 {
92     guint32 a,b,c;
93
94     /* Set up the internal state */
95     a = b = c = 0xdeadbeef + (((guint32)length)<<2) + initval;
96
97     /* handle most of the key */
98     while (length > 3)
99     {
100         a += key[0];
101         b += key[1];
102         c += key[2];
103         mix(a,b,c);
104         length -= 3;
105         key += 3;
106     }
107
108     /* handle the last 3 guint32's */
109     switch(length)      /* all the case statements fall through */
110     { 
111     case 3: c+=key[2];
112     case 2: b+=key[1];
113     case 1: a+=key[0];
114         final(a,b,c);
115     case 0:             /* case 0: nothing left to add */
116         break;
117     }
118     /* report the result */
119     return c;
120 }
121
122 #define HASH_INITVAL 0xf00d
123
124 guint RrImagePicHash(const RrImagePic *p)
125 {
126     return hashword(p->data, p->width * p->height, HASH_INITVAL);
127 }
128
129 static gboolean RrImagePicEqual(const RrImagePic *p1,
130                                 const RrImagePic *p2)
131 {
132     guint s1, s2;
133     RrPixel32 *data1, *data2;
134     gint i;
135
136     if (p1->width != p2->width || p1->height != p2->height) return FALSE;
137
138     /* strcmp() would probably suck on 4k of data.. sum all their values and
139        see if they get the same thing.  they already matched on their hashes
140        at this point. */
141     s1 = s2 = 0;
142     data1 = p1->data;
143     data2 = p2->data;
144     for (i = 0; i < p1->width * p1->height; ++i, ++data1)
145         s1 += *data1;
146     for (i = 0; i < p2->width * p2->height; ++i, ++data2)
147         s2 += *data2;
148     return s1 == s2;
149 }