1

#include "cache.h"

     2

#include "shared/util.h"

     3

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

     4

#include "error.h"

     5

     6

#include <stdlib.h>

     7

#include <unistd.h>

     8

#include <sys/types.h>

     9

#include <sys/stat.h>

    10

#include <fcntl.h>

    11

#include <sys/mman.h>

    12

#include <errno.h>

    13

#include <assert.h>

    14

    15

    16

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

    17

{

    18

    struct pt_cache *cache;

    19

    int err;

    20

    21

    // alloc

    22

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

    23

        RETURN_ERROR(PT_ERR_MEM);

    24

    25

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

    26

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    27

    28

    // init

    29

    cache->fd = -1;

    30

    cache->mode = mode;

    31

    32

    // ok

    33

    *cache_ptr = cache;

    34

    35

    return 0;

    36

    37

error:

    38

    // cleanup

    39

    if (cache)

    40

        pt_cache_destroy(cache);

    41

    42

    return err;

    43

}

    44

    45

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

    46

{

    47

    struct stat st_img, st_cache;

    48

    49

    // test original file

    50

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

    51

        RETURN_ERROR(PT_ERR_IMG_STAT);

    52

    53

    // test cache file

    54

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

    55

        // always stale if it doesn't exist yet

    56

        if (errno == ENOENT)

    57

            return PT_CACHE_NONE;

    58

        else

    59

            RETURN_ERROR(PT_ERR_CACHE_STAT);

    60

    }

    61

    62

    // compare mtime

    63

    if (st_img.st_mtime > st_cache.st_mtime)

    64

        return PT_CACHE_STALE;

    65

    66

    else

    67

        return PT_CACHE_FRESH;

    68

}

    69

    70

int pt_cache_info (struct pt_cache *cache, struct pt_image_info *info)

    71

{

    72

    int err;

    73

    74

    // ensure open

    75

    if ((err = pt_cache_open(cache)))

    76

        return err;

    77

    78

    info->width = cache->header->width;

    79

    info->height = cache->header->height;

    80

    81

    return 0;

    82

}

    83

    84

/**

    85

 * Abort any incomplete open operation, cleaning up

    86

 */

    87

static void pt_cache_abort (struct pt_cache *cache)

    88

{

    89

    if (cache->header != NULL) {

    90

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

    91

    92

        cache->header = NULL;

    93

        cache->data = NULL;

    94

    }

    95

    96

    if (cache->fd >= 0) {

    97

        close(cache->fd);

    98

    99

        cache->fd = -1;

   100

    }

   101

}

   102

   103

/**

   104

 * Open the cache file as an fd for reading

   105

 *

   106

 * XXX: needs locking

   107

 */

   108

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

   109

{

   110

    int fd;

   111

   112

    // actual open()

   113

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

   114

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   115

   116

    // ok

   117

    *fd_ptr = fd;

   118

   119

    return 0;

   120

}

   121

   122

/**

   123

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

   124

 */

   125

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

   126

{

   127

    int fd;

   128

    char tmp_path[1024];

   129

   130

    // get .tmp path

   131

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

   132

        RETURN_ERROR(PT_ERR_PATH);

   133

   134

    // open for write, create

   135

    // XXX: locking?

   136

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

   137

        RETURN_ERROR(PT_ERR_CACHE_OPEN_TMP);

   138

   139

    // ok

   140

    *fd_ptr = fd;

   141

   142

    return 0;

   143

}

   144

   145

   146

/**

   147

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

   148

 */

   149

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

   150

{

   151

    int prot = 0;

   152

    void *addr;

   153

   154

    // determine prot

   155

    prot |= PROT_READ;

   156

   157

    if (!readonly) {

   158

        assert(cache->mode & PT_OPEN_UPDATE);

   159

   160

        prot |= PROT_WRITE;

   161

    }

   162

   163

    // perform mmap() from second page on

   164

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

   165

        RETURN_ERROR(PT_ERR_CACHE_MMAP);

   166

   167

    // ok

   168

    *addr_ptr = addr;

   169

   170

    return 0;

   171

}

   172

   173

/**

   174

 * Read in the cache header from the open file

   175

 */

   176

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

   177

