1

#include "png.h" // pt_png header

     2

#include "error.h"

     3

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

     4

     5

#include <png.h> // sysmtem libpng header

     6

#include <assert.h>

     7

     8

     9

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

    10

    11

int pt_png_check (const char *path)

    12

{

    13

    FILE *fp;

    14

    uint8_t header[8];

    15

    int ret;

    16

    17

    // fopen

    18

    if ((fp = fopen(path, "rb")) == NULL)

    19

        RETURN_ERROR(PT_ERR_IMG_OPEN);

    20

    21

    // read

    22

    if (fread(header, 1, sizeof(header), fp) != sizeof(header))

    23

        JUMP_SET_ERROR(ret, PT_ERR_IMG_FORMAT);

    24

    25

    // compare signature  

    26

    if (png_sig_cmp(header, 0, sizeof(header)))

    27

        // not a PNG file

    28

        ret = 1;

    29

    30

    else

    31

        // valid PNG file

    32

        ret = 0;

    33

    34

error:

    35

    // cleanup

    36

    fclose(fp);

    37

    38

    return ret;

    39

}

    40

    41

int pt_png_open (struct pt_image *image, struct pt_png_img *img)

    42

{

    43

    int err;

    44

    45

    // init

    46

    memset(img, 0, sizeof(*img));

    47

    48

    // open I/O

    49

    if ((err = pt_image_open_file(image, &img->fh)))

    50

        JUMP_ERROR(err);

    51

    52

    // create the struct

    53

    if ((img->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL)

    54

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    55

    56

    // create the info

    57

    if ((img->info = png_create_info_struct(img->png)) == NULL)

    58

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    59

    60

    // setup error trap for the I/O

    61

    if (setjmp(png_jmpbuf(img->png)))

    62

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    63

    64

    // setup error trap

    65

    if (setjmp(png_jmpbuf(img->png)))

    66

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    67

    68

    69

    // setup I/O to FILE

    70

    png_init_io(img->png, img->fh);

    71

    72

    // read meta-info

    73

    png_read_info(img->png, img->info);

    74

    75

    76

    // img->fh will be closed by pt_png_release_read

    77

    return 0;

    78

    79

error:

    80

    // cleanup

    81

    pt_png_release_read(img);

    82

    83

    return err;

    84

}

    85

    86

int pt_png_read_header (struct pt_png_img *img, struct pt_png_header *header, size_t *data_size)

    87

{

    88

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

    89

    if (png_get_interlace_type(img->png, img->info) != PNG_INTERLACE_NONE) {

    90

        log_warn("Can't handle interlaced PNG");

    91

    92

        RETURN_ERROR(PT_ERR_IMG_FORMAT);

    93

    }

    94

    95

    96

    // initialize

    97

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

    98

    99

    // fill in basic info

   100

    header->width = png_get_image_width(img->png, img->info);

   101

    header->height = png_get_image_height(img->png, img->info);

   102

    header->bit_depth = png_get_bit_depth(img->png, img->info);

   103

    header->color_type = png_get_color_type(img->png, img->info);

   104

   105

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

   106

            header->width, header->height, header->bit_depth, header->color_type

   107

    );

   108

   109

    // only pack 1 pixel per byte, changes rowbytes

   110

    if (header->bit_depth < 8)

   111

        png_set_packing(img->png);

   112

   113

    // fill in other info

   114

    header->row_bytes = png_get_rowbytes(img->png, img->info);

   115

   116

    // calculate bpp as num_channels * bpc

   117

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

   118

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

   119

   120

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

   121

   122

    // palette etc.

   123

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

   124

        int num_palette;

   125

        png_colorp palette;

   126

   127

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

   128

            // PLTE chunk not read?

   129

            RETURN_ERROR(PT_ERR_PNG);

   130

   131

        // should only be 256 of them at most

   132

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   133

   134

        // copy

   135

        header->num_palette = num_palette;

   136

        memcpy(&header->palette, palette, num_palette * sizeof(*palette));

   137

   138

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

   139

    }

   140

   141

    // calculate data size

   142

    *data_size = header->height * header->row_bytes;

   143

   144

    return 0;

   145

}

   146

   147

