1

#include "shared/log.h"

     2

     3

#include "pngtile.h"

     4

     5

#include <getopt.h>

     6

#include <string.h>

     7

#include <stdio.h>

     8

#include <unistd.h>

     9

#include <stdbool.h>

    10

    11

enum option_names {

    12

    13

    _OPT_LONGONLY       = 255,

    14

    15

    OPT_BENCHMARK,

    16

    OPT_RANDOMIZE,

    17

};

    18

    19

/**

    20

 * Command-line options

    21

 */

    22

static const struct option options[] = {

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

    { "out",            true,   NULL,   'o' },

    36

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

    37

    38

    // --long-only options

    39

    { "benchmark",      true,   NULL,   OPT_BENCHMARK   },

    40

    { "randomize",      false,  NULL,   OPT_RANDOMIZE   },

    41

    { 0,                0,      0,      0               }

    42

};

    43

    44

/**

    45

 * Print usage/help info on stderr

    46

 */

    47

void help (const char *argv0)

    48

{

    49

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

    50

    fprintf(stderr,

    51

        "Open each of the given image files, check cache status, optionally update their cache, display image info, and\n"

    52

        "optionally render a tile of each.\n"

    53

        "\n"

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

        "\t-B, --background         set background pattern for sparse cache file: 0xHH..\n"

    61

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

    62

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

    63

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

    64

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

    65

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

    66

        "\t-o, --out        FILE    set tile output file\n"

    67

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

    68

        "\t--benchmark      N       do N tile renders\n"

    69

        "\t--randomize              randomize tile x/y coords\n"

    70

    );

    71

}

    72

    73

unsigned long parse_uint (const char *val, const char *name)

    74

{

    75

    char *endptr;

    76

    long int out;

    77

    78

    // decode

    79

    out = strtol(val, &endptr, 0);

    80

    81

    // validate

    82

    if (*endptr || out < 0)

    83

        EXIT_ERROR(EXIT_FAILURE, "Invalid value for %s: %s", name, val);

    84

    85

    // ok

    86

    return out;

    87

}

    88

    89

signed long parse_sint (const char *val, const char *name)

    90

{

    91

    char *endptr;

    92

    long int out;

    93

    94

    // decode

    95

    out = strtol(val, &endptr, 0);

    96

    97

    // validate

    98

    if (*endptr)

    99

        EXIT_ERROR(EXIT_FAILURE, "Invalid value for %s: %s", name, val);

   100

   101

    // ok

   102

    return out;

   103

}

   104

   105

long randrange (long start, long end)

   106

{

   107

    return start + (rand() * (end - start) / RAND_MAX);

   108

}

   109

   110

/**

   111

 * Randomize tile x/y with given image info

   112

 */

   113

void randomize_tile (struct pt_tile_info *ti, const struct pt_image_info *info)

   114

{

   115

    ti->x = randrange(0, info->img_width - ti->width);

   116

    ti->y = randrange(0, info->img_height - ti->height);

   117

}

   118

   119

/**

   120

 * Render a tile

   121

 */

   122

int do_tile (struct pt_ctx *ctx, struct pt_image *image, const struct pt_tile_info *ti, const char *out_path)

   123

{

   124

    FILE *out_file = NULL;

   125

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

   126

    int err = 0;

   127

   128

    if (!out_path) {

   129

        int fd;

   130

   131

        // temporary file for output

   132

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

   133

            log_errno("mkstemp");

   134

            goto error;

   135

        }

   136

   137

        out_path = tmp_name;

   138

   139

        // open out

   140

        if ((out_file = fdopen(fd, "wb")) == NULL) {

   141

            log_errno("fdopen");

   142

            goto error;

   143

        }

   144

   145

    } else if (strcmp(out_path, "-") == 0) {

   146

        // use stdout

   147

        if ((out_file = fdopen(STDOUT_FILENO, "wb")) == NULL) {

   148

            log_errno("fdopen: STDOUT_FILENO");

   149

            goto error;

   150

        }

   151

   152

    } else {

   153

        // use file

   154

        if ((out_file = fopen(out_path, "wb")) == NULL) {

   155

            log_errno("fopen: %s", out_path);

   156

            goto error;

   157

        }

   158

   159

    }

   160

   161

   162

    if (ctx) {

   163

        // render

   164

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

   165

   166

        if ((err = pt_image_tile_async(image, ti, out_file))) {

   167

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

   168

            goto error;

   169

        }

   170

   171

        // will close it itself

   172

        out_file = NULL;

   173

   174

    } else {

   175

        // render

   176

        log_info("\tRender tile %zux%zu@(%zu,%zu) -> %s", ti->width, ti->height, ti->x, ti->y, out_path);

   177

   178

        if ((err = pt_image_tile_file(image, ti, out_file))) {

   179

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

   180

            goto error;

   181

        }

   182

    }

   183

   184

error:

   185

    // cleanup

   186

    if (out_file && fclose(out_file))

   187

        log_warn_errno("fclose: out_file");

   188

   189

    return err;

   190

}

   191

   192

int main (int argc, char **argv)

   193

