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 "render.h"

    10

#include "mandelbrot.h"

    11

#include "common.h"

    12

    13

static int verbose;

    14

    15

void render_local (int img_w, int img_h, FILE *output) {

    16

    render_t ctx;

    17

    18

    render_init(&ctx, RENDER_PNG);

    19

    render_set_size(&ctx, img_w, img_h);

    20

    render_region_full(&ctx);

    21

    render_io_stream(&ctx, output);

    22

    23

    double duration;

    24

    25

    if (mandelbrot_render_timed(&ctx, &duration) != MANDELBROT_OK)

    26

        err_exit("mandelbrot_render_region failed");

    27

    28

    if (verbose) 

    29

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

    30

}

    31

    32

#if 0

    33

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

    34

    render_t ctx;

    35

    struct render_cmd cmd;

    36

    37

    render_init(&ctx, RENDER_PNG);

    38

    render_set_size(&ctx, img_w, img_h);

    39

    render_region_full(&ctx);

    40

    41

    if (render_cmd_build(&ctx, &cmd))

    42

        err_exit("mandelbrot_render_remote failed");

    43

    44

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

    45

    46

    if (ret != 1)

    47

        perr_exit("fwrite(remote)");

    48

    49

    if (verbose)

    50

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

    51

    52

    // shuffle data around

    53

    while (!feof(remote)) {

    54

        char buf[1024];

    55

    56

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

    57

    58

        if (bytes)

    59

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

    60

                perr_exit("fwrite(output)");

    61

    }

    62

    63

    if (verbose)

    64

        printf("got PNG data\n");

    65

    66

    if (ferror(remote))

    67

        perr_exit("fread(remote)");

    68

}

    69

    70

FILE *open_remote (char *remote) {

    71

    char *addr_str, *port_str = NULL;

    72

    73

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

    74

    75

    if (remote)

    76

        port_str = remote;

    77

    78

    struct sockaddr_in addr;

    79

    80

    addr.sin_family = AF_INET;

    81

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

    82

    83

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

    84

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

    85

    86

    int sock;

    87

    88

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

    89

        perr_exit("socket");

    90

    91

    if (verbose)

    92

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

    93

    94

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

    95

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

    96

    97

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

    98

    99

    if (!fh || ferror(fh))

   100

        perr_exit("fdopen");

   101

   102

    setbuffer(fh, NULL, 0);

   103

   104

    return fh;

   105

}

   106

#endif

   107

   108

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

   109

    int opt;

   110

   111

    FILE *output = NULL /*, *remote = NULL */ ;

   112

    int img_w = 256, img_h = 256;

   113

   114

   115

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

   116

        switch(opt) {

   117

            case 'w' :

   118

                img_w = atoi(optarg);

   119

                break;

   120

   121

            case 'h' :

   122

                img_h = atoi(optarg);

   123

                break;

   124

   125

            case 'o' :

   126

                if (output)

   127

                    err_exit("Only use -o once");

   128

   129

                output = fopen(optarg, "w");

   130

   131

                if (!output)

   132

                    die(optarg);

   133

   134

                break;

   135

   136

            case 'v' :

   137

                verbose = 1;

   138

                break;

   139

   140

#if 0

   141

            case 'r' :

   142

                if (remote)

   143

                    err_exit("Only use -r once");

   144

   145

                remote = open_remote(optarg);

   146

   147

                break;

   148

#endif

   149

   150

            default :

   151

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

   152

        }

   153

    }

   154

   155

    if (!output)

   156

        output = stdout;

   157

   158

#if 0

   159

    if (remote) {

   160

        if (verbose)

   161

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

   162

   163

        render_remote(img_w, img_h, output, remote);

   164

   165

        fclose(remote);

   166

    } else

   167

#endif    

   168

    {

   169

        if (verbose)

   170

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

   171

   172

        render_local(img_w, img_h, output);

   173

    }

   174

   175

    fclose(output);

   176

   177

    return 0;

   178

}