1

#include "cache.h"

     2

#include "shared/util.h"

     3

#include "shared/log.h" // only LOG_DEBUG

     4

     5

#include <stdlib.h>

     6

#include <unistd.h>

     7

#include <sys/types.h>

     8

#include <sys/stat.h>

     9

#include <fcntl.h>

    10

#include <sys/mman.h>

    11

#include <errno.h>

    12

#include <assert.h>

    13

    14

    15

int pt_cache_new (struct pt_cache **cache_ptr, const char *path, int mode)

    16

{

    17

    struct pt_cache *cache;

    18

    19

    // alloc

    20

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

    21

        return -1;

    22

    23

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

    24

        goto error;

    25

    26

    // init

    27

    cache->fd = -1;

    28

    cache->mode = mode;

    29

    30

    // ok

    31

    *cache_ptr = cache;

    32

    33

    return 0;

    34

    35

error:

    36

    // cleanup

    37

    if (cache)

    38

        pt_cache_destroy(cache);

    39

    40

    return -1;

    41

}

    42

    43

int pt_cache_status (struct pt_cache *cache, const char *img_path)

    44

{

    45

    struct stat st_img, st_cache;

    46

    47

    // test original file

    48

    if (stat(img_path, &st_img) < 0)

    49

        return -1;

    50

    51

    // test cache file

    52

    if (stat(cache->path, &st_cache) < 0) {

    53

        // always stale if it doesn't exist yet

    54

        if (errno == ENOENT)

    55

            return PT_CACHE_NONE;

    56

        else

    57

            return -1;

    58

    }

    59

    60

    // compare mtime

    61

    if (st_img.st_mtime > st_cache.st_mtime)

    62

        return PT_CACHE_STALE;

    63

    64

    else

    65

        return PT_CACHE_FRESH;

    66

}

    67

    80

/**

    81

 * Abort any incomplete open operation, cleaning up

    82

 */

    83

static void pt_cache_abort (struct pt_cache *cache)

    84

{

    85

    if (cache->header != NULL) {

    86

        munmap(cache->header, PT_CACHE_HEADER_SIZE + cache->size);

    87

    88

        cache->header = NULL;

    89

        cache->data = NULL;

    90

    }

    91

    92

    if (cache->fd >= 0) {

    93

        close(cache->fd);

    94

    95

        cache->fd = -1;

    96

    }

    97

}

    98

    99

/**

   100

 * Open the cache file as an fd for reading

   101

 *

   102

 * XXX: needs locking

   103

 */

   104

static int pt_cache_open_read_fd (struct pt_cache *cache, int *fd_ptr)

   105

{

   106

    int fd;

   107

   108

    // actual open()

   109

    if ((fd = open(cache->path, O_RDONLY)) < 0)

   110

        return -1;

   111

   112

    // ok

   113

    *fd_ptr = fd;

   114

   115

    return 0;

   116

}

   117

   118

/**

   119

 * Open the .tmp cache file as an fd for writing

   120

 */

   121

static int pt_cache_open_tmp_fd (struct pt_cache *cache, int *fd_ptr)

   122

{

   123

    int fd;

   124

    char tmp_path[1024];

   125

   126

    // check mode

   127

    if (!(cache->mode & PT_IMG_WRITE)) {

   128

        errno = EPERM;

   129

        return -1;

   130

    }

   131

   132

    // get .tmp path

   133

    if (path_with_fext(cache->path, tmp_path, sizeof(tmp_path), ".tmp"))

   134

        return -1;

   135

   136

    // open for write, create

   137

    // XXX: locking?

   138

    if ((fd = open(tmp_path, O_RDWR | O_CREAT, 0644)) < 0)

   139

        return -1;

   140

   141

    // ok

   142

    *fd_ptr = fd;

   143

   144

    return 0;

   145

}

   146

   147

   148

/**

   149

 * Mmap the opened cache file using PT_CACHE_HEADER_SIZE plus the calculated size stored in cache->size

   150

 */

   151

static int pt_cache_open_mmap (struct pt_cache *cache, void **addr_ptr, bool readonly)

   152