{

   178

    size_t len = sizeof(*header);

   179

    char *buf = (char *) header;

   180

   181

    // seek to start

   182

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

   183

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   184

   185

    // write out full header

   186

    while (len) {

   187

        ssize_t ret;

   188

   189

        // try and write out the header

   190

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

   191

            RETURN_ERROR(PT_ERR_CACHE_READ);

   192

   193

        // update offset

   194

        buf += ret;

   195

        len -= ret;

   196

    }

   197

   198

    // done

   199

    return 0;

   200

}

   201

   202

/**

   203

 * Write out the cache header into the opened file

   204

 */

   205

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

   206

{

   207

    size_t len = sizeof(*header);

   208

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

   209

   210

    // seek to start

   211

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

   212

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   213

   214

    // write out full header

   215

    while (len) {

   216

        ssize_t ret;

   217

   218

        // try and write out the header

   219

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

   220

            RETURN_ERROR(PT_ERR_CACHE_WRITE);

   221

   222

        // update offset

   223

        buf += ret;

   224

        len -= ret;

   225

    }

   226

   227

    // done

   228

    return 0;

   229

}

   230

   231

/**

   232

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

   233

 */

   234

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

   235

{

   236

    void *base;

   237

    int err;

   238

   239

    // no access

   240

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

   241

        RETURN_ERROR(PT_ERR_OPEN_MODE);

   242

   243

    // open as .tmp

   244

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

   245

        return err;

   246

   247

    // calculate data size

   248

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

   249

   250

    // grow file

   251

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

   252

        JUMP_SET_ERROR(err, PT_ERR_CACHE_TRUNC);

   253

   254

    // mmap header and data

   255

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

   256

        JUMP_ERROR(err);

   257

   258

    cache->header = base;

   259

    cache->data = base + PT_CACHE_HEADER_SIZE;

   260

   261

    // write header

   262

    // XXX: should just mmap...

   263

    if ((err = pt_cache_write_header(cache, header)))

   264

        JUMP_ERROR(err);

   265

   266

    // done

   267

    return 0;

   268

   269

error:

   270

    // cleanup

   271

    pt_cache_abort(cache);

   272

   273

    return err;

   274

}

   275

   276

/**

   277

 * Rename the opened .tmp to .cache

   278

 */

   279

static int pt_cache_create_done (struct pt_cache *cache)

   280

{

   281

    char tmp_path[1024];

   282

   283

    // get .tmp path

   284

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

   285

        RETURN_ERROR(PT_ERR_PATH);

   286

   287

    // rename

   288

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

   289

        RETURN_ERROR(PT_ERR_CACHE_RENAME_TMP);

   290

   291

    // ok

   292

    return 0;

   293

}

   294

   295

int pt_cache_open (struct pt_cache *cache)

   296

{

   297

    struct pt_cache_header header;

   298

    void *base;

   299

    int err;

   300

   301

    // ignore if already open

   302

    if (cache->header && cache->data)

   303

        return 0;

   304

   305

    // open the .cache

   306

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

   307

        return err;

   308

   309

    // read in header

   310

    if ((err = pt_cache_read_header(cache, &header)))

   311

        JUMP_ERROR(err);

   312

   313

    // calculate data size

   314

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

   315

   316

    // mmap header and data

   317

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

   318

        JUMP_ERROR(err);

   319

   320

    cache->header = base;

   321

    cache->data = base + PT_CACHE_HEADER_SIZE;

   322

   323

    // done

   324

    return 0;

   325

   326

error:

   327

    // cleanup

   328

    pt_cache_abort(cache);

   329

   330

    return err;

   331

}

   332

   333

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

   334

