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

    { "zoom",           true,   NULL,   'z' },

    23

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

    24

    { 0,                0,      0,      0   }

    25

};

    26

    27

/**

    28

 * Print usage/help info on stderr

    29

 */

    30

void help (const char *argv0)

    31

{

    32

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

    33

    fprintf(stderr,

    34

        "XXX: Process some image files.\n"

    35

        "\n"

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

        "\t-z, --zoom           set zoom factor (<0)\n"

    46

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

    47

    );

    48

}

    49

    50

int main (int argc, char **argv)

    51

{

    52

    int opt;

    53

    bool force_update = false;

    54

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

    55

    int threads = 2;

    56

    int tmp, err;

    57

    58

    // parse arguments

    59

    while ((opt = getopt_long(argc, argv, "hqvDUW:H:x:y:z:j:", options, NULL)) != -1) {

    60

        switch (opt) {

    61

            case 'h':

    62

                // display help

    63

                help(argv[0]);

    64

    65

                return EXIT_SUCCESS;

    66

    67

            case 'q':

    68

                // supress excess log output

    69

                set_log_level(LOG_WARN);

    70

    71

                break;

    72

    73

            case 'v':

    74

            case 'D':

    75

                // display additional output

    76

                set_log_level(LOG_DEBUG);

    77

    78

                break;

    79

    80

            case 'U':

    81

                // force update of image caches

    82

                force_update = true;

    83

    84

                break;

    85

    86

            case 'W':

    87

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

    88

    89

            case 'H':

    90

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

    91

    92

            case 'x':

    93

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

    94

    95

            case 'y':

    96

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

    97

    98

            case 'z':

    99

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

   100

   101

            case 'j':

   102

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

   103

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

   104

   105

                threads = tmp; break;

   106

   107

            case '?':

   108

                // useage error

   109

                help(argv[0]);

   110

   111

                return EXIT_FAILURE;

   112

   113

            default:

   114

                // getopt???

   115

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

   116

        }

   117

    }

   118

   119

    // end-of-arguments?

   120

    if (!argv[optind])

   121

        EXIT_WARN(EXIT_FAILURE, "No images given");

   122

   123

   124

   125

    struct pt_ctx *ctx = NULL;

   126

    struct pt_image *image = NULL;

   127

    enum pt_cache_status status;

   128

   129

    // build ctx

   130

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

   131

   132

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

   133

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

   134

   135

   136

    // process each image in turn

   137

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

   138

   139

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

   140

        const char *img_path = argv[i];

   141

   142

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

   143

   144

        // open

   145

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

   146

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

   147

            continue;

   148

        }

   149

   150

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

   151

   152

        // check if stale

   153

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

   154

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

   155

            goto error;

   156

        }

   157

   158

        // update if stale

   159

        if (status != PT_CACHE_FRESH || force_update) {

   160

            if (status == PT_CACHE_NONE)

   161

                log_debug("\tImage cache is missing");

   162

   163

            else if (status == PT_CACHE_STALE)

   164

                log_debug("\tImage cache is stale");

   165

   166

            else if (status == PT_CACHE_FRESH)

   167

                log_debug("\tImage cache is fresh");

   168

   169

            log_debug("\tUpdating image cache...");

   170

   171

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

   172

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

   173

            }

   174

   175

            log_info("\tUpdated image cache");

   176

   177

        } else {

   178

            log_debug("\tImage cache is fresh");

   179

        }

   180

   181

        // show info

   182

        const struct pt_image_info *img_info;

   183

   184

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

   185

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

   186

   187

        else

   188

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

   189

   190

        // render tile?

   191

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

   192

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

   193

            int fd;

   194

            FILE *out;

   195

   196

            // temporary file for output

   197

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

   198

                log_errno("mkstemp");

   199

   200

                continue;

   201

            }

   202

   203

            // open out

   204

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

   205

                log_errno("fdopen");

   206

   207

                continue;

   208

            }

   209

   210

            // ensure it's loaded

   211

            log_debug("\tLoad image cache...");

   212

   213

            if ((err = pt_image_load(image)))

   214

                log_errno("pt_image_load: %s", pt_strerror(err));

   215

   216

            // render

   217

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

   218

   219

   220

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

   221

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

   222

        }

   223

   224

error:

   225

        // cleanup

   226

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

   227

        ;

   228

    }

   229

   230

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

   231

   232

    // wait for tile operations to finish...

   233

    pt_ctx_shutdown(ctx);

   234

   235

    log_info("Done");

   236

   237

    return 0;

   238

}

   239