1

#include <stdlib.h>

     2

#include <unistd.h>

     3

#include <errno.h>

     4

#include <assert.h>

     5

     6

#include "common.h"

     7

#include "render_struct.h"

     8

#include "render_multi.h"

     9

#include "render_remote.h"

    10

#include "remote_node.h"

    11

#include "remote_pool.h"

    12

#include "render_slices_struct.h"

    13

#include "render_slices.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

    26

enum render_multi_node_state {

    27

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

    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

    40

    struct render_multi_node {

    41

        // the slice info

    42

        struct render_slice_info *info;

    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

        // passed in the last segment of data?

    57

        int render_done;

    58

    59

        // a pointer to ourself

    60

        struct render_multi *self;

    61

    62

    } nodes[RENDER_SLICES_MAX];

    63

    64

    // how many nodes we have

    65

    int node_count;

    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

    79

    // the render_slices thing

    80

    struct render_slices slices;

    81

    82

    // has render_slices_done returned?

    83

    int slices_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

   114

    render_slices_deinit(&ctx->slices);

   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

   128

    // check that all the nodes have indeed been sent

   129

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

   130

        assert(ctx->nodes[i].render_sent);

   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->slices_done && evbuffer_get_length(ctx->out_buf) == 0) {

   158

        // PNG data done!

   159

        _render_multi_do_png_done(ctx);

   160

    }

   161

}

   162

   163

// the PNG rendering completed succesfully

   164

static void _render_multi_do_png_done (struct render_multi *ctx) {

   165

    // check that ctx is still valid

   166

    assert(ctx->alive);

   167

   168

    // mark as not alive

   169

    ctx->alive = 0;

   170

   171

    // call cb_done

   172

    ctx->cb_done(ctx->cb_arg);

   173

   174

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

   175

    return;

   176

}

   177

   178

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

   179

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

   180

static void _render_multi_do_done (struct render_multi *ctx) {

   181

    assert(ctx->alive);

   182

   183

    int i;

   184

   185

    // check that all the remote_renders are indeed complete

   186

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

   187

        assert(ctx->nodes[i].render_remote == NULL);

   188

        assert(ctx->nodes[i].col == 0);

   189

    }

   190

   191

    // finish off the render_slices

   192

    if (render_slices_done(&ctx->slices))

   193

        ERROR("render_slices_done");

   194

   195

    // mark this as complete, all data is now in the out buffer

   196

    ctx->slices_done = 1;

   197

   198

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

   199

    _render_multi_do_png_data(ctx);

   200

   201

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

   202

    return;

   203

   204

error:    

   205

    /* render_slices_done -> render_png_done failed, probably because we didn't have enough data */

   206

    _render_multi_do_fail(ctx, FAIL_PARTIAL);

   207

}

   208

   209

// the request completed abnormally. Flags:

   210

//  FAIL_SILENT     - don't call cb_fail

   211

//  FAIL_PARTIAL    - assume png_info may be NULL

   212

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

   213

    int i;

   214

   215

    // check that ctx is still valid

   216

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

   217

   218

    // mark as not alive

   219

    ctx->alive = 0;

   220

   221

    // cancel any in-progress remote renders

   222

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

   223

        if (ctx->nodes[i].render_remote) {

   224

            render_remote_cancel(ctx->nodes[i].render_remote);

   225

            ctx->nodes[i].render_remote = NULL;

   226

        }

   227

   228

    // XXX: does render_slices need an abort?

   229

   230

    // check that both callbacks are still valid

   231

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

   232

   233

    if (!(flags & FAIL_SILENT)) {

   234

        // call cb_fail and then invalidate it

   235

        ctx->cb_fail(ctx->cb_arg);

   236

    }

   237

   238

    ctx->cb_fail = NULL;

   239

   240

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

   241

}

   242

   243

/*

   244

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

   245

 *

   246

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

   247

 */

   248

static void _render_multi_sent (void *arg) {

   249

    struct render_multi_node *ctx = arg;

   250

   251

    // mark these as sent

   252

    ctx->render_sent = 1;

   253

    ctx->self->renders_sent++;

   254

   255

    // have all render_sub_ctxs been sent?

   256

    if (ctx->self->renders_sent == ctx->self->node_count) {

   257

        // tell our user

   258

        _render_multi_do_sent(ctx->self);

   259

    }

   260

}

   261

   262

/*

   263

 * One render node failed, abort the whole thing

   264

 */

   265

static void _render_multi_fail (void *arg) {

   266

    struct render_multi_node *ctx = arg;

   267

   268

    // free this ctx's remote render

   269

    render_remote_free(ctx->render_remote);

   270

    ctx->render_remote = NULL;

   271

   272

    // cancel the rest + cb_fail

   273

    _render_multi_do_fail(ctx->self, 0);

   274

}

   275

   276

