1

#include <stdlib.h>

     2

#include <unistd.h>

     3

#include <errno.h>

     4

#include <assert.h>

     5

     6

#include "common.h"

     8

#include "render_multi.h"

     9

#include "render_remote.h"

    10

#include "remote_node.h"

    14

    15

/*

    16

// the states we can go through

    17

enum render_multi_state {

    18

    STATE_INIT,                 // the render_multi is in the process of being initialized

    19

    STATE_SENDING,              // we're still waiting for some of the requests to be sent

    20

    STATE_RENDER,               // we're handling data now!

    21

    STATE_DATA_DONE,            // we're finished with all the data

    22

    STATE_PNG_DONE,             // PNG data's done

    23

    STATE_FAILED,               // we failed

    24

};

    25

    28

    STATE_SENDING,              // we're waiting for the requests to be sent

    29

    STATE_FILL_ROW,             // we're filling the row with data

    30

    STATE_ROW_FULL,             // our row is full

    31

    STATE_DATA_DONE,            // we're finished with all the data

    32

    STATE_PNG_DONE,             // PNG data's done

    33

    STATE_FAILED,               // we failed

    34

    35

};

    36

*/

    37

    38

struct render_multi {

    39

    // these are used as arguments to render_remote

    43

    44

        // the render_remote_ctx

    45

        struct render_remote *render_remote;

    46

    47

        // _render_multi_sent called for this?

    48

        int render_sent;

    49

    50

        // how wide our slice is, static

    51

        size_t slice_width;

    52

    53

        // how many bytes we have already written into the current row

    54

        size_t col;

    55

    56

        // _render_multi_done called for this?

    57

        int render_done;

    61

    63

    66

    67

    // is this still alive?

    68

    int alive;

    69

    70

    // how many remote renders have been succesfully cb_sent?

    71

    int renders_sent;

    72

    73

    // how many of the renders are done?

    74

    int renders_done;

    75

    76

    // have we called cb_sent?

    77

    int have_sent;

    78

    81

    82

    // has render_png_done returned?

    83

    int png_done;

    84

    85

    // buffer render_png output in this

    86

    struct evbuffer *out_buf;

    87

    88

    // our own callbacks that we call

    89

    void (*cb_sent)(void *arg);

    90

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

    91

    void (*cb_done)(void *arg);

    92

    void (*cb_fail)(void *arg);

    93

    94

    void *cb_arg;

    95

};

    96

    97

#define FAIL_PARTIAL 0x01

    98

#define FAIL_SILENT 0x02

    99

   100

// prototypes

   101

static void _render_multi_do_free (struct render_multi *ctx);

   102

static void _render_multi_do_sent (struct render_multi *ctx);

   103

static void _render_multi_do_png_data (struct render_multi *ctx);

   104

static void _render_multi_do_png_done (struct render_multi *ctx);

   105

static void _render_multi_do_done (struct render_multi *ctx);

   106

static void _render_multi_do_fail (struct render_multi *ctx, int flags);

   107

   108

/*

   109

 * Actually free the request. Should be de-initialized (either _render_multi_error, or _render_done when this is called

   110

 */

   111

static void _render_multi_do_free (struct render_multi *ctx) {

   112

    assert(ctx && ctx->alive == 0);

   113

   115

   116

    if (ctx->out_buf) {

   117

        evbuffer_free(ctx->out_buf);

   118

        ctx->out_buf = NULL;

   119

    }

   120

   121

    free(ctx);

   122

}

   123

   124

// the request has been sent

   125

static void _render_multi_do_sent (struct render_multi *ctx) {

   126

    int i;

   127

   131

    }

   132

   133

    // assert the callbacks are still valid

   134

    assert(ctx->cb_sent && ctx->cb_fail && ctx->cb_done);

   135

   136

    // call cb_sent and then invalidate it

   137

    ctx->cb_sent(ctx->cb_arg);

   138

    ctx->cb_sent = NULL;

   139

    ctx->have_sent = 1;

   140

   141

    // we're going to always have the PNG header data buffered at this point, so give that to the user right away

   142

    assert(evbuffer_get_length(ctx->out_buf) > 0);

   143

    _render_multi_do_png_data(ctx);

   144

}

   145

   146

