1

#include "tile.h"

     2

#include "error.h"

     3

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

     4

     5

#include <stdlib.h>

     7

#include <assert.h>

     8

     9

int pt_tile_mem_write (struct pt_tile_mem *buf, void *data, size_t len)

    10

{

    11

    size_t buf_len = buf->len;

    12

    13

    // grow?

    14

    while (buf->off + len > buf_len)

    15

        buf_len *= 2;

    16

    17

    if (buf_len != buf->len) {

    18

        char *tmp;

    19

    20

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

    21

            RETURN_ERROR(PT_ERR_MEM);

    22

    23

        buf->base = tmp;

    24

        buf->len = buf_len;

    25

    }

    26

    27

    // copy

    28

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

    29

    30

    buf->off += len;

    31

    32

    return 0;

    33

}

    34

    35

    36

int pt_tile_new (struct pt_tile **tile_ptr)

    37

{

    38

    struct pt_tile *tile;

    39

    40

    if ((tile = calloc(1, sizeof(*tile))) == NULL)

    41

        return -PT_ERR_MEM;

    42

    43

    *tile_ptr = tile;

    44

    45

    return 0;

    46

}

    47

    48

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

    49

{

    50

    // init

    51

    tile->cache = cache;

    52

    tile->info = *info;

    53

    tile->out_type = out_type;

    54

}

    55

    56

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

    57

{

    58

    pt_tile_init(tile, cache, info, PT_TILE_OUT_FILE);

    59

    60

    tile->out.file = out;

    61

    62

    return 0;

    63

}

    64

    65

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

    66

{

    67

    pt_tile_init(tile, cache, info, PT_TILE_OUT_MEM);

    68

    69

    // init buffer

    70

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

    71

        RETURN_ERROR(PT_ERR_MEM);

    72

    73

    tile->out.mem.len = PT_TILE_BUF_SIZE;

    74

    tile->out.mem.off = 0;

    75

    76

    return 0;

    77

}

    78

    79

    80

int pt_tile_render (struct pt_tile *tile)

    81

{

    82

    // validate dimensions

    83

    if (!tile->info.width || !tile->info.height)

    84

        RETURN_ERROR(PT_ERR_TILE_DIM);

    85

    86

    return pt_cache_tile(tile->cache, tile);

    87

}

    88

    89

void pt_tile_abort (struct pt_tile *tile)

    90

{

    91

    // cleanup

    92

    switch (tile->out_type) {

    93

        case PT_TILE_OUT_FILE:

    94

            // no-op

    95

            break;

    96

    97

        case PT_TILE_OUT_MEM:

    98

            // drop buffer

    99

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

   100

   101

            break;

   102

    }

   103

}

   104

   105

void pt_tile_destroy (struct pt_tile *tile)

   106

{

   107

    pt_tile_abort(tile);

   108

   109

    free(tile);

   110

}

   111