{

   153

    int prot = 0;

   154

    void *addr;

   155

   156

    // determine prot

   157

    prot |= PROT_READ;

   158

   159

    if (!readonly) {

   160

        assert(cache->mode & PT_IMG_WRITE);

   161

   162

        prot |= PROT_WRITE;

   163

    }

   164

   165

    // perform mmap() from second page on

   166

    if ((addr = mmap(NULL, PT_CACHE_HEADER_SIZE + cache->size, prot, MAP_SHARED, cache->fd, 0)) == MAP_FAILED)

   167

        return -1;

   168

   169

    // ok

   170

    *addr_ptr = addr;

   171

   172

    return 0;

   173

}

   174

   175

/**

   176

 * Read in the cache header from the open file

   177

 */

   178

static int pt_cache_read_header (struct pt_cache *cache, struct pt_cache_header *header)

   179

{

   180

    size_t len = sizeof(*header);

   181

    char *buf = (char *) header;

   182

   183

    // seek to start

   184

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   185

        return -1;

   186

   187

    // write out full header

   188

    while (len) {

   189

        ssize_t ret;

   190

   191

        // try and write out the header

   192

        if ((ret = read(cache->fd, buf, len)) < 0)

   193

            return -1;

   194

   195

        // update offset

   196

        buf += ret;

   197

        len -= ret;

   198

    }

   199

   200

    // done

   201

    return 0;

   202

}

   203

   204

/**

   205

 * Write out the cache header into the opened file

   206

 */

   207

static int pt_cache_write_header (struct pt_cache *cache, const struct pt_cache_header *header)

   208

{

   209

    size_t len = sizeof(*header);

   210

    const char *buf = (const char *) header;

   211

   212

    // seek to start

   213

    if (lseek(cache->fd, 0, SEEK_SET) != 0)

   214

        return -1;

   215

   216

    // write out full header

   217

    while (len) {

   218

        ssize_t ret;

   219

   220

        // try and write out the header

   221

        if ((ret = write(cache->fd, buf, len)) < 0)

   222

            return -1;

   223

   224

        // update offset

   225

        buf += ret;

   226

        len -= ret;

   227

    }

   228

   229

    // done

   230

    return 0;

   231

}

   232

   233

/**

   234

 * Create a new .tmp cache file, open it, and write out the header.

   235

 */

   236

static int pt_cache_open_create (struct pt_cache *cache, struct pt_cache_header *header)

   237

{

   238

    void *base;

   239

   240

    // no access

   241

    if (!(cache->mode & PT_IMG_WRITE)) {

   242

        errno = EPERM;

   243

        return -1;

   244

    }

   245

   246

    // open as .tmp

   247

    if (pt_cache_open_tmp_fd(cache, &cache->fd))

   248

        return -1;

   249

   250

    // calculate data size

   251

    cache->size = sizeof(*header) + header->height * header->row_bytes;

   252

   253

    // grow file

   254

    if (ftruncate(cache->fd, PT_CACHE_HEADER_SIZE + cache->size) < 0)

   255

        goto error;

   256

   257

    // mmap header and data

   258

    if (pt_cache_open_mmap(cache, &base, false))

   259

        goto error;

   260

   261

    cache->header = base;

   262

    cache->data = base + PT_CACHE_HEADER_SIZE;

   263

   264

    // write header

   265

    // XXX: should just mmap...

   266

    if (pt_cache_write_header(cache, header))

   267

        goto error;

   268

   269

    // done

   270

    return 0;

   271

   272

error:

   273

    // cleanup

   274

    pt_cache_abort(cache);

   275

   276

    return -1;

   277

}

   278

   279

/**

   280

 * Rename the opened .tmp to .cache

   281

 */

   282

static int pt_cache_create_done (struct pt_cache *cache)

   283

{

   284

    char tmp_path[1024];

   285

   286

    // get .tmp path

   287

    if (path_with_fext(cache->path, tmp_path, sizeof(tmp_path), ".tmp"))

   288

        return -1;

   289

   290

    // rename

   291

    if (rename(tmp_path, cache->path) < 0)

   292

        return -1;

   293

   294

    // ok

   295

    return 0;

   296

}

   297

   298

int pt_cache_open (struct pt_cache *cache)

   299

{

   300

    struct pt_cache_header header;

   301

    void *base;

   302

   307

    // open the .cache

   308

    if (pt_cache_open_read_fd(cache, &cache->fd))

   309

        return -1;

   310

   311

    // read in header

   312

    if (pt_cache_read_header(cache, &header))

   313

        return -1;

   314

   315

    // calculate data size

   316

    cache->size = sizeof(header) + header.height * header.row_bytes;

   317

   318

    // mmap header and data

   319

    if (pt_cache_open_mmap(cache, &base, true))

   320

        goto error;

   321

   322

    cache->header = base;

   323

    cache->data = base + PT_CACHE_HEADER_SIZE;

   324

   325

    // done

   326

    return 0;

   327

   328

error:

   329

    // cleanup

   330

    pt_cache_abort(cache);

   331

   332

    return -1;

   333

}

   334

   335

