1

#include <stdlib.h>

     2

#include <assert.h>

     3

     4

#include "common.h"

     5

#include "render_struct.h"

     6

#include "render_slices_struct.h"

     7

#include "render_slices.h"

     8

     9

void render_slices_free (struct render_slices *ctx) {

    10

    render_slices_deinit(ctx);

    11

    12

    if (ctx->owned_by_me)

    13

        free(ctx);

    14

}

    15

    21

    22

    render_png_deinit(&ctx->png_info);

    23

}

    24

    25

#define HALF(a, b) (( a + b) / 2)

    26

    27

int render_slices_init (struct render_slices *ctx, struct render *render) {

    28

    // initialize the slices

    29

    // for now, just split it in half into two render_ts

    30

    ctx->slices[0].info.index = 0;

    31

    ctx->slices[0].info.render_info = &ctx->slices[0].render_info;

    32

    ctx->slices[0].self = ctx;

    33

    ctx->slices[0].row_offset = 0;

    34

    35

    ctx->slices[1].info.index = 1;

    36

    ctx->slices[1].info.render_info = &ctx->slices[1].render_info;

    37

    ctx->slices[1].self = ctx;

    38

    ctx->slices[1].row_offset = render->img_w / 2;

    39

    40

    ctx->num_slices = 2;

    41

    ctx->render_row = 0;

    42

    ctx->done_row = -1;

    43

    44

    assert(RENDER_SLICES_MAX >= 2);

    45

    46

    if (

    47

            render_init         (&ctx->slices[0].render_info,   RENDER_RAW)

    48

         || render_init         (&ctx->slices[1].render_info,   RENDER_RAW)

    49

    50

         || render_set_size     (&ctx->slices[0].render_info,   render->img_w / 2,                      render->img_h)

    51

         || render_set_size     (&ctx->slices[1].render_info,   render->img_w / 2 + render->img_w % 2,  render->img_h)

    52

    53

         || render_region_raw   (&ctx->slices[0].render_info,   render->x1,                     render->y1, HALF(render->x1, render->x2),   render->y2)

    54

         || render_region_raw   (&ctx->slices[1].render_info,   HALF(render->x1, render->x2),   render->y1, render->x2,                     render->y2)

    55

    )

    56

        ERROR("render_{init,set_size,set_region_raw}");

    57

    58

    // allocate the rowbuf

    59

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

    60

        ERROR("malloc");

    61

    62

    // update the slice_buf pointers

    63

    ctx->rows[0] = ctx->rowbuf;

    64

    ctx->rows[1] = ctx->rowbuf + render->img_w;

    65

    ctx->slices[0].info.render_buf = ctx->rows[ctx->render_row] + ctx->slices[0].row_offset;

    66

    ctx->slices[1].info.render_buf = ctx->rows[ctx->render_row] + ctx->slices[1].row_offset;

    67

    68

    // png info

    69

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

    70

        ERROR("render_png_init");

    71

    72

    // great success!

    73

    return 0;

    74

    75

error:

    76

    render_slices_deinit(ctx);

    77

    return -1;

    78

}

    79

    80

struct render_slices *render_slices_alloc (struct render *render) {

    81

    struct render_slices *ctx = NULL;

    82

    83

    // allocate it

    84

    if (!(ctx = calloc(1, sizeof(*ctx))))

    85

        ERROR("calloc");

    86

    87

    // mark it for free()ing

    88

    ctx->owned_by_me = 1;

    89

    90

    // initialize it

    91

    if (render_slices_init(ctx, render))

    92

        goto error;

    93

    94

    return ctx;

    95

    96

error :

    97

    render_slices_free(ctx);

    98

    return NULL;

    99

}

   100

   101

int render_slices_get_count (struct render_slices *ctx) {

   102

    return ctx->num_slices;

   103

}

   104

   105

struct render_slice_info *render_slices_get_slice_info (struct render_slices *ctx, int index) {

   106

    assert(index >= 0 && index < ctx->num_slices);

   107

   108

    return &ctx->slices[index].info;

   109

}

   110

   111

int render_slices_segment_done (struct render_slices *ctx, int index) {

   112

    assert(index >= 0 && index < ctx->num_slices);

   115

   116

    // our return status

   118

   121

        // the row is complete

   122

        ctx->segments_done = 0;

   123

   124

        // once we fill up a row we can always call process_row

   125

        status |= SLICE_PROCESS_ROW;

   126

   128

        if (ctx->done_row < 0) {

   130

            ctx->done_row = ctx->render_row;

   131

            ctx->render_row = (ctx->render_row == 0 ? 1 : 0);

   132

   136

            // update the remaining render buffers

   137

            for (i = 0; i < ctx->num_slices; i++) {

   138

                ctx->slices[i].info.render_buf = ctx->rows[ctx->render_row] + ctx->slices[i].row_offset;

   139

            }

   140

   141

        } else {

   142

            // cannot continue rendering, need to have process_row complete first

   146

   147

   148

    } else {

   149

        // the row is not complete, do not render the next segment, do not call process_row

   150

   151

    }

   152

   153

    return status;

   154

}

   155

   156

int render_slices_process_row (struct render_slices *ctx) {

   157

    assert(ctx->done_row >= 0);

   158

   161

    // pass the data to render_png, this results in calls to _render_multi_png_data

   162

    if (render_png_row(&ctx->png_info, ctx->rows[ctx->done_row]))

   163

        ERROR("render_png_row");

   164

   192

   193

error:

   194

    // user needs to deinit/free us

   195

    return -1;

   196

}   

   197

   198

int render_slices_done (struct render_slices *ctx) {

   199

    // finish off render_png

   200

    if (render_png_done(&ctx->png_info))

   202

   203

    return 0;

   204

   205

error:

   206

    render_slices_free(ctx);

   207

    return -1;

   208

}