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_open (struct pt_image *image, struct pt_png_img *img)

    12

{

    13

    FILE *fp = NULL;

    14

    int err;

    15

    16

    // open I/O

    17

    if ((err = pt_image_open_file(image, &fp)))

    18

        JUMP_ERROR(err);

    19

    20

    // create the struct

    21

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

    22

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    23

    24

    // create the info

    25

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

    26

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    27

    28

    // setup error trap for the I/O

    29

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

    30

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    31

    32

    // setup error trap

    33

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

    34

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    35

    36

    37

    // setup I/O to FILE

    38

    png_init_io(img->png, fp);

    39

    40

    // read meta-info

    41

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

    42

    43

    44

    // XXX: what to do with fp? Should fclose() when done?

    45

    return 0;

    46

    47

error:

    48

    // cleanup

    49

    pt_png_release_read(img);

    50

    51

    if (fp) fclose(fp);

    52

    53

    return err;

    54

}

    55

    56

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

    57

{

    58

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

    59

    60

    // initialize

    61

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

    62

    63

    // fill in basic info

    64

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

    65

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

    66

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

    67

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

    68

    69

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

    70

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

    71

    );

    72

    73

    // only pack 1 pixel per byte, changes rowbytes

    74

    if (header->bit_depth < 8)

    75

        png_set_packing(img->png);

    76

    77

    // fill in other info

    78

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

    79

    80

    // calculate bpp as num_channels * bpc

    81

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

    82

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

    83

    84

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

    85

    86

    // palette etc.

    87

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

    88

        int num_palette;

    89

        png_colorp palette;

    90

    91

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

    92

            // XXX: PLTE chunk not read?

    93

            RETURN_ERROR(PT_ERR_PNG);

    94

    95

        // should only be 256 of them at most

    96

        assert(num_palette <= PNG_MAX_PALETTE_LENGTH);

    97

    98

        // copy

    99

        header->num_palette = num_palette;

   100

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

   101

   102

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

   103

    }

   104

   105

    // calculate data size

   106

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

   107

   108

    return 0;

   109

}

   110

   111

/**

   112

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

   113

 */

   114

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

   115

{

   116

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

   117

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

   118

        // read row data, non-interlaced

   119

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

   120

    }

   121

   122

    return 0;

   123

}

   124

   125

/**

   126

 * Decode the PNG data, filtering it for sparse regions

   127

 */

   128

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)

   129

{

   130

    // one row of pixel data

   131

    uint8_t *row_buf;

   132

   133

    // alloc

   134

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

   135

        RETURN_ERROR(PT_ERR_MEM);

   136

   137

    // decode each row at a time

   138

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

   139

        // read row data, non-interlaced

   140

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

   141

   142

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

   143

        // ...in blocks of PT_CACHE_BLOCK_SIZE bytes

   144

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

   145

            // size of this block in bytes

   146

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

   147

   148

            // ...each pixel

   149

            for (

   150

                    size_t col = col_base;

   151

   152

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

   153

                    col < col_base + block_size; 

   154

   155

                    col += header->col_bytes

   156

            ) {

   157

                // test this pixel

   158

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

   159

                    // differs

   160

                    memcpy(

   161

                            out + row * header->row_bytes + col_base, 

   162

                            row_buf + col_base,

   163

                            block_size

   164

                    );

   165

   166

                    // skip to next block

   167

                    break;

   168

                }

   169

            }

   170

   171

            // skip this block

   172

            continue;

   173

        }

   174

    }

   175

   176

    return 0;

   177

}

   178

   179

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

   180

{

   181

    int err;

   182

   183

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

   184

        return err;

   185

   186

    // finish off, ignore trailing data

   187

    png_read_end(img->png, NULL);

   188

   189

    return 0;

   190

}

   191

   192

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

   193

{

   194

    // fill in info from header

   195

    info->img_width = header->width;

   196

    info->img_height = header->height;

   197

    info->img_bpp = header->bit_depth;

   198

   199

    return 0;

   200

}

   201

   202

/** 

   203

 * libpng I/O callback: write out data

   204

 */

   205

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

   206

{

   207

    struct pt_tile_mem *buf = png_get_io_ptr(png);

   208

    int err;

   209

   210

    // write to buffer

   211

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

   212

        // XXX: log pt_strerror(err)

   213

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

   214

}

   215

   216

/** 

   217

 * libpng I/O callback: flush buffered data

   218

 */

   219

static void pt_png_mem_flush (png_structp png_ptr)

   220

{

   221

    // no-op

   222

}

   223

   224

   225

/**

   226

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

   227

 */

   228

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

   229

{

   230

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

   231

}

   232

   233

/**

   234

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

   235

 */

   236

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

   237

{

   238

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

   239

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

   240

}

   241

   242

/**

   243

 * Write raw tile image data, directly from the cache

   244

 */

   245

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

   246

{

   247

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

   248

        // write data directly

   249

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

   250

   251

    return 0;

   252

}

   253

   254

/**

   255

 * 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

   256

 */

   257

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

   258