/**

   148

 * Decode the PNG data directly to memory - not good for sparse backgrounds

   149

 */

   150

static int pt_png_decode_direct (struct pt_png_img *img, const struct pt_png_header *header, const struct pt_image_params *params, uint8_t *out)

   151

{

   152

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

   153

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

   154

        // read row data, non-interlaced

   155

        png_read_row(img->png, out + row * header->row_bytes, NULL);

   156

    }

   157

   158

    return 0;

   159

}

   160

   161

/**

   162

 * Decode the PNG data, filtering it for sparse regions

   163

 */

   164

static int pt_png_decode_sparse (struct pt_png_img *img, const struct pt_png_header *header, const struct pt_image_params *params, uint8_t *out)

   165

{

   166

    // one row of pixel data

   167

    uint8_t *row_buf;

   168

   169

    // alloc

   170

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

   171

        RETURN_ERROR(PT_ERR_MEM);

   172

   173

    // decode each row at a time

   174

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

   175

        // read row data, non-interlaced

   176

        png_read_row(img->png, row_buf, NULL);

   177

   178

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

   179

        // ...in blocks of PT_CACHE_BLOCK_SIZE bytes

   180

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

   181

            // size of this block in bytes

   182

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

   183

   184

            // ...each pixel

   185

            for (

   186

                    size_t col = col_base;

   187

   188

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

   189

                    col < col_base + block_size; 

   190

   191

                    col += header->col_bytes

   192

            ) {

   193

                // test this pixel

   194

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

   195

                    // differs

   196

                    memcpy(

   197

                            out + row * header->row_bytes + col_base, 

   198

                            row_buf + col_base,

   199

                            block_size

   200

                    );

   201

   202

                    // skip to next block

   203

                    break;

   204

                }

   205

            }

   206

   207

            // skip this block

   208

            continue;

   209

        }

   210

    }

   211

   212

    return 0;

   213

}

   214

   215

int pt_png_decode (struct pt_png_img *img, const struct pt_png_header *header, const struct pt_image_params *params, uint8_t *out)

   216

{

   217

    int err;

   218

   219

    // decode

   220

    // XXX: it's an array, you silly

   221

    if (params->background_color)

   222

        err = pt_png_decode_sparse(img, header, params, out);

   223

   224

    else

   225

        err = pt_png_decode_direct(img, header, params, out);

   226

   227

    if (err)

   228

        return err;

   229

   230

    // finish off, ignore trailing data

   231

    png_read_end(img->png, NULL);

   232

   233

    return 0;

   234

}

   235

   236

int pt_png_info (struct pt_png_header *header, struct pt_image_info *info)

   237

{

   238

    // fill in info from header

   239

    info->img_width = header->width;

   240

    info->img_height = header->height;

   241

    info->img_bpp = header->bit_depth;

   242

   243

    return 0;

   244

}

   245

   246

/** 

   247

 * libpng I/O callback: write out data

   248

 */

   249

static void pt_png_mem_write (png_structp png, png_bytep data, png_size_t length)

   250

{

   251

    struct pt_tile_mem *buf = png_get_io_ptr(png);

   252

    int err;

   253

   254

    // write to buffer

   255

    if ((err = pt_tile_mem_write(buf, data, length)))

   256

        // drop err, because png_error doesn't do formatted output

   257

        png_error(png, "pt_tile_mem_write: ...");

   258

}

   259

   260

/** 

   261

 * libpng I/O callback: flush buffered data

   262

 */

   263

static void pt_png_mem_flush (png_structp png_ptr)

   264

{

   265

    // no-op

   266

}

   267

   268

   269

/**

   270

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

   271

 */

   272

static inline const void* tile_row_col (const struct pt_png_header *header, const uint8_t *data, size_t row, size_t col)

   273

