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

    { "no-update",      false,  NULL,   'N' },

    19

    { "background",     true,   NULL,   'B' },

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

    { 0,                0,      0,      0   }

    27

};

    28

    29

/**

    30

 * Print usage/help info on stderr

    31

 */

    32

void help (const char *argv0)

    33

{

    34

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

    35

    fprintf(stderr,

    38

        "\n"

    39

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

    40

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

    41

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

    42

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

    43

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

    44

        "\t-N, --no-update      do not update the image cache\n"

    45

        "\t-B, --background     set background pattern for cache update\n"

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

    );

    53

}

    54

    55

int main (int argc, char **argv)

    56

{

    57

    int opt;

    58

    bool force_update = false, no_update = false;

    59

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

    60

    struct pt_image_params update_params = { };

    61

    int threads = 2;

    62

    int tmp, err;

    63

    64

    // parse arguments

    65

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

    66

        switch (opt) {

    67

            case 'h':

    68

                // display help

    69

                help(argv[0]);

    70

    71

                return EXIT_SUCCESS;

    72

    73

            case 'q':

    74

                // supress excess log output

    75

                set_log_level(LOG_WARN);

    76

    77

                break;

    78

    79

            case 'v':

    80

            case 'D':

    81

                // display additional output

    82

                set_log_level(LOG_DEBUG);

    83

    84

                break;

    85

    86

            case 'U':

    87

                // force update of image caches

    88

                force_update = true;

    89

    90

                break;

    91

    92

            case 'N':

    93

                // supress update of image caches

    94

                no_update = true;

    95

    96

                break;

    97

    98

            case 'B':

    99

                // background pattern

   100

                {

   101

                    unsigned int b1 = 0, b2 = 0, b3 = 0, b4 = 0;

   102

   103

                    // parse 0xXXXXXXXX

   104

                    if (sscanf(optarg, "0x%02x%02x%02x%02x", &b1, &b2, &b3, &b4) < 1)

   105

                        FATAL("Invalid hex value for -B/--background: %s", optarg);

   106

   107

                    // store

   108

                    update_params.background_color[0] = b1;

   109

                    update_params.background_color[1] = b2;

   110

                    update_params.background_color[2] = b3;

   111

                    update_params.background_color[3] = b4;

   112

   113

                } break;

   114

   115

            case 'W':

   116

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

   117

   118

            case 'H':

   119

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

   120

   121

            case 'x':

   122

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

   123

   124

            case 'y':

   125

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

   126

   127

            case 'z':

   128

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

   129

   130

            case 'j':

   131

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

   132

                    FATAL("Invalid value for -j/--threads: %s", optarg);

   133

   134

                threads = tmp; break;

   135

   136

            case '?':

   137

                // useage error

   138

                help(argv[0]);

   139

   140

                return EXIT_FAILURE;

   141

   142

            default:

   143

                // getopt???

   144

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

   145

        }

   146

    }

   147

   148

    // end-of-arguments?

   149

    if (!argv[optind])

   150

        EXIT_WARN(EXIT_FAILURE, "No images given");

   151

   152

   153

   154

    struct pt_ctx *ctx = NULL;

   155

    struct pt_image *image = NULL;

   156

    enum pt_cache_status status;

   157

   158

    // build ctx

   159

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

   160

   161

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

   162

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

   163

   164

   165

    // process each image in turn

   166

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

   167

   168

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

   169

        const char *img_path = argv[i];

   170

   171

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

   172

   173

        // open

   174

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

   175

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

   176

            continue;

   177

        }

   178

   179

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

   180

   181

        // check if stale

   182

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

   183

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

   184

            goto error;

   185

        }

   186

   187

        // update if stale

   188

        if (status != PT_CACHE_FRESH || force_update) {

   189

            if (status == PT_CACHE_NONE)

   190

                log_debug("\tImage cache is missing");

   191

   192

            else if (status == PT_CACHE_STALE)

   193

                log_debug("\tImage cache is stale");

   194

   195

            else if (status == PT_CACHE_INCOMPAT)

   196

                log_debug("\tImage cache is incompatible");

   197

   198

            else if (status == PT_CACHE_FRESH)

   199

                log_debug("\tImage cache is fresh");

   200

   201

            if (!no_update) {

   202

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

   203

   204

                if ((err = pt_image_update(image, &update_params))) {

   205

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

   206

                }

   207

   208

                log_info("\tUpdated image cache");

   209

   210

            } else {

   211

                log_warn("\tSupressing cache update");

   212

            }

   213

   214

        } else {    

   215

            log_debug("\tImage cache is fresh");

   216

        }

   217

   218

        // show info

   219

        const struct pt_image_info *info;

   220

   221

        if ((err = pt_image_info(image, &info))) {

   222

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

   223

   224

        } else {

   225

            log_info("\tImage dimensions: %zux%zu", info->img_width, info->img_height);

   226

            log_info("\tImage mtime=%ld, bytes=%zu", (long) info->image_mtime, info->image_bytes);

   227

            log_info("\tCache mtime=%ld, bytes=%zu, blocks=%zu (%zu bytes)", 

   228

                    (long) info->cache_mtime, info->cache_bytes, info->cache_blocks, info->cache_blocks * 512

   229

            );

   230

        }

   231

   232

        // render tile?

   233

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

   234

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

   235

            int fd;

   236

            FILE *out;

   237

   238

            // temporary file for output

   239

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

   240

                log_errno("mkstemp");

   241

   242

                continue;

   243

            }

   244

   245

            // open out

   246

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

   247

                log_errno("fdopen");

   248

   249

                continue;

   250

            }

   251

   252

            // ensure it's loaded

   253

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

   254

   255

            if ((err = pt_image_load(image)))

   256

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

   257

   258

            // render

   259

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

   260

   261

   262

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

   263

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

   264

        }

   265

   266

error:

   267

        // cleanup

   268

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

   269

        ;

   270

    }

   271

   272

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

   273

   274

    // wait for tile operations to finish...

   275

    pt_ctx_shutdown(ctx);

   276

   277

    log_info("Done");

   278

   279

    return 0;

   280

}

   281