{

   259

    png_byte *rowbuf;

   260

    size_t row;

   261

   262

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

   263

    size_t clip_x, clip_y;

   264

   265

   266

    // figure out if the tile clips over the right edge

   267

    // XXX: use min()

   268

    if (ti->x + ti->width > header->width)

   269

        clip_x = header->width;

   270

    else

   271

        clip_x = ti->x + ti->width;

   272

   273

    // figure out if the tile clips over the bottom edge

   274

    // XXX: use min()

   275

    if (ti->y + ti->height > header->height)

   276

        clip_y = header->height;

   277

    else

   278

        clip_y = ti->y + ti->height;

   279

   280

   281

    // allocate buffer for a single row of image data

   282

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

   283

        RETURN_ERROR(PT_ERR_MEM);

   284

   285

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

   286

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

   287

    size_t row_px = clip_x - ti->x;

   288

    size_t row_bytes = row_px * header->col_bytes;

   289

   290

    // write the rows that we have

   291

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

   292

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

   293

        // copy in the actual tile data...

   294

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

   295

   296

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

   297

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

   298

   299

        // write

   300

        png_write_row(img->png, rowbuf);

   301

    }

   302

   303

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

   304

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

   305

   306

    // write out the remaining rows as clipped data

   307

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

   308

        png_write_row(img->png, rowbuf);

   309

   310

    // ok

   311

    return 0;

   312

}

   313

   314

static size_t scale_by_zoom_factor (size_t value, int z)

   315

{

   316

    if (z > 0)

   317

        return value << z;

   318

   319

    else if (z < 0)

   320

        return value >> -z;

   321

   322

    else

   323

        return value;

   324

}

   325

   326

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

   327

   328

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

   329

{

   330

    if (header->color_type == PNG_COLOR_TYPE_PALETTE) {

   331

        // palette entry number

   332

        int p;

   333

   334

        if (header->bit_depth == 8)

   335

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

   336

        else

   337

            return -1;

   338

   339

        if (p >= header->num_palette)

   340

            return -1;

   341

   342

        // reference data from palette

   343

        *out = header->palette[p];

   344

   345

        return 0;

   346

   347

    } else {

   348

        return -1;

   349

    }

   350

}

   351

   352

/**

   353

 * Write unscaled tile data

   354

 */

   355

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

   356

{

   357

    int err;

   358

   359

    // set basic info

   360

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

   361

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   362

    );

   363

   364

    // set palette?

   365

    if (header->color_type == PNG_COLOR_TYPE_PALETTE)

   366

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

   367

   368

    // write meta-info

   369

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

   370

   371

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

   372

    png_set_packing(img->png);

   373

   374

    // figure out if the tile clips

   375

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

   376

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

   377

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

   378

   379

    else

   380

        // fill in clipped regions

   381

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

   382

   383

    return err;

   384

}

   385

   386

/**

   387

 * Write scaled tile data

   388

 */

   389

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

   390

{

   391

    // size of the image data in px

   392

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

   393

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

   394

   395

    // input pixels per output pixel

   396

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

   397

   398

    // bytes per output pixel

   399

    size_t pixel_bytes = 3;

   400

   401

    // size of the output tile in px

   402

    size_t row_width = ti->width;

   403

   404

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

   405

    size_t row_bytes = row_width * 3;

   406

   407

    // buffer to hold output rows

   408

    uint8_t *row_buf;

   409

   410

    // XXX: only supports zooming out...

   411

    if (ti->zoom >= 0)

   412

        RETURN_ERROR(PT_ERR_ZOOM);

   413

   414

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

   415

        RETURN_ERROR(PT_ERR_MEM);

   416

   417

    // suppress warning...

   418

    (void) data_height;

   419

   420

    // define pixel format: 8bpp RGB

   421

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

   422

            PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT

   423

    );

   424

   425

    // write meta-info

   426

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

   427

   428

    // ...each output row

   429

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

   430

        memset(row_buf, 0, row_bytes);

   431

   432

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

   433

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

   434

   435

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

   436

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

   437

            // and includes each input pixel

   438

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

   439

                png_color c;

   440

   441

                // ...for this output pixel

   442

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

   443

   444

                // get pixel RGB data

   445

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

   446

                    return -1;

   447

   448

                // average the RGB data        

   449

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

   450

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

   451

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

   452

            }

   453

        }

   454

   455

        // output

   456

        png_write_row(img->png, row_buf);

   457

    }

   458

   459

    // done

   460

    return 0;

   461

}

   462

   463

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

   464

{

   465

    struct pt_png_img _img, *img = &_img;

   466

    struct pt_tile_info *ti = &tile->info;

   467

    int err;

   468

   469

    // check within bounds

   470

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

   471

        // completely outside

   472

        RETURN_ERROR(PT_ERR_TILE_CLIP);

   473

   474

    // XXX: init img

   475

    // open PNG writer

   476

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

   477

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

   478

   479

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

   480

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

   481

   482

    // libpng error trap

   483

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

   484

        JUMP_SET_ERROR(err, PT_ERR_PNG);

   485

   486

   487

   488

    // setup output I/O

   489

    switch (tile->out_type) {

   490

        case PT_TILE_OUT_FILE:

   491

            // use default FILE* operation

   492

            png_init_io(img->png, tile->out.file);

   493

   494

            break;

   495

   496

        case PT_TILE_OUT_MEM:

   497

            // use pt_tile_mem struct via pt_png_mem_* callbacks

   498

            png_set_write_fn(img->png, &tile->out.mem, pt_png_mem_write, pt_png_mem_flush);

   499

   500

            break;

   501

   502

        default:

   503

            FATAL("tile->out_type: %d", tile->out_type);

   504

    }

   505

   506

   507

   508

    // unscaled or scaled?

   509

    if (ti->zoom)

   510

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

   511

   512

    else

   513

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

   514

   515

    if (err)

   516

        goto error;

   517

   518

   519

    // flush remaining output

   520

    png_write_flush(img->png);

   521

   522

    // done

   523

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

   524

   525

error:

   526

    // cleanup

   527

    pt_png_release_write(img);

   528

   529

    return err;

   530

}