{

   274

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

   275

}

   276

   277

/**

   278

 * Write raw tile image data, directly from the cache

   279

 */

   280

static int pt_png_encode_direct (struct pt_png_img *img, const struct pt_png_header *header, const uint8_t *data, const struct pt_tile_info *ti)

   281

{

   282

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

   283

        // write data directly

   284

        // missing const...

   285

        png_write_row(img->png, (const png_bytep) tile_row_col(header, data, row, ti->x));

   286

   287

    return 0;

   288

}

   289

   290

/**

   291

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

   292

 */

   293

static inline void tile_row_fill_clip (const struct pt_png_header *header, png_byte *row, size_t width_px)

   294

{

   295

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

   296

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

   297

}

   298

   299

/**

   300

 * 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

   301

 */

   302

static int pt_png_encode_clipped (struct pt_png_img *img, const struct pt_png_header *header, const uint8_t *data, const struct pt_tile_info *ti)

   303

{

   304

    png_byte *rowbuf;

   305

    size_t row;

   306

   307

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

   308

    size_t clip_x, clip_y;

   309

   310

   311

    // fit the left/bottom edge against the image dimensions

   312

    clip_x = min(ti->x + ti->width, header->width);

   313

    clip_y = min(ti->y + ti->height, header->height);

   314

   315

   316

    // allocate buffer for a single row of image data

   317

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

   318

        RETURN_ERROR(PT_ERR_MEM);

   319

   320

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

   321

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

   322

    size_t row_px = clip_x - ti->x;

   323

    size_t row_bytes = row_px * header->col_bytes;

   324

   325

    // write the rows that we have

   326

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

   327

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

   328

        // copy in the actual tile data...

   329

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

   330

   331

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

   332

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

   333

   334

        // write

   335

        png_write_row(img->png, rowbuf);

   336

    }

   337

   338

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

   339

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

   340

   341

    // write out the remaining rows as clipped data

   342

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

   343

        png_write_row(img->png, rowbuf);

   344

   345

    // ok

   346

    return 0;

   347

}

   348

   349

/**

   350

 * Write unscaled tile data

   351

 */

   352

static int pt_png_encode_unzoomed (struct pt_png_img *img, const struct pt_png_header *header, const uint8_t *data, const struct pt_tile_info *ti)

   353

{

   354

    int err;

   355

   356

    // set basic info

   357

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

   358

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   359

    );

   360

   361

    // set palette?

   362

    if (header->color_type == PNG_COLOR_TYPE_PALETTE)

   363

        // oops... missing const

   364

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

   365

   366

    // write meta-info

   367

    png_write_info(img->png, img->info);

   368

   369

    // our pixel data is packed into 1 pixel per byte (8bpp or 16bpp)

   370

    png_set_packing(img->png);

   371

   372

    // figure out if the tile clips

   373

    if (ti->x + ti->width <= header->width && ti->y + ti->height <= header->height)

   374

        // doesn't clip, just use the raw data

   375

        err = pt_png_encode_direct(img, header, data, ti);

   376

   377

    else

   378

        // fill in clipped regions

   379

        err = pt_png_encode_clipped(img, header, data, ti);

   380

   381

    return err;

   382

}

   383

   384

/**

   385

 * Manipulate powers of two

   386

 */

   387

static inline size_t scale_by_zoom_factor (size_t value, int z)

   388

{

   389

    if (z > 0)

   390

        return value << z;

   391

   392

    else if (z < 0)

   393

        return value >> -z;

   394

   395

    else

   396

        return value;

   397

}

   398

   399

#define ADD_AVG(l, r) (l) = ((l) + (r)) / 2

   400

   401

/**

   402

 * Converts a pixel's data into a png_color

   403

 */

   404

static inline void png_pixel_data (const png_color **outp, const struct pt_png_header *header, const uint8_t *data, size_t row, size_t col)

   405

