1

     2

     3

#include "render_multi.h"

     4

#include "remote_node.h"

     5

     6

     7

struct render_multi {

     8

    // these are used as arguments to render_remote

     9

    struct render_sub_ctx {

    10

        // our offset in the list

    11

        int index;

    12

    13

        // the remote_render_ctx

    14

        struct remote_render_ctx *remote_render;

    15

    16

        // a pointer to ourself

    17

        struct render_multi *self;

    18

    19

        // _render_sent called for this?

    20

        int render_sent;

    21

    } remote_renders[RENDER_MULTI_NODES_MAX];

    22

    23

    // how many remote_renders we have

    24

    int remote_render_count;

    25

    26

    // our own callbacks that we call

    27

    void (*cb_sent)(void *arg);

    28

    void (*cb_data)(struct evbuffer *buf, void *arg);

    29

    void (*cb_done)(void *arg);

    30

    void (*cb_fail)(void *arg);

    31

    32

    void *cb_arg;

    33

    34

};

    35

    36

// our render_remote callbacks

    37

void _render_sent (void *arg) {

    38

    struct render_sub_ctx *ctx, *ctx2 = arg;

    39

    40

    ctx->render_sent = 1;

    41

    42

    // have all render_sub_ctxs been sent?

    43

    int i;

    44

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

    45

        if (!ctx->self->remote_renders[i].render_sent)

    46

            break;

    47

    }

    48

    49

    if (i == ctx->self->remote_render_count) {

    50

        // call cb_sent

    51

        ctx->self->cb_sent(ctx->self->cb_arg);

    52

    }

    53

}

    54

    55

void _render_data (struct evbuffer *buf, void *arg) {

    56

    57

}

    58

    59

void _render_done (void *arg) {

    60

    61

}

    62

    63

void _render_fail (void *arg) {

    64

    65

}

    66

    67

#define ROUND_DOWN(dividend, divisor) ((dividend) / (divisor))

    68

#define ROUND_UP(dividend, divisor) (((dividend) / (divisor)) + ((dividend) % (divisor)))

    69

    70

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

    71

    72

struct render_multi *render_multi (

    73

        render_t *render_ctx,               // what to render

    74

        struct remote_pool *render_pool,    // what render pool to use

    75

        void (*cb_sent)(void *arg),

    76

        void (*cb_data)(struct evbuffer *buf, void *arg),

    77

        void (*cb_done)(void *arg),

    78

        void (*cb_fail)(void *arg),

    79

        void *cb_arg

    80

) {

    81

    struct render_multi *ctx = NULL;

    82

    render_t r_left, r_right;

    83

    84

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

    85

    assert(RENDER_MULTI_NODES_MAX >= 2);

    86

    87

    if (

    88

            render_init(&r_left, RENDER_RAW)

    89

         || render_init(&r_right, RENDER_RAW)

    90

         || render_set_size(&r_left, render_ctx->img_w / 2, render_ctx->img_h)

    91

         || render_set_size(&r_right, render_ctx->img_w / 2 +  render_ctx->img_w % 2, render_ctx->img_h)

    92

         || render_set_region_raw(&r_left, render_ctx->x1, render_ctx->y1, HALF(render_ctx->x1, render_ctx->x2), render_ctx->y2)

    93

         || render_set_region_raw(&r_right, HALF(render_ctx->x1, render_ctx->x2), render_ctx->y1, render_ctx->x2, render_ctx->y2)

    94

    )

    95

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

    96

    97

    // alloc the render_multi

    98

    ctx = calloc(1, sizeof(struct render_multi));

    99

   100

    if (!ctx)

   101

        ERROR("calloc");

   102

   103

    // store the provided callback functions

   104

    ctx->cb_sent = cb_sent;

   105

    ctx->cb_data = cb_data;

   106

    ctx->cb_done = cb_done;

   107

    ctx->cb_fail = cb_fail;

   108

    ctx->cb_arg = cb_arg;

   109

   110

    // pull two nodes from the pool

   111

    struct remote_node *node_left, *node_right;

   112

   113

    if (

   114

            !(node_left = remote_pool_get(pool_info))

   115

         || !(node_right = remote_pool_get(pool_info))

   116

    )

   117

        ERROR("remote_pool_get");

   118

   119

    // init the remote_render

   120

    ctx->remote_renders[0].index = 0;

   121

    ctx->remote_renders[0].self = &ctx

   122

    ctx->remote_renders[1].index = 1;

   123

    ctx->remote_renders[1].self = &ctx

   124

    ctx->remote_render_count = 2;

   125

   126

    // the two render_remote calls

   127

    if (

   128

            !(ctx->remote_renders[0].remote_render = render_remote(&r_left, node_left, 

   129

                &_render_sent, &_render_data, &_render_done, &_render_fail, &ctx->remote_renders[0]))

   130

         || !(ctx->remote_renders[1].remote_render = render_remote(&r_right, node_right,

   131

                &_render_sent, &_render_data, &_render_done, &_render_fail, &ctx->remote_renders[1]))

   132

    )

   133

        ERROR("render_remote");

   134

   135

    // I guess that's a succesfull start now

   136

    return 0;

   137

   138

error:

   139

    free(ctx);

   140

   141

    return -1;

   142

}

   143