1

#include <stdlib.h>

     2

     3

#include "common.h"

     4

#include "render_internal.h"

     5

#include "render_raw.h"

     6

     7

struct render_raw {

     8

    // some info that we need to keep from the struct render

     9

    u_int32_t img_w;

    10

    11

    // cb or stream?

    12

    FILE *io_stream;

    13

    render_ctx_write_cb io_write_fn;

    14

    render_ctx_flush_cb io_flush_fn;

    15

    void *cb_arg;

    16

};

    17

    18

static void _render_raw_free (struct render_raw *ctx) {

    19

    free(ctx);

    20

}

    21

    22

struct render_raw *render_raw_init (struct render *render) {

    23

    struct render_raw *ctx = NULL;

    24

    25

    // calloc the render_png

    26

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

    27

        ERROR("calloc");

    28

    29

    // store some info from the struct render

    30

    ctx->img_w = render->img_w;

    31

    ctx->io_stream = render->io_stream;

    32

    ctx->io_write_fn = render->io_write_fn;

    33

    ctx->io_flush_fn = render->io_flush_fn;

    34

    ctx->cb_arg = render->cb_arg;

    35

    36

    // success

    37

    return ctx;

    38

    39

error:

    40

    _render_raw_free(ctx);

    41

    return NULL;

    42

}

    43

    44

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

    45

    // write it out

    46

    if (ctx->io_stream) {

    47

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

    48

            PERROR("fwrite");

    49

    50

    } else if (ctx->io_write_fn) {

    51

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

    52

            ERROR("io_write_fn");

    53

    54

    } else {

    55

        // ignore

    56

    }

    57

    58

    // success

    59

    return 0;

    60

    61

error:

    62

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

    63

    return -1;

    64

}

    65

    66

int render_raw_done (struct render_raw *ctx) {

    67

    // flush

    68

    if (ctx->io_stream) {

    69

        if (fflush(ctx->io_stream))

    70

            PERROR("fflush");

    71

    72

    } else if (ctx->io_flush_fn) {

    73

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

    74

            ERROR("io_flush_fn");

    75

    76

    } else {

    77

        // ignore

    78

    }

    79

    80

    // free everything

    81

    _render_raw_free(ctx);

    82

    83

    // success

    84

    return 0;

    85

    86

error:

    87

    _render_raw_free(ctx);

    88

    return -1;

    89

}

    90

    91

int render_raw_abort (struct render_raw *ctx) {

    92

    // just free it

    93

    _render_raw_free(ctx);

    94

    95

    // success

    96

    return 0;

    97

}

    98