1

cdef extern from "errno.h" :

     2

    extern int errno

     3

     4

cdef extern from "string.h" :

     5

    char* strerror (int err)

     6

     7

    void* memset (void *, int, size_t)

     8

    void* memcpy (void *, void *, size_t)

     9

    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 :

    28

        PT_OPEN_READ    # 0

    29

        PT_OPEN_UPDATE

    30

    31

    enum pt_cache_status :

    32

        PT_CACHE_ERROR  # -1

    33

        PT_CACHE_FRESH

    34

        PT_CACHE_NONE

    35

        PT_CACHE_STALE

    36

        PT_CACHE_INCOMPAT

    37

    38

    struct pt_image_info :

    39

        size_t img_width, img_height, img_bpp

    40

        int image_mtime, cache_mtime, cache_version

    41

        size_t image_bytes, cache_bytes

    42

        size_t cache_blocks

    43

    44

    struct pt_image_params :

    45

        int background_color[4]

    46

    47

    struct pt_tile_info :

    48

        size_t width, height

    49

        size_t x, y

    50

        int zoom

    51

    52

    ctypedef pt_image_info* const_image_info_ptr "const struct pt_image_info *"

    53

    54

    ## functions

    55

    int pt_image_open (pt_image **image_ptr, pt_ctx *ctx, char *png_path, int cache_mode) nogil

    56

    int pt_image_info_ "pt_image_info" (pt_image *image, pt_image_info **info_ptr) nogil

    57

    int pt_image_status (pt_image *image) nogil

    58

    int pt_image_load (pt_image *image) nogil

    59

    int pt_image_update (pt_image *image, pt_image_params *params) nogil

    60

    int pt_image_tile_file (pt_image *image, pt_tile_info *info, stdio.FILE *out) nogil

    61

    int pt_image_tile_mem (pt_image *image, pt_tile_info *info, char **buf_ptr, size_t *len_ptr) nogil

    62

    void pt_image_destroy (pt_image *image) nogil

    63

    64

    # error code -> name

    65

    char* pt_strerror (int err)

    66

    67

## constants

    68

# Image()

    69

OPEN_READ       = PT_OPEN_READ

    70

OPEN_UPDATE     = PT_OPEN_UPDATE

    71

    72

# Image.status -> ...

    73

CACHE_FRESH     = PT_CACHE_FRESH

    74

CACHE_NONE      = PT_CACHE_NONE

    75

CACHE_STALE     = PT_CACHE_STALE

    76

CACHE_INCOMPAT  = PT_CACHE_INCOMPAT

    77

    78

class Error (BaseException) :

    79

    """

    80

        Base class for errors raised by pypngtile.

    81

    """

    82

    83

    def __init__ (self, func, err) :

    84

        super(Error, self).__init__("%s: %s: %s" % (func, pt_strerror(err), strerror(errno)))

    85

    86

