1

#include "image.h"

     2

#include "ctx.h"

     3

#include "cache.h"

     4

#include "tile.h"

     5

#include "error.h"

     6

#include "shared/util.h"

     7

#include "shared/log.h"

     8

     9

#include <stdlib.h>

    10

#include <errno.h>

    11

    12

#include <png.h>

    13

    14

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

    15

{

    16

    struct pt_image *image;

    17

    int err = 0;

    18

    19

    // alloc

    20

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

    21

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    22

    23

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

    24

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    25

    26

    // init

    27

    image->ctx = ctx;

    28

    29

    // ok

    30

    *image_ptr = image;

    31

    32

    return 0;

    33

    34

error:

    35

    pt_image_destroy(image);

    36

    37

    return err;

    38

}

    39

    40

/**

    41

 * Open the image's FILE

    42

 */

    43

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

    44

{

    45

    FILE *fp;

    46

    47

    // open

    48

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

    49

        RETURN_ERROR(PT_ERR_IMG_FOPEN);

    50

    51

    // ok

    52

    *file_ptr = fp;

    53

    54

    return 0;

    55

}

    56

    57

/**

    58

 * Open the PNG image, setting up the I/O and returning the png_structp and png_infop

    59

 */

    60

static int pt_image_open_png (struct pt_image *image, png_structp *png_ptr, png_infop *info_ptr)

    61

{

    62

    FILE *fp = NULL;

    63

    png_structp png = NULL;

    64

    png_infop info = NULL;

    65

    int err;

    66

    67

    // open I/O

    68

    if ((err = pt_image_open_file(image, &fp)))

    69

        JUMP_ERROR(err);

    70

    71

    // create the struct

    72

    if ((png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL)

    73

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    74

    75

    // create the info

    76

    if ((info = png_create_info_struct(png)) == NULL)

    77

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    78

    79

    // setup error trap for the I/O

    80

    if (setjmp(png_jmpbuf(png)))

    81

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    82

    83

    // setup I/O to FILE

    84

    png_init_io(png, fp);

    85

    86

    // ok

    87

    // XXX: what to do with fp? Should fclose() when done?

    88

    *png_ptr = png;

    89

    *info_ptr = info;

    90

    91

    return 0;

    92

    93

error:

    94

    // cleanup file

    95

    if (fp) fclose(fp);

    96

    97

    // cleanup PNG state

    98

    png_destroy_read_struct(&png, &info, NULL);

    99

   100

    return err;

   101

}

   102

   103

/**

   104

 * Update the image_info field from the given png object.

   105

 *

   106

 * Must be called under libpng-error-trap!

   107

 *

   108

 * XXX: currently this info is not used, pulled from the cache instead

   109

 */

   110

static int pt_image_update_info (struct pt_image *image, png_structp png, png_infop info)

   111

{

   112

    // query png_get_*

   113

    image->info.width = png_get_image_width(png, info); 

   114

    image->info.height = png_get_image_height(png, info); 

   115

   116

    return 0;

   117

}

   118

   119

/**

   120

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

   121

 */

   122

static int pt_image_update_cache (struct pt_image *image)

   123

{

   124

    png_structp png;

   125

    png_infop info;

   126

    int err = 0;

   127

   128

    // pre-check enabled

   129

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

   130

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   131

   132

    // open .png

   133

    if ((err = pt_image_open_png(image, &png, &info)))

   134

        return err;

   135

   136

    // setup error trap

   137

    if (setjmp(png_jmpbuf(png)))

   138

        JUMP_SET_ERROR(err, PT_ERR_PNG);

   139

   140

    // read meta-info

   141

    png_read_info(png, info);

   142

   143

    // update our meta-info

   144

    if ((err = pt_image_update_info(image, png, info)))

   145

        JUMP_ERROR(err);

   146

   147

    // pass to cache object

   148

    if ((err = pt_cache_update_png(image->cache, png, info)))

   149

        JUMP_ERROR(err);

   150

   151

    // finish off, ignore trailing data

   152

    png_read_end(png, NULL);

   153

   154

error:

   155

    // clean up

   156

    // XXX: we need to close the fopen'd .png

   157

    png_destroy_read_struct(&png, &info, NULL);

   158

   159

    return err;

   160

}

   161

   162

/**

   163

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

   164

 * buffer.

   165

 */

   166

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

   167

{

   168

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

   169

        RETURN_ERROR(PT_ERR_PATH);

   170

   171

    return 0;

   172

}

   173

   174

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

   175

{

   176

    struct pt_image *image;

   177

    char cache_path[1024];

   178

    int err;

   179

   180

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

   181

   182

    // alloc

   183

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

   184

        return err;

   185

   186

    // compute cache file path

   187

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

   188

        JUMP_ERROR(err);

   189

   190

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

   191

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

   192

        JUMP_ERROR(err);

   193

   194

    // ok, ready for access

   195

    *image_ptr = image;

   196

   197

    return 0;

   198

   199

error:

   200

    pt_image_destroy(image);

   201

   202

    return err;

   203

}

   204

   205

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

   206

{

   207

    int err;

   208

   209

    // update info

   210

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

   211

        return err;

   212

   213

    // return pointer

   214

    *info_ptr = &image->info;

   215

   216

    return 0;

   217

}

   218

   219

int pt_image_status (struct pt_image *image)

   220

{

   221

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

   222

}

   223

   224

int pt_image_update (struct pt_image *image)

   225

{

   226

    return pt_image_update_cache(image);

   227

}

   228

   234

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

   235

{

   236

    struct pt_tile tile;

   237

    int err;

   238

   239

    // init

   240

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

   241

        return err;

   242

   243

    // render

   244

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

   245

        JUMP_ERROR(err);

   246

   247

    // ok

   248

    return 0;

   249

   250

error:

   251

    pt_tile_abort(&tile);

   252

   253

    return err;

   254

}

   255

   256

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

   257

{

   258

    struct pt_tile tile;

   259

    int err;

   260

   261

    // init

   262

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

   263

        return err;

   264

   265

    // render

   266

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

   267

        JUMP_ERROR(err);

   268

   269

    // ok

   270

    *buf_ptr = tile.out.mem.base;

   271

    *len_ptr = tile.out.mem.len;

   272

   273

    return 0;

   274

   275

error:

   276

    pt_tile_abort(&tile);

   277

   278

    return err;

   279

}

   280

   281

static void _pt_image_tile_async (void *arg)

   282

{

   283

    struct pt_tile *tile = arg;

   284

    int err;

   285

   286

    // do render op

   287

    if ((err = pt_tile_render(tile)))

   288

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

   289

   290

    // signal done

   291

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

   292

        log_warn_errno("fclose");

   293

   294

    // cleanup

   295

    pt_tile_destroy(tile);

   296

}

   297

   298

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

   299

{

   300

    struct pt_tile *tile;

   301

    int err;

   302

   303

    // alloc

   304

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

   305

        return err;

   306

   307

    // init

   308

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

   309

        JUMP_ERROR(err);

   310

   311

    // enqueue work

   312

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

   313

        JUMP_ERROR(err);

   314

   315

    // ok, running

   316

    return 0;

   317

   318

error:

   319

    pt_tile_destroy(tile);

   320

   321

    return err;

   322

}

   323

   324

void pt_image_destroy (struct pt_image *image)

   325

{

   326

    free(image->path);

   327

   328

    if (image->cache)

   329

        pt_cache_destroy(image->cache);

   330

   331

    free(image);

   332

}

   333