1

#include "cache.h"

     2

     3

#include <stdlib.h>

     4

#include <unistd.h>

     5

#include <sys/types.h>

     6

#include <sys/stat.h>

     7

#include <fcntl.h>

     8

#include <sys/mman.h>

    10

    11

    12

    13

static int pt_cache_new (struct pt_cache **cache_ptr, const char *path)

    14

{

    15

    struct pt_cache *cache;

    16

    17

    // alloc

    18

    if ((cache = calloc(1, sizeof(*cache))) == NULL)

    19

        return -1;

    20

    21

    if ((cache->path = strdup(path)) == NULL)

    22

        goto error;

    23

    24

    // init

    25

    cache->fd = -1;

    26

    27

    // ok

    28

    *cache_ptr = cache;

    29

    30

    return 0;

    31

    32

error:

    33

    // cleanup

    34

    if (cache)

    35

        pt_cache_destroy(cache);

    36

    37

    return -1;

    38

}

    39

    40

int pt_cache_open (struct pt_cache **cache_ptr, const char *path, int mode)

    41

{

    42

    struct pt_cache *cache;

    43

    44

    // alloc

    45

    if (pt_cache_new(&cache, path))

    46

        return -1;

    47

    48

    // ok

    49

    *cache_ptr = cache;

    50

    51

    return 0;

    52

}

    53

    55

{

    73

}

    74

    75

/**

    76

 * Abort any incomplete open operation, cleaning up

    77

 */

    78

static void pt_cache_abort (struct pt_cache *cache)

    79

{

    80

    if (cache->mmap != NULL) {

    81

        munmap(cache->mmap, cache->size);

    82

    83

        cache->mmap = NULL;

    84

    }

    85

    86

    if (cache->fd >= 0) {

    87

        close(cache->fd);

    88

    89

        cache->fd = -1;

    90

    }

    91

}

    92

    93

/**

    94

 * Open the cache file as an fd.

    95

 *

    96

 * XXX: needs locking

    97

 */

    98

static int pt_cache_open_fd (struct pt_cache *cache, int *fd_ptr)

    99

{

   100

    int fd;

   101

    int flags = 0;

   102

   103

    // determine open flags

   104

    // XXX: O_RDONLY | O_WRONLY == O_RDWR?

   105

    if (cache->mode & PT_IMG_READ)

   106

        flags |= O_RDONLY;

   107

   108

    if (cache->mode & PT_IMG_WRITE)

   109

        flags |= (O_WRONLY | O_CREAT);

   110

   111

    // actual open()

   112

    if ((fd = open(cache->path, flags)) < 0)

   113

        return -1;

   114

   115

    // ok

   116

    *fd_ptr = fd;

   117

   118

    return 0;

   119

}

   120

   121

/**

   122

 * Mmap the opened cache file from offset PT_CACHE_PAGE, using the calculated size stored in cache->size

   123

 */

   124

static int pt_cache_open_mmap (struct pt_cache *cache, void **addr_ptr)

   125

{

   126

    int prot = 0;

   127

    void *addr;

   128

   129

    // determine prot

   130

    if (cache->mode & PT_IMG_READ)

   131

        prot |= PROT_READ;

   132

   133

    if (cache->mode & PT_IMG_WRITE)

   134

        prot |= PROT_WRITE;

   135

   136

    // perform mmap() from second page on

   137

    if ((addr = mmap(NULL, cache->size, prot, MAP_SHARED, cache->fd, PT_CACHE_PAGE)) == MAP_FAILED)

   138

        return -1;

   139

   140

    // ok

   141

    *addr_ptr = addr;

   142

   143

    return 0;

   144

}

   145

   146

/**

   147

 * Write out the cache header into the opened file

   148

 */

   149

static int pt_cache_write_header (struct pt_cache *cache, const struct pt_cache_header *header)

   150

{

   151

    size_t len = sizeof(*header);

   152

    const char *buf = (const char *) header;

   153

   154

    // seek to start

   155

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   156

        return -1;

   157

   158

    // write out full header

   159

    while (len) {

   160

        ssize_t ret;

   161

   162

        // try and write out the header

   163

        if ((ret = write(cache->fd, buf, len)) < 0)

   164

            return -1;

   165

   166

        // update offset

   167

        buf += ret;

   168

        len -= ret;

   169

    }

   170

   171

    // done

   172

    return 0;

   173

}

   174

   175

/**

   176

 * Create a new cache file, open it, and write out the header.

   177

 */

   178

static int pt_cache_open_create (struct pt_cache *cache, struct pt_cache_header *header)

   179

{

   186

    // open

   187

    if (pt_cache_open_fd(cache, &cache->fd))

   188

        return -1;

   189

   190

    // calculate data size

   191

    cache->size = sizeof(*header) + header->height * header->row_bytes;

   192

   193

    // grow file

   194

    if (ftruncate(cache->fd, PT_CACHE_PAGE + cache->size) < 0)

   195

        goto error;

   196

   197

    // open mmap

   198

    if (pt_cache_open_mmap(cache, (void **) &cache->mmap))

   199

        goto error;

   200

   201

    // write header

   202

    if (pt_cache_write_header(cache, header))

   203

        goto error;

   204

   205

    // done

   206

    return 0;

   207

   208

error:

   209

    // cleanup

   210

    pt_cache_abort(cache);

   211

   212

    return -1;

   213

}

   214

   215

int pt_cache_update_png (struct pt_cache *cache, png_structp png, png_infop info)

   216

{

   217

    struct pt_cache_header header;

   218

   219

    // XXX: check cache_mode

   220

    // XXX: check image doesn't use any options we don't handle

   221

   222

    memset(&header, 0, sizeof(header));

   223

   224

    // fill in basic info

   225

    header.width = png_get_image_width(png, info);

   226

    header.height = png_get_image_height(png, info);

   227

    header.bit_depth = png_get_bit_depth(png, info);

   228

    header.color_type = png_get_color_type(png, info);

   229

   230

    // fill in other info

   231

    header.row_bytes = png_get_rowbytes(png, info);

   232

   233

    // create and write out header

   234

    if (pt_cache_open_create(cache, &header))

   235

        return -1;

   236

   237

    // XXX: pallette etc.

   238

   239

    // write out raw image data a row at a time

   240

    for (size_t row = 0; row < header.height; row++) {

   241

        // read row data, non-interlaced

   242

        png_read_row(png, cache->mmap + row * header.row_bytes, NULL);

   243

    }

   244

   245

    // done!

   246

    return 0;

   247

}

   248

   249

void pt_cache_destroy (struct pt_cache *cache)

   250

{

   251

    free(cache->path);

   252

   253

    pt_cache_abort(cache);

   254

   255

    free(cache);

   256

}