1

#include "image.h"

     2

#include "ctx.h"

     3

#include "png.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>

    12

#include <sys/stat.h>

    13

#include <unistd.h>

    14

#include <errno.h>

    15

    16

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

    17

{

    18

    struct pt_image *image;

    19

    int err = 0;

    20

    21

    // alloc

    22

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

    23

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    24

    25

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

    26

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    27

    28

    // init

    29

    image->ctx = ctx;

    30

    31

    // ok

    32

    *image_ptr = image;

    33

    34

    return 0;

    35

    36

error:

    37

    pt_image_destroy(image);

    38

    39

    return err;

    40

}

    41

    42

/**

    43

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

    44

 * buffer.

    45

 */

    46

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

    47

{

    48

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

    49

        RETURN_ERROR(PT_ERR_PATH);

    50

    51

    return 0;

    52

}

    53

    54

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

    55

{

    56

    struct pt_image *image;

    57

    char cache_path[1024];

    58

    int err;

    59

    60

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

    61

    if ((err = pt_png_check(path)) < 0)

    62

        return err;

    63

    64

    if (err)

    65

        // fail, not a PNG

    66

        RETURN_ERROR(PT_ERR_IMG_FORMAT);

    67

    68

    // alloc

    69

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

    70

        return err;

    71

    72

    // compute cache file path

    73

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

    74

        JUMP_ERROR(err);

    75

    76

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

    77

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

    78

        JUMP_ERROR(err);

    79

    80

    // ok, ready for access

    81

    *image_ptr = image;

    82

    83

    return 0;

    84

    85

error:

    86

    pt_image_destroy(image);

    87

    88

    return err;

    89

}

    90

    91

int pt_image_open_file (struct pt_image *image, FILE **file_ptr)

    92

{

    93

    FILE *fp;

    94

    95

    // open

    96

    if ((fp = fopen(image->path, "rb")) == NULL)

    97

        RETURN_ERROR(PT_ERR_IMG_OPEN);

    98

    99

    // ok

   100

    *file_ptr = fp;

   101

   102

    return 0;

   103

}

   104

   105

/**

   106

 * Open the PNG image, and write out to the cache

   107

 */

   108

int pt_image_update (struct pt_image *image, const struct pt_image_params *params)

   109

{

   110

    struct pt_png_img img;

   111

    int err = 0;

   112

   113

    // pre-check enabled

   114

    if (!(image->cache->mode & PT_OPEN_UPDATE))

   115

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   116

   117

    // open .png

   118

    if ((err = pt_png_open(image, &img)))

   119

        return err;

   120

   121

    // pass to cache object

   122

    if ((err = pt_cache_update(image->cache, &img, params)))

   123

        JUMP_ERROR(err);

   124

   125

error:

   126

    // clean up

   127

    pt_png_release_read(&img);

   128

   129

    return err;

   130

}

   131

   132

   133

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

   134

{

   135

    struct stat st;

   136

   137

    // update info from cache

   138

    pt_cache_info(image->cache, &image->info);

   139

   140

    // stat our info

   141

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

   142

        // unknown

   143

        image->info.image_mtime = 0;

   144

        image->info.image_bytes = 0;

   145

   146

    } else {

   147

        // store

   148

        image->info.image_mtime = st.st_mtime;

   149

        image->info.image_bytes = st.st_size;

   150

    }

   151

   152

    // return pointer

   153

    *info_ptr = &image->info;

   154

   155

    return 0;

   156

}

   157

   158

int pt_image_status (struct pt_image *image)

   159

{

   160

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

   161

}

   162

   163

   164

int pt_image_load (struct pt_image *image)

   165

{

   166

    return pt_cache_open(image->cache);

   167

}

   168

   169

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

   170

{

   171

    struct pt_tile tile;

   172

    int err;

   173

   174

    // init

   175

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

   176

        return err;

   177

   178

    // render

   179

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

   180

        JUMP_ERROR(err);

   181

   182

    // ok

   183

    return 0;

   184

   185

error:

   186

    pt_tile_abort(&tile);

   187

   188

    return err;

   189

}

   190

   191

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

   192

{

   193

    struct pt_tile tile;

   194

    int err;

   195

   196

    // init

   197

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

   198

        return err;

   199

   200

    // render

   201

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

   202

        JUMP_ERROR(err);

   203

   204

    // ok

   205

    *buf_ptr = tile.out.mem.base;

   206

    *len_ptr = tile.out.mem.len;

   207

   208

    return 0;

   209

   210

error:

   211

    pt_tile_abort(&tile);

   212

   213

    return err;

   214

}

   215

   216

/**

   217

 * Async work func for pt_image_tile_async

   218

 */

   219

static void _pt_image_tile_async (void *arg)

   220

{

   221

    struct pt_tile *tile = arg;

   222

    int err;

   223

   224

    // do render op

   225

    if ((err = pt_tile_render(tile)))

   226

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

   227

   228

    // signal done

   229

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

   230

        log_warn_errno("fclose");

   231

   232

    // cleanup

   233

    pt_tile_destroy(tile);

   234

}

   235

   236

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

   237

{

   238

    struct pt_tile *tile;

   239

    int err;

   240

   241

    // need a ctx for this

   242

    if (!image->ctx)

   243

        return -1;

   244

   245

    // alloc

   246

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

   247

        return err;

   248

   249

    // init

   250

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

   251

        JUMP_ERROR(err);

   252

   253

    // enqueue work

   254

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

   255

        JUMP_ERROR(err);

   256

   257

    // ok, running

   258

    return 0;

   259

   260

error:

   261

    pt_tile_destroy(tile);

   262

   263

    return err;

   264

}

   265

   266

void pt_image_destroy (struct pt_image *image)

   267

{

   268

    free(image->path);

   269

   270

    if (image->cache)

   271

        pt_cache_destroy(image->cache);

   272

   273

    free(image);

   274

}

   275