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

void render_slices_deinit (struct render_slices *ctx) {

    17

    if (ctx->rowbuf) {

    18

        free(ctx->rowbuf);

    19

        ctx->rowbuf = NULL;

    20

    }

    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

    // should probably use memcpy instead...

    47

    if (

    48

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

    49

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

    50

    51

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

    52

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

    53

    54

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

    55

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

    56

    57

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

    58

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

    59

    )

    60

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

    61

    62

    // set the offsets

    63

    ctx->slices[0].render_info.img_left = 0;

    64

    ctx->slices[0].render_info.img_right = render->img_w / 2;

    65

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

    66

    ctx->slices[1].render_info.img_right = render->img_w;

    67

    68

    // allocate the rowbuf

    69

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

    70

        ERROR("malloc");

    71

    72

    // update the slice_buf pointers

    73

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

    74

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

    75

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

    76

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

    77

    78

    // png info

    79

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

    80

        ERROR("render_png_init");

    81

    82

    // great success!

    83

    return 0;

    84

    85

error:

    86

    render_slices_deinit(ctx);

    87

    return -1;

    88

}

    89

    90

struct render_slices *render_slices_alloc (struct render *render) {

    91

    struct render_slices *ctx = NULL;

    92

    93

    // allocate it

    94

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

    95

        ERROR("calloc");

    96

    97

    // mark it for free()ing

    98

    ctx->owned_by_me = 1;

    99

   100

    // initialize it

   101

    if (render_slices_init(ctx, render))

   102

        goto error;

   103

   104

    return ctx;

   105

   106

error :

   107

    render_slices_free(ctx);

   108

    return NULL;

   109

}

   110

   111

int render_slices_get_count (struct render_slices *ctx) {

   112

    return ctx->num_slices;

   113

}

   114

   115

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

   116

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

   117

   118

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

   119

}

   120

   121

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

   122

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

   123

    assert(ctx->render_row >= 0);

   124

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

   125

   126

    // our return status

   127

    int i, status = 0;

   128

   129

    // is this row now complete?

   130

    if (++ctx->segments_done == ctx->num_slices) {

   131

        // the row is complete

   132

        ctx->segments_done = 0;

   133

   134

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

   135

        status |= SLICE_PROCESS_ROW;

   136

   137

        // is the other row already rendered?

   138

        if (ctx->done_row < 0) {

   139

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

   140

            ctx->done_row = ctx->render_row;

   141

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

   142

   143

            // can now continue rendering as well as call process_row

   144

            status |= SLICE_CONTINUE;

   145

   146

            // update the remaining render buffers

   147

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

   148

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

   149

            }

   150

   151

        } else {

   152

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

   153

   154

            ctx->render_row = -1;

   155

        }

   156

   157

   158

    } else {

   159

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

   160

   161

    }

   162

   163

    return status;

   164

}

   165

   166

int render_slices_process_row (struct render_slices *ctx) {

   167

    assert(ctx->done_row >= 0);

   168

   169

    int i;

   170

   171

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

   172

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

   173

        ERROR("render_png_row");

   174

   175

    // is the other row still in the process of being assembled?

   176

    if (ctx->render_row == -1) {

   177

        // no, both rows were full

   178

        ctx->render_row = ctx->done_row;

   179

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

   180

   181

        // update the remaining render buffers

   182

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

   183

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

   184

        }

   185

   186

        // you can call me again, but also segment_done

   187

        return SLICE_PROCESS_ROW | SLICE_CONTINUE;

   188

   189

    } else {

   190

        // yes, so that still needs to be finished

   191

        ctx->done_row = -1;

   192

   193

        if (ctx->segments_done == 0) {

   194

            // that row is empty, then we can continue

   195

            return SLICE_CONTINUE;

   196

   197

        } else {

   198

            // that row is partially built, so some segment is still on the way - don't resume the other slices until that's arrived!

   199

            return 0;

   200

        }

   201

    }

   202

   203

error:

   204

    // user needs to deinit/free us

   205

    return -1;

   206

}   

   207

   208

int render_slices_done (struct render_slices *ctx) {

   209

    // finish off render_png

   210

    if (render_png_done(&ctx->png_info))

   211

        goto error;

   212

   213

    return 0;

   214

   215

error:

   216

    render_slices_free(ctx);

   217

    return -1;

   218

}

   219