1

#include "image.h"

     2

#include "cache.h"

     3

#include "shared/util.h"

     4

     5

#include <stdlib.h>

     6

#include <errno.h>

     7

     8

#include <png.h>

     9

    10

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

    11

{

    12

    struct pt_image *img;

    13

    14

    // alloc

    15

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

    16

        return -1;

    17

    18

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

    19

        goto error;

    20

    21

    // init

    22

    img->ctx = ctx;

    23

    24

    // ok

    25

    *img_ptr = img;

    26

    27

    return 0;

    28

    29

error:

    30

    pt_image_destroy(img);

    31

    32

    return -1;

    33

}

    34

    35

/**

    36

 * Open the image's FILE

    37

 */

    38

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

    39

{

    40

    FILE *fp;

    41

    42

    // open

    43

    if ((fp = fopen(img->path, "rb")) < 0)

    44

        return -1;

    45

    46

    // ok

    47

    *file_ptr = fp;

    48

    49

    return 0;

    50

}

    51

    52

/**

    53

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

    54

 */

    55

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

    56

{

    57

    FILE *fp = NULL;

    58

    png_structp png = NULL;

    59

    png_infop info = NULL;

    60

    61

    // open I/O

    62

    if (pt_image_open_file(img, &fp))

    63

        goto error;

    64

    65

    // create the struct

    66

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

    67

        goto error;

    68

    69

    // create the info

    70

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

    71

        goto error;

    72

    73

    // setup error trap for the I/O

    74

    if (setjmp(png_jmpbuf(png)))

    75

        goto error;

    76

    77

    // setup I/O to FILE

    78

    png_init_io(png, fp);

    79

    80

    // ok

    81

    // XXX: what to do with fp?

    82

    *png_ptr = png;

    83

    *info_ptr = info;

    84

    85

    return 0;

    86

    87

error:

    88

    // cleanup file

    89

    if (fp) fclose(fp);

    90

    91

    // cleanup PNG state

    92

    png_destroy_read_struct(&png, &info, NULL);

    93

    94

    return -1;

    95

}

    96

    97

/**

    98

 * Update the image_info field from the given png object.

    99

 *

   100

 * Must be called under libpng-error-trap!

   101

 */

   102

static int pt_image_update_info (struct pt_image *image, png_structp png, png_infop info)

   103

{

   104

    // query png_get_*

   105

    image->info.width = png_get_image_width(png, info); 

   106

    image->info.height = png_get_image_height(png, info); 

   107

   108

    return 0;

   109

}

   110

   111

/**

   112

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

   113

 */

   114

static int pt_image_update_cache (struct pt_image *image)

   115

{

   116

    png_structp png;

   117

    png_infop info;

   118

   119

    // pre-check enabled

   120

    if (!(image->cache->mode & PT_IMG_WRITE)) {

   121

        errno = EPERM;

   122

        return -1;

   123

    }

   124

   125

    // open .png

   126

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

   127

        return -1;

   128

   129

    // setup error trap

   130

    if (setjmp(png_jmpbuf(png)))

   131

        goto error;

   132

   133

    // read meta-info

   134

    png_read_info(png, info);

   135

   136

    // update our meta-info

   137

    if (pt_image_update_info(image, png, info))

   138

        goto error;

   139

   140

    // pass to cache object

   141

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

   142

        goto error;

   143

   144

    // finish off, ignore trailing data

   145

    png_read_end(png, NULL);

   146

   147

    // clean up

   148

    png_destroy_read_struct(&png, &info, NULL);

   149

   150

    return 0;

   151

   152

error:

   153

    // clean up

   154

    png_destroy_read_struct(&png, &info, NULL);

   155

   156

    return -1;

   157

}

   158

   159

/**

   160

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

   161

 * buffer.

   162

 */

   163

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

   164

{

   165

    return path_with_fext(image->path, buf, len, ".cache"); 

   166

}

   167

   168

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

   169

{

   170

    struct pt_image *image;

   171

    char cache_path[1024];

   172

   173

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

   174

   175

    // alloc

   176

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

   177

        return -1;

   178

   179

    // compute cache file path

   180

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

   181

        goto error;

   182

   183

    // open the cache object for this image

   184

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

   185

        goto error;

   186

   187

    // ok, ready for access

   188

    *image_ptr = image;

   189

   190

    return 0;

   191

   192

error:

   193

    pt_image_destroy(image);

   194

   195

    return -1;

   196

}

   197

   198

int pt_image_info (struct pt_image *image, const struct pt_image_info **info_ptr)

   199

{

   200

    // XXX: ensure that this was read?

   201

    *info_ptr = &image->info;

   202

   203

    return 0;

   204

}

   205

   207

{

   209

}

   210

   211

int pt_image_update (struct pt_image *image)

   212

{

   213

    return pt_image_update_cache(image);

   214

}

   215

   216

void pt_image_destroy (struct pt_image *image)

   217

{

   218

    free(image->path);

   219

   220

    if (image->cache)

   221

        pt_cache_destroy(image->cache);

   222

   223

    free(image);

   224

}