1

#include "shared/log.h"

     2

     3

#include "pngtile.h"

     4

     5

#include <getopt.h>

     6

#include <stdio.h>

     7

#include <stdbool.h>

     8

     9

/**

    10

 * Command-line options

    11

 */

    12

static const struct option options[] = {

    13

    { "help",           false,  NULL,   'h' },

    14

    { "quiet",          false,  NULL,   'q' },

    15

    { "verbose",        false,  NULL,   'v' },

    16

    { "debug",          false,  NULL,   'D' },

    17

    { "force-update",   false,  NULL,   'U' },

    18

    { "width",          true,   NULL,   'W' },

    19

    { "height",         true,   NULL,   'H' },

    20

    { "x",              true,   NULL,   'x' },

    21

    { "y",              true,   NULL,   'y' },

    22

    { "threads",        true,   NULL,   'j' },

    23

    { 0,                0,      0,      0   }

    24

};

    25

    26

/**

    27

 * Print usage/help info on stderr

    28

 */

    29

void help (const char *argv0)

    30

{

    31

    fprintf(stderr, "Usage: %s [options] <image> [...]\n", argv0);

    32

    fprintf(stderr,

    33

        "XXX: Process some image files.\n"

    34

        "\n"

    35

        "\t-h, --help           show this help and exit\n"

    36

        "\t-q, --quiet          supress informational output\n"

    37

        "\t-v, --verbose        display more informational output\n"

    38

        "\t-D, --debug          equivalent to -v\n"

    39

        "\t-U, --force-update   unconditionally update image caches\n"

    40

        "\t-W, --width          set tile width\n"

    41

        "\t-H, --height         set tile height\n"

    42

        "\t-x, --x              set tile x offset\n"

    43

        "\t-y, --y              set tile z offset\n"

    44

        "\t-j, --threads        number of threads\n"

    45

    );

    46

}

    47

    48

int main (int argc, char **argv)

    49

{

    50

    int opt;

    51

    bool force_update = false;

    52

    struct pt_tile_info ti = {0, 0, 0, 0};

    53

    int threads = 2;

    54

    int tmp, err;

    55

    56

    // parse arguments

    58

        switch (opt) {

    59

            case 'h':

    60

                // display help

    61

                help(argv[0]);

    62

    63

                return EXIT_SUCCESS;

    64

    65

            case 'q':

    66

                // supress excess log output

    67

                set_log_level(LOG_WARN);

    68

    69

                break;

    70

    71

            case 'v':

    72

            case 'D':

    73

                // display additional output

    74

                set_log_level(LOG_DEBUG);

    75

    76

                break;

    77

    78

            case 'U':

    79

                // force update of image caches

    80

                force_update = true;

    81

    82

                break;

    83

    84

            case 'W':

    85

                ti.width = strtol(optarg, NULL, 0); break;

    86

    87

            case 'H':

    88

                ti.height = strtol(optarg, NULL, 0); break;

    89

    90

            case 'x':

    91

                ti.x = strtol(optarg, NULL, 0); break;

    92

    93

            case 'y':

    94

                ti.y = strtol(optarg, NULL, 0); break;

    95

    96

            case 'j':

    97

                if ((tmp = strtol(optarg, NULL, 0)) < 1)

    98

                    FATAL("Invalid value for -j/--threads");

    99

   100

                threads = tmp; break;

   101

   102

            case '?':

   103

                // useage error

   104

                help(argv[0]);

   105

   106

                return EXIT_FAILURE;

   107

   108

            default:

   109

                // getopt???

   110

                FATAL("getopt_long returned unknown code %d", opt);

   111

        }

   112

    }

   113

   114

    // end-of-arguments?

   115

    if (!argv[optind])

   116

        EXIT_WARN(EXIT_FAILURE, "No images given");

   117

   118

   119

   120

    struct pt_ctx *ctx = NULL;

   121

    struct pt_image *image = NULL;

   122

    enum pt_cache_status status;

   123

   124

    // build ctx

   125

    log_debug("Construct pt_ctx with %d threads", threads);

   126

   127

    if ((err = pt_ctx_new(&ctx, threads)))

   128

        EXIT_ERROR(EXIT_FAILURE, "pt_ctx_new: threads=%d", threads);

   129

   130

   131

    // process each image in turn

   132

    log_debug("Processing %d images...", argc - optind);

   133

   134

    for (int i = optind; i < argc; i++) {

   135

        const char *img_path = argv[i];

   136

   137

        log_debug("Loading image from: %s...", img_path);

   138

   139

        // open

   140

        if ((err = pt_image_open(&image, ctx, img_path, PT_OPEN_UPDATE))) {

   141

            log_errno("pt_image_open: %s: %s", img_path, pt_strerror(err));

   142

            continue;

   143

        }

   144

   145

        log_info("Opened image at: %s", img_path);

   146

   147

        // check if stale

   148

        if ((status = pt_image_status(image)) < 0) {

   149

            log_errno("pt_image_status: %s: %s", img_path, pt_strerror(status));

   150

            goto error;

   151

        }

   152

   153

        // update if stale

   154

        if (status != PT_CACHE_FRESH || force_update) {

   155

            if (status == PT_CACHE_NONE)

   156

                log_debug("Image cache is missing");

   157

   158

            else if (status == PT_CACHE_STALE)

   159

                log_debug("Image cache is stale");

   160

   161

            else if (status == PT_CACHE_FRESH)

   162

                log_debug("Image cache is fresh");

   163

   164

            log_debug("Updating image cache...");

   165

   166

            if ((err = pt_image_update(image))) {

   167

                log_warn_errno("pt_image_update: %s: %s", img_path, pt_strerror(err));

   168

            }

   169

   170

            log_info("Updated image cache");

   171

   172

        } else {

   173

            log_debug("Image cache is fresh");

   174

        }

   175

   176

        // show info

   177

        const struct pt_image_info *img_info;

   178

   179

        if ((err = pt_image_info(image, &img_info)))

   180

            log_warn_errno("pt_image_info: %s: %s", img_path, pt_strerror(err));

   181

   182

        else

   183

            log_info("\tImage dimensions: %zux%zu", img_info->width, img_info->height);

   184

   185

        // render tile?

   186

        if (ti.width && ti.height) {

   187

            char tmp_name[] = "pt-tile-XXXXXX";

   188

            int fd;

   189

            FILE *out;

   190

   191

            // temporary file for output

   192

            if ((fd = mkstemp(tmp_name)) < 0) {

   193

                log_errno("mkstemp");

   194

   195

                continue;

   196

            }

   197

   198

            // open out

   199

            if ((out = fdopen(fd, "w")) == NULL) {

   200

                log_errno("fdopen");

   201

   202

                continue;

   203

            }

   204

   205

            // render

   206

            log_debug("Async render tile %zux%zu@(%zu,%zu) -> %s", ti.width, ti.height, ti.x, ti.y, tmp_name);

   207

   208

            if ((err = pt_image_tile_async(image, &ti, out)))

   209

                log_errno("pt_image_tile: %s: %s", img_path, pt_strerror(err));

   210

        }

   211

   212

error:

   213

        // cleanup

   214

        // XXX: leak because of async: pt_image_destroy(image);

   215

        ;

   216

    }

   217

   218

    log_info("Waiting for images to finish...");

   219

   220

    // wait for tile operations to finish...

   221

    pt_ctx_shutdown(ctx);

   222

   223

    log_info("Done");

   224

   225

    return 0;

   226

}

   227