1

#include <stdlib.h>

     2

     3

#include "common.h"

     4

#include "render_struct.h"

     5

#include "render.h"

     6

#include "render_raw_struct.h"

     7

#include "render_raw.h"

     8

     9

    10

    11

int render_raw_deinit (struct render_raw *ctx) {

    12

    return 0;

    13

}

    14

    15

void render_raw_free (struct render_raw *ctx) {

    16

    render_raw_deinit(ctx);

    17

    18

    if (ctx->owned_by_me)

    19

        free(ctx);

    20

}

    21

    22

int render_raw_init (struct render_raw *ctx, struct render *render) {

    23

    // store some info from the struct render

    24

    ctx->img_w = render->img_w;

    25

    ctx->io_stream = render->io_stream;

    26

    ctx->io_write_fn = render->io_write_fn;

    27

    ctx->io_flush_fn = render->io_flush_fn;

    28

    ctx->cb_arg = render->cb_arg;

    29

    30

    // success

    31

    return 0;

    32

    33

/*

    34

error:

    35

    _render_raw_deinit(ctx);

    36

    return -1;

    37

*/    

    38

}

    39

    40

struct render_raw *render_raw_alloc (struct render *render) {

    41

    struct render_raw *ctx = NULL;

    42

    43

    // calloc the render_png

    44

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

    45

        ERROR("calloc");

    46

    47

    // mark it to be freed

    48

    ctx->owned_by_me = 1;

    49

    50

    // initialize

    51

    if (render_raw_init(ctx, render))

    52

        goto error;

    53

    54

    return ctx;

    55

    56

error:

    57

    render_raw_free(ctx);

    58

    return NULL;

    59

}

    60

    61

int render_raw_row (struct render_raw *ctx, unsigned char *rowbuf) {

    62

    // write it out

    63

    if (ctx->io_stream) {

    64

        if (fwrite(rowbuf, ctx->img_w, 1, ctx->io_stream) != 1)

    65

            PERROR("fwrite");

    66

    67

    } else if (ctx->io_write_fn) {

    68

        if (ctx->io_write_fn(rowbuf, ctx->img_w, ctx->cb_arg))

    69

            ERROR("io_write_fn");

    70

    71

    } else {

    72

        // ignore

    73

    }

    74

    75

    // success

    76

    return 0;

    77

    78

error:

    79

    // don't free it yet, raw_{done,abort} does that!

    80

    return -1;

    81

}

    82

    83

int render_raw_done (struct render_raw *ctx) {

    84

    // flush

    85

    if (ctx->io_stream) {

    86

        if (fflush(ctx->io_stream))

    87

            PERROR("fflush");

    88

    89

    } else if (ctx->io_flush_fn) {

    90

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

    91

            ERROR("io_flush_fn");

    92

    93

    } else {

    94

        // ignore

    95

    }

    96

    97

    // free everything

    98

    render_raw_free(ctx);

    99

   100

    // success

   101

    return 0;

   102

   103

error:

   104

    render_raw_free(ctx);

   105

    return -1;

   106

}

   107

   108

int render_raw_abort (struct render_raw *ctx) {

   109

    // just free it

   110

    render_raw_free(ctx);

   111

   112

    // success

   113

    return 0;

   114

}

   115