// possibly call cb_data, and if the renders are all done and the buffer is empty, cb_done

   147

static void _render_multi_do_png_data (struct render_multi *ctx) {

   148

    // at first we have to wait until we've called cb_sent

   149

    if (!ctx->have_sent)

   150

        return;

   151

   152

    // got any PNG data in there?

   153

    if (evbuffer_get_length(ctx->out_buf))

   154

        ctx->cb_data(ctx->out_buf, ctx->cb_arg);

   155

   156

    // was that the last piece of PNG data?

   157

    if (ctx->png_done && evbuffer_get_length(ctx->out_buf) == 0) {

   158

        // PNG data done!

   159

        _render_multi_do_png_done(ctx);

   160

   161

    }

   162

}

   163

   164

// the PNG rendering completed succesfully

   165

static void _render_multi_do_png_done (struct render_multi *ctx) {

   166

    // check that ctx is still valid

   167

    assert(ctx->alive);

   168

   169

    // mark as not alive

   170

    ctx->alive = 0;

   171

   172

    // call cb_done

   173

    ctx->cb_done(ctx->cb_arg);

   174

   175

    // don't free ourself, our user does that (probably did already)

   176

    return;

   177

}

   178

   179

// the request completed normally, flush the png data and return

   180

// _render_multi_png_done takes care of calling cb_done, not us!

   181

static void _render_multi_do_done (struct render_multi *ctx) {

   183

   184

    int i;

   185

   186

    // check that all the remote_renders are indeed complete

   190

    }

   194

   195

    // if that all the data handled now, we're done

   196

    _render_multi_do_png_data(ctx);

   197

   198

    // don't free ourself, our user does that (probably already did, via render_png_done)

   199

    return;

   200

   202

error:    

   204

    _render_multi_do_fail(ctx, FAIL_PARTIAL);

   206

}

   207

   208

// the request completed abnormally. Flags:

   209

//  FAIL_SILENT     - don't call cb_fail

   210

//  FAIL_PARTIAL    - assume png_info may be NULL

   211

static void _render_multi_do_fail (struct render_multi *ctx, int flags) {

   212

    int i;

   213

   214

    // check that ctx is still valid

   215

    assert(ctx->alive || flags & FAIL_PARTIAL);

   216

   217

    // mark as not alive

   218

    ctx->alive = 0;

   219

   220

    // cancel any in-progress remote renders

   225

        }

   226

   228

   229

    // check that both callbacks are still valid

   230

    assert(ctx->cb_fail && ctx->cb_done);

   231

   232

    if (!(flags & FAIL_SILENT)) {

   233

        // call cb_fail and then invalidate it

   234

        ctx->cb_fail(ctx->cb_arg);

   235

    }

   236

   237

    ctx->cb_fail = NULL;

   238

   239

    // don't free ourself, our user does that

   240

}

   241

   242

/*

   243

 * One of the remote render commands has succesfully been sent.

   244

 *

   245

 * Once all of these commands have been sent, invoke our cb_sent.

   246

 */

   247

static void _render_multi_sent (void *arg) {

   249

   250

    // mark these as sent

   251

    ctx->render_sent = 1;

   252

    ctx->self->renders_sent++;

   253

   254

    // have all render_sub_ctxs been sent?

   256

        // tell our user

   257

        _render_multi_do_sent(ctx->self);

   258

    }

   259

}

   260

   261

/*

   262

 * One render node failed, abort the whole thing

   263

 */

   264

static void _render_multi_fail (void *arg) {

   266

   267

    // free this ctx's remote render

   268

    render_remote_free(ctx->render_remote);

   269

    ctx->render_remote = NULL;

   270

   271

    // cancel the rest + cb_fail

   272

    _render_multi_do_fail(ctx->self, 0);

   273

}

   274

   275

/*

   276

 * Got new data for some remote render

   277

 */

   278

