1

#include <stdlib.h>

     2

#include <time.h>

     3

     4

#include <png.h>

     5

     6

#include "render.h"

     7

#include "mandelbrot.h"

     8

#include "common.h"

     9

    10

#define DETAIL 255

    11

    12

#define absdelta(a, b) (a>b ? a-b : b-a)

    13

    14

void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length) {

    15

    struct render_ctx *ctx = (struct render_ctx *) png_get_io_ptr(png_ptr);

    16

    17

    if (ctx->io_write_fn)

    18

        switch (ctx->io_write_fn(data, length, ctx->io_cb_arg)) {

    19

            case RENDER_CB_ERR :

    20

                ctx->io_error = 1;

    21

                break;

    22

    23

            case RENDER_CB_OK :

    24

                // great!

    25

                break;

    26

        }

    27

}

    28

    29

void user_flush_data(png_structp png_ptr) {

    30

    struct render_ctx *ctx = (struct render_ctx *) png_get_io_ptr(png_ptr);

    31

    32

    if (ctx->io_flush_fn)

    33

        switch (ctx->io_flush_fn(ctx->io_cb_arg)) {

    34

            case RENDER_CB_ERR :

    35

                ctx->io_error = 1;

    36

                break;

    37

    38

            case RENDER_CB_OK :

    39

                // great!

    40

                break;

    41

        }

    42

}

    43

    44

int mandelbrot_render (render_t *ctx) {

    45

    // libpng handles

    46

    png_structp png_ptr = NULL;

    47

    png_infop info_ptr = NULL;

    48

    49

    // render algorithm vars

    50

    u_int32_t img_x, img_y;

    51

    double x0, y0, x, y, _x, _y, w_scale, h_scale;

    52

    u_int8_t iter;

    53

    u_int8_t *row;

    54

    55

    // clear out any potential error in ctx

    56

    ctx->io_error = 0;

    57

    58

    // calcluate the scale factors

    59

    w_scale = ctx->img_w/absdelta(ctx->x1, ctx->x2);

    60

    h_scale = ctx->img_h/absdelta(ctx->y1, ctx->y2);

    61

    62

    // malloc the memory used to render each row

    63

    row = (u_int8_t *) malloc(ctx->img_w);

    64

    65

    if (!row)

    66

        goto error;

    67

    68

    // PNG or not?

    69

    if (ctx->mode == RENDER_PNG) {

    70

        // libpng initialization

    71

        png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

    72

    73

        if (!png_ptr)

    74

            goto error;

    75

    76

        info_ptr = png_create_info_struct(png_ptr);

    77

    78

        if (!info_ptr)

    79

            goto error;

    80

    81

        // libpng error handling

    82

        if (setjmp(png_jmpbuf(png_ptr))) {

    83

            goto error;

    84

        }

    85

    86

        if (ctx->io_stream) {

    87

            // use normal libpng I/O

    88

            png_init_io(png_ptr, ctx->io_stream);

    89

        } else {

    90

            // setup our custom I/O callbacks

    91

            png_set_write_fn(png_ptr, ctx, &user_write_data, &user_flush_data);

    92

        }

    93

    94

        // some PNG metadata

    95

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

    96

    97

        // write out the PNG header

    98

        png_write_info(png_ptr, info_ptr);

    99

   100

        // possible error return

   101

        if (ctx->io_error)

   102

            goto error;

   103

    }

   104

   105

    // start rendering!

   106

    for (img_y=0; img_y < ctx->img_h; img_y++) {

   107

        // render the current row

   108

        for (img_x=0; img_x < ctx->img_w; img_x++) {

   109

            x = 0;

   110

            y = 0;

   111

            x0 = img_x/w_scale + ctx->x1;

   112

            y0 = img_y/h_scale + ctx->y1;

   113

            iter = DETAIL; 

   114

   115

            while (x*x + y*y < (2*2) && iter > 0) {

   116

                _x = x*x - y*y + x0;

   117

                _y = 2*x*y + y0;

   118

   119

                x = _x;

   120

                y = _y;

   121

   122

                iter--;

   123

            }

   124

   125

            row[img_x] = iter;

   126

        }

   127

   128

        if (ctx->mode == RENDER_PNG) {

   129

            // write the raw pixels to libpng

   130

            png_write_row(png_ptr, row);

   131

   132

            // check for user errors return

   133

            if (ctx->io_error)

   134

                goto error;

   135

        } else {

   136

            // pass on the pixels to the io callback

   137

            if (ctx->io_write_fn(row, ctx->img_w, ctx->io_cb_arg) == RENDER_CB_ERR) {

   138

                ctx->io_error = 1;

   139

                goto error;

   140

            }

   141

        }

   142

    }

   143

   144

    if (ctx->mode == RENDER_PNG) {

   145

        // finished writing

   146

        png_write_end(png_ptr, info_ptr);

   147

    }

   148

   149

    // clean up

   150

    png_destroy_write_struct(&png_ptr, &info_ptr);

   151

    free(row); row = NULL;

   152

   153

    // check for user errors return

   154

    if (ctx->io_error)

   155

        goto error;

   156

   157

    // return succesfully

   158

    return MANDELBROT_OK;

   159

   160

error:

   161

    if (png_ptr || info_ptr)

   162

        png_destroy_write_struct(&png_ptr, &info_ptr);

   163

   164

    if (row) 

   165

        free(row);

   166

   167

    row = NULL;

   168

   169

    return MANDELBROT_ERR;

   170

}

   171

   172

int mandelbrot_render_timed (render_t *ctx, double *duration) {

   173

    clock_t t1 = clock();

   174

    int ret = mandelbrot_render(ctx);

   175

    clock_t t2 = clock();

   176

   177

    *duration = ((double)(t2 - t1))/CLOCKS_PER_SEC;

   178

   179

    return ret;

   180

}

   181