int pt_cache_update_png (struct pt_cache *cache, png_structp png, png_infop info)

   336

{

   337

    struct pt_cache_header header;

   338

   339

    // XXX: check cache_mode

   340

    // XXX: check image doesn't use any options we don't handle

   341

    // XXX: close any already-opened cache file

   342

   343

    memset(&header, 0, sizeof(header));

   344

   345

    // fill in basic info

   346

    header.width = png_get_image_width(png, info);

   347

    header.height = png_get_image_height(png, info);

   348

    header.bit_depth = png_get_bit_depth(png, info);

   349

    header.color_type = png_get_color_type(png, info);

   350

   351

    log_debug("width=%u, height=%u, bit_depth=%u, color_type=%u", 

   352

            header.width, header.height, header.bit_depth, header.color_type

   353

    );

   354

   355

    // only pack 1 pixel per byte

   356

    if (header.bit_depth < 8)

   357

        png_set_packing(png);

   358

   359

    // fill in other info

   360

    header.row_bytes = png_get_rowbytes(png, info);

   361

   362

    // calculate bpp as num_channels * bpc

   363

    // XXX: this assumes the packed bit depth will be either 8 or 16

   364

    header.col_bytes = png_get_channels(png, info) * (header.bit_depth == 16 ? 2 : 1);

   365

   366

    log_debug("row_bytes=%u, col_bytes=%u", header.row_bytes, header.col_bytes);

   367

   368

    // palette etc.

   369

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   370

        int num_palette;

   371

        png_colorp palette;

   372

   373

        if (png_get_PLTE(png, info, &palette, &num_palette) == 0)

   374

            // XXX: PLTE chunk not read?

   375

            return -1;

   376

   377

        // should only be 256 of them at most

   378

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   379

   380

        // copy

   381

        header.num_palette = num_palette;

   382

        memcpy(&header.palette, palette, num_palette * sizeof(*palette));

   383

   384

        log_debug("num_palette=%u", num_palette);

   385

    }

   386

   387

    // create .tmp and write out header

   388

    if (pt_cache_open_create(cache, &header))

   389

        return -1;

   390

   391

   392

    // write out raw image data a row at a time

   393

    for (size_t row = 0; row < header.height; row++) {

   394

        // read row data, non-interlaced

   395

        png_read_row(png, cache->data + row * header.row_bytes, NULL);

   396

    }

   397

   398

   399

    // move from .tmp to .cache

   400

    if (pt_cache_create_done(cache))

   401

        return -1;

   402

   403

    // done!

   404

    return 0;

   405

}

   406

   407

int pt_cache_tile_png (struct pt_cache *cache, png_structp png, png_infop info, const struct pt_tile_info *ti)

   408

{

   412

   413

    // set basic info

   414

    png_set_IHDR(png, info, ti->width, ti->height, cache->header->bit_depth, cache->header->color_type,

   415

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   416

    );

   417

   418

    // set palette?

   419

    if (cache->header->color_type == PNG_COLOR_TYPE_PALETTE)

   420

        png_set_PLTE(png, info, cache->header->palette, cache->header->num_palette);

   421

   422

    // write meta-info

   423

    png_write_info(png, info);

   424

   425

    // pixel data is packed into 1 pixel per byte

   426

    png_set_packing(png);

   427

   428

    // write image data

   429

    for (size_t row = ti->y; row < ti->y + ti->height; row++) {

   430

        size_t col = ti->x;

   431

   432

        // XXX: fill out-of-range regions in some background color

   433

        png_write_row(png, cache->data + (row * cache->header->row_bytes) + (col * cache->header->col_bytes));

   434

    }

   435

   436

    // done, flush remaining output

   437

    png_write_flush(png);

   438

   439

    // ok

   440

    return 0;

   441

}

   442

   443

void pt_cache_destroy (struct pt_cache *cache)

   444

{

   445

    free(cache->path);

   446

   447

    pt_cache_abort(cache);

   448

   449

    free(cache);

   450

}