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

    struct stat st;

    73

    int err;

    74

    75

    // ensure open

    76

    if ((err = pt_cache_open(cache)))

    77

        return err;

    78

    79

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

    80

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

    81

    82

    // stat

    83

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

    84

        // unknown

    85

        info->cache_mtime = 0;

    86

        info->cache_bytes = 0;

    87

        info->cache_blocks = 0;

    88

    89

    } else {

    90

        // store

    91

        info->cache_mtime = st.st_mtime;

    92

        info->cache_bytes = st.st_size;

    93

        info->cache_blocks = st.st_blocks;

    94

    }

    95

    96

    return 0;

    97

}

    98

    99

/**

   100

 * Abort any incomplete open operation, cleaning up

   101

 */

   102

static void pt_cache_abort (struct pt_cache *cache)

   103

{

   104

    if (cache->header != NULL) {

   105

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

   106

   107

        cache->header = NULL;

   108

        cache->data = NULL;

   109

    }

   110

   111

    if (cache->fd >= 0) {

   112

        close(cache->fd);

   113

   114

        cache->fd = -1;

   115

    }

   116

}

   117

   118

/**

   119

 * Open the cache file as an fd for reading

   120

 *

   121

 * XXX: needs locking

   122

 */

   123

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

   124

{

   125

    int fd;

   126

   127

    // actual open()

   128

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

   129

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   130

   131

    // ok

   132

    *fd_ptr = fd;

   133

   134

    return 0;

   135

}

   136

   137

/**

   138

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

   139

 */

   140

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

   141

{

   142

    int fd;

   143

    char tmp_path[1024];

   144

   145

    // get .tmp path

   146

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

   147

        RETURN_ERROR(PT_ERR_PATH);

   148

   149

    // open for write, create

   150

    // XXX: locking?

   151

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

   152

        RETURN_ERROR(PT_ERR_CACHE_OPEN_TMP);

   153

   154

    // ok

   155

    *fd_ptr = fd;

   156

   157

    return 0;

   158

}

   159

   160

   161

/**

   162

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

   163

 */

   164

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

   165

{

   166

    int prot = 0;

   167

    void *addr;

   168

   169

    // determine prot

   170

    prot |= PROT_READ;

   171

   172

    if (!readonly) {

   173

        assert(cache->mode & PT_OPEN_UPDATE);

   174

   175

        prot |= PROT_WRITE;

   176

    }

   177

   178

    // mmap() the full file including header

   179

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

   180

        RETURN_ERROR(PT_ERR_CACHE_MMAP);

   181

   182

    // ok

   183

    *addr_ptr = addr;

   184

   185

    return 0;

   186

}

   187

   188

/**

   189

 * Read in the cache header from the open file

   190

 */

   191

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

   192

{

   193

    size_t len = sizeof(*header);

   194

    char *buf = (char *) header;

   195

   196

    // seek to start

   197

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

   198

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   199

   200

    // write out full header

   201

    while (len) {

   202

        ssize_t ret;

   203

   204

        // try and write out the header

   205

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

   206

            RETURN_ERROR(PT_ERR_CACHE_READ);

   207

   208

        // update offset

   209

        buf += ret;

   210

        len -= ret;

   211

    }

   212

   213

    // done

   214

    return 0;

   215

}

   216

   217

/**

   218

 * Write out the cache header into the opened file

   219

 */

   220

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

   221

{

   222

    size_t len = sizeof(*header);

   223

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

   224

   225

    // seek to start

   226

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

   227

        RETURN_ERROR(PT_ERR_CACHE_SEEK);

   228

   229

    // write out full header

   230

    while (len) {

   231

        ssize_t ret;

   232

   233

        // try and write out the header

   234

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

   235

            RETURN_ERROR(PT_ERR_CACHE_WRITE);

   236

   237

        // update offset

   238

        buf += ret;

   239

        len -= ret;

   240

    }

   241

   242

    // done

   243

    return 0;

   244

}

   245

   246

/**

   247

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

   248

 */

   249

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

   250

{

   251

    void *base;

   252

    int err;

   253

   254

    // no access

   255

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

   256

        RETURN_ERROR(PT_ERR_OPEN_MODE);

   257

   258

    // open as .tmp

   259

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

   260

        return err;

   261

   262

    // calculate data size

   263

    cache->size = header->height * header->row_bytes;

   264

   265

    // grow file

   266

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

   267

        JUMP_SET_ERROR(err, PT_ERR_CACHE_TRUNC);

   268

   269

    // mmap header and data

   270

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

   271

        JUMP_ERROR(err);

   272

   273

    cache->header = base;

   274

    cache->data = base + PT_CACHE_HEADER_SIZE;

   275

   276

    // write header

   277

    // XXX: should just mmap...

   278

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

   279

        JUMP_ERROR(err);

   280

   281

    // done

   282

    return 0;

   283

   284

error:

   285

    // cleanup

   286

    pt_cache_abort(cache);

   287

   288

    return err;

   289

}

   290

   291

