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

     7

#include <assert.h>

     8

     9

    10

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

    11

    12

int pt_png_check (const char *path)

    13

{

    14

    FILE *fp;

    15

    uint8_t header[8];

    16

    int ret;

    17

    18

    // fopen

    19

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

    20

        RETURN_ERROR(PT_ERR_IMG_OPEN);

    21

    22

    // read

    23

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

    24

        JUMP_SET_ERROR(ret, PT_ERR_IMG_FORMAT);

    25

    26

    // compare signature  

    27

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

    28

        // not a PNG file

    29

        ret = 1;

    30

    31

    else

    32

        // valid PNG file

    33

        ret = 0;

    34

    35

error:

    36

    // cleanup

    37

    fclose(fp);

    38

    39

    return ret;

    40

}

    41

    42

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

    43

{

    44

    int err;

    45

    46

    // init

    47

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

    48

    49

    // open I/O

    50

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

    51

        JUMP_ERROR(err);

    52

    53

    // create the struct

    54

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

    55

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    56

    57

    // create the info

    58

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

    59

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    60

    61

    // setup error trap for the I/O

    62

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

    63

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    64

    65

    // setup error trap

    66

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

    67

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    68

    69

    70

    // setup I/O to FILE

    71

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

    72

    73

    // read meta-info

    74

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

    75

    76

    77

    // img->fh will be closed by pt_png_release_read

    78

    return 0;

    79

    80

error:

    81

    // cleanup

    82

    pt_png_release_read(img);

    83

    84

    return err;

    85

}

    86

    87

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

    88

{

    89

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

    90

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

    91

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

    92

    93

        RETURN_ERROR(PT_ERR_IMG_FORMAT);

    94

    }

    95

    96

    97

    // initialize

    98

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

    99

   100

    // fill in basic info

   101

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

   102

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

   103

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

   104

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

   105

   106

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

   107

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

   108

    );

   109

   110

    // only pack 1 pixel per byte, changes rowbytes

   111

    if (header->bit_depth < 8)

   112

        png_set_packing(img->png);

   113

   114

    // fill in other info

   115

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

   116

   117

    // calculate bpp as num_channels * bpc

   118

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

   119

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

   120

   121

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

   122

   123

    // palette etc.

   124

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

   125

        int num_palette;

   126

        png_colorp palette;

   127

   128

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

   129

            // PLTE chunk not read?

   130

            RETURN_ERROR(PT_ERR_PNG);

   131

   132

        // should only be 256 of them at most

   133

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

   134

   135

        // copy

   136

        header->num_palette = num_palette;

   137

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

   138

   139

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

   140

    }

   141

   142

    // calculate data size

   143

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

   144

   145

    return 0;

   146

}

   147

   148

/**

   149

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

   150

 */

   151

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)

   152

{

   153

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

   154

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

   155

        // read row data, non-interlaced

   156

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

   157

    }

   158

   159

    return 0;

   160

}

   161

   162

/**

   163

 * Decode the PNG data, filtering it for sparse regions

   164

 */

   165

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)

   166

{

   167

    // one row of pixel data

   168

    uint8_t *row_buf;

   169

   170

    // alloc

   171

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

   172

        RETURN_ERROR(PT_ERR_MEM);

   173

   174

    // decode each row at a time

   175

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

   176

        // read row data, non-interlaced

   177

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

   178

   179

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

   180

        // ...in blocks of PT_CACHE_BLOCK_SIZE bytes

   181

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

   182

            // size of this block in bytes

   183

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

   184

   185

            // ...each pixel

   186

            for (

   187

                    size_t col = col_base;

   188

   189

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

   190

                    col < col_base + block_size; 

   191

   192

                    col += header->col_bytes

   193

            ) {

   194

                // test this pixel

   195

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

   196

                    // differs

   197

                    memcpy(

   198

                            out + row * header->row_bytes + col_base, 

   199

                            row_buf + col_base,

   200

                            block_size

   201

                    );

   202

   203

                    // skip to next block

   204

                    break;

   205

                }

   206

            }

   207

   208

            // skip this block

   209

            continue;

   210

        }

   211

    }

   212

   213

    return 0;

   214

}

   215

   216

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

   217

{

   218

    int err;

   219

   220

    // decode

   221

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

   222

    if (params->background_color)

   223

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

   224

   225

    else

   226

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

   227

   228

    if (err)

   229

        return err;

   230

   231

    // finish off, ignore trailing data

   232

    png_read_end(img->png, NULL);

   233

   234

    return 0;

   235

}

   236

   237

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

   238

{

   239

    // fill in info from header

   240

    info->img_width = header->width;

   241

    info->img_height = header->height;

   242

    info->img_bpp = header->bit_depth;

   243

   244

    return 0;

   245

}

   246

   247

/** 

   248

 * libpng I/O callback: write out data

   249

 */

   250

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

   251

{

   252

    struct pt_tile_mem *buf = png_get_io_ptr(png);

   253

    int err;

   254

   255

    // write to buffer

   256

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

   257

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

   258

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

   259

}

   260

   261

/** 

   262

 * libpng I/O callback: flush buffered data

   263

 */

   264

