1

from libc.errno cimport (

     2

        errno,

     3

)

     4

from libc.string cimport (

     5

        strerror,

     6

        memset,

     7

        memcpy,

     8

)

     9

from libc.stdio cimport (

    10

        FILE,

    11

)

    12

from libc.stdlib cimport (

    13

        free,

    14

)

    15

from cpython.string cimport (

    16

    PyString_FromStringAndSize,

    17

)

    18

from pypngtile cimport *

    19

    20

cdef extern from "Python.h" :

    21

    int PyFile_Check (object p)

    22

    FILE* PyFile_AsFile (object p)

    23

    24

## constants

    25

# Image()

    26

OPEN_READ       = PT_OPEN_READ

    27

OPEN_UPDATE     = PT_OPEN_UPDATE

    28

    29

# Image.status -> ...

    30

CACHE_FRESH     = PT_CACHE_FRESH

    31

CACHE_NONE      = PT_CACHE_NONE

    32

CACHE_STALE     = PT_CACHE_STALE

    33

CACHE_INCOMPAT  = PT_CACHE_INCOMPAT

    34

    36

    """

    37

        Base class for errors raised by pypngtile.

    38

    """

    39

    40

    def __init__ (self, func, err) :

    41

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

    42

    43

cdef class Image :

    44

    """

    45

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

    46

    47

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

    48

    49

        path        - filesystem path to .png file

    50

        mode        - mode to operate cache in

    51

            OPEN_READ       - read-only access to cache

    52

            OPEN_UPDATE     - allow .update()

    53

    """

    54

    55

    cdef pt_image *image

    56

    57

    # XXX: should really be a pt_image property...

    58

    cdef readonly object path

    59

    60

    61

    # open the pt_image

    62

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

    63

        cdef int err

    64

    65

        # store

    66

        self.path = path

    67

    68

        # open

    69

        with nogil :

    70

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

    71

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

    72

    73

        if err :

    74

            raise Error("pt_image_open", err)

    75

    76

    77

    def info (self) :

    78

        """

    79

            Return a dictionary containing various information about the image.

    80

    81

            img_width           - pixel dimensions of the source image

    82

            img_height            only available if the cache was opened

    83

            img_bpp             - bits per pixel for the source image

    84

    85

            image_mtime         - last modification timestamp for source image

    86

            image_bytes         - size of source image file in bytes

    87

    88

            cache_version       - version of cache file available

    89

            cache_mtime         - last modification timestamp for cache file

    90

            cache_bytes         - size of cache file in bytes

    91

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

    92

        """

    93

    94

        cdef const_image_info_ptr infop

    95

        cdef int err

    96

    97

        with nogil :

    98

            err = pt_image_info_(self.image, &infop)

    99

   100

        if err :

   101

            raise Error("pt_image_info", err)

   102

   103

        # return as a struct

   104

        return infop[0]

   105

   106

   107

    def status (self) :

   108

        """

   109

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

   110

   111

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

   112

            CACHE_NONE          - the cache file does not exist

   113

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

   114

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

   115

        """

   116

   117

        cdef int ret

   118

   119

        with nogil :

   120

            ret = pt_image_status(self.image)

   121

   122

        if ret :

   123

            raise Error("pt_image_status", ret)

   124

   125

        return ret

   126

   127

    def open (self) :

   128

        """

   129

            Open the underlying cache file for reading, if available.

   130

        """

   131

   132

        cdef int err

   133

   134

        with nogil :

   135

            err = pt_image_load(self.image)

   136

   137

        if err :

   138

            raise Error("pt_image_load", err)

   139

   140

   141

    def update (self, background_color = None) :

   142

        """

   143

            Update the underlying cache file from the source image.

   144

   145

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

   146

   147

            Requires that the Image was opened using OPEN_UPDATE.

   148

        """

   149

   150

        cdef pt_image_params params

   151

        cdef char *bgcolor

   152

        cdef int err

   153

   154

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

   155

   156

        # params

   157

        if background_color :

   158

            # cast

   159

            bgcolor = <char *>background_color

   160

   161

            if 0 >= len(bgcolor) > 4 :

   162

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

   163

   164

            # decode 

   165

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

   166

   167

        # run update

   168

        with nogil :

   169

            err = pt_image_update(self.image, &params)

   170

   171

        if err :

   172

            raise Error("pt_image_update", err)

   173

   174

   175

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

   176

        """

   177

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

   178

   179

            width       - dimensions of the output tile in px

   180

            height      

   181

            x           - coordinates in the source file

   182

            y

   183

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

   184

            out         - output file

   185

   186

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

   187

        """

   188

   189

        cdef FILE *outf

   190

        cdef pt_tile_info ti

   191

        cdef int err

   192

   193

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

   194

   195

        # convert to FILE

   196

        if not PyFile_Check(out) :

   197

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

   198

   199

        outf = PyFile_AsFile(out)

   200

   201

        if not outf :

   202

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

   203

   204

        # pack params

   205

        ti.width = width

   206

        ti.height = height

   207

        ti.x = x

   208

        ti.y = y

   209

        ti.zoom = zoom

   210

   211

        # render

   212

        with nogil :

   213

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

   214

   215

        if err :

   216

            raise Error("pt_image_tile_file", err)

   217

   218

   219

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

   220

        """

   221

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

   222

   223

            width       - dimensions of the output tile in px

   224

            height      

   225

            x           - coordinates in the source file

   226

            y

   227

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

   228

        """

   229

   230

        cdef pt_tile_info ti

   231

        cdef char *buf

   232

        cdef size_t len

   233

        cdef int err

   234

   235

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

   236

   237

        # pack params

   238

        ti.width = width

   239

        ti.height = height

   240

        ti.x = x

   241

        ti.y = y

   242

        ti.zoom = zoom

   243

   244

        # render and return via buf/len

   245

        with nogil :

   246

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

   247

   248

        if err :

   249

            raise Error("pt_image_tile_mem", err)

   250

   251

        # copy buffer as str...

   252

        data = PyString_FromStringAndSize(buf, len)

   253

   254

        # drop buffer...

   255

        free(buf)

   256

   257

        return data

   258

   259

    # release the pt_image

   260

    def __dealloc__ (self) :

   261

        if self.image :

   262

            pt_image_destroy(self.image)

   263

   264

            self.image = NULL

   265