/**

   292

 * Rename the opened .tmp to .cache

   293

 */

   294

static int pt_cache_create_done (struct pt_cache *cache)

   295

{

   296

    char tmp_path[1024];

   297

   298

    // get .tmp path

   299

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

   300

        RETURN_ERROR(PT_ERR_PATH);

   301

   302

    // rename

   303

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

   304

        RETURN_ERROR(PT_ERR_CACHE_RENAME_TMP);

   305

   306

    // ok

   307

    return 0;

   308

}

   309

   310

int pt_cache_open (struct pt_cache *cache)

   311

{

   312

    struct pt_cache_header header;

   313

    void *base;

   314

    int err;

   315

   316

    // ignore if already open

   317

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

   318

        return 0;

   319

   320

    // open the .cache

   321

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

   322

        return err;

   323

   324

    // read in header

   325

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

   326

        JUMP_ERROR(err);

   327

   328

    // calculate data size

   329

    cache->size = header.height * header.row_bytes;

   330

   331

    // mmap header and data

   332

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

   333

        JUMP_ERROR(err);

   334

   335

    cache->header = base;

   336

    cache->data = base + PT_CACHE_HEADER_SIZE;

   337

   338

    // done

   339

    return 0;

   340

   341

error:

   342

    // cleanup

   343

    pt_cache_abort(cache);

   344

   345

    return err;

   346

}

   347

   348

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

   349

   350

/**

   351

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

   352

 */

   353

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

   354

{

   355

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

   356

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

   357

        // read row data, non-interlaced

   358

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

   359

    }

   360

   361

    return 0;

   362

}

   363

   364

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

   365

{

   366

    // one row of pixel data

   367

    uint8_t *row_buf;

   368

   369

    // alloc

   370

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

   371

        RETURN_ERROR(PT_ERR_MEM);

   372

   373

    // decode each row at a time

   374

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

   375

        // read row data, non-interlaced

   376

        png_read_row(png, row_buf, NULL);

   377

   378

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

   379

        // ...in blocks of PT_CACHE_BLOCK_SIZE bytes

   381

            // size of this block in bytes

   382

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

   383

   384

            // ...each pixel

   385

            for (

   386

                    size_t col = col_base;

   387

   388

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

   389

                    col < col_base + block_size; 

   390

   391

                    col += cache->header->col_bytes

   392

            ) {

   393

                // test this pixel

   394

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

   395

                    // differs

   396

                    memcpy(

   397

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

   398

                            row_buf + col_base,

   399

                            block_size

   400

                    );

   401

   402

                    // skip to next block

   403

                    break;

   404

                }

   405

            }

   406

   407

            // skip this block

   408

            continue;

   409

        }

   410

    }

   411

   412

    return 0;

   413

}

   414

   415

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

   416

{

   417

    struct pt_cache_header header;

   418

    int err;

   419

   420

    // XXX: check cache_mode

   421

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

   422

    // XXX: close any already-opened cache file

   423

   424

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

   425

   426

    // fill in basic info

   427

    header.width = png_get_image_width(png, info);

   428

    header.height = png_get_image_height(png, info);

   429

    header.bit_depth = png_get_bit_depth(png, info);

   430

    header.color_type = png_get_color_type(png, info);

   431

   432

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

   433

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

   434

    );

   435

   436

    // only pack 1 pixel per byte, changes rowbytes

   437

    if (header.bit_depth < 8)

   438

        png_set_packing(png);

   439

   440

    // fill in other info

   441

    header.row_bytes = png_get_rowbytes(png, info);

   442

   443

    // calculate bpp as num_channels * bpc

   444

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

   445

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

   446

   447

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

   448

   449

    // palette etc.

   450

    if (header.color_type == PNG_COLOR_TYPE_PALETTE) {

   451

        int num_palette;

   452

        png_colorp palette;

   453

   454

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

   455

            // XXX: PLTE chunk not read?

   456

            RETURN_ERROR(PT_ERR_PNG);

   457

   458

        // should only be 256 of them at most

   459

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   460

   461

        // copy

   462

        header.num_palette = num_palette;

   463

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

   464

   465

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

   466

    }

   467

   468

    // any params

   469

    if (params)

   470

        header.params = *params;

   471

   472

    // create .tmp and write out header

   473

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

   474

        return err;

   475

   476

    // decode

   477

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

   478

        return err;

   479

   480

    // move from .tmp to .cache

   481

    if ((err = pt_cache_create_done(cache)))

   482

        // XXX: pt_cache_abort?

   483

        return err;

   484

   485

    // done!

   486

    return 0;

   487

}