{

   194

    int opt;

   195

    bool force_update = false, no_update = false, randomize = false;

   196

    struct pt_tile_info ti = {

   197

        .width  = 800,

   198

        .height = 600,

   199

        .x      = 0,

   200

        .y      = 0,

   201

        .zoom   = 0

   202

    };

   203

    struct pt_image_params update_params = { };

   204

    const char *out_path = NULL;

   205

    int threads = 0, benchmark = 0;

   206

    int err;

   207

   208

    // parse arguments

   209

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

   210

        switch (opt) {

   211

            case 'h':

   212

                // display help

   213

                help(argv[0]);

   214

   215

                return EXIT_SUCCESS;

   216

   217

            case 'q':

   218

                // supress excess log output

   219

                set_log_level(LOG_WARN); break;

   220

   221

            case 'v':

   222

            case 'D':

   223

                // display additional output

   224

                set_log_level(LOG_DEBUG); break;

   225

   226

            case 'U':

   227

                // force update of image caches

   228

                force_update = true; break;

   229

   230

            case 'N':

   231

                // supress update of image caches

   232

                no_update = true; break;

   233

   234

            case 'B':

   235

                // background pattern

   236

                {

   237

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

   238

   239

                    // parse 0xXXXXXXXX

   240

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

   241

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

   242

   243

                    // store

   244

                    update_params.background_color[0] = b1;

   245

                    update_params.background_color[1] = b2;

   246

                    update_params.background_color[2] = b3;

   247

                    update_params.background_color[3] = b4;

   248

   249

                } break;

   250

   251

            case 'W':

   252

                ti.width = parse_uint(optarg, "--width"); break;

   253

   254

            case 'H':

   255

                ti.height = parse_uint(optarg, "--height"); break;

   256

   257

            case 'x':

   258

                ti.x = parse_uint(optarg, "--x"); break;

   259

   260

            case 'y':

   261

                ti.y = parse_uint(optarg, "--y"); break;

   262

   263

            case 'z':

   264

                ti.zoom = parse_sint(optarg, "--zoom"); break;

   265

   266

            case 'o':

   267

                // output file

   268

                out_path = optarg; break;

   269

   270

            case 'j':

   271

                threads = parse_uint(optarg, "--threads"); break;

   272

   273

            case OPT_BENCHMARK:

   274

                benchmark = parse_uint(optarg, "--benchmark"); break;

   275

   276

            case OPT_RANDOMIZE:

   277

                randomize = true; break;

   278

   279

            case '?':

   280

                // useage error

   281

                help(argv[0]);

   282

   283

                return EXIT_FAILURE;

   284

   285

            default:

   286

                // getopt???

   287

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

   288

        }

   289

    }

   290

   291

    // end-of-arguments?

   292

    if (!argv[optind])

   293

        EXIT_WARN(EXIT_FAILURE, "No images given");

   294

   295

   296

   297

    struct pt_ctx *ctx = NULL;

   298

    struct pt_image *image = NULL;

   299

    enum pt_cache_status status;

   300

   301

    if (threads) {

   302

        // build ctx

   303

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

   304

   305

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

   306

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

   307

    }

   308

   309

    // process each image in turn

   310

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

   311

   312

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

   313

        const char *img_path = argv[i];

   314

   315

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

   316

   317

        // open

   318

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

   319

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

   320

            continue;

   321

        }

   322

   323

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

   324

   325

        // check if stale

   326

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

   327

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

   328

            goto error;

   329

        }

   330

   331

        // update if stale

   332

        if (status != PT_CACHE_FRESH || force_update) {

   333

            if (status == PT_CACHE_NONE)

   335

   336

            else if (status == PT_CACHE_STALE)

   338

   339

            else if (status == PT_CACHE_INCOMPAT)

   341

   342

            else if (status == PT_CACHE_FRESH)

   344

   345

            else

   346

                log_warn("\tImage cache status is unknown");

   347

   348

            if (!no_update) {

   350

   351

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

   352

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

   353

                    goto error;

   354

                }

   355

   357

   358

            } else {

   359

                log_warn("\tSupressing cache update");

   360

            }

   361

   362

        } else {    

   363

            log_debug("\tImage cache is fresh");

   364

   365

            // ensure it's loaded

   367

   368

            if ((err = pt_image_load(image))) {

   369

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

   370

                goto error;

   371

            }

   372

        }

   373

   374

        // show info

   375

        const struct pt_image_info *info;

   376

   377

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

   378

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

   379

   380

        } else {

   381

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

   382

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

   383

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

   384

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

   385

            );

   386

        }

   387

   388

        // render tile?

   389

        if (benchmark) {

   390

            log_info("\tRunning %d %stile renders...", benchmark, randomize ? "randomized " : "");

   391

   392

            // n times

   393

            for (int i = 0; i < benchmark; i++) {

   394

                // randomize x, y

   395

                if (randomize)

   396

                    randomize_tile(&ti, info);

   397

   398

                if (do_tile(ctx, image, &ti, out_path))

   399

                    goto error;

   400

            }

   401

   402

        } else if (out_path) {

   403

            // randomize x, y

   404

            if (randomize)

   405

                randomize_tile(&ti, info);

   406

   407

            // just once

   408

            if (do_tile(ctx, image, &ti, out_path))

   409

                goto error;

   410

   411

        }

   412

        // cleanup

   413

        // XXX: leak because of async

   414

        if (!ctx)

   415

            pt_image_destroy(image);

   416

   417

        continue;

   418

   419

error:

   420

        // quit

   421

        EXIT_ERROR(EXIT_FAILURE, "Processing image failed: %s", img_path);

   422

    }

   423

   424

    if (ctx) {

   425

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

   426

   427

        // wait for tile operations to finish...

   428

        pt_ctx_shutdown(ctx);

   429

    }

   430

   431

    log_info("Done");

   432

   433

    return 0;

   434

}

   435