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

    16

int render_slices_deinit (struct render_slices *ctx) {

    17

    // if it's not initialized, just ignore

    18

    if (!ctx->rowbuf)

    19

        return 1;

    20

    21

    free(ctx->rowbuf);

    22

    23

    render_png_deinit(&ctx->png_info);

    24

    25

    return 0;

    26

}

    27

    28

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

    29

    30

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

    31

    // initialize the slices

    32

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

    33

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

    34

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

    35

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

    36

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

    37

    38

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

    39

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

    40

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

    41

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

    42

    43

    ctx->num_slices = 2;

    44

    ctx->render_row = 0;

    45

    ctx->done_row = -1;

    46

    47

    assert(RENDER_SLICES_MAX >= 2);

    48

    49

    if (

    50

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

    51

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

    52

    53

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

    54

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

    55

    56

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

    57

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

    58

    )

    59

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

    60

    61

    // allocate the rowbuf

    62

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

    63

        ERROR("malloc");

    64

    65

    // update the slice_buf pointers

    66

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

    67

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

    68

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

    69

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

    70

    71

    // png info

    72

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

    73

        ERROR("render_png_init");

    74

    75

    // great success!

    76

    return 0;

    77

    78

error:

    79

    render_slices_deinit(ctx);

    80

    return -1;

    81

}

    82

    83

struct render_slices *render_slices_alloc (struct render *render) {

    84

    struct render_slices *ctx = NULL;

    85

    86

    // allocate it

    87

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

    88

        ERROR("calloc");

    89

    90

    // mark it for free()ing

    91

    ctx->owned_by_me = 1;

    92

    93

    // initialize it

    94

    if (render_slices_init(ctx, render))

    95

        goto error;

    96

    97

    return ctx;

    98

    99

error :

   100

    render_slices_free(ctx);

   101

    return NULL;

   102

}

   103

   104

int render_slices_get_count (struct render_slices *ctx) {

   105

    return ctx->num_slices;

   106

}

   107

   108

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

   109

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

   110

   111

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

   112

}

   113

   114

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

   115

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

   116

    assert(ctx->slices_done < ctx->num_slices);

   117

   118

    // keep track of the number of full slices

   119

    ctx->slices_done++;

   120

   121

    // is the row complete?

   122

    if (ctx->slices_done == ctx->num_slices) {

   123

        // the row is complete

   124

        ctx->slices_done = 0;

   125

   126

        // is the other row waiting for it to get processed?

   127

        if (ctx->done_row < 0) {

   128

            // no, point the done_row at this row, point the render buffers to the unused row

   129

            ctx->done_row = ctx->render_row;

   130

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

   131

   132

            int i ;

   133

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

   134

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

   135

            }

   136

   137

            // can now continue rendering as well as call process_row

   138

            return SLICE_PROCESS_ROW & SLICE_CONTINUE;

   139

   140

        } else {

   141

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

   142

            return SLICE_PROCESS_ROW;

   143

   144

        }

   145

   146

    } else {

   147

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

   148

        return 0;

   149

   150

    }

   151

}

   152

   153

int render_slices_process_row (struct render_slices *ctx) {

   154

    assert(ctx->done_row >= 0);

   155

   156

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

   157

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

   158

        ERROR("render_png_row");

   159

   160

    // mark the row as processed

   161

    ctx->done_row = -1;

   162

   163

    // ok, but don't call me again until I tell you to.

   164

    return SLICE_CONTINUE;

   165

   166

error:

   167

    // user needs to deinit/free us

   168

    return -1;

   169

}   

   170

   171