1

#include <stdio.h>

     2

#include <stdlib.h>

     3

#include <unistd.h>

     4

#include <string.h>

     5

#include <sys/types.h>

     6

#include <sys/socket.h>

     7

#include <arpa/inet.h>

     8

     9

#include "common.h"

    10

#include "render.h"

    11

#include "render_local.h"

    12

    13

static int verbose;

    14

    15

int render_file_local (struct render *ctx, FILE *fh) {

    16

    double duration;

    17

    18

    if (render_io_stream(ctx, fh))

    19

        ERROR("render_io_stream");

    20

    21

    if (render_local(ctx, &duration))

    22

        ERROR("render_local");

    23

    24

    if (verbose) {

    25

        u_int32_t img_w, img_h;

    26

    27

        if (render_get_size(ctx, &img_w, &img_h))

    28

            ERROR("render_get_size");

    29

    30

        fprintf(stdout, "rendered %dx%d mandelbrot in %f seconds\n", img_w, img_h, duration);

    31

    }

    32

    33

    return 0;

    34

    35

error:

    36

    return -1;

    37

}

    38

    39

int main (int argc, char **argv) {

    40

    int error = 1;

    41

    42

    struct render *ctx = NULL;

    43

    44

    // parse arguments

    45

    int opt;

    46

    FILE *output = NULL;

    47

    int img_w = 256, img_h = 256;

    48

    49

    while ((opt = getopt(argc, argv, "w:h:o:v")) != -1) {

    50

        switch(opt) {

    51

            case 'w' :

    52

                img_w = atoi(optarg);

    53

                break;

    54

    55

            case 'h' :

    56

                img_h = atoi(optarg);

    57

                break;

    58

    59

            case 'o' :

    60

                if (output)

    61

                    err_exit("Only use -o once");

    62

    63

                output = fopen(optarg, "w");

    64

    65

                if (!output)

    66

                    PFATAL("fopen: %s", optarg);

    67

    68

                break;

    69

    70

            case 'v' :

    71

                verbose = 1;

    72

                break;

    73

    74

    75

            default :

    76

                err_exit("Usage: %s [-w img_w] [-h img_h] [-o output_file] [-v]", argv[0]);

    77

        }

    78

    }

    79

    80

    if (!output)

    81

        output = stdout;

    82

    83

    // setup the struct render

    84

    if (!(ctx = render_alloc()))

    85

        ERROR("render_alloc");

    86

    87

    if (render_set_mode(ctx, RENDER_PNG))

    88

        ERROR("render_set_mode");

    89

    90

    if (render_set_size(ctx, img_w, img_h))

    91

        ERROR("render_set_size");

    92

    93

    if (render_region_full(ctx))

    94

        ERROR("render_region_full");

    95

    96

    // do the render!

    97

    if (verbose)

    98

        fprintf(stderr, "Render [%dx%d] mandelbrot locally...\n", img_w, img_h);

    99

   100

    if (render_file_local(ctx, output))

   101

        ERROR("render_local");

   102

   103

    // success

   104

    error = 0;

   105

   106

error:

   107

    if (output)

   108

        fclose(output);

   109

   110

    free(ctx);

   111

   112

    return error;

   113

}

   114

   115

#if 0

   116

void render_remote (int img_w, int img_h, FILE *output, FILE *remote) {

   117

    render_t ctx;

   118

    struct render_cmd cmd;

   119

   120

    render_init(&ctx, RENDER_PNG);

   121

    render_set_size(&ctx, img_w, img_h);

   122

    render_region_full(&ctx);

   123

   124

    if (render_cmd_build(&ctx, &cmd))

   125

        err_exit("mandelbrot_render_remote failed");

   126

   127

    int ret = fwrite((void *) &cmd, sizeof(cmd), 1, remote);

   128

   129

    if (ret != 1)

   130

        perr_exit("fwrite(remote)");

   131

   132

    if (verbose)

   133

        printf("sent render command of %zu bytes\n", sizeof(cmd));

   134

   135

    // shuffle data around

   136

    while (!feof(remote)) {

   137

        char buf[1024];

   138

   139

        int bytes = fread(buf, 1, sizeof(buf), remote);

   140

   141

        if (bytes)

   142

            if (fwrite(buf, bytes, 1, output) != 1)

   143

                perr_exit("fwrite(output)");

   144

    }

   145

   146

    if (verbose)

   147

        printf("got PNG data\n");

   148

   149

    if (ferror(remote))

   150

        perr_exit("fread(remote)");

   151

}

   152

   153

FILE *open_remote (char *remote) {

   154

    char *addr_str, *port_str = NULL;

   155

   156

    addr_str = strsep(&remote, ":");

   157

   158

    if (remote)

   159

        port_str = remote;

   160

   161

    struct sockaddr_in addr;

   162

   163

    addr.sin_family = AF_INET;

   164

    addr.sin_port = htons(port_str ? atoi(port_str) : RENDER_PORT);

   165

   166

    if (inet_aton(addr_str, &addr.sin_addr) == 0)

   167

        err_exit("invalid address: %s", addr_str);

   168

   169

    int sock;

   170

   171

    if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == -1)

   172

        perr_exit("socket");

   173

   174

    if (verbose)

   175

        printf("connect(%s, %d)\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

   176

   177

    if (connect(sock, (const struct sockaddr *) &addr, sizeof(addr)) == -1)

   178

        perr_exit("connect(%s, %d)", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

   179

   180

    FILE *fh = fdopen(sock, "w+");

   181

   182

    if (!fh || ferror(fh))

   183

        perr_exit("fdopen");

   184

   185

    setbuffer(fh, NULL, 0);

   186

   187

    return fh;

   188

}

   189

#endif

   190

   191