{

   335

    struct pt_cache_header header;

   336

    int err;

   337

   338

    // XXX: check cache_mode

   339

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

   340

    // XXX: close any already-opened cache file

   341

   342

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

   343

   344

    // fill in basic info

   345

    header.width = png_get_image_width(png, info);

   346

    header.height = png_get_image_height(png, info);

   347

    header.bit_depth = png_get_bit_depth(png, info);

   348

    header.color_type = png_get_color_type(png, info);

   349

   350

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

   351

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

   352

    );

   353

   354

    // only pack 1 pixel per byte, changes rowbytes

   355

    if (header.bit_depth < 8)

   356

        png_set_packing(png);

   357

   358

    // fill in other info

   359

    header.row_bytes = png_get_rowbytes(png, info);

   360

   361

    // calculate bpp as num_channels * bpc

   362

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

   363

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

   364

   365

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

   366

   367

    // palette etc.

   368

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   369

        int num_palette;

   370

        png_colorp palette;

   371

   372

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

   373

            // XXX: PLTE chunk not read?

   374

            RETURN_ERROR(PT_ERR_PNG);

   375

   376

        // should only be 256 of them at most

   377

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   378

   379

        // copy

   380

        header.num_palette = num_palette;

   381

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

   382

   383

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

   384

    }

   385

   386

    // create .tmp and write out header

   387

    if ((err = pt_cache_create(cache, &header)))

   388

        return err;

   389

   390

   391

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

   392

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

   393

        // read row data, non-interlaced

   394

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

   395

    }

   396

   397

   398

    // move from .tmp to .cache

   399

    if ((err = pt_cache_create_done(cache)))

   401

        return err;

   402

   403

    // done!

   404

    return 0;

   405

}

   406

   407

/**

   408

 * Return a pointer to the pixel data on \a row, starting at \a col.

   409

 */

   410

static inline void* tile_row_col (struct pt_cache *cache, size_t row, size_t col)

   411

{

   412

    return cache->data + (row * cache->header->row_bytes) + (col * cache->header->col_bytes);

   413

}

   414

   415

/**

   416

 * Fill in a clipped region of \a width_px pixels at the given row segment

   417

 */

   418

static inline void tile_row_fill_clip (struct pt_cache *cache, png_byte *row, size_t width_px)

   419

{

   420

    // XXX: use a configureable background color, or full transparency?

   421

    memset(row, /* 0xd7 */ 0x00, width_px * cache->header->col_bytes);

   422

}

   423

   424

/**

   425

 * Write raw tile image data, directly from the cache

   426

 */

   427

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

   428

{

   429

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

   430

        // write data directly

   431

        png_write_row(png, tile_row_col(cache, row, ti->x));

   432

   433

    return 0;

   434

}

   435

   436

/**

   437

 * Write clipped tile image data (a tile that goes over the edge of the actual image) by aligning the data from the cache as needed

   438

 */

   439

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

   440

{

   441

    png_byte *rowbuf;

   442

    size_t row;

   443

   444

    // image data goes from (ti->x ... clip_x, ti->y ... clip_y), remaining region is filled

   445

    size_t clip_x, clip_y;

   446

   447

   448

    // figure out if the tile clips over the right edge

   449

    // XXX: use min()

   450

    if (ti->x + ti->width > cache->header->width)

   451

        clip_x = cache->header->width;

   452

    else

   453

        clip_x = ti->x + ti->width;

   454

   455

    // figure out if the tile clips over the bottom edge

   456

    // XXX: use min()

   457

    if (ti->y + ti->height > cache->header->height)

   458

        clip_y = cache->header->height;

   459

    else

   460

        clip_y = ti->y + ti->height;

   461

   462

   463

    // allocate buffer for a single row of image data

   464

    if ((rowbuf = malloc(ti->width * cache->header->col_bytes)) == NULL)

   465

        RETURN_ERROR(PT_ERR_MEM);

   466

   467

    // how much data we actually have for each row, in px and bytes

   468

    // from [(tile x)---](clip x)

   469

    size_t row_px = clip_x - ti->x;

   470

    size_t row_bytes = row_px * cache->header->col_bytes;

   471

   472

    // write the rows that we have

   473

    // from [(tile y]---](clip y)

   474

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

   475

        // copy in the actual tile data...

   476

        memcpy(rowbuf, tile_row_col(cache, row, ti->x), row_bytes);

   477

   478

        // generate the data for the remaining, clipped, columns

   479

        tile_row_fill_clip(cache, rowbuf + row_bytes, (ti->width - row_px));

   480

   481

        // write

   482

        png_write_row(png, rowbuf);

   483

    }

   484

   485

    // generate the data for the remaining, clipped, rows

   486

    tile_row_fill_clip(cache, rowbuf, ti->width);

   487