cdef class Image :

    87

    """

    88

        An image file on disk (.png) and an associated .cache file.

    89

    90

        Open the .png file at the given path using the given mode.

    91

    92

        path        - filesystem path to .png file

    93

        mode        - mode to operate cache in

    94

            OPEN_READ       - read-only access to cache

    95

            OPEN_UPDATE     - allow .update()

    96

    """

    97

    98

    cdef pt_image *image

    99

   103

   104

    # open the pt_image

   105

    def __cinit__ (self, char *path, int mode = 0) :

   106

        cdef int err

   110

   111

        # open

   112

        with nogil :

   113

            # XXX: I hope use of path doesn't break...

   114

            err = pt_image_open(&self.image, NULL, path, mode)

   115

   116

        if err :

   117

            raise Error("pt_image_open", err)

   118

   119

   120

    def info (self) :

   121

        """

   122

            Return a dictionary containing various information about the image.

   123

   124

            img_width           - pixel dimensions of the source image

   125

            img_height            only available if the cache was opened

   126

            img_bpp             - bits per pixel for the source image

   127

   128

            image_mtime         - last modification timestamp for source image

   129

            image_bytes         - size of source image file in bytes

   130

   131

            cache_version       - version of cache file available

   132

            cache_mtime         - last modification timestamp for cache file

   133

            cache_bytes         - size of cache file in bytes

   134

            cache_blocks        - size of cache file in disk blocks - 512 bytes / block

   135

        """

   136

   137

        cdef const_image_info_ptr infop

   138

        cdef int err

   139

   140

        with nogil :

   141

            err = pt_image_info_(self.image, &infop)

   142

   143

        if err :

   144

            raise Error("pt_image_info", err)

   145

   146

        # return as a struct

   147

        return infop[0]

   148

   149

   150

    def status (self) :

   151

        """

   152

            Return a code describing the status of the underlying cache file.

   153

   154

            CACHE_FRESH         - the cache file exists and is up-to-date

   155

            CACHE_NONE          - the cache file does not exist

   156

            CACHE_STALE         - the cache file exists, but is older than the source image

   157

            CACHE_INCOMPAT      - the cache file exists, but is incompatible with this version of the library

   158

        """

   159

   160

        cdef int ret

   161

   162

        with nogil :

   163

            ret = pt_image_status(self.image)

   164

   165

        if ret :

   166

            raise Error("pt_image_status", ret)

   167

   168

        return ret

   169

   170

    def open (self) :

   171

        """

   172

            Open the underlying cache file for reading, if available.

   173

        """

   174

   175

        cdef int err

   176

   177

        with nogil :

   178

            err = pt_image_load(self.image)

   179

   180

        if err :

   181

            raise Error("pt_image_load", err)

   182

   183

   184

    def update (self, background_color = None) :

   185

        """

   186

            Update the underlying cache file from the source image.

   187

   188

            background_color    - skip consecutive pixels that match this byte pattern in output

   189

   190

            Requires that the Image was opened using OPEN_UPDATE.

   191

        """

   192

   193

        cdef pt_image_params params

   194

        cdef char *bgcolor

   195

        cdef int err

   196

   197

        memset(&params, 0, sizeof(params))

   198

   199

        # params

   200

        if background_color :

   201

            # cast

   202

            bgcolor = <char *>background_color

   203

   204

            if 0 >= len(bgcolor) > 4 :

   205

                raise ValueError("background_color must be a str of between 1 and 4 bytes")

   206

   207

            # decode 

   208

            memcpy(params.background_color, bgcolor, len(bgcolor))

   209

   210

        # run update

   211

        with nogil :

   212

            err = pt_image_update(self.image, &params)

   213

   214

        if err :

   215

            raise Error("pt_image_update", err)

   216

   217

   218

    def tile_file (self, size_t width, size_t height, size_t x, size_t y, int zoom, object out) :

   219

        """

   220

            Render a region of the source image as a PNG tile to the given output file.

   221

   222

            width       - dimensions of the output tile in px

   223

            height      

   224

            x           - coordinates in the source file

   225

            y

   226

            zoom        - zoom level: out = 2**(-zoom) * in

   227

            out         - output file

   228

   229

            Note that the given file object MUST be a *real* stdio FILE*, not a fake Python object.

   230

        """

   231

   232

        cdef stdio.FILE *outf

   233

        cdef pt_tile_info ti

   234

        cdef int err

   235

   236

        memset(&ti, 0, sizeof(ti))

   237

   238

        # convert to FILE

   239

        if not PyFile_Check(out) :

   240

            raise TypeError("out: must be a file object")

   241

   242

        outf = PyFile_AsFile(out)

   243

   244

        if not outf :

   245

            raise TypeError("out: must have a FILE*")

   246

   247

        # pack params

   248

        ti.width = width

   249

        ti.height = height

   250

        ti.x = x

   251

        ti.y = y

   252

        ti.zoom = zoom

   253

   254

        # render

   255

        with nogil :

   256

            err = pt_image_tile_file(self.image, &ti, outf)

   257

   258

        if err :

   259

            raise Error("pt_image_tile_file", err)

   260

   261

   262

    def tile_mem (self, size_t width, size_t height, size_t x, size_t y, int zoom) :

   263

        """

   264

            Render a region of the source image as a PNG tile, and return the PNG data a a string.

   265

   266

            width       - dimensions of the output tile in px

   267

            height      

   268

            x           - coordinates in the source file

   269

            y

   270

            zoom        - zoom level: out = 2**(-zoom) * in

   271

        """

   272

   273

        cdef pt_tile_info ti

   274

        cdef char *buf

   275

        cdef size_t len

   276

        cdef int err

   277

   278

        memset(&ti, 0, sizeof(ti))

   279

   280

        # pack params

   281

        ti.width = width

   282

        ti.height = height

   283

        ti.x = x

   284

        ti.y = y

   285

        ti.zoom = zoom

   286

   287

        # render and return via buf/len

   288

        with nogil :

   289

            err = pt_image_tile_mem(self.image, &ti, &buf, &len)

   290

   291

        if err :

   292

            raise Error("pt_image_tile_mem", err)

   293

   294

        # copy buffer as str...

   295

        data = python_string.PyString_FromStringAndSize(buf, len)

   296

   297

        # drop buffer...

   298

        stdlib.free(buf)

   299

   300

        return data

   301

   302

    # release the pt_image

   303

    def __dealloc__ (self) :

   304

        if self.image :

   305

            pt_image_destroy(self.image)

   306

   307

            self.image = NULL

   308