1

#include "tile.h"

     2

#include "error.h"

     3

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

     4

     5

#include <stdlib.h>

     6

     7

static void pt_tile_init (struct pt_tile *tile, const struct pt_tile_info *info, enum pt_tile_output out_type)

     8

{

     9

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

    10

    11

    // init

    12

    tile->info = *info;

    13

    tile->out_type = out_type;

    14

}

    15

    16

    17

int pt_tile_init_file (struct pt_tile *tile, const struct pt_tile_info *info, FILE *out)

    18

{

    19

    pt_tile_init(tile, info, PT_TILE_OUT_FILE);

    20

    21

    tile->out.file = out;

    22

    23

    return 0;

    24

}

    25

    26

int pt_tile_init_mem (struct pt_tile *tile, const struct pt_tile_info *info)

    27

{

    28

    pt_tile_init(tile, info, PT_TILE_OUT_MEM);

    29

    30

    // init buffer

    31

    if ((tile->out.mem.base = malloc(PT_TILE_BUF_SIZE)) == NULL)

    32

        RETURN_ERROR(PT_ERR_MEM);

    33

    34

    tile->out.mem.len = PT_TILE_BUF_SIZE;

    35

    tile->out.mem.off = 0;

    36

    37

    return 0;

    38

}

    39

    40

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

    41

{

    42

    struct pt_tile_mem *buf = png_get_io_ptr(png);

    43

    size_t buf_len = buf->len;

    44

    45

    // grow?

    46

    while (buf->off + length > buf_len)

    47

        buf_len *= 2;

    48

    49

    if (buf_len != buf->len) {

    50

        char *tmp;

    51

    52

        if ((tmp = realloc(buf->base, buf_len)) == NULL)

    53

            png_error(png, "pt_tile_buf_write - realloc failed");

    54

    55

        buf->base = tmp;

    56

        buf->len = buf_len;

    57

    }

    58

    59

    // copy

    60

    memcpy(buf->base + buf->off, data, length);

    61

    62

    buf->off += length;

    63

}

    64

    65

static void pt_tile_mem_flush (png_structp png_ptr)

    66

{

    67

    // no-op

    68

}

    69

    70

    71

int pt_tile_render (struct pt_tile *tile, struct pt_cache *cache)

    72

{

    73

    png_structp png = NULL;

    74

    png_infop info = NULL;

    75

    int err = 0;

    76

    77

    // open PNG writer

    78

    if ((png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL)

    79

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    80

    81

    if ((info = png_create_info_struct(png)) == NULL)

    82

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    83

    84

    // libpng error trap

    85

    if (setjmp(png_jmpbuf(png)))

    86

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    87

    88

    // setup output I/O

    89

    switch (tile->out_type) {

    90

        case PT_TILE_OUT_FILE:

    91

            // use default FILE* operation

    92

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

    93

    94

            break;

    95

    96

        case PT_TILE_OUT_MEM:

    97

            // use pt_tile_mem struct via pt_tile_mem_* callbacks

    98

            png_set_write_fn(png, &tile->out.mem, pt_tile_mem_write, pt_tile_mem_flush);

    99

   100

            break;

   101

   102

        default:

   103

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

   104

    }

   105

   106

    // render tile

   107

    if ((err = pt_cache_tile_png(cache, png, info, &tile->info)))

   108

        JUMP_ERROR(err);

   109

   110

    // done

   111

    png_write_end(png, info);

   112

   113

error:

   114

    // cleanup

   115

    png_destroy_write_struct(&png, &info);

   116

   117

    return err;

   118

}

   119

   120

void pt_tile_abort (struct pt_tile *tile)

   121

{

   122

    // cleanup

   123

    switch (tile->out_type) {

   124

        case PT_TILE_OUT_FILE:

   125

            // no-op

   126

            break;

   127

   128

        case PT_TILE_OUT_MEM:

   129

            // drop buffer

   130

            free(tile->out.mem.base);

   131

   132

            break;

   133

    }

   134

}

   135