{

   406

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

   407

        // palette entry number

   408

        int p;

   409

   410

        if (header->bit_depth == 8)

   411

            p = *((uint8_t *) tile_row_col(header, data, row, col));

   412

        else

   413

            // unknown

   414

            return;

   415

   418

   419

        // reference data from palette

   420

        *outp = &header->palette[p];

   421

   422

    } else {

   423

        // unknown

   424

    }

   425

}

   426

   427

/**

   428

 * Write scaled tile data

   429

 */

   430

static int pt_png_encode_zoomed (struct pt_png_img *img, const struct pt_png_header *header, const uint8_t *data, const struct pt_tile_info *ti)

   431

{

   432

    // size of the image data in px

   433

    size_t data_width = scale_by_zoom_factor(ti->width, -ti->zoom);

   434

    size_t data_height = scale_by_zoom_factor(ti->height, -ti->zoom);

   435

   436

    // input pixels per output pixel

   437

    size_t pixel_size = scale_by_zoom_factor(1, -ti->zoom);

   438

   439

    // bytes per output pixel

   440

    size_t pixel_bytes = 3;

   441

   442

    // size of the output tile in px

   443

    size_t row_width = ti->width;

   444

   445

    // size of an output row in bytes (RGB)

   446

    size_t row_bytes = row_width * 3;

   447

   448

    // buffer to hold output rows

   449

    uint8_t *row_buf;

   450

   451

    // color entry for pixel

   452

    const png_color *c = &header->palette[0];

   453

   454

    // only supports zooming out...

   455

    if (ti->zoom >= 0)

   456

        RETURN_ERROR(PT_ERR_TILE_ZOOM);

   457

   458

    if ((row_buf = malloc(row_bytes)) == NULL)

   459

        RETURN_ERROR(PT_ERR_MEM);

   460

   461

    // suppress warning...

   462

    (void) data_height;

   463

   464

    // define pixel format: 8bpp RGB

   465

    png_set_IHDR(img->png, img->info, ti->width, ti->height, 8, PNG_COLOR_TYPE_RGB,

   466

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   467

    );

   468

   469

    // write meta-info

   470

    png_write_info(img->png, img->info);

   471

   472

    // ...each output row

   473

    for (size_t out_row = 0; out_row < ti->height; out_row++) {

   474

        memset(row_buf, 0, row_bytes);

   475

   476

        // ...includes pixels starting from this row.

   477

        size_t in_row_offset = ti->y + scale_by_zoom_factor(out_row, -ti->zoom);

   478

   479

        // ...each out row includes pixel_size in rows

   480

        for (size_t in_row = in_row_offset; in_row < in_row_offset + pixel_size && in_row < header->height; in_row++) {

   481

            // and includes each input pixel

   482

            for (size_t in_col = ti->x; in_col < ti->x + data_width && in_col < header->width; in_col++) {

   483

   484

                // ...for this output pixel

   485

                size_t out_col = scale_by_zoom_factor(in_col - ti->x, ti->zoom);

   486

   487

                // get pixel RGB data

   488

                png_pixel_data(&c, header, data, in_row, in_col);

   489

   490

                // average the RGB data        

   491

                ADD_AVG(row_buf[out_col * pixel_bytes + 0], c->red);

   492

                ADD_AVG(row_buf[out_col * pixel_bytes + 1], c->green);

   493

                ADD_AVG(row_buf[out_col * pixel_bytes + 2], c->blue);

   494

            }

   495

        }

   496

   497

        // output

   498

        png_write_row(img->png, row_buf);

   499

    }

   500

   501

    // done

   502

    return 0;

   503

}

   504

   505

int pt_png_tile (const struct pt_png_header *header, const uint8_t *data, struct pt_tile *tile)

   506

{

   507

    struct pt_png_img _img, *img = &_img;

   508

    struct pt_tile_info *ti = &tile->info;

   509

    int err;

   510

   511

    // init img

   512

    memset(img, 0, sizeof(*img));

   513

   514

    // check within bounds

   515

    if (ti->x >= header->width || ti->y >= header->height)

   516

        // completely outside