1

#include "image.h"

     2

#include "cache.h"

     3

     4

#include <stdlib.h>

     5

#include <limits.h> // for _POSIX_PATH_MAX

     6

     7

#include <png.h>

     8

     9

static int pt_image_new (struct pt_image **img_ptr, struct pt_ctx *ctx, const char *path)

    10

{

    11

    struct pt_image *img;

    12

    13

    // alloc

    14

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

    15

        return -1;

    16

    17

    if ((img->path = strdup(path)) == NULL)

    18

        goto error;

    19

    20

    // init

    21

    img->ctx = ctx;

    22

    23

    // ok

    24

    *img_ptr = img;

    25

    26

    return 0;

    27

    28

error:

    29

    pt_image_destroy(img);

    30

    31

    return -1;

    32

}

    33

    34

/**

    35

 * Open the image's FILE

    36

 */

    37

static int pt_image_open_file (struct pt_image *img, FILE **file_ptr)

    38

{

    39

    FILE *fp;

    40

    41

    // open

    43

        return -1;

    44

    45

    // ok

    46

    *file_ptr = fp;

    47

    48

    return 0;

    49

}

    50

    51

/**

    52

 * Open the PNG image, setting up the I/O and returning the png_structp and png_infop

    53

 */

    54

static int pt_image_open_png (struct pt_image *img, png_structp *png_ptr, png_infop *info_ptr)

    55

{

    56

    FILE *fp = NULL;

    57

    png_structp png = NULL;

    58

    png_infop info = NULL;

    59

    60

    // open I/O

    61

    if (pt_image_open_file(img, &fp))

    62

        goto error;

    63

    64

    // create the struct

    65

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

    66

        goto error;

    67

    68

    // create the info

    69

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

    70

        goto error;

    71

    72

    // setup error trap for the I/O

    73

    if (setjmp(png_jmpbuf(png)))

    74

        goto error;

    75

    76

    // setup I/O to FILE

    77

    png_init_io(png, fp);

    78

    79

    // ok

    80

    // XXX: what to do with fp?

    81

    *png_ptr = png;

    82

    *info_ptr = info;

    83

    84

    return 0;

    85

    86

error:

    87

    // cleanup file

    88

    if (fp) fclose(fp);

    89

    90

    // cleanup PNG state

    91

    png_destroy_read_struct(&png, &info, NULL);

    92

    93

    return -1;

    94

}

    95

    96

/**

    97

 * Open the PNG image, and write out to the cache

    98

 */

    99

static int pt_image_update_cache (struct pt_image *img)

   100

{

   101

    png_structp png;

   102

    png_infop info;

   103

   104

    // open .png

   105

    if (pt_image_open_png(img, &png, &info))

   106

        return -1;

   107

   108

    // setup error trap

   109

    if (setjmp(png_jmpbuf(png)))

   110

        goto error;

   111

   112

    // read meta-info

   113

    png_read_info(png, info);

   114

   115

    // pass to cache object

   116

    if (pt_cache_update_png(img->cache, png, info))

   117

        goto error;

   118

   119

    // finish off, ignore trailing data

   120

    png_read_end(png, NULL);

   121

   122

    // clean up

   123

    png_destroy_read_struct(&png, &info, NULL);

   124

   125

    return 0;

   126

   127

error:

   128

    // clean up

   129

    png_destroy_read_struct(&png, &info, NULL);

   130

   131

    return -1;

   132

}

   133

   134

/**

   135

 * Build a filesystem path representing the appropriate path for this image's cache entry, and store it in the given

   136

 * buffer.

   137

 */

   138

static int pt_image_cache_path (struct pt_image *image, char *buf, size_t len)

   139

{

   156

}

   157

   158

int pt_image_open (struct pt_image **image_ptr, struct pt_ctx *ctx, const char *path, int cache_mode)

   159

{

   160

    struct pt_image *image;

   161

    char cache_path[_POSIX_PATH_MAX];

   163

   164

    // XXX: verify that the path exists and looks like a PNG file

   165

   166

    // alloc

   167

    if (pt_image_new(&image, ctx, path))

   168

        return -1;

   169

   170

    // compute cache file path

   171

    if (pt_image_cache_path(image, cache_path, sizeof(cache_path)))

   172

        goto error;

   173

   174

    // open the cache object for this image

   175

    if (pt_cache_open(&image->cache, cache_path, cache_mode))

   176

        goto error;

   177

   178

    // update if not fresh

   179

    // XXX: check cache_mode

   184

        pt_image_update_cache(image);

   185

   186

    // ok, ready for access

   187

    *image_ptr = image;

   188

   189

    return 0;

   190

   191

error:

   192

    pt_image_destroy(image);

   193

   194

    return -1;

   195

}

   196

   197

void pt_image_destroy (struct pt_image *image)

   198

{

   199

    free(image->path);

   200

   201

    if (image->cache)

   202

        pt_cache_destroy(image->cache);

   203

   204

    free(image);

   205

}