static void _render_multi_data_raw (int fd, short event, void *arg) {

   280

    int ret;

   281

   282

    assert(ctx->col <= ctx->slice_width);   // check it isn't out of range

   283

   284

    // if our slice is full, we don't want to receive any more data

   285

    if (ctx->col == ctx->slice_width)

   286

        return;

   287

   288

    // read new data into our slice

   289

    ret = read(fd, 

   292

    );

   293

   294

    // errors/EOF?

   295

    if (ret == -1) {

   296

        if (errno == EAGAIN) {

   297

            // false alarm

   298

            goto reschedule;

   299

   300

        } else

   301

            ERROR("read");

   302

   303

    } else if (ret == 0) {

   304

        // mark it as done

   305

        ctx->render_done = 1;

   306

        ctx->self->renders_done++;

   307

   308

        // this ctx's remote render is done

   309

        render_remote_done(ctx->render_remote);

   310

        ctx->render_remote = NULL;

   311

   315

   316

        // are all of them done?

   318

            // finish it off

   319

            _render_multi_do_done(ctx->self);

   320

   321

        } // else, just wait for the rest to complete

   322

   323

        // do *NOT* reschedule ourself, ctx->render_remote is invalid anyways (as is ctx!)

   324

        return;

   325

    }

   328

   329

    // ok, we received some data normally

   330

    ctx->col += ret;

   331

   332

    // is our slice full now?

   333

    if (ctx->col == ctx->slice_width) {

   336

   344

   360

            }

   361

        }

   365

    }

   366

   367

    // ok, reschedule ourselves

   368

   369

reschedule:

   370

    // reschedule a new call once we get more data

   371

    render_remote_reschedule(ctx->render_remote);

   372

   373

    return;

   374

   375

error:

   376

    _render_multi_do_fail(ctx->self, 0);

   377

}

   378

   379

/*

   380

 * We fed a row of pixels into render_png, and this PNG data came out.

   381

 *

   382

 * We need to pass it back to our caller

   383

 */

   384

static int _render_multi_png_data (const unsigned char *data, size_t length, void *arg) {

   385

    struct render_multi *ctx = arg;

   386

   387

    // XXX: need a better user-API to avoid these data copies

   388

    if (evbuffer_add(ctx->out_buf, data, length))

   389

        ERROR("evbuffer_add");

   390

   391

    // handle cb_data/cb_done

   392

    _render_multi_do_png_data(ctx);

   393

   394

    // ok

   395

    return 0;

   396

   397

error:

   398

    // don't do any failing here, this will return control to a _render_* function that will handle it

   399

    return -1;

   400

}

   401

   402

struct render_multi *render_multi (

   403

        struct render *render,               // what to render

   404

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

   405

        void (*cb_sent)(void *arg),

   406

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

   407

        void (*cb_done)(void *arg),

   408

        void (*cb_fail)(void *arg),

   409

        void *cb_arg

   410

) {

   411

    struct render_multi *ctx = NULL;

   412

   413

    // alloc the render_multi

   414

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

   415

   416

    if (!ctx)

   417

        ERROR("calloc");

   418

   419

    // store the provided callback functions

   420

    ctx->cb_sent = cb_sent;

   421

    ctx->cb_data = cb_data;

   422

    ctx->cb_done = cb_done;

   423

    ctx->cb_fail = cb_fail;

   424

    ctx->cb_arg = cb_arg;

   425

   426

    // store our render_png callbacks, must be before png_info

   427

    if (render_io_custom(render, &_render_multi_png_data, NULL, ctx))

   428

        ERROR("render_io_custom");

   429

   430

    // evbuffer, must be before png_info

   431

    if (!(ctx->out_buf = evbuffer_new()))

   432

        ERROR("evbuffer_new");

   433

   440

   464

   465

    // we are now alive

   466

    ctx->alive = 1;

   467

   468

    // I guess that's a succesfull start now

   469

    return ctx;

   470

   471

error:

   472

    _render_multi_do_fail(ctx, FAIL_SILENT | FAIL_PARTIAL);

   473

   474

    return NULL;

   475

}

   476

   477

   478

void render_multi_set_recv (struct render_multi *ctx, size_t recv_threshold, size_t unread_buffer) {

   479

   480

}

   481

   482

int render_multi_flush (struct render_multi *ctx) {

   483

    _render_multi_do_png_data(ctx);

   484

   485

    return 0;

   486

}

   487

   488

void render_multi_cancel (struct render_multi *ctx) {

   489

    _render_multi_do_fail(ctx, FAIL_SILENT);

   490

}

   491