|
30
|
1 |
cdef extern from "errno.h" :
|
|
|
2 |
extern int errno
|
|
|
3 |
|
|
|
4 |
cdef extern from "string.h" :
|
|
|
5 |
char* strerror (int err)
|
|
|
6 |
|
|
78
|
7 |
void* memset (void *, int, size_t)
|
|
|
8 |
void* memcpy (void *, void *, size_t)
|
|
|
9 |
|
|
30
|
10 |
cimport stdio
|
|
|
11 |
cimport stdlib
|
|
|
12 |
cimport python_string
|
|
|
13 |
|
|
|
14 |
cdef extern from "Python.h" :
|
|
|
15 |
int PyFile_Check (object p)
|
|
|
16 |
stdio.FILE* PyFile_AsFile (object p)
|
|
|
17 |
void PyFile_IncUseCount (object p)
|
|
|
18 |
void PyFile_DecUseCount (object p)
|
|
|
19 |
|
|
|
20 |
cdef extern from "pngtile.h" :
|
|
|
21 |
struct pt_ctx :
|
|
|
22 |
pass
|
|
|
23 |
|
|
|
24 |
struct pt_image :
|
|
|
25 |
pass
|
|
|
26 |
|
|
|
27 |
enum pt_open_mode :
|
|
78
|
28 |
PT_OPEN_READ # 0
|
|
30
|
29 |
PT_OPEN_UPDATE
|
|
|
30 |
|
|
|
31 |
enum pt_cache_status :
|
|
78
|
32 |
PT_CACHE_ERROR # -1
|
|
30
|
33 |
PT_CACHE_FRESH
|
|
|
34 |
PT_CACHE_NONE
|
|
|
35 |
PT_CACHE_STALE
|
|
57
|
36 |
PT_CACHE_INCOMPAT
|
|
30
|
37 |
|
|
|
38 |
struct pt_image_info :
|
|
78
|
39 |
size_t img_width, img_height, img_bpp
|
|
|
40 |
int image_mtime, cache_mtime, cache_version
|
|
|
41 |
size_t image_bytes, cache_bytes
|
|
57
|
42 |
size_t cache_blocks
|
|
|
43 |
|
|
|
44 |
struct pt_image_params :
|
|
|
45 |
int background_color[4]
|
|
30
|
46 |
|
|
|
47 |
struct pt_tile_info :
|
|
|
48 |
size_t width, height
|
|
|
49 |
size_t x, y
|
|
34
|
50 |
int zoom
|
|
57
|
51 |
|
|
30
|
52 |
int pt_image_open (pt_image **image_ptr, pt_ctx *ctx, char *png_path, int cache_mode)
|
|
|
53 |
int pt_image_info_func "pt_image_info" (pt_image *image, pt_image_info **info_ptr)
|
|
|
54 |
int pt_image_status (pt_image *image)
|
|
57
|
55 |
int pt_image_update (pt_image *image, pt_image_params *params)
|
|
30
|
56 |
int pt_image_tile_file (pt_image *image, pt_tile_info *info, stdio.FILE *out)
|
|
|
57 |
int pt_image_tile_mem (pt_image *image, pt_tile_info *info, char **buf_ptr, size_t *len_ptr)
|
|
|
58 |
void pt_image_destroy (pt_image *image)
|
|
|
59 |
|
|
|
60 |
char* pt_strerror (int err)
|
|
|
61 |
|
|
78
|
62 |
## constants
|
|
|
63 |
# Image()
|
|
|
64 |
OPEN_READ = PT_OPEN_READ
|
|
|
65 |
OPEN_UPDATE = PT_OPEN_UPDATE
|
|
|
66 |
|
|
|
67 |
# Image.status -> ...
|
|
|
68 |
CACHE_FRESH = PT_CACHE_FRESH
|
|
|
69 |
CACHE_NONE = PT_CACHE_NONE
|
|
|
70 |
CACHE_STALE = PT_CACHE_STALE
|
|
|
71 |
CACHE_INCOMPAT = PT_CACHE_INCOMPAT
|
|
30
|
72 |
|
|
|
73 |
class Error (BaseException) :
|
|
|
74 |
pass
|
|
|
75 |
|
|
|
76 |
cdef int trap_err (char *op, int ret) except -1 :
|
|
|
77 |
if ret < 0 :
|
|
|
78 |
raise Error("%s: %s: %s" % (op, pt_strerror(ret), strerror(errno)))
|
|
|
79 |
|
|
|
80 |
else :
|
|
|
81 |
return ret
|
|
|
82 |
|
|
|
83 |
cdef class Image :
|
|
78
|
84 |
"""
|
|
|
85 |
An image file on disk (.png) and an associated .cache file.
|
|
|
86 |
|
|
|
87 |
Open the .png file at the given path using the given mode.
|
|
|
88 |
|
|
|
89 |
path - filesystem path to .png file
|
|
|
90 |
mode - mode to operate cache in
|
|
|
91 |
OPEN_READ - read-only access to cache
|
|
|
92 |
OPEN_UPDATE - allow .update()
|
|
|
93 |
"""
|
|
|
94 |
|
|
30
|
95 |
cdef pt_image *image
|
|
|
96 |
|
|
78
|
97 |
|
|
|
98 |
# open the pt_image
|
|
|
99 |
def __cinit__ (self, char *path, int mode = 0) :
|
|
30
|
100 |
trap_err("pt_image_open",
|
|
78
|
101 |
pt_image_open(&self.image, NULL, path, mode)
|
|
30
|
102 |
)
|
|
78
|
103 |
|
|
|
104 |
|
|
30
|
105 |
def info (self) :
|
|
78
|
106 |
"""
|
|
|
107 |
Return a dictionary containing various information about the image.
|
|
|
108 |
|
|
|
109 |
img_width - pixel dimensions of the source image
|
|
|
110 |
img_height only available if the cache was opened
|
|
|
111 |
img_bpp - bits per pixel for the source image
|
|
|
112 |
|
|
|
113 |
image_mtime - last modification timestamp for source image
|
|
|
114 |
image_bytes - size of source image file in bytes
|
|
|
115 |
|
|
|
116 |
cache_version - version of cache file available
|
|
|
117 |
cache_mtime - last modification timestamp for cache file
|
|
|
118 |
cache_bytes - size of cache file in bytes
|
|
|
119 |
cache_blocks - size of cache file in disk blocks - 512 bytes / block
|
|
|
120 |
"""
|
|
|
121 |
|
|
|
122 |
cdef pt_image_info *info
|
|
30
|
123 |
|
|
|
124 |
trap_err("pt_image_info",
|
|
78
|
125 |
pt_image_info_func(self.image, &info)
|
|
30
|
126 |
)
|
|
|
127 |
|
|
78
|
128 |
# return as a struct
|
|
|
129 |
return info[0]
|
|
|
130 |
|
|
|
131 |
|
|
30
|
132 |
def status (self) :
|
|
78
|
133 |
"""
|
|
|
134 |
Return a code describing the status of the underlying cache file.
|
|
|
135 |
|
|
|
136 |
CACHE_FRESH - the cache file exists and is up-to-date
|
|
|
137 |
CACHE_NONE - the cache file does not exist
|
|
|
138 |
CACHE_STALE - the cache file exists, but is older than the source image
|
|
|
139 |
CACHE_INCOMPAT - the cache file exists, but is incompatible with this version of the library
|
|
|
140 |
"""
|
|
|
141 |
|
|
30
|
142 |
return trap_err("pt_image_status",
|
|
|
143 |
pt_image_status(self.image)
|
|
|
144 |
)
|
|
78
|
145 |
|
|
|
146 |
|
|
|
147 |
def update (self, background_color = None) :
|
|
|
148 |
"""
|
|
|
149 |
Update the underlying cache file from the source image.
|
|
|
150 |
|
|
|
151 |
background_color - skip consecutive pixels that match this byte pattern in output
|
|
|
152 |
|
|
|
153 |
Requires that the Image was opened using OPEN_UPDATE.
|
|
|
154 |
"""
|
|
|
155 |
|
|
|
156 |
cdef pt_image_params params
|
|
|
157 |
cdef char *bgcolor
|
|
|
158 |
memset(¶ms, 0, sizeof(params))
|
|
|
159 |
|
|
|
160 |
# params
|
|
|
161 |
if background_color :
|
|
|
162 |
# cast
|
|
|
163 |
bgcolor = <char *>background_color
|
|
|
164 |
|
|
|
165 |
if 0 >= len(bgcolor) > 4 :
|
|
|
166 |
raise ValueError("background_color must be a str of between 1 and 4 bytes")
|
|
|
167 |
|
|
|
168 |
# decode
|
|
|
169 |
memcpy(params.background_color, bgcolor, len(bgcolor))
|
|
30
|
170 |
|
|
78
|
171 |
# run update
|
|
30
|
172 |
trap_err("pt_image_update",
|
|
78
|
173 |
pt_image_update(self.image, ¶ms)
|
|
30
|
174 |
)
|
|
|
175 |
|
|
78
|
176 |
|
|
34
|
177 |
def tile_file (self, size_t width, size_t height, size_t x, size_t y, int zoom, object out) :
|
|
30
|
178 |
cdef stdio.FILE *outf
|
|
|
179 |
cdef pt_tile_info ti
|
|
|
180 |
|
|
|
181 |
if not PyFile_Check(out) :
|
|
|
182 |
raise TypeError("out: must be a file object")
|
|
|
183 |
|
|
|
184 |
outf = PyFile_AsFile(out)
|
|
|
185 |
|
|
|
186 |
if not outf :
|
|
|
187 |
raise TypeError("out: must have a FILE*")
|
|
|
188 |
|
|
|
189 |
ti.width = width
|
|
|
190 |
ti.height = height
|
|
|
191 |
ti.x = x
|
|
|
192 |
ti.y = y
|
|
34
|
193 |
ti.zoom = zoom
|
|
30
|
194 |
|
|
|
195 |
trap_err("pt_image_tile_file",
|
|
|
196 |
pt_image_tile_file(self.image, &ti, outf)
|
|
|
197 |
)
|
|
|
198 |
|
|
78
|
199 |
|
|
34
|
200 |
def tile_mem (self, size_t width, size_t height, size_t x, size_t y, int zoom) :
|
|
30
|
201 |
cdef pt_tile_info ti
|
|
|
202 |
cdef char *buf
|
|
|
203 |
cdef size_t len
|
|
|
204 |
|
|
|
205 |
ti.width = width
|
|
|
206 |
ti.height = height
|
|
|
207 |
ti.x = x
|
|
|
208 |
ti.y = y
|
|
34
|
209 |
ti.zoom = zoom
|
|
30
|
210 |
|
|
|
211 |
# render and return ptr to buffer
|
|
|
212 |
trap_err("pt_image_tile_mem",
|
|
|
213 |
pt_image_tile_mem(self.image, &ti, &buf, &len)
|
|
|
214 |
)
|
|
|
215 |
|
|
|
216 |
# copy buffer as str...
|
|
|
217 |
data = python_string.PyString_FromStringAndSize(buf, len)
|
|
|
218 |
|
|
|
219 |
# drop buffer...
|
|
|
220 |
stdlib.free(buf)
|
|
|
221 |
|
|
|
222 |
return data
|
|
|
223 |
|
|
78
|
224 |
# release the pt_image
|
|
30
|
225 |
def __dealloc__ (self) :
|
|
|
226 |
if self.image :
|
|
|
227 |
pt_image_destroy(self.image)
|
|
|
228 |
|