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 <sys/stat.h>

    11

#include <unistd.h>

    12

#include <errno.h>

    13

    14

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

 * Open the image's FILE

    44

 */

    45

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

    46

{

    47

    FILE *fp;

    48

    49

    // open

    50

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

    51

        RETURN_ERROR(PT_ERR_IMG_FOPEN);

    52

    53

    // ok

    54

    *file_ptr = fp;

    55

    56

    return 0;

    57

}

    58

    59

/**

    60

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

    61

 */

    62

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

    63

{

    64

    FILE *fp = NULL;

    65

    png_structp png = NULL;

    66

    png_infop info = NULL;

    67

    int err;

    68

    69

    // open I/O

    70

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

    71

        JUMP_ERROR(err);

    72

    73

    // create the struct

    74

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

    75

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    76

    77

    // create the info

    78

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

    79

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    80

    81

    // setup error trap for the I/O

    82

    if (setjmp(png_jmpbuf(png)))

    83

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    84

    85

    // setup I/O to FILE

    86

    png_init_io(png, fp);

    87

    88

    // ok

    89

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

    90

    *png_ptr = png;

    91

    *info_ptr = info;

    92

    93

    return 0;

    94

    95

error:

    96

    // cleanup file

    97

    if (fp) fclose(fp);

    98

    99

    // cleanup PNG state

   100

    png_destroy_read_struct(&png, &info, NULL);

   101

   102

    return err;

   103

}

   104

   105

/**

   106

 * Update the image_info field from the given png object.

   107

 *

   108

 * Must be called under libpng-error-trap!

   109

 *

   110

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

   111

 */

   112

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

   113

{

   114

    // query png_get_*

   115

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

   116

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

   117

   118

    return 0;

   119

}

   120

   121

/**

   122

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

   123

 */

   124

static int pt_image_update_cache (struct pt_image *image, const struct pt_image_params *params)

   125

{

   126

    png_structp png;

   127

    png_infop info;

   128

    int err = 0;

   129

   130

    // pre-check enabled

   131

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

   132

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   133

   134

    // open .png

   135

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

   136

        return err;

   137

   138

    // setup error trap

   139

    if (setjmp(png_jmpbuf(png)))

   140

        JUMP_SET_ERROR(err, PT_ERR_PNG);

   141

   142

    // read meta-info

   143

    png_read_info(png, info);

   144

   145

    // update our meta-info

   146

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

   147

        JUMP_ERROR(err);

   148

   149

    // pass to cache object

   150

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

   151

        JUMP_ERROR(err);

   152

   153

    // finish off, ignore trailing data

   154

    png_read_end(png, NULL);

   155

   156

error:

   157

    // clean up

   158

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

   159

    png_destroy_read_struct(&png, &info, NULL);

   160

   161

    return err;

   162

}

   163

   164

/**

   165

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

   166

 * buffer.

   167

 */

   168

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

   169

{

   170

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

   171

        RETURN_ERROR(PT_ERR_PATH);

   172

   173

    return 0;

   174

}

   175

   176

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

   177

{

   178

    struct pt_image *image;

   179

    char cache_path[1024];

   180

    int err;

   181

   182

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

   183

   184

    // alloc

   185

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

   186

        return err;

   187

   188

    // compute cache file path

   189

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

   190

        JUMP_ERROR(err);

   191

   192

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

   193

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

   194

        JUMP_ERROR(err);

   195

   196

    // ok, ready for access

   197

    *image_ptr = image;

   198

   199

    return 0;

   200

   201

error:

   202

    pt_image_destroy(image);

   203

   204

    return err;

   205

}

   206

   207

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

   208

{

   209

    struct stat st;

   210

    int err;

   211

   212

    // update info

   213

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

   214

        return err;

   215

   216

    // stat our info

   217

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

   218

        // unknown

   219

        image->info.image_mtime = 0;

   220

        image->info.image_bytes = 0;

   221

   222

    } else {

   223

        // store

   224

        image->info.image_mtime = st.st_mtime;

   225

        image->info.image_bytes = st.st_size;

   226

    }

   227

   228

    // return pointer

   229

    *info_ptr = &image->info;

   230

   231

    return 0;

   232

}

   233

   234

int pt_image_status (struct pt_image *image)

   235

{

   236

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

   237

}

   238

   239

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

   240

{

   241

    return pt_image_update_cache(image, params);

   242

}

   243

   244

int pt_image_load (struct pt_image *image)

   245

{

   246

    return pt_cache_open(image->cache);

   247

}

   248

   249

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

   250

{

   251

    struct pt_tile tile;

   252

    int err;

   253

   254

    // init

   255

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

   256

        return err;

   257

   258

    // render

   259

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

   260

        JUMP_ERROR(err);

   261

   262

    // ok

   263

    return 0;

   264

   265

error:

   266

    pt_tile_abort(&tile);

   267

   268

    return err;

   269

}

   270

   271

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

   272

{

   273

    struct pt_tile tile;

   274

    int err;

   275

   276

    // init

   277

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

   278

        return err;

   279

   280

    // render

   281

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

   282

        JUMP_ERROR(err);

   283

   284

    // ok

   285

    *buf_ptr = tile.out.mem.base;

   286

    *len_ptr = tile.out.mem.len;

   287

   288

    return 0;

   289

   290

error:

   291

    pt_tile_abort(&tile);

   292

   293

    return err;

   294

}

   295

   296

static void _pt_image_tile_async (void *arg)

   297

{

   298

    struct pt_tile *tile = arg;

   299

    int err;

   300

   301

    // do render op

   302

    if ((err = pt_tile_render(tile)))

   303

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

   304

   305

    // signal done

   306

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

   307

        log_warn_errno("fclose");

   308

   309

    // cleanup

   310

    pt_tile_destroy(tile);

   311

}

   312

   313

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

   314

{

   315

    struct pt_tile *tile;

   316

    int err;

   317

   318

    // alloc

   319

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

   320

        return err;

   321

   322

    // init

   323

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

   324

        JUMP_ERROR(err);

   325

   326

    // enqueue work

   327

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

   328

        JUMP_ERROR(err);

   329

   330

    // ok, running

   331

    return 0;

   332

   333

error:

   334

    pt_tile_destroy(tile);

   335

   336

    return err;

   337

}

   338

   339

void pt_image_destroy (struct pt_image *image)

   340

{

   341

    free(image->path);

   342

   343

    if (image->cache)

   344

        pt_cache_destroy(image->cache);

   345

   346

    free(image);

   347

}

   348