1

#include <stdlib.h>

     2

     3

#include <png.h>

     4

     5

#include "common.h"

     6

#include "render_struct.h"

     7

#include "render_png_struct.h"

     8

#include "render_png.h"

     9

    10

    11

static void _render_png_write(png_structp png_ptr, png_bytep data, png_size_t length) {

    12

    struct render_png *ctx = png_get_io_ptr(png_ptr);

    13

    14

    if (ctx->io_write_fn)

    15

        if (ctx->io_write_fn(data, length, ctx->cb_arg)) {

    16

            // error, doesn't return

    17

            png_error(png_ptr, "_render_png_write: io_write_fn");

    18

        }

    19

}

    20

    21

static void _render_png_flush(png_structp png_ptr) {

    22

    struct render_png *ctx = png_get_io_ptr(png_ptr);

    23

    24

    if (ctx->io_flush_fn)

    25

        if (ctx->io_flush_fn(ctx->cb_arg)) {

    26

            // error, doesn't return

    27

            png_error(png_ptr, "_render_png_flush: io_flush_fn");

    28

        }

    29

}

    30

    31

static void _render_png_free (struct render_png *ctx) {

    32

    render_png_deinit(ctx);

    33

    34

    if (ctx->owned_by_me)

    35

        free(ctx);

    36

}

    37

    38

void render_png_deinit (struct render_png *ctx) {

    39

    // are we initialized?

    40

    if (ctx->png_ptr) {

    41

        // libpng error handling

    42

        if (setjmp(png_jmpbuf(ctx->png_ptr)))

    43

            ERROR("libpng");

    44

    45

        png_destroy_write_struct(&ctx->png_ptr, &ctx->info_ptr);

    46

    }

    47

    48

    return;

    49

    50

error:

    51

    WARNING("destroying our libpng structures failed, possible memory leak?");

    52

}

    53

    54

/*

    55

 * Note that it's vitally important not to call any libpng functions directly,

    56

 * the error-handling setjmp will be invalid.

    57

 */

    58

    59

int render_png_init (struct render_png *ctx, struct render *render) {

    60

    // store some info from the struct render

    61

    ctx->io_write_fn = render->io_write_fn;

    62

    ctx->io_flush_fn = render->io_flush_fn;

    63

    ctx->cb_arg = render->cb_arg;

    64

    65

    // libpng initialization

    66

    if (!(ctx->png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)))

    67

        ERROR("png_create_write_struct");

    68

    69

    if (!(ctx->info_ptr = png_create_info_struct(ctx->png_ptr)))

    70

        ERROR("png_create_info_struct");

    71

    72

    // libpng error handling

    73

    if (setjmp(png_jmpbuf(ctx->png_ptr)))

    74

        ERROR("libpng");

    75

    76

    if (render->io_stream) {

    77

        // use normal libpng I/O

    78

        // XXX: who fcloses this?

    79

        png_init_io(ctx->png_ptr, render->io_stream);

    80

    } else {

    81

        // setup our custom I/O callbacks

    82

        png_set_write_fn(ctx->png_ptr, ctx, &_render_png_write, &_render_png_flush);

    83

    }

    84

    85

    // some PNG metadata

    86

    png_set_IHDR(ctx->png_ptr, ctx->info_ptr, render->img_w, render->img_h, 8, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

    87

    88

    // write out the PNG header

    89

    png_write_info(ctx->png_ptr, ctx->info_ptr);

    90

    91

    // success

    92

    return 0;

    93

    94

error:

    95

    render_png_deinit(ctx);

    96

    return -1;

    97

}

    98

    99

struct render_png *render_png_alloc (struct render *render) {

   100

    struct render_png *ctx = NULL;

   101

   102

    // calloc the render_png

   103

    if (!(ctx = calloc(1, sizeof(struct render_png))))

   104

        ERROR("calloc");

   105

   106

    // I need to free it

   107

    ctx->owned_by_me = 1;

   108

   109

    // init it

   110

    if (render_png_init(ctx, render))

   111

        goto error;

   112

   113

    // success

   114

    return ctx;

   115

   116

error:

   117

    _render_png_free(ctx);

   118

    return NULL;

   119

}

   120

   121

int render_png_row (struct render_png *ctx, unsigned char *rowbuf) {

   122

    // libpng error handling

   123

    if (setjmp(png_jmpbuf(ctx->png_ptr)))

   124

        ERROR("libpng");

   125

   126

    // write it in

   127

    png_write_row(ctx->png_ptr, rowbuf);

   128

   129

    // success

   130

    return 0;

   131

   132

error:

   133

    // don't free it here, our user needs to do that

   134

    return -1;

   135

}

   136

   137

int render_png_done (struct render_png *ctx) {

   138

    // libpng error handling

   139

    if (setjmp(png_jmpbuf(ctx->png_ptr)))

   140

        ERROR("libpng");

   141

   142

    // write end

   143

    png_write_end(ctx->png_ptr, ctx->info_ptr);

   144

   145

    // free everything

   146

    _render_png_free(ctx);

   147

   148

    // success

   149

    return 0;

   150

   151

error:

   152

    _render_png_free(ctx);

   153

    return -1;

   154

}

   155

   156

int render_png_abort (struct render_png *ctx) {

   157

    // just free it

   158

    _render_png_free(ctx);

   159

   160

    // success

   161

    return 0;

   162

}

   163