← Back to branch summary

~ubuntu-branches/debian/sid/openbox/sid

« back to all changes in this revision

Viewing changes to render/imagecache.c

  • Committer: Bazaar Package Importer
  • Author(s): Nico Golde, Nico Golde, Eugenio Paolantonio
  • Date: 2011-10-03 22:59:30 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20111003225930-tdvyax5tx63dyoez
Tags: 3.5.0-1
http://bugs.debian.org/638783
http://bugs.debian.org/563891
http://bugs.debian.org/627912
[Nico Golde]
* New upstream release (Closes: #638783).
  - Fix crashes in the menu code (Closes: #563891).
* Add Brazilian translation to openbox.desktop,
  thanks Sérgio Cipolla (Closes: #627912).
* Remove 06_fix_swap_byte_order.patch, applied upstream.
* Bump debhelper dependency to >= 7.0.50~ due to override.
* Remove CHANGELOG from openbox.docs to prevent double installation.
* Add 02_fix_freedesktop_compliance.dpatch desktop file to
  /usr/share/applications.

[Eugenio Paolantonio]
* debian/patches:
  - Disabled 03_place_windows_in_quadrants.patch
  - Updated 01_rc.xml.patch and 06_fix_swap_byte_order.patch
  - Removed 04_fix_ftbfs_no-add-needed.patch and 20_24bits_support.patch
* debian/control:
  - Added myself to the Uploaders.
  - Build-Depends: removed libxau-dev, libxft-dev and python-xdg;
    added libimlib2-dev
  - openbox Suggests: added python-xdg
  - libobrender21 renamed to libobrender27
  - libobparser21 renamed to libobt0
* debian/rules:
  - Rewrote using a simpler debhelper syntax
  - Moved the install pass to openbox.install
* debian/*.{install,links,dirs}:
  - Updated.
* debian/openbox.xsession:
  - Removed. Openbox now ships it by default.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
#include "image.h"
22
 
 
23
 
static gboolean RrImagePicEqual(const RrImagePic *p1,
24
 
                                const RrImagePic *p2);
25
 
 
26
 
RrImageCache* RrImageCacheNew(gint max_resized_saved)
27
 
{
28
 
    RrImageCache *self;
29
 
 
30
 
    g_assert(max_resized_saved >= 0);
31
 
 
32
 
    self = g_new(RrImageCache, 1);
33
 
    self->ref = 1;
34
 
    self->max_resized_saved = max_resized_saved;
35
 
    self->table = g_hash_table_new((GHashFunc)RrImagePicHash,
36
 
                                   (GEqualFunc)RrImagePicEqual);
37
 
    return self;
38
 
}
39
 
 
40
 
void RrImageCacheRef(RrImageCache *self)
41
 
{
42
 
    ++self->ref;
43
 
}
44
 
 
45
 
void RrImageCacheUnref(RrImageCache *self)
46
 
{
47
 
    if (self && --self->ref == 0) {
48
 
        g_assert(g_hash_table_size(self->table) == 0);
49
 
        g_hash_table_unref(self->table);
50
 
 
51
 
        g_free(self);
52
 
    }
53
 
}
54
 
 
55
 
/*! Finds an image in the cache, if it is already in there */
56
 
RrImage* RrImageCacheFind(RrImageCache *self,
57
 
                          RrPixel32 *data, gint w, gint h)
58
 
{
59
 
    RrImagePic pic;
60
 
 
61
 
    RrImagePicInit(&pic, w, h, data);
62
 
    return g_hash_table_lookup(self->table, &pic);
63
 
}
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
 
/* This is a fast, reversable hash function called "lookup3", found here:
91
 
   http://burtleburtle.net/bob/c/lookup3.c, by Bob Jenkins
92
 
 
93
 
   This hashing algorithm is "reversible", that is, not cryptographically
94
 
   secure at all.  But we don't care about that, we just want something to
95
 
   tell when images are the same or different relatively quickly.
96
 
*/
97
 
guint32 hashword(const guint32 *key, gint length, guint32 initval)
98
 
{
99
 
    guint32 a,b,c;
100
 
 
101
 
    /* Set up the internal state */
102
 
    a = b = c = 0xdeadbeef + (((guint32)length)<<2) + initval;
103
 
 
104
 
    /* handle most of the key */
105
 
    while (length > 3)
106
 
    {
107
 
        a += key[0];
108
 
        b += key[1];
109
 
        c += key[2];
110
 
        mix(a,b,c);
111
 
        length -= 3;
112
 
        key += 3;
113
 
    }
114
 
 
115
 
    /* handle the last 3 guint32's */
116
 
    switch(length)      /* all the case statements fall through */
117
 
    { 
118
 
    case 3: c+=key[2];
119
 
    case 2: b+=key[1];
120
 
    case 1: a+=key[0];
121
 
        final(a,b,c);
122
 
    case 0:             /* case 0: nothing left to add */
123
 
        break;
124
 
    }
125
 
    /* report the result */
126
 
    return c;
127
 
}
128
 
 
129
 
/*! This is some arbitrary initial value for the hashing function.  It's
130
 
  constant so that you get the same result from the same data each time.
131
 
*/
132
 
#define HASH_INITVAL 0xf00d
133
 
 
134
 
guint RrImagePicHash(const RrImagePic *p)
135
 
{
136
 
    return hashword(p->data, p->width * p->height, HASH_INITVAL);
137
 
}
138
 
 
139
 
static gboolean RrImagePicEqual(const RrImagePic *p1,
140
 
                                const RrImagePic *p2)
141
 
{
142
 
    return p1->width == p2->width && p1->height == p2->height &&
143
 
        p1->sum == p2->sum;
144
 
}