1

#include <unistd.h>

     2

#include <errno.h>

     3

#include <string.h>

     4

#include <assert.h>

     5

#include <stdlib.h>

     6

     7

#include <pthread.h>

     8

#include <event2/event.h>

     9

    10

#include "common.h"

    11

#include "render_thread.h"

    12

#include "render_thread_struct.h"

    13

#include "render_local.h"

    14

    15

static void *_render_thread_func (void *arg) {

    16

    struct render_thread *ctx = arg;

    17

    18

    // measure how long it takes

    19

    double duration;

    20

    21

    // render it...

    22

    if (render_local(&ctx->render_info, &duration))

    23

        goto error;

    24

    25

#ifdef DEBUG_INFO

    26

    u_int32_t img_w, img_h;

    27

    28

    render_get_size(&ctx->render_info, &img_w, &img_h);

    29

    30

    // report the duration

    31

    INFO("rendered [%ux%u] in %f seconds", img_w, img_h, duration);

    32

#endif

    33

    34

    // notify completion, writeall()

    35

    ssize_t ret;

    36

    char *buf = (void *) &ctx;

    37

    size_t len = sizeof(ctx);

    38

    39

    do {

    40

        ret = write(ctx->notify_fd, buf, len);

    41

    42

        if (ret > 0) {

    43

            buf += ret;

    44

            len -= ret;

    45

        }

    46

    } while ((ret == -1 && errno == EINTR) || len > 0);

    47

    48

    if (ret == -1)

    49

        PERROR("write");

    50

    51

    // done...

    52

    return NULL;

    53

    54

error:

    55

    return ctx;

    56

}

    57

    58

static void _render_thread_done (evutil_socket_t fd, short what, void *arg) {

    59

    struct render_thread *ctx = arg;

    60

    void *thread_return;

    61

    62

    // make a lazy effort to read the contents of the pipe

    63

    struct render_thread *ctx2;

    64

    char *buf = (void *) &ctx2;

    65

    size_t len = sizeof(ctx);

    66

    67

    ssize_t ret;

    68

    69

    if ((ret = read(fd, buf, len)) == -1)

    70

        PWARNING("read");

    71

    72

    else if (ret != len)

    73

        WARNING("short read");

    74

    75

    else if (ctx2 != ctx)

    76

        FATAL("wrong ctx: %p <> %p", ctx, ctx2);

    77

    78

    // close the pipe

    79

    if (close(fd))

    80

        PWARNING("close(pipe-read)");

    81

    82

    if (close(ctx->notify_fd))

    83

        PWARNING("close(pipe-write)");

    84

    85

    // join the thread and check the return value

    86

    if (pthread_join(ctx->thread_id, &thread_return))

    87

        PWARNING("pthread_join");

    88

    else if (thread_return == PTHREAD_CANCELED)

    89

        PWARNING("PTHREAD_CANCELED");

    90

    else if (thread_return != NULL)

    91

        PWARNING("thread_return != NULL");

    92

    93

    // mark it as done

    94

    ctx->is_active = 0;

    95

    96

    // call our callback

    97

    ctx->cb_func(ctx, ctx->cb_arg);

    98

}

    99

   100

int render_thread_init (struct render_thread *ctx, struct render *render_info, render_thread_done_cb cb_func, void *cb_arg) {

   101

    // we need to copy over the render info, as it will probably be invalidated before the thread finishes

   102

    memcpy(&ctx->render_info, render_info, sizeof(ctx->render_info));

   103

   104

    // the cb stuff

   105

    ctx->cb_func = cb_func;

   106

    ctx->cb_arg = cb_arg;

   107

   108

    // the notify pipe

   109

    int pipefds[2];

   110

   111

    if (pipe(pipefds))

   112

        PERROR("pipe");

   113

   114

    // the write end...

   115

    ctx->notify_fd = pipefds[1];

   116

   117

    // the read end...

   118

    event_set(&ctx->ev, pipefds[0], EV_READ, &_render_thread_done, ctx);

   119

   120

    if (event_add(&ctx->ev, NULL))

   121

        PERROR("event_add");

   122

   123

    // spawn the render thread

   124

    if (pthread_create(&ctx->thread_id, NULL, &_render_thread_func, ctx))

   125

        PERROR("pthread_create(manager_func)");

   126

   127

    // mark it as active

   128

    ctx->is_active = 1;

   129

   130

    return 0;

   131

   132

error:

   133

    render_thread_deinit(ctx);

   134

    return -1;

   135

}

   136

   137

void render_thread_cancel (struct render_thread *ctx) {

   138

    assert(ctx->is_active);

   139

   140

    // we don't care about joining the thread, detach

   141

    // XXX if already detached, it won't get canceled here

   142

    if (pthread_detach(ctx->thread_id))

   143

        PWARNING("pthread_detach");

   144

   145

    // cancel it

   146

    else if (pthread_cancel(ctx->thread_id))

   147

        PWARNING("pthread_cancel");

   148

   149

    // XXX: should we actually join it before continuing?

   150

   151

    // slam the pipe shut in front of its face

   152

    if (close(event_get_fd(&ctx->ev)))

   153

        PWARNING("close");

   154

   155

    if (close(ctx->notify_fd))

   156

        PWARNING("close");

   157

   158

    // pipe's closed, and don't call _render_thread_func

   159

    event_del(&ctx->ev);

   160

   161

    // we are now ready for deinit

   162

    ctx->is_active = 0;

   163

}

   164

   165

void render_thread_deinit (struct render_thread *ctx) {

   166

    assert(!ctx->is_active);

   167

   168

    // nothing to do

   169

}

   170

   171

struct render_thread *render_thread_alloc (struct render *render_info, render_thread_done_cb cb_func, void *cb_arg) {

   172

    struct render_thread *ctx = NULL;

   173

   174

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

   175

        ERROR("calloc");

   176

   177

    // flag it for free()ing

   178

    ctx->owned_by_me = 1;

   179

   180

    // init with silent fall-through

   181

    if (render_thread_init(ctx, render_info, cb_func, cb_arg))

   182

        goto error;

   183

   184

    // success

   185

    return ctx;

   186

   187

error:

   188

    // XXX: do other modules do this?

   189

    free(ctx);

   190

   191

    return NULL;

   192

}

   193

   194

void render_thread_free (struct render_thread *ctx) {

   195

    render_thread_deinit(ctx);

   196

   197

    if (ctx->owned_by_me)

   198

        free(ctx);

   199

}

   200