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

   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

   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

   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

#define min(a, b) (((a) < (b)) ? (a) : (b))

   334

   335

/**

   336

 * Decode the PNG data directly to mmap() - not good for sparse backgrounds

   337

 */

   338

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

   339

{

   340

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

   341

    for (size_t row = 0; row < cache->header->height; row++) {

   342

        // read row data, non-interlaced

   343

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

   344

    }

   345

   346

    return 0;

   347

}

   348

   349

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

   350

{

   351

    // one row of pixel data

   352

    uint8_t *row_buf;

   353

   354

    // alloc

   355

    if ((row_buf = malloc(cache->header->row_bytes)) == NULL)

   356

        RETURN_ERROR(PT_ERR_MEM);

   357

   358

    // decode each row at a time

   359

    for (size_t row = 0; row < cache->header->height; row++) {

   360

        // read row data, non-interlaced

   361

        png_read_row(png, row_buf, NULL);

   362

   363

        // skip background-colored regions to keep the cache file sparse

   364

        // ...in blocks of PT_CACHE_BLOCK_SIZE bytes

   365

        for (size_t col_base = 0; col_base < cache->header->width; ){

   366

            // size of this block in bytes

   367

            size_t block_size = min(PT_CACHE_BLOCK_SIZE * cache->header->col_bytes, cache->header->row_bytes - col_base);

   368

   369

            // ...each pixel

   370

            for (

   371

                    size_t col = col_base;

   372

   373

                    // BLOCK_SIZE * col_bytes wide, don't go over the edge

   374

                    col < col_base + block_size; 

   375

   376

                    col += cache->header->col_bytes

   377

            ) {

   378

                // test this pixel

   379

                if (bcmp(row_buf + col, cache->header->params.background_color, cache->header->col_bytes)) {

   380

                    // differs

   381

                    memcpy(

   382

                            cache->data + row * cache->header->row_bytes + col_base, 

   383

                            row_buf + col_base,

   384

                            block_size

   385

                    );

   386

   387

                    // skip to next block

   388

                    break;

   389

                }

   390

            }

   391

   392

            // skip this block

   393

            continue;

   394

        }

   395

    }

   396

   397

    return 0;

   398

}

   399

   400

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

   401

{

   402

    struct pt_cache_header header;

   403

    int err;

   404

   405

    // XXX: check cache_mode

   406

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

   407

    // XXX: close any already-opened cache file

   408

   409

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

   410

   411

    // fill in basic info

   412

    header.width = png_get_image_width(png, info);

   413

    header.height = png_get_image_height(png, info);

   414

    header.bit_depth = png_get_bit_depth(png, info);

   415

    header.color_type = png_get_color_type(png, info);

   416

   417

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

   418

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

   419

    );

   420

   421

    // only pack 1 pixel per byte, changes rowbytes

   422

    if (header.bit_depth < 8)

   423

        png_set_packing(png);

   424

   425

    // fill in other info

   426

    header.row_bytes = png_get_rowbytes(png, info);

   427

   428

    // calculate bpp as num_channels * bpc

   429

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

   430

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

   431

   432

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

   433

   434

    // palette etc.

   435

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   436

        int num_palette;

   437

        png_colorp palette;

   438

   439

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

   440

            // XXX: PLTE chunk not read?

   441

            RETURN_ERROR(PT_ERR_PNG);

   442

   443

        // should only be 256 of them at most

   444

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   445

   446

        // copy

   447

        header.num_palette = num_palette;

   448

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

   449

   450

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

   451

    }

   452

   453

    // any params

   454

    if (params)

   455

        header.params = *params;

   456

   457

    // create .tmp and write out header

   458

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

   459

        return err;

   460

   461

    // decode

   462

    if ((err = decode_png_sparse(cache, png, info)))

   463

        return err;

   464

   465

    // move from .tmp to .cache

   466

    if ((err = pt_cache_create_done(cache)))

   467

        // XXX: pt_cache_abort?

   468

        return err;

   469

   470

    // done!

   471

    return 0;

   472

}

   473

   474

/**

   475

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

   476

 */

   477

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

   478

{

   479

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

   480

}

   481

   482

/**

   483

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

   484

 */

   485

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

   486

{

   487

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