1

#include "image.h"

     2

#include "cache.h"

     4

#include "error.h"

     5

#include "shared/util.h"

     6

     7

#include <stdlib.h>

     8

#include <errno.h>

     9

    10

#include <png.h>

    11

    12

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

    13

{

    14

    struct pt_image *image;

    15

    int err = 0;

    16

    17

    // alloc

    18

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

    19

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    20

    21

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

    22

        JUMP_SET_ERROR(err, PT_ERR_MEM);

    23

    24

    // init

    25

    image->ctx = ctx;

    26

    27

    // ok

    28

    *image_ptr = image;

    29

    30

    return 0;

    31

    32

error:

    33

    pt_image_destroy(image);

    34

    35

    return err;

    36

}

    37

    38

/**

    39

 * Open the image's FILE

    40

 */

    41

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

    42

{

    43

    FILE *fp;

    44

    45

    // open

    46

    if ((fp = fopen(image->path, "rb")) == NULL)

    47

        RETURN_ERROR(PT_ERR_IMG_FOPEN);

    48

    49

    // ok

    50

    *file_ptr = fp;

    51

    52

    return 0;

    53

}

    54

    55

/**

    56

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

    57

 */

    58

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

    59

{

    60

    FILE *fp = NULL;

    61

    png_structp png = NULL;

    62

    png_infop info = NULL;

    63

    int err;

    64

    65

    // open I/O

    66

    if ((err = pt_image_open_file(image, &fp)))

    67

        JUMP_ERROR(err);

    68

    69

    // create the struct

    70

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

    71

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    72

    73

    // create the info

    74

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

    75

        JUMP_SET_ERROR(err, PT_ERR_PNG_CREATE);

    76

    77

    // setup error trap for the I/O

    78

    if (setjmp(png_jmpbuf(png)))

    79

        JUMP_SET_ERROR(err, PT_ERR_PNG);

    80

    81

    // setup I/O to FILE

    82

    png_init_io(png, fp);

    83

    84

    // ok

    85

    // XXX: what to do with fp? Should fclose() when done?

    86

    *png_ptr = png;

    87

    *info_ptr = info;

    88

    89

    return 0;

    90

    91

error:

    92

    // cleanup file

    93

    if (fp) fclose(fp);

    94

    95

    // cleanup PNG state

    96

    png_destroy_read_struct(&png, &info, NULL);

    97

    98

    return err;

    99

}

   100

   101

/**

   102

 * Update the image_info field from the given png object.

   103

 *

   104

 * Must be called under libpng-error-trap!

   107

 */

   108

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

   109

{

   110

    // query png_get_*

   111

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

   112

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

   113

   114

    return 0;

   115

}

   116

   117

/**

   118

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

   119

 */

   120

static int pt_image_update_cache (struct pt_image *image)

   121

{

   122

    png_structp png;

   123

    png_infop info;

   124

    int err = 0;

   125

   126

    // pre-check enabled

   127

    if (!(image->cache->mode & PT_OPEN_UPDATE))

   128

        RETURN_ERROR_ERRNO(PT_ERR_OPEN_MODE, EACCES);

   129

   130

    // open .png

   131

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

   132

        return err;

   133

   134

    // setup error trap

   135

    if (setjmp(png_jmpbuf(png)))

   136

        JUMP_SET_ERROR(err, PT_ERR_PNG);

   137

   138

    // read meta-info

   139

    png_read_info(png, info);

   140

   141

    // update our meta-info

   142

    if ((err = pt_image_update_info(image, png, info)))

   143

        JUMP_ERROR(err);

   144

   145

    // pass to cache object

   146

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

   147

        JUMP_ERROR(err);

   148

   149

    // finish off, ignore trailing data

   150

    png_read_end(png, NULL);

   151

   152

error:

   153

    // clean up

   154

    // XXX: we need to close the fopen'd .png

   155

    png_destroy_read_struct(&png, &info, NULL);

   156

   157

    return err;

   158

}

   159

   160

/**

   161

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

   162

 * buffer.

   163

 */

   164

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

   165

{

   166

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

   167

        RETURN_ERROR(PT_ERR_PATH);

   168

   169

    return 0;

   170

}

   171

   172

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

   173

{

   174

    struct pt_image *image;

   175

    char cache_path[1024];

   176

    int err;

   177

   178

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

   179

   180

    // alloc

   181

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

   182

        return err;

   183

   184

    // compute cache file path

   185

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

   186

        JUMP_ERROR(err);

   187

   188

    // create the cache object for this image (doesn't yet open it)

   189

    if ((err = pt_cache_new(&image->cache, cache_path, cache_mode)))

   190

        JUMP_ERROR(err);

   191

   192

    // ok, ready for access

   193

    *image_ptr = image;

   194

   195

    return 0;

   196

   197

error:

   198

    pt_image_destroy(image);

   199

   200

    return err;

   201

}

   202

   203

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

   204

{

   205

    int err;

   206

   207

    // update info

   208

    if ((err = pt_cache_info(image->cache, &image->info)))

   209

        return err;

   210

   211

    // return pointer

   212

    *info_ptr = &image->info;

   213

   214

    return 0;

   215

}

   216

   217

int pt_image_status (struct pt_image *image)

   218

{

   219

    return pt_cache_status(image->cache, image->path);

   220

}

   221

   222

int pt_image_update (struct pt_image *image)

   223

{

   224

    return pt_image_update_cache(image);

   225

}

   226

   228

{

   231

   238

        JUMP_ERROR(err);

   239

   242

   243

error:

   270

   271

    return err;

   272

}

   273

   274

void pt_image_destroy (struct pt_image *image)

   275

{

   276

    free(image->path);

   277

   278

    if (image->cache)

   279

        pt_cache_destroy(image->cache);

   280

   281

    free(image);

   282

}