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

    if (params->background_color)

   221

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

   222

   223

    else

   224

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

   225

   226

    if (err)

   227

        return err;

   228

   229

    // finish off, ignore trailing data

   230

    png_read_end(img->png, NULL);

   231

   232

    return 0;

   233

}

   234

   235

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

   236

{

   237

    // fill in info from header

   238

    info->img_width = header->width;

   239

    info->img_height = header->height;

   240

    info->img_bpp = header->bit_depth;

   241

   242

    return 0;

   243

}

   244

   245

/** 

   246

 * libpng I/O callback: write out data

   247

 */

   248

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

   249

{

   250

    struct pt_tile_mem *buf = png_get_io_ptr(png);

   251

    int err;

   252

   253

    // write to buffer

   254

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

   255

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

   256

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

   257

}

   258

   259

/** 

   260

 * libpng I/O callback: flush buffered data

   261

 */

   262

static void pt_png_mem_flush (png_structp png_ptr)

   263

{

   264

    // no-op

   265

}

   266

   267

   268

/**

   269

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

   270

 */

   271

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

   272

{

   273

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

   274

}

   275

   276

/**

   277

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

   278

 */

   279

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

   280

{

   281

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

   282

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

   283

}

   284

   285

/**

   286

 * Write raw tile image data, directly from the cache

   287

 */

   288

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)

   289

{

   290

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

   291

        // write data directly

   292

        // missing const...

   293

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

   294

   295

    return 0;

   296

}

   297

   298

/**

   299

 * 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

   300

 */

   301

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)

   302

{

   303

    png_byte *rowbuf;

   304

    size_t row;

   305

   306

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

   307

    size_t clip_x, clip_y;

   308

   309

   310

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

   311

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

   312

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

   313

   314

   315

    // allocate buffer for a single row of image data

   316

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

   317

        RETURN_ERROR(PT_ERR_MEM);

   318

   319

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

   320

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

   321

    size_t row_px = clip_x - ti->x;

   322

    size_t row_bytes = row_px * header->col_bytes;

   323

   324

    // write the rows that we have

   325

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

   326

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

   327

        // copy in the actual tile data...

   328

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

   329

   330

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

   331

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

   332

   333

        // write

   334

        png_write_row(img->png, rowbuf);

   335

    }

   336

   337

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

   338

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

   339

   340

    // write out the remaining rows as clipped data

   341

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

   342

        png_write_row(img->png, rowbuf);

   343

   344

    // ok

   345

    return 0;

   346

}

   347

   348

static size_t scale_by_zoom_factor (size_t value, int z)

   349

{

   350

    if (z > 0)

   351

        return value << z;

   352

   353

    else if (z < 0)

   354

        return value >> -z;

   355

   356

    else

   357

        return value;

   358

}

   359

   360

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

   361

   362

static int png_pixel_data (png_color *out, const struct pt_png_header *header, const uint8_t *data, size_t row, size_t col)

   363

{

   364

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

   365

        // palette entry number

   366

        int p;

   367

   368

        if (header->bit_depth == 8)

   369

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

   370

        else

   371

            return -1;

   372

   373

        if (p >= header->num_palette)

   374

            return -1;

   375

   376

        // reference data from palette

   377

        *out = header->palette[p];

   378

   379

        return 0;

   380

   381

    } else {

   382

        return -1;

   383

    }

   384

}

   385

   386

/**

   387

 * Write unscaled tile data

   388

 */

   389

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)

   390

{

   391

    int err;

   392

   393

    // set basic info

   394

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

   395

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   396

    );

   397

   398

    // set palette?

   399

    if (header->color_type == PNG_COLOR_TYPE_PALETTE)

   400

        // oops... missing const

   401

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

   402

   403

    // write meta-info

   404

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

   405

   406

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

   407

    png_set_packing(img->png);

   408

   409

    // figure out if the tile clips

   410

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

   411

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

   412

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

   413

   414

    else

   415

        // fill in clipped regions

   416

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

   417

   418

    return err;

   419

}

   420

   421

/**

   422

 * Write scaled tile data

   423

 */

   424

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)

   425

{

   426

    // size of the image data in px

   427

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

   428

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

   429

   430

    // input pixels per output pixel

   431

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

   432

   433

    // bytes per output pixel

   434

    size_t pixel_bytes = 3;

   435

   436

    // size of the output tile in px

   437

    size_t row_width = ti->width;

   438

   439

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

   440

    size_t row_bytes = row_width * 3;

   441

   442

    // buffer to hold output rows

   443

    uint8_t *row_buf;

   444

   445

    // only supports zooming out...

   446

    if (ti->zoom >= 0)

   447

        RETURN_ERROR(PT_ERR_ZOOM);

   448

   449

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

   450

        RETURN_ERROR(PT_ERR_MEM);

   451

   452

    // suppress warning...

   453

    (void) data_height;

   454

   455

    // define pixel format: 8bpp RGB

   456

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

   457

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   458

    );

   459

   460

    // write meta-info

   461

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

   462

   463

    // ...each output row

   464

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

   465

        memset(row_buf, 0, row_bytes);

   466

   467

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

   468

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

   469

   470

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

   471

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

   472

            // and includes each input pixel

   473

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

   474

                png_color c;

   475

   476

                // ...for this output pixel

   477

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

   478

   479

                // get pixel RGB data

   480

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

   481

                    return -1;

   482

   483

                // average the RGB data        

   484

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

   485

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

   486

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

   487

            }

   488

        }

   489

   490

        // output

   491

        png_write_row(img->png, row_buf);

   492

    }

   493

   494

    // done

   495

    return 0;

   496

}

   497

   498

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

   499

{

   500

    struct pt_png_img _img, *img = &_img;

   501

    struct pt_tile_info *ti = &tile->info;

   502

    int err;

   503

   504

    // init img

   506

   507

    // check within bounds

   508

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

   509

        // completely outside

   510

        RETURN_ERROR(PT_ERR_TILE_CLIP);

   511

   512

    // open PNG writer

   513

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

   514

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

   515

   516

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

   517

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

   518

   519

    // libpng error trap

   520

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

   521

        JUMP_SET_ERROR(err, PT_ERR_PNG);