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>

    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

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

    60

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

    61

        return err;

    62

    63

    if (err)

    64

        // fail, not a PNG

    65

        RETURN_ERROR(PT_ERR_IMG_FORMAT);

    66

    67

    // alloc

    68

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

    69

        return err;

    70

    71

    // compute cache file path

    72

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

    73

        JUMP_ERROR(err);

    74

    75

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

    76

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

    77

        JUMP_ERROR(err);

    78

    79

    // ok, ready for access

    80

    *image_ptr = image;

    81

    82

    return 0;

    83

    84

error:

    85

    pt_image_destroy(image);

    86

    87

    return err;

    88

}

    89

    90

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

    91

{

    92

    FILE *fp;

    93

    94

    // open

    95

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

    96

        RETURN_ERROR(PT_ERR_IMG_OPEN);

    97

    98

    // ok

    99

    *file_ptr = fp;

   100

   101

    return 0;

   102

}

   103

   104

/**

   105

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

   106

 */

   107

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

   108

{

   109

    struct pt_png_img img;

   110

    int err = 0;

   111

   112

    // pre-check enabled

   113

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

   114

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   115

   116

    // open .png

   117

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

   118

        return err;

   119

   120

    // pass to cache object

   121

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

   122

        JUMP_ERROR(err);

   123

   124

error:

   125

    // clean up

   126

    pt_png_release_read(&img);

   127

   128

    return err;

   129

}

   130

   131

   132

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

   133

{

   134

    struct stat st;

   135

   136

    // update info from cache

   137

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

   138

   139

    // stat our info

   140

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

   141

        // unknown

   142

        image->info.image_mtime = 0;

   143

        image->info.image_bytes = 0;

   144

   145

    } else {

   146

        // store

   147

        image->info.image_mtime = st.st_mtime;

   148

        image->info.image_bytes = st.st_size;

   149

    }

   150

   151

    // return pointer

   152

    *info_ptr = &image->info;

   153

   154

    return 0;

   155

}

   156

   157

int pt_image_status (struct pt_image *image)

   158

{

   159

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

   160

}

   161

   162

   163

int pt_image_load (struct pt_image *image)

   164

{

   165

    return pt_cache_open(image->cache);

   166

}

   167

   168

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

   169

{

   170

    struct pt_tile tile;

   171

    int err;

   172

   173

    // init

   174

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

   175

        return err;

   176

   177

    // render

   178

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

   179

        JUMP_ERROR(err);

   180

   181

    // ok

   182

    return 0;

   183

   184

error:

   185

    pt_tile_abort(&tile);

   186

   187

    return err;

   188

}

   189

   190

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

   191

{

   192

    struct pt_tile tile;

   193

    int err;

   194

   195

    // init

   196

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

   197

        return err;

   198

   199

    // render

   200

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

   201

        JUMP_ERROR(err);

   202

   203

    // ok

   204

    *buf_ptr = tile.out.mem.base;

   205

    *len_ptr = tile.out.mem.len;

   206

   207

    return 0;

   208

   209

error:

   210

    pt_tile_abort(&tile);

   211

   212

    return err;

   213

}

   214

   215

/**

   216

 * Async work func for pt_image_tile_async

   217

 */

   218

static void _pt_image_tile_async (void *arg)

   219

{

   220

    struct pt_tile *tile = arg;

   221

    int err;

   222

   223

    // do render op

   224

    if ((err = pt_tile_render(tile)))

   225

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

   226

   227

    // signal done

   228

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

   229

        log_warn_errno("fclose");

   230

   231

    // cleanup

   232

    pt_tile_destroy(tile);

   233

}

   234

   235

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

   236

{

   237

    struct pt_tile *tile;

   238

    int err;

   239

   240

    // need a ctx for this

   241

    if (!image->ctx)

   242

        return -1;

   243

   244

    // alloc

   245

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

   246

        return err;

   247

   248

    // init

   249

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

   250

        JUMP_ERROR(err);

   251

   252

    // enqueue work

   253

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

   254

        JUMP_ERROR(err);

   255

   256

    // ok, running

   257

    return 0;

   258

   259

error:

   260

    pt_tile_destroy(tile);

   261

   262

    return err;

   263

}

   264

   265

void pt_image_destroy (struct pt_image *image)

   266

{

   267

    free(image->path);

   268

   269

    if (image->cache)

   270

        pt_cache_destroy(image->cache);

   271

   272

    free(image);

   273

}

   274