1

#include "tile.h"

     2

#include "error.h"

     3

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

     4

     5

#include <stdlib.h>

     6

#include <assert.h>

     7

     8

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

     9

{

    10

    size_t buf_len = buf->len;

    11

    12

    // grow?

    13

    while (buf->off + len > buf_len)

    14

        buf_len *= 2;

    15

    16

    if (buf_len != buf->len) {

    17

        char *tmp;

    18

    19

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

    20

            RETURN_ERROR(PT_ERR_MEM);

    21

    22

        buf->base = tmp;

    23

        buf->len = buf_len;

    24

    }

    25

    26

    // copy

    27

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

    28

    29

    buf->off += len;

    30

    31

    return 0;

    32

}

    33

    34

    35

int pt_tile_new (struct pt_tile **tile_ptr)

    36

{

    37

    struct pt_tile *tile;

    38

    39

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

    40

        return -PT_ERR_MEM;

    41

    42

    *tile_ptr = tile;

    43

    44

    return 0;

    45

}

    46

    47

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)

    48

{

    49

    // init

    50

    tile->cache = cache;

    51

    tile->info = *info;

    52

    tile->out_type = out_type;

    53

}

    54

    55

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

    56

{

    57

    pt_tile_init(tile, cache, info, PT_TILE_OUT_FILE);

    58

    59

    tile->out.file = out;

    60

    61

    return 0;

    62

}

    63

    64

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

    65

{

    66

    pt_tile_init(tile, cache, info, PT_TILE_OUT_MEM);

    67

    68

    // init buffer

    69

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

    70

        RETURN_ERROR(PT_ERR_MEM);

    71

    72

    tile->out.mem.len = PT_TILE_BUF_SIZE;

    73

    tile->out.mem.off = 0;

    74

    75

    return 0;

    76

}

    77

    78

    79

int pt_tile_render (struct pt_tile *tile)

    80

{

    81

    // validate dimensions

    82

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

    83

        RETURN_ERROR(PT_ERR_TILE_DIM);

    84

    85

    return pt_cache_tile(tile->cache, tile);

    86

}

    87

    88

void pt_tile_abort (struct pt_tile *tile)

    89

{

    90

    // cleanup

    91

    switch (tile->out_type) {

    92

        case PT_TILE_OUT_FILE:

    93

            // no-op

    94

            break;

    95

    96

        case PT_TILE_OUT_MEM:

    97

            // drop buffer

    98

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

    99

   100

            break;

   101

    }

   102

}

   103

   104

void pt_tile_destroy (struct pt_tile *tile)

   105

{

   106

    pt_tile_abort(tile);

   107

   108

    free(tile);

   109

}

   110