/*

   277

 * Got new data for some remote render

   278

 */

   279

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

   280

    struct render_multi_node *ctx = arg;

   281

    int ret;

   282

   283

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

   284

   285

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

   286

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

   287

        return;

   288

   289

    // read new data into our slice

   290

    ret = read(fd, 

   291

        ctx->info->render_buf + ctx->col,               // our segment buffer + partial segment offset

   292

        ctx->slice_width - ctx->col                     // how many bytes left in the segment

   293

    );

   294

   295

    // errors/EOF?

   296

    if (ret == -1) {

   297

        if (errno == EAGAIN) {

   298

            // false alarm

   299

            goto reschedule;

   300

   301

        } else

   302

            ERROR("read");

   303

   304

    } else if (ret == 0) {

   305

        // this ctx's remote render is done

   306

        render_remote_done(ctx->render_remote);

   307

        ctx->render_remote = NULL;

   308

   309

        // count how many are done

   310

        ctx->self->renders_done++;

   311

   312

        // are all of them done?

   313

        if (ctx->self->renders_done == ctx->self->node_count) {

   314

            // finish it off

   315

            _render_multi_do_done(ctx->self);

   316

   317

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

   318

   319

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

   320

        return;

   321

    }

   322

   323

    // ok, we received some data normally

   324

    ctx->col += ret;

   325

   326

    // is this segment full now?

   327

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

   328

        int status;

   329

   330

        // pass the segment in to render_slices

   331

        if ((status = render_slices_segment_done(&ctx->self->slices, ctx->info->index)) == -1)

   332

            ERROR("render_slices_segment_done");

   333

   334

        // reset the col marker

   335

        ctx->col = 0;

   336

   337

        // row done?

   338

        if (status & SLICE_PROCESS_ROW) {

   339

            // process the row via render_slices

   340

            status = render_slices_process_row(&ctx->self->slices);

   341

   342

        }

   343

   344

        // do we need to continue?

   345

        if (status & SLICE_CONTINUE) {

   346

            // reschedule the reads in case they were ~SLICE_CONTINUE

   347

            int i;

   348

   349

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

   350

                // just don't reschedule those that are already EOF...

   351

                if (ctx->self->nodes[i].render_remote)

   352

                    render_remote_reschedule(ctx->self->nodes[i].render_remote);

   353

            }

   354

   355

        } else {

   356

            // don't read any more data yet, we'll be rescheduled by someone else

   357

            return;

   358

   359

        }

   360

    }

   361

   362

    // ok, reschedule ourselves

   363

   364

reschedule:

   365

    // reschedule a new call once we get more data

   366

    render_remote_reschedule(ctx->render_remote);

   367

   368

    return;

   369

   370

error:

   371

    _render_multi_do_fail(ctx->self, 0);

   372

}

   373

   374

/*

   375

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

   376

 *

   377

 * We need to pass it back to our caller

   378

 */

   379

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

   380

    struct render_multi *ctx = arg;

   381

   382

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

   383

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

   384

        ERROR("evbuffer_add");

   385

   386

    // handle cb_data/cb_done

   387

    _render_multi_do_png_data(ctx);

   388

   389

    // ok

   390

    return 0;

   391

   392

error:

   393

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

   394

    return -1;

   395

}

   396

   397

struct render_multi *render_multi (

   398

        struct render *render,               // what to render

   399

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

   400

        void (*cb_sent)(void *arg),

   401

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

   402

        void (*cb_done)(void *arg),

   403

        void (*cb_fail)(void *arg),

   404

        void *cb_arg

   405

) {

   406

    struct render_multi *ctx = NULL;

   407

   408

    // alloc the render_multi

   409

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

   410

   411

    if (!ctx)

   412

        ERROR("calloc");

   413

   414

    // store the provided callback functions

   415

    ctx->cb_sent = cb_sent;

   416

    ctx->cb_data = cb_data;

   417

    ctx->cb_done = cb_done;

   418

    ctx->cb_fail = cb_fail;

   419

    ctx->cb_arg = cb_arg;

   420

   421

    // store our render_png callbacks, must be before png_info

   422

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

   423

        ERROR("render_io_custom");

   424

   425

    // evbuffer, must be before png_info

   426

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

   427

        ERROR("evbuffer_new");

   428

   429

    // then initialize the render_slices

   430

    if (render_slices_init(&ctx->slices, render))

   431

        ERROR("render_slices_init");

   432

   433

    // how many nodes?

   434

    ctx->node_count = render_slices_get_count(&ctx->slices);

   435

   436

    // load them

   437

    int i;

   438

   439

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

   440

        // store the info struct

   441

        ctx->nodes[i].info = render_slices_get_slice_info(&ctx->slices, i);

   442

   443

        // some simple attributes

   444

        ctx->nodes[i].slice_width = ctx->nodes[i].info->render_info->img_w;

   445

        ctx->nodes[i].self = ctx;

   446

   447

   448

        // the render_remote

   449

        if (!(ctx->nodes[i].render_remote = render_remote_rawio(ctx->nodes[i].info->render_info, pool_info, 

   450

                &_render_multi_sent, &_render_multi_fail, &_render_multi_data_raw, &ctx->nodes[i]))

   451

        )

   452

            ERROR("render_remote_rawio");

   453

    }

   454

   455

    // we are now alive

   456

    ctx->alive = 1;

   457

   458

    // I guess that's a succesfull start now

   459

    return ctx;

   460

   461

error:

   462

    _render_multi_do_fail(ctx, FAIL_SILENT | FAIL_PARTIAL);

   463

   464

    return NULL;

   465

}

   466

   467

   468

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

   469

   470

}

   471

   472

int render_multi_flush (struct render_multi *ctx) {

   473

    _render_multi_do_png_data(ctx);

   474

   475

    return 0;

   476

}

   477

   478

void render_multi_cancel (struct render_multi *ctx) {

   479

    _render_multi_do_fail(ctx, FAIL_SILENT);

   480

}

   481

   482

void render_multi_free (struct render_multi *ctx) {

   483

    _render_multi_do_free(ctx);

   484

}