1

#include <stdlib.h>

     2

#include <time.h>

     3

#include <assert.h>

     4

     5

#include "common.h"

     6

#include "render_struct.h"

     7

#include "render_local.h"

     8

#include "render_png.h"

     9

#include "render_raw.h"

    10

#include "render_mandelbrot.h"

    11

    12

int render_local (struct render *render, double *duration) {

    13

    struct render_local ctx;

    14

    15

    if (render_local_init(&ctx, render))

    16

        return -1;

    17

    18

    int err = render_local_run(&ctx, duration);

    19

    20

    render_local_deinit(&ctx);

    21

    22

    return err;

    23

}

    24

    25

int render_local_init (struct render_local *ctx, struct render *render) {

    26

    // zero

    27

    memset(ctx, 0, sizeof(*ctx));

    28

    29

    ctx->render_info = render;

    30

    31

    // alloc the memory buffer

    32

    if (!(ctx->rowbuf = malloc(render->img_w)))

    33

        ERROR("malloc");

    34

    35

    // what mode?

    36

    switch (render->mode) {

    37

        case RENDER_PNG :

    38

            // the render_png stuff

    39

            memset(&ctx->png_ctx, 0, sizeof(ctx->png_ctx));

    40

    41

            if (render_png_init(&ctx->png_ctx, render))

    42

                ERROR("render_png_init");

    43

    44

            ctx->must_deinit = RENDER_PNG;

    45

    46

            //  set render_* to use the render_png

    47

            if (render_local_mem(render, &ctx->rowbuf, (int(*)(void *arg, unsigned char *)) &render_png_row, &ctx->png_ctx))

    48

                ERROR("render_local_mem");

    49

    50

            break;

    51

    52

        case RENDER_RAW :

    53

            // the render_raw stuff

    54

            memset(&ctx->raw_ctx, 0, sizeof(ctx->raw_ctx));

    55

    56

            if (render_raw_init(&ctx->raw_ctx, render))

    57

                ERROR("render_raw_init");

    58

    59

            ctx->must_deinit = RENDER_RAW;

    60

    61

            //  set render_* to use the render_raw

    62

            if (render_local_mem(render, &ctx->rowbuf, (int(*)(void *arg, unsigned char *)) &render_raw_row, &ctx->raw_ctx))

    63

                ERROR("render_local_mem");

    64

    65

            break;

    66

    67

        default :

    68

            assert(0);

    69

    }

    70

    71

    // success

    72

    return 0;

    73

    74

error:

    75

    render_local_deinit(ctx);

    76

    77

    return -1;

    78

}

    79

    80

int render_local_run (struct render_local *ctx, double *duration) {

    81

    clock_t t1, t2;

    82

    83

    if (duration)

    84

        *duration = -1;

    85

    86

    // then we can actually render

    87

    t1 = clock();

    88

    89

    if (render_mandelbrot(ctx->render_info))

    90

        goto error;

    91

    92

    t2 = clock();

    93

    94

    // flush the PNG

    95

    if (render_png_done(&ctx->png_ctx))

    96

        goto error;

    97

    98

    // calculate the time taken

    99

    if (duration)

   100

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

   101

   102

    // success

   103

    return 0;

   104

   105

error:

   106

    // caller must deinit

   107

    //

   108

    return -1;

   109

}

   110

   111

void render_local_deinit (struct render_local *ctx) {

   112

    free(ctx->rowbuf);

   113

   114

    if (ctx->must_deinit == RENDER_PNG)

   115

        render_png_deinit(&ctx->png_ctx);

   116

   117

    else if (ctx->must_deinit == RENDER_RAW)

   118

        render_raw_deinit(&ctx->raw_ctx);

   119

}

   120