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,

    36

        "XXX: Process some image files.\n"

    37

        "\n"

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

    );

    52

}

    53

    54

int main (int argc, char **argv)

    55

{

    56

    int opt;

    57

    bool force_update = false, no_update = false;

    58

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

    59

    struct pt_image_params update_params = { };

    60

    int threads = 2;

    61

    int tmp, err;

    62

    63

    // parse arguments

    64

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

    65

        switch (opt) {

    66

            case 'h':

    67

                // display help

    68

                help(argv[0]);

    69

    70

                return EXIT_SUCCESS;

    71

    72

            case 'q':

    73

                // supress excess log output

    74

                set_log_level(LOG_WARN);

    75

    76

                break;

    77

    78

            case 'v':

    79

            case 'D':

    80

                // display additional output

    81

                set_log_level(LOG_DEBUG);

    82

    83

                break;

    84

    85

            case 'U':

    86

                // force update of image caches

    87

                force_update = true;

    88

    89

                break;

    90

    91

            case 'N':

    92

                // supress update of image caches

    93

                no_update = true;

    94

    95

                break;

    96

    97

            case 'B':

    98

                // background pattern

    99

                {

   100

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

   101

   102

                    // parse 0xXXXXXXXX

   103

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

   104

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

   105

   106

                    // store

   107

                    update_params.background_color[0] = b1;

   108

                    update_params.background_color[1] = b2;

   109

                    update_params.background_color[2] = b3;

   110

                    update_params.background_color[3] = b4;

   111

   112

                } break;

   113

   114

            case 'W':

   115

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

   116

   117

            case 'H':

   118

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

   119

   120

            case 'x':

   121

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

   122

   123

            case 'y':

   124

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

   125

   126

            case 'z':

   127

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

   128

   129

            case 'j':

   130

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

   131

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

   132

   133

                threads = tmp; break;

   134

   135

            case '?':

   136

                // useage error

   137

                help(argv[0]);

   138

   139

                return EXIT_FAILURE;

   140

   141

            default:

   142

                // getopt???

   143

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

   144

        }

   145

    }

   146

   147

    // end-of-arguments?

   148

    if (!argv[optind])

   149

        EXIT_WARN(EXIT_FAILURE, "No images given");

   150

   151

   152

   153

    struct pt_ctx *ctx = NULL;

   154

    struct pt_image *image = NULL;

   155

    enum pt_cache_status status;

   156

   157

    // build ctx

   158

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

   159

   160

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

   161

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

   162

   163

   164

    // process each image in turn

   165

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

   166

   167

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

   168

        const char *img_path = argv[i];

   169

   170

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

   171

   172

        // open

   173

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

   174

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

   175

            continue;

   176

        }

   177

   178

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

   179

   180

        // check if stale

   181

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

   182

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

   183

            goto error;

   184

        }

   185

   186

        // update if stale

   187

        if (status != PT_CACHE_FRESH || force_update) {

   188

            if (status == PT_CACHE_NONE)

   189

                log_debug("\tImage cache is missing");

   190

   191

            else if (status == PT_CACHE_STALE)

   192

                log_debug("\tImage cache is stale");

   193

   194

            else if (status == PT_CACHE_INCOMPAT)

   195

                log_debug("\tImage cache is incompatible");

   196

   197

            else if (status == PT_CACHE_FRESH)

   198

                log_debug("\tImage cache is fresh");

   199

   200

            if (!no_update) {

   201

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

   202

   203

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

   204

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

   205

                }

   206

   207

                log_info("\tUpdated image cache");

   208

   209

            } else {

   210

                log_warn("\tSupressing cache update");

   211

            }

   212

   213

        } else {    

   214

            log_debug("\tImage cache is fresh");

   215

        }

   216

   217

        // show info

   218

        const struct pt_image_info *info;

   219

   220

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

   221

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

   222

   223

        } else {

   224

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

   228

            );

   229

        }

   230

   231

        // render tile?

   232

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

   233

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

   234

            int fd;

   235

            FILE *out;

   236

   237

            // temporary file for output

   238

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

   239

                log_errno("mkstemp");

   240

   241

                continue;

   242

            }

   243

   244

            // open out

   245

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

   246

                log_errno("fdopen");

   247

   248

                continue;

   249

            }

   250

   251

            // ensure it's loaded

   252

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

   253

   254

            if ((err = pt_image_load(image)))

   255

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

   256

   257

            // render

   258

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

   259

   260

   261

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

   262

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

   263

        }

   264

   265

error:

   266

        // cleanup

   267

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

   268

        ;

   269

    }

   270

   271

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

   272

   273

    // wait for tile operations to finish...

   274

    pt_ctx_shutdown(ctx);

   275

   276

    log_info("Done");

   277

   278

    return 0;

   279

}

   280