1

#include "image.h"

     2

#include "ctx.h"

     4

#include "cache.h"

     5

#include "tile.h"

     6

#include "error.h"

     7

#include "shared/util.h"

     8

#include "shared/log.h"

     9

    10

#include <stdlib.h>

    11

#include <sys/stat.h>

    12

#include <unistd.h>

    13

#include <errno.h>

    14

    15

static int pt_image_new (struct pt_image **image_ptr, struct pt_ctx *ctx, const char *path)

    16

{

    17

    struct pt_image *image;

    18

    int err = 0;

    19

    20

    // alloc

    21

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

    22

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    23

    24

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

    25

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    26

    27

    // init

    28

    image->ctx = ctx;

    29

    30

    // ok

    31

    *image_ptr = image;

    32

    33

    return 0;

    34

    35

error:

    36

    pt_image_destroy(image);

    37

    38

    return err;

    39

}

    40

    41

/**

    42

 * Build a filesystem path representing the appropriate path for this image's cache entry, and store it in the given

    43

 * buffer.

    44

 */

    45

static int pt_image_cache_path (struct pt_image *image, char *buf, size_t len)

    46

{

    47

    if (path_with_fext(image->path, buf, len, ".cache"))

    48

        RETURN_ERROR(PT_ERR_PATH);

    49

    50

    return 0;

    51

}

    52

    53

int pt_image_open (struct pt_image **image_ptr, struct pt_ctx *ctx, const char *path, int cache_mode)

    54

{

    55

    struct pt_image *image;

    56

    char cache_path[1024];

    57

    int err;

    58

    59

    // XXX: verify that the path exists and looks like a PNG file

    60

    61

    // alloc

    62

    if ((err = pt_image_new(&image, ctx, path)))

    63

        return err;

    64

    65

    // compute cache file path

    66

    if ((err = pt_image_cache_path(image, cache_path, sizeof(cache_path))))

    67

        JUMP_ERROR(err);

    68

    69

    // create the cache object for this image (doesn't yet open it)

    70

    if ((err = pt_cache_new(&image->cache, cache_path, cache_mode)))

    71

        JUMP_ERROR(err);

    72

    73

    // ok, ready for access

    74

    *image_ptr = image;

    75

    76

    return 0;

    77

    78

error:

    79

    pt_image_destroy(image);

    80

    81

    return err;

    82

}

    83

   126

int pt_image_info (struct pt_image *image, const struct pt_image_info **info_ptr)

   127

{

   128

    struct stat st;

   129

   132

   133

    // stat our info

   134

    if (stat(image->path, &st) < 0) {

   135

        // unknown

   136

        image->info.image_mtime = 0;

   137

        image->info.image_bytes = 0;

   138

   139

    } else {

   140

        // store

   141

        image->info.image_mtime = st.st_mtime;

   142

        image->info.image_bytes = st.st_size;

   143

    }

   144

   145

    // return pointer

   146

    *info_ptr = &image->info;

   147

   148

    return 0;

   149

}

   150

   151

int pt_image_status (struct pt_image *image)

   152

{

   153

    return pt_cache_status(image->cache, image->path);

   154

}

   155

   156

   157

int pt_image_load (struct pt_image *image)

   158

{

   159

    return pt_cache_open(image->cache);

   160

}

   161

   162

int pt_image_tile_file (struct pt_image *image, const struct pt_tile_info *info, FILE *out)

   163

{

   164

    struct pt_tile tile;

   165

    int err;

   166

   167

    // init

   168

    if ((err = pt_tile_init_file(&tile, image->cache, info, out)))

   169

        return err;

   170

   171

    // render

   172

    if ((err = pt_tile_render(&tile)))

   173

        JUMP_ERROR(err);

   174

   175

    // ok

   176

    return 0;

   177

   178

error:

   179

    pt_tile_abort(&tile);

   180

   181

    return err;

   182

}

   183

   184

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

   185

{

   186

    struct pt_tile tile;

   187

    int err;

   188

   189

    // init

   190

    if ((err = pt_tile_init_mem(&tile, image->cache, info)))

   191

        return err;

   192

   193

    // render

   194

    if ((err = pt_tile_render(&tile)))

   195

        JUMP_ERROR(err);

   196

   197

    // ok

   198

    *buf_ptr = tile.out.mem.base;

   199

    *len_ptr = tile.out.mem.len;

   200

   201

    return 0;

   202

   203

error:

   204

    pt_tile_abort(&tile);

   205

   206

    return err;

   207

}

   208

   209

static void _pt_image_tile_async (void *arg)

   210

{

   211

    struct pt_tile *tile = arg;

   212

    int err;

   213

   214

    // do render op

   215

    if ((err = pt_tile_render(tile)))

   216

        log_warn_errno("pt_tile_render: %s", pt_strerror(err));

   217

   218

    // signal done

   219

    if (fclose(tile->out.file))

   220

        log_warn_errno("fclose");

   221

   222

    // cleanup

   223

    pt_tile_destroy(tile);

   224

}

   225

   226

int pt_image_tile_async (struct pt_image *image, const struct pt_tile_info *info, FILE *out)

   227

{

   228

    struct pt_tile *tile;

   229

    int err;

   230

   231

    // alloc

   232

    if ((err = pt_tile_new(&tile)))

   233

        return err;

   234

   235

    // init

   236

    if ((err = pt_tile_init_file(tile, image->cache, info, out)))

   237

        JUMP_ERROR(err);

   238

   239

    // enqueue work

   240

    if ((err = pt_ctx_work(image->ctx, _pt_image_tile_async, tile)))

   241

        JUMP_ERROR(err);

   242

   243

    // ok, running

   244

    return 0;

   245

   246

error:

   247

    pt_tile_destroy(tile);

   248

   249

    return err;

   250

}

   251

   252

void pt_image_destroy (struct pt_image *image)

   253

{

   254

    free(image->path);

   255

   256

    if (image->cache)

   257

        pt_cache_destroy(image->cache);

   258

   259

    free(image);

   260

}

   261