static void pt_png_mem_flush (png_structp png_ptr)

   265

{

   266

    // no-op

   267

}

   268

   269

   270

/**

   271

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

   272

 */

   273

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

   274

{

   275

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

   276

}

   277

   278

/**

   279

 * Write raw tile image data, directly from the cache

   280

 */

   281

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)

   282

{

   283

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

   284

        // write data directly

   285

        // missing const...

   286

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

   287

   288

    return 0;

   289

}

   290

   291

/**

   292

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

   293

 */

   294

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

   295

{

   296

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

   297

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

   298

}

   299

   300

/**

   301

 * 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

   302

 */

   303

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)

   304

{

   305

    png_byte *rowbuf;

   306

    size_t row;

   307

   308

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

   309

    size_t clip_x, clip_y;

   310

   311

   312

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

   313

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

   314

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

   315

   316

   317

    // allocate buffer for a single row of image data

   318

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

   319

        RETURN_ERROR(PT_ERR_MEM);

   320

   321

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

   322

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

   323

    size_t row_px = clip_x - ti->x;

   324

    size_t row_bytes = row_px * header->col_bytes;

   325

   326

    // write the rows that we have

   327

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

   328

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

   329

        // copy in the actual tile data...

   330

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

   331

   332

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

   333

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

   334

   335

        // write

   336

        png_write_row(img->png, rowbuf);

   337

    }

   338

   339

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

   340

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

   341

   342

    // write out the remaining rows as clipped data

   343

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

   344

        png_write_row(img->png, rowbuf);

   345

   346

    // ok

   347

    return 0;

   348

}

   349

   350

/**

   351

 * Write unscaled tile data

   352

 */

   353

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)

   354

{

   355

    int err;

   356

   357

    // set basic info

   358

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

   359

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   360

    );

   361

   362

    // set palette?

   363

    if (header->color_type == PNG_COLOR_TYPE_PALETTE)

   364

        // oops... missing const

   365

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

   366

   367

    // write meta-info

   368

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

   369

   370

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

   371

    png_set_packing(img->png);

   372

   373

    // figure out if the tile clips

   374

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

   375

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

   376

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

   377

   378

    else

   379

        // fill in clipped regions

   380

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

   381

   382

    return err;

   383

}

   384

   385

/**

   386

 * Manipulate powers of two

   387

 */

   388

static inline size_t scale_by_zoom_factor (size_t value, int z)

   389

{

   390

    if (z > 0)

   391

        return value << z;

   392

   393

    else if (z < 0)

   394

        return value >> -z;

   395

   396

    else

   397

        return value;

   398

}

   399

   400

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

   401

   402

/**

   403

 * Converts a pixel's data into a png_color

   404

 */

   405

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)

   406

{

   407

    // palette entry number

   408

    int p;

   409

   410

    switch (header->color_type) {

   411

        case PNG_COLOR_TYPE_PALETTE:

   412

            switch (header->bit_depth) {

   413

                case 8:

   414

                    // 8bpp palette

   415

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

   416

   417

                    break;

   418

   419

                default :

   420

                    // unknown

   421

                    return;

   422

            }

   423

   424

            // hrhr - assume our working data is valid (or we have 255 palette entries, so it doesn't matter...)

   425

            assert(p < header->num_palette);

   426

   427

            // reference data from palette

   428

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

   429

   430

            return;

   431

   432

        default :

   433

            // unknown pixel format

   434

            return;

   435

    }

   436

}

   437

   438

/**

   439

 * Write scaled tile data

   440

 */

   441

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)

   442

{

   443

    // size of the image data in px

   444

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

   445

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

   446

   447

    // input pixels per output pixel

   448

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

   449

   450

    // bytes per output pixel

   451

    size_t pixel_bytes = 3;

   452

   453

    // size of the output tile in px

   454

    size_t row_width = ti->width;

   455

   456

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

   457

    size_t row_bytes = row_width * 3;

   458

   459

    // buffer to hold output rows

   460

    uint8_t *row_buf;

   461

   462

    // color entry for pixel

   463

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

   464

   465

    // only supports zooming out...

   466

    if (ti->zoom < 0)

   467

        RETURN_ERROR(PT_ERR_TILE_ZOOM);

   468

   469

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

   470

        RETURN_ERROR(PT_ERR_MEM);

   471

   472

    // suppress warning...

   473

    (void) data_height;

   474

   475

    // define pixel format: 8bpp RGB

   476

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

   477

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   478

    );

   479

   480

    // write meta-info

   481

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

   482

   483

    // ...each output row

   484

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

   485

        memset(row_buf, 0, row_bytes);

   486

   487

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

   488

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

   489

   490

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

   491

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

   492

            // and includes each input pixel

   493

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

   494

   495

                // ...for this output pixel

   496

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

   497

   498

                // get pixel RGB data

   499

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

   500

   501

                // average the RGB data        

   502

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

   503

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

   504

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

   505

            }

   506

        }

   507

   508

        // output

   509

        png_write_row(img->png, row_buf);

   510

    }

   511

   512

    // done

   513

    return 0;

   514

}

   515