link.c

   1 /* lots of code c&p-ed directly from mupdf */
   2 #include <errno.h>
   3 #include <stdio.h>
   4 #include <ctype.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7
   8 #define PIGGYBACK
   9
  10 #ifdef _WIN32
  11 #define WIN32_LEAN_AND_MEAN
  12 #include <windows.h>
  13 #ifdef _WIN64
  14 #define FMT_s "i64u"
  15 #else
  16 #define FMT_s "u"
  17 #endif
  18 #endif
  19
  20 #ifdef _MSC_VER
  21 #pragma warning (disable:4244)
  22 #pragma warning (disable:4996)
  23 #pragma warning (disable:4995)
  24 #define NORETURN __declspec (noreturn)
  25 #define UNUSED
  26 #define OPTIMIZE(n)
  27 #elif defined __GNUC__
  28 #define NORETURN __attribute__ ((noreturn))
  29 #define UNUSED __attribute__ ((unused))
  30 #define OPTIMIZE(n) __attribute__ ((optimize ("O"#n)))
  31 #define GCC_FMT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
  32 #else
  33 #define NORETURN
  34 #define UNUSED
  35 #define OPTIMIZE(n)
  36 #endif
  37
  38 #ifdef __MINGW32__
  39 /* some versions of MingW have non idempotent %p */
  40 #include <inttypes.h>
  41 #define FMT_ptr PRIxPTR
  42 #define FMT_ptr_cast(p) ((intptr_t *) (p))
  43 #define FMT_ptr_cast2(p) ((intptr_t) (p))
  44 #else
  45 #define FMT_ptr "p"
  46 #define FMT_ptr_cast(p) (p)
  47 #define FMT_ptr_cast2(p) (p)
  48 #endif
  49
  50 #ifndef _WIN32
  51 #define FMT_s "zu"
  52 #include <unistd.h>
  53 #endif
  54
  55 #include <regex.h>
  56 #include <ctype.h>
  57 #include <stdarg.h>
  58 #include <limits.h>
  59
  60 #ifndef _WIN32
  61 #include <pthread.h>
  62 #include <sys/time.h>
  63 #include <sys/types.h>
  64 #include <sys/ioctl.h>
  65 #else
  66 static void NORETURN GCC_FMT_ATTR (2, 3)
  67     winerr (int exitcode, const char *fmt, ...)
  68 {
  69     va_list ap;
  70     DWORD savederror = GetLastError ();
  71
  72     va_start (ap, fmt);
  73     vfprintf (stderr, fmt, ap);
  74     va_end (ap);
  75     fprintf (stderr, ": 0x%lx\n",  savederror);
  76     fflush (stderr);
  77     _exit (exitcode);
  78 }
  79 #endif
  80
  81 static void NORETURN GCC_FMT_ATTR (2, 3)
  82     err (int exitcode, const char *fmt, ...)
  83 {
  84     va_list ap;
  85     int savederrno;
  86
  87     savederrno = errno;
  88     va_start (ap, fmt);
  89     vfprintf (stderr, fmt, ap);
  90     va_end (ap);
  91     fprintf (stderr, ": %s\n", strerror (savederrno));
  92     fflush (stderr);
  93     _exit (exitcode);
  94 }
  95
  96 static void NORETURN GCC_FMT_ATTR (2, 3)
  97     errx (int exitcode, const char *fmt, ...)
  98 {
  99     va_list ap;
 100
 101     va_start (ap, fmt);
 102     vfprintf (stderr, fmt, ap);
 103     va_end (ap);
 104     fputc ('\n', stderr);
 105     fflush (stderr);
 106     _exit (exitcode);
 107 }
 108
 109 #ifdef __APPLE__
 110 #include <OpenGL/gl.h>
 111 #else
 112 #include <GL/gl.h>
 113 #endif
 114
 115 #ifndef GL_TEXTURE_RECTANGLE_ARB
 116 #define GL_TEXTURE_RECTANGLE_ARB          0x84F5
 117 #endif
 118
 119 #ifndef GL_BGRA
 120 #define GL_BGRA                           0x80E1
 121 #endif
 122
 123 #ifndef GL_UNSIGNED_INT_8_8_8_8
 124 #define GL_UNSIGNED_INT_8_8_8_8           0x8035
 125 #endif
 126
 127 #ifndef GL_UNSIGNED_INT_8_8_8_8_REV
 128 #define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
 129 #endif
 130
 131 #include <caml/fail.h>
 132 #include <caml/alloc.h>
 133 #include <caml/memory.h>
 134 #include <caml/unixsupport.h>
 135
 136 #include <fitz.h>
 137 #include <mupdf.h>
 138 #include <muxps.h>
 139 #include <mucbz.h>
 140
 141 #include FT_FREETYPE_H
 142
 143 #if 0
 144 #define lprintf printf
 145 #else
 146 #define lprintf(...)
 147 #endif
 148
 149 #define ARSERT(cond) for (;;) {                         \
 150     if (!(cond)) {                                      \
 151         errx (1, "%s:%d " #cond, __FILE__, __LINE__);   \
 152     }                                                   \
 153     break;                                              \
 154 }
 155
 156 struct slice {
 157     int h;
 158     int texindex;
 159 };
 160
 161 struct tile {
 162     int x, y, w, h;
 163     int slicecount;
 164     int sliceheight;
 165     fz_pixmap *pixmap;
 166     struct slice slices[1];
 167 };
 168
 169 struct pagedim {
 170     int pageno;
 171     int rotate;
 172     int left;
 173     int tctmready;
 174     fz_bbox bounds;
 175     fz_rect pagebox;
 176     fz_rect mediabox;
 177     fz_matrix ctm, zoomctm, lctm, tctm;
 178 };
 179
 180 enum { DPDF, DXPS, DCBZ };
 181
 182 struct page {
 183     int gen;
 184     int type;
 185     int pageno;
 186     int pdimno;
 187     fz_text_span *text;
 188     union {
 189         void *ptr;
 190         pdf_page *pdfpage;
 191         xps_page *xpspage;
 192         cbz_page *cbzpage;
 193     } u;
 194     fz_display_list *dlist;
 195     struct mark {
 196         int i;
 197         fz_text_span *span;
 198     } fmark, lmark;
 199     void (*freepage) (void *);
 200 };
 201
 202 struct {
 203 #ifdef _WIN32
 204     HANDLE cr, cw;
 205 #else
 206     int cr, cw;
 207 #endif
 208     int type;
 209     int sliceheight;
 210     struct pagedim *pagedims;
 211     int pagecount;
 212     int pagedimcount;
 213     union {
 214         pdf_document *pdf;
 215         xps_document *xps;
 216         cbz_document *cbz;
 217     } u;
 218     fz_context *ctx;
 219     fz_glyph_cache *cache;
 220     int w, h;
 221
 222     int texindex;
 223     int texcount;
 224     GLuint *texids;
 225
 226     GLenum texiform;
 227     GLenum texform;
 228     GLenum texty;
 229
 230     fz_colorspace *colorspace;
 231
 232     struct {
 233         int w, h;
 234         struct slice *slice;
 235     } *texowners;
 236
 237     int rotate;
 238     int proportional;
 239     int trimmargins;
 240     int needoutline;
 241     int gen;
 242     int aalevel;
 243
 244     int trimanew;
 245     fz_bbox trimfuzz;
 246     fz_pixmap *pig;
 247
 248 #ifdef _WIN32
 249     HANDLE thread;
 250 #else
 251     pthread_t thread;
 252 #endif
 253     FT_Face face;
 254
 255     void (*closedoc) (void);
 256     void (*freepage) (void *);
 257 } state;
 258
 259 static void UNUSED debug_rect (const char *cap, fz_rect r)
 260 {
 261     printf ("%s(rect) %.2f,%.2f,%.2f,%.2f\n", cap, r.x0, r.y0, r.x1, r.y1);
 262 }
 263
 264 static void UNUSED debug_bbox (const char *cap, fz_bbox r)
 265 {
 266     printf ("%s(bbox) %d,%d,%d,%d\n", cap, r.x0, r.y0, r.x1, r.y1);
 267 }
 268
 269 static void UNUSED debug_matrix (const char *cap, fz_matrix m)
 270 {
 271     printf ("%s(matrix) %.2f,%.2f,%.2f,%.2f %.2f %.2f\n", cap,
 272             m.a, m.b, m.c, m.d, m.e, m.f);
 273 }
 274
 275 #ifdef _WIN32
 276 static CRITICAL_SECTION critsec;
 277
 278 static void lock (void *unused)
 279 {
 280     (void) unused;
 281     EnterCriticalSection (&critsec);
 282 }
 283
 284 static void unlock (void *unused)
 285 {
 286     (void) unused;
 287     LeaveCriticalSection (&critsec);
 288 }
 289
 290 static int trylock (void *unused)
 291 {
 292     return TryEnterCriticalSection (&critsec) == 0;
 293 }
 294 #else
 295 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 296
 297 static void lock (const char *cap)
 298 {
 299     int ret = pthread_mutex_lock (&mutex);
 300     if (ret) {
 301         errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
 302     }
 303 }
 304
 305 static void unlock (const char *cap)
 306 {
 307     int ret = pthread_mutex_unlock (&mutex);
 308     if (ret) {
 309         errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
 310     }
 311 }
 312
 313 static int trylock (const char *cap)
 314 {
 315     int ret = pthread_mutex_trylock (&mutex);
 316
 317     if (ret && ret != EBUSY) {
 318         errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
 319     }
 320     return ret == EBUSY;
 321 }
 322 #endif
 323
 324 static void *parse_pointer (const char *cap, const char *s)
 325 {
 326     int ret;
 327     void *ptr;
 328
 329     ret = sscanf (s, "%" FMT_ptr, FMT_ptr_cast (&ptr));
 330     if (ret != 1) {
 331         errx (1, "%s: cannot parse pointer in `%s'", cap, s);
 332     }
 333     return ptr;
 334 }
 335
 336 #ifdef _WIN32
 337 static double now (void)
 338 {
 339     FILETIME ft;
 340     uint64 tmp;
 341
 342     GetSystemTimeAsFileTime (&ft);
 343     tmp = ft.dwHighDateTime;
 344     tmp <<= 32;
 345     tmp |= ft.dwLowDateTime;
 346     return tmp * 1e-7;
 347 }
 348
 349 static int hasdata (void)
 350 {
 351     DWORD ret;
 352
 353     ret = WaitForSingleObject (state.cr, 0);
 354     if (ret != WAIT_OBJECT_0 && ret != WAIT_TIMEOUT) {
 355         winerr (1, "hasdata, WaitForSingleObject ret=%d", ret);
 356     }
 357     return ret == WAIT_OBJECT_0;
 358 }
 359
 360 static void readdata (char *p, int size)
 361 {
 362     BOOL okay;
 363     DWORD nread;
 364
 365     okay = ReadFile (state.cr, p, size, &nread, NULL);
 366     if (!okay || nread - size) {
 367         err (1, "ReadFile (req %d, okay %d, ret %ld)", size, okay, nread);
 368     }
 369 }
 370
 371 static int readlen (void)
 372 {
 373     unsigned char p[4];
 374
 375     readdata (p, 4);
 376     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 377 }
 378
 379 static void writedata (char *p, int size)
 380 {
 381     BOOL okay;
 382     char buf[4];
 383     DWORD nwritten;
 384
 385     buf[0] = (size >> 24) & 0xff;
 386     buf[1] = (size >> 16) & 0xff;
 387     buf[2] = (size >>  8) & 0xff;
 388     buf[3] = (size >>  0) & 0xff;
 389
 390     okay = WriteFile (state.cw, buf, 4, &nwritten, NULL);
 391     if (!okay || nwritten != 4) {
 392         winerr (1, "WriteFile okay %d ret %ld", okay, nwritten);
 393     }
 394
 395     okay = WriteFile (state.cw, p, size, &nwritten, NULL);
 396     if (!okay || nwritten - size) {
 397         winerr (1, "WriteFile (req %d, okay %d, ret %ld)",
 398                 size, okay, nwritten);
 399     }
 400 }
 401 #else
 402 static double now (void)
 403 {
 404     struct timeval tv;
 405
 406     if (gettimeofday (&tv, NULL)) {
 407         err (1, "gettimeofday");
 408     }
 409     return tv.tv_sec + tv.tv_usec*1e-6;
 410 }
 411
 412 static int hasdata (void)
 413 {
 414     int ret;
 415     int avail;
 416     ret = ioctl (state.cr, FIONREAD, &avail);
 417     if (ret) err (1, "hasdata: FIONREAD error ret=%d", ret);
 418     return avail > 0;
 419 }
 420
 421 static void readdata (void *p, int size)
 422 {
 423     ssize_t n;
 424
 425     n = read (state.cr, p, size);
 426     if (n - size) {
 427         if (!n) errx (1, "EOF while reading");
 428         err (1, "read (req %d, ret %zd)", size, n);
 429     }
 430 }
 431
 432 static int readlen (void)
 433 {
 434     unsigned char p[4];
 435
 436     readdata (p, 4);
 437     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 438 }
 439
 440 static void writedata (char *p, int size)
 441 {
 442     char buf[4];
 443     ssize_t n;
 444
 445     buf[0] = (size >> 24) & 0xff;
 446     buf[1] = (size >> 16) & 0xff;
 447     buf[2] = (size >>  8) & 0xff;
 448     buf[3] = (size >>  0) & 0xff;
 449
 450     n = write (state.cw, buf, 4);
 451     if (n != 4) {
 452         if (!n) errx (1, "EOF while writing length");
 453         err (1, "write %zd", n);
 454     }
 455
 456     n = write (state.cw, p, size);
 457     if (n - size) {
 458         if (!n) errx (1, "EOF while writing data");
 459         err (1, "write (req %d, ret %zd)", size, n);
 460     }
 461 }
 462 #endif
 463
 464 static void GCC_FMT_ATTR (1, 2) printd (const char *fmt, ...)
 465 {
 466     int size = 200, len;
 467     va_list ap;
 468     char *buf;
 469
 470     buf = malloc (size);
 471     for (;;) {
 472         if (!buf) err (errno, "malloc for temp buf (%d bytes) failed", size);
 473
 474         va_start (ap, fmt);
 475         len = vsnprintf (buf, size, fmt, ap);
 476         va_end (ap);
 477
 478         if (len > -1 && len < size) {
 479             writedata (buf, len);
 480             break;
 481         }
 482
 483         if (len > -1) {
 484             size = len + 1;
 485         }
 486         else  {
 487             size *= 2;
 488         }
 489         buf = realloc (buf, size);
 490     }
 491     free (buf);
 492 }
 493
 494 static void closepdf (void)
 495 {
 496     if (state.u.pdf) {
 497         pdf_close_document (state.u.pdf);
 498         state.u.pdf = NULL;
 499     }
 500 }
 501
 502 static void closexps (void)
 503 {
 504     if (state.u.xps) {
 505         xps_close_document (state.u.xps);
 506         state.u.xps = NULL;
 507     }
 508 }
 509
 510 static void closecbz (void)
 511 {
 512     if (state.u.cbz) {
 513         cbz_close_document (state.u.cbz);
 514         state.u.cbz = NULL;
 515     }
 516 }
 517
 518 static void freepdfpage (void *ptr)
 519 {
 520     pdf_free_page (state.u.pdf, ptr);
 521 }
 522
 523 static void freexpspage (void *ptr)
 524 {
 525     xps_free_page (state.u.xps, ptr);
 526 }
 527
 528 static void freecbzpage (void *ptr)
 529 {
 530     cbz_free_page (state.u.cbz, ptr);
 531 }
 532
 533 static void openxref (char *filename, char *password)
 534 {
 535     int i, len;
 536
 537     for (i = 0; i < state.texcount; ++i)  {
 538         state.texowners[i].w = -1;
 539         state.texowners[i].slice = NULL;
 540     }
 541
 542     if (state.closedoc) state.closedoc ();
 543
 544     len = strlen (filename);
 545
 546     state.type = DPDF;
 547     if (len > 4) {
 548         char ext[4];
 549
 550         ext[0] = tolower (filename[len-3]);
 551         ext[1] = tolower (filename[len-2]);
 552         ext[2] = tolower (filename[len-1]);
 553
 554         /**/ if (ext[0] == 'x' && ext[1] == 'p' && ext[2] == 's') {
 555             state.type = DXPS;
 556         }
 557         else if (ext[0] == 'c' && ext[1] == 'b' && ext[2] == 'z') {
 558             state.type = DCBZ;
 559         }
 560     }
 561
 562     if (state.pagedims) {
 563         free (state.pagedims);
 564         state.pagedims = NULL;
 565     }
 566     state.pagedimcount = 0;
 567
 568     fz_set_aa_level (state.ctx, state.aalevel);
 569     switch (state.type) {
 570     case DPDF:
 571         state.u.pdf = pdf_open_document (state.ctx, filename);
 572         if (pdf_needs_password (state.u.pdf)) {
 573             int okay = pdf_authenticate_password (state.u.pdf, password);
 574             if (!okay) {
 575                 errx (1, "invalid password");
 576             }
 577         }
 578         state.pagecount = pdf_count_pages (state.u.pdf);
 579         state.closedoc = closepdf;
 580         state.freepage = freepdfpage;
 581         break;
 582
 583     case DXPS:
 584         state.u.xps = xps_open_document (state.ctx, filename);
 585         state.pagecount = xps_count_pages (state.u.xps);
 586         state.closedoc = closexps;
 587         state.freepage = freexpspage;
 588         break;
 589
 590     case DCBZ:
 591         state.u.cbz = cbz_open_document (state.ctx, filename);
 592         state.pagecount = cbz_count_pages (state.u.cbz);
 593         state.closedoc = closecbz;
 594         state.freepage = freecbzpage;
 595         break;
 596     }
 597 }
 598
 599 static void pdfinfo (void)
 600 {
 601     if (state.type == DPDF) {
 602         fz_obj *infoobj;
 603
 604         printd ("info PDF version\t%d.%d",
 605                 state.u.pdf->version / 10, state.u.pdf->version % 10);
 606
 607         infoobj = fz_dict_gets (state.u.pdf->trailer, "Info");
 608         if (infoobj) {
 609             int i;
 610             char *s;
 611             char *items[] = { "Title", "Author", "Creator",
 612                               "Producer", "CreationDate" };
 613
 614             for (i = 0; i < sizeof (items) / sizeof (*items); ++i) {
 615                 fz_obj *obj = fz_dict_gets (infoobj, items[i]);
 616                 s = pdf_to_utf8 (state.ctx, obj);
 617                 if (*s) {
 618                     if (i == 0) {
 619                         printd ("title %s", s);
 620                     }
 621                     printd ("info %s\t%s", items[i], s);
 622                 }
 623                 fz_free (state.ctx, s);
 624             }
 625         }
 626         printd ("infoend");
 627     }
 628 }
 629
 630 static void unlinktile (struct tile *tile)
 631 {
 632     int i;
 633
 634     for (i = 0; i < tile->slicecount; ++i) {
 635         struct slice *s = &tile->slices[i];
 636
 637         if (s->texindex != -1) {
 638             if (state.texowners[s->texindex].slice == s) {
 639                 state.texowners[s->texindex].slice = NULL;
 640             }
 641         }
 642     }
 643 }
 644
 645 static void freepage (struct page *page)
 646 {
 647     if (page->text) {
 648         fz_free_text_span (state.ctx, page->text);
 649     }
 650     page->freepage (page->u.ptr);
 651     fz_free_display_list (state.ctx, page->dlist);
 652     free (page);
 653 }
 654
 655 static void freetile (struct tile *tile)
 656 {
 657     unlinktile (tile);
 658 #ifndef PIGGYBACK
 659     fz_drop_pixmap (state.ctx, tile->pixmap);
 660 #else
 661     if (state.pig) {
 662         fz_drop_pixmap (state.ctx, state.pig);
 663     }
 664     state.pig = tile->pixmap;
 665 #endif
 666     free (tile);
 667 }
 668
 669 #ifdef __ALTIVEC__
 670 #include <altivec.h>
 671
 672 static int cacheline32bytes;
 673 extern char **environ;
 674
 675 static void __attribute__ ((constructor)) clcheck (void)
 676 {
 677     char **envp = environ;
 678     unsigned long *auxv;
 679
 680     while (*envp++);
 681
 682     for (auxv = (unsigned long *) envp; *auxv != 0; auxv += 2) {
 683         if (*auxv == 19) {
 684             cacheline32bytes = auxv[1] == 32;
 685             return;
 686         }
 687     }
 688 }
 689
 690 static void OPTIMIZE (3) clearpixmap (fz_pixmap *pixmap)
 691 {
 692     if (cacheline32bytes) {
 693         intptr_t a1, a2, diff;
 694         size_t sizea, i, size = pixmap->w * pixmap->h * pixmap->n;
 695         vector unsigned char v = vec_splat_u8 (-1);
 696         vector unsigned char *p;
 697
 698         a1 = a2 = (intptr_t) pixmap->samples;
 699         a2 = (a1 + 31) & ~31;
 700         diff = a2 - a1;
 701         sizea = size - diff;
 702         p = (void *) a2;
 703
 704         while (a1 != a2) *(char *) a1++ = 0xff;
 705         for (i = 0; i < (sizea & ~31); i += 32)  {
 706             __asm volatile ("dcbz %0, %1"::"b"(a2),"r"(i));
 707             vec_st (v, i, p);
 708             vec_st (v, i + 16, p);
 709         }
 710         while (i < sizea) *((char *) a1 + i++) = 0xff;
 711     }
 712     else fz_clear_pixmap_with_value (state.ctx, pixmap, 0xff);
 713 }
 714 #else
 715 #define clearpixmap(p) fz_clear_pixmap_with_value (state.ctx, p, 0xff)
 716 #endif
 717
 718 static fz_matrix trimctm (pdf_page *page, int pindex)
 719 {
 720     fz_matrix ctm;
 721     struct pagedim *pdim = &state.pagedims[pindex];
 722
 723     if (!pdim->tctmready) {
 724         if (state.trimmargins) {
 725             fz_rect realbox;
 726
 727             ctm = fz_concat (fz_rotate (-pdim->rotate), fz_scale (1, -1));
 728             realbox = fz_transform_rect (ctm, pdim->mediabox);
 729             ctm = fz_concat (ctm, fz_translate (-realbox.x0, -realbox.y0));
 730             ctm = fz_concat (fz_invert_matrix (page->ctm), ctm);
 731         }
 732         else {
 733             ctm = fz_identity;
 734         }
 735         pdim->tctm = ctm;
 736         pdim->tctmready = 1;
 737     }
 738     return pdim->tctm;
 739 }
 740
 741 static fz_matrix pagectm (struct page *page)
 742 {
 743     if (page->type == DPDF) {
 744         return fz_concat (trimctm (page->u.pdfpage, page->pdimno),
 745                           state.pagedims[page->pdimno].ctm);
 746     }
 747     else {
 748         fz_matrix ctm;
 749         struct pagedim *pdim = &state.pagedims[page->pdimno];
 750
 751         ctm = state.pagedims[page->pdimno].ctm;
 752         ctm = fz_concat (fz_translate (-pdim->mediabox.x0,
 753                                        -pdim->mediabox.y0), ctm);
 754         return ctm;
 755     }
 756 }
 757
 758 static void *loadpage (int pageno, int pindex)
 759 {
 760     fz_device *dev;
 761     struct page *page = NULL;
 762
 763     page = calloc (sizeof (struct page), 1);
 764     if (!page) {
 765         err (1, "calloc page %d", pageno);
 766     }
 767
 768     page->dlist = fz_new_display_list (state.ctx);
 769     dev = fz_new_list_device (state.ctx, page->dlist);
 770     switch (state.type) {
 771     case DPDF:
 772         page->u.pdfpage = pdf_load_page (state.u.pdf, pageno);
 773         pdf_run_page (state.u.pdf, page->u.pdfpage, dev, fz_identity, NULL);
 774         page->freepage = freepdfpage;
 775         break;
 776
 777     case DXPS:
 778         page->u.xpspage = xps_load_page (state.u.xps, pageno);
 779         xps_run_page (state.u.xps, page->u.xpspage, dev, fz_identity, NULL);
 780         page->freepage = freexpspage;
 781         break;
 782
 783     case DCBZ:
 784         page->u.cbzpage = cbz_load_page (state.u.cbz, pageno);
 785         cbz_run_page (state.u.cbz, page->u.cbzpage, dev, fz_identity, NULL);
 786         page->freepage = freecbzpage;
 787         break;
 788     }
 789     fz_free_device (dev);
 790
 791     page->pdimno = pindex;
 792     page->pageno = pageno;
 793     page->gen = state.gen;
 794     page->type = state.type;
 795
 796     return page;
 797 }
 798
 799 static struct tile *alloctile (int h)
 800 {
 801     int i;
 802     int slicecount;
 803     size_t tilesize;
 804     struct tile *tile;
 805
 806     slicecount = (h + state.sliceheight - 1) / state.sliceheight;
 807     tilesize = sizeof (*tile) + ((slicecount - 1) * sizeof (struct slice));
 808     tile = calloc (tilesize, 1);
 809     if (!tile) {
 810         err (1, "can not allocate tile (%" FMT_s " bytes)", tilesize);
 811     }
 812     for (i = 0; i < slicecount; ++i) {
 813         int sh = MIN (h, state.sliceheight);
 814         tile->slices[i].h = sh;
 815         tile->slices[i].texindex = -1;
 816         h -= sh;
 817     }
 818     tile->slicecount = slicecount;
 819     tile->sliceheight = state.sliceheight;
 820     return tile;
 821 }
 822
 823 static struct tile *rendertile (struct page *page, int x, int y, int w, int h)
 824 {
 825     fz_bbox bbox;
 826     fz_device *dev;
 827     struct tile *tile;
 828     struct pagedim *pdim;
 829
 830     tile = alloctile (h);
 831     pdim = &state.pagedims[page->pdimno];
 832
 833     bbox = pdim->bounds;
 834     bbox.x0 += x;
 835     bbox.y0 += y;
 836     bbox.x1 = bbox.x0 + w;
 837     bbox.y1 = bbox.y0 + h;
 838
 839     if (state.pig) {
 840         if (state.pig->w == w
 841             && state.pig->h == h
 842             && state.pig->colorspace == state.colorspace) {
 843             tile->pixmap = state.pig;
 844             tile->pixmap->x = bbox.x0;
 845             tile->pixmap->y = bbox.y0;
 846         }
 847         else {
 848             fz_drop_pixmap (state.ctx, state.pig);
 849         }
 850         state.pig = NULL;
 851     }
 852     if (!tile->pixmap) {
 853         tile->pixmap =
 854             fz_new_pixmap_with_rect (state.ctx, state.colorspace, bbox);
 855     }
 856
 857     tile->w = w;
 858     tile->h = h;
 859     clearpixmap (tile->pixmap);
 860     dev = fz_new_draw_device (state.ctx, tile->pixmap);
 861     fz_run_display_list (page->dlist, dev, pagectm (page), bbox, NULL);
 862     fz_free_device (dev);
 863
 864     return tile;
 865 }
 866
 867 static void initpdims (void)
 868 {
 869     int pageno;
 870     double start, end;
 871
 872     start = now ();
 873     for (pageno = 0; pageno < state.pagecount; ++pageno) {
 874         int rotate;
 875         fz_obj *pageobj;
 876         struct pagedim *p;
 877         fz_rect mediabox;
 878
 879         switch (state.type) {
 880         case DPDF:
 881             pageobj = state.u.pdf->page_objs[pageno];
 882
 883             if (state.trimmargins) {
 884                 fz_obj *obj;
 885                 pdf_page *page;
 886
 887                 page = pdf_load_page (state.u.pdf, pageno);
 888                 obj = fz_dict_gets (pageobj, "llpp.TrimBox");
 889                 if (state.trimanew || !obj) {
 890                     fz_rect rect;
 891                     fz_bbox bbox;
 892                     fz_matrix ctm;
 893                     fz_device *dev;
 894
 895                     dev = fz_new_bbox_device (state.ctx, &bbox);
 896                     dev->hints |= FZ_IGNORE_SHADE;
 897                     ctm = fz_invert_matrix (page->ctm);
 898                     pdf_run_page (state.u.pdf, page, dev, fz_identity, NULL);
 899                     fz_free_device (dev);
 900
 901                     rect.x0 = bbox.x0 + state.trimfuzz.x0;
 902                     rect.x1 = bbox.x1 + state.trimfuzz.x1;
 903                     rect.y0 = bbox.y0 + state.trimfuzz.y0;
 904                     rect.y1 = bbox.y1 + state.trimfuzz.y1;
 905                     rect = fz_transform_rect (ctm, rect);
 906                     rect = fz_intersect_rect (rect, page->mediabox);
 907
 908                     if (fz_is_empty_rect (rect)) {
 909                         mediabox = page->mediabox;
 910                     }
 911                     else {
 912                         mediabox = rect;
 913                     }
 914
 915                     obj = fz_new_array (state.ctx, 4);
 916                     fz_array_push (obj, fz_new_real (state.ctx, mediabox.x0));
 917                     fz_array_push (obj, fz_new_real (state.ctx, mediabox.y0));
 918                     fz_array_push (obj, fz_new_real (state.ctx, mediabox.x1));
 919                     fz_array_push (obj, fz_new_real (state.ctx, mediabox.y1));
 920                     fz_dict_puts (pageobj, "llpp.TrimBox", obj);
 921                 }
 922                 else {
 923                     mediabox.x0 = fz_to_real (fz_array_get (obj, 0));
 924                     mediabox.y0 = fz_to_real (fz_array_get (obj, 1));
 925                     mediabox.x1 = fz_to_real (fz_array_get (obj, 2));
 926                     mediabox.y1 = fz_to_real (fz_array_get (obj, 3));
 927                 }
 928
 929                 rotate = page->rotate;
 930                 pdf_free_page (state.u.pdf, page);
 931
 932                 printd ("progress %f Trimming %d",
 933                         (double) (pageno + 1) / state.pagecount,
 934                         pageno + 1);
 935             }
 936             else {
 937                 fz_rect cropbox;
 938
 939                 mediabox = pdf_to_rect (state.ctx,
 940                                         fz_dict_gets (pageobj, "MediaBox"));
 941                 if (fz_is_empty_rect (mediabox)) {
 942                     fprintf (stderr, "cannot find page size for page %d\n",
 943                              pageno+1);
 944                     mediabox.x0 = 0;
 945                     mediabox.y0 = 0;
 946                     mediabox.x1 = 612;
 947                     mediabox.y1 = 792;
 948                 }
 949
 950                 cropbox = pdf_to_rect (state.ctx,
 951                                        fz_dict_gets (pageobj, "CropBox"));
 952                 if (!fz_is_empty_rect (cropbox)) {
 953                     mediabox = fz_intersect_rect (mediabox, cropbox);
 954                 }
 955                 rotate = fz_to_int (fz_dict_gets (pageobj, "Rotate"));
 956             }
 957             break;
 958
 959         case DXPS:
 960             {
 961                 xps_page *page;
 962
 963                 page = xps_load_page (state.u.xps, pageno);
 964                 mediabox = xps_bound_page (state.u.xps, page);
 965                 rotate = 0;
 966                 if (state.trimmargins) {
 967                     fz_rect rect;
 968                     fz_bbox bbox;
 969                     fz_device *dev;
 970
 971                     dev = fz_new_bbox_device (state.ctx, &bbox);
 972                     dev->hints |= FZ_IGNORE_SHADE;
 973                     xps_run_page (state.u.xps, page, dev, fz_identity, NULL);
 974                     fz_free_device (dev);
 975
 976                     rect.x0 = bbox.x0 + state.trimfuzz.x0;
 977                     rect.x1 = bbox.x1 + state.trimfuzz.x1;
 978                     rect.y0 = bbox.y0 + state.trimfuzz.y0;
 979                     rect.y1 = bbox.y1 + state.trimfuzz.y1;
 980                     rect = fz_intersect_rect (rect, mediabox);
 981
 982                     if (!fz_is_empty_rect (rect)) {
 983                         mediabox = rect;
 984                     }
 985                 }
 986                 xps_free_page (state.u.xps, page);
 987                 printd ("progress %f loading %d",
 988                         (double) (pageno + 1) / state.pagecount,
 989                         pageno + 1);
 990             }
 991             break;
 992
 993         case DCBZ:
 994             {
 995                 rotate = 0;
 996                 if (state.trimmargins) {
 997                     cbz_page *page;
 998
 999                     page = cbz_load_page (state.u.cbz, pageno);
1000                     mediabox = cbz_bound_page (state.u.cbz, page);
1001                     cbz_free_page (state.u.cbz, page);
1002                     printd ("progress %f Trimming %d",
1003                             (double) (pageno + 1) / state.pagecount,
1004                             pageno + 1);
1005                 }
1006                 else {
1007                     mediabox.x0 = mediabox.y0 = 0;
1008                     mediabox.x1 = 900;
1009                     mediabox.y1 = 900;
1010                 }
1011             }
1012             break;
1013
1014         default:
1015             ARSERT (0 && state.type);
1016         }
1017
1018         if (state.pagedimcount == 0
1019             || (p = &state.pagedims[state.pagedimcount-1], p->rotate != rotate)
1020             || memcmp (&p->mediabox, &mediabox, sizeof (mediabox))) {
1021             size_t size;
1022
1023             size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
1024             state.pagedims = realloc (state.pagedims, size);
1025             if (!state.pagedims) {
1026                 err (1, "realloc pagedims to %" FMT_s " (%d elems)",
1027                      size, state.pagedimcount + 1);
1028             }
1029
1030             p = &state.pagedims[state.pagedimcount++];
1031             p->rotate = rotate;
1032             p->mediabox = mediabox;
1033             p->pageno = pageno;
1034         }
1035     }
1036     end = now ();
1037     if (state.trimmargins) {
1038         printd ("progress 1 Trimmed %d pages in %f seconds",
1039                 state.pagecount, end - start);
1040     }
1041     else {
1042         printd ("vmsg Processed %d pages in %f seconds",
1043                 state.pagecount, end - start);
1044     }
1045     state.trimanew = 0;
1046 }
1047
1048 static void layout (void)
1049 {
1050     int pindex;
1051     fz_rect box;
1052     fz_matrix ctm;
1053     double zoom, w, maxw = 0;
1054     struct pagedim *p = state.pagedims;
1055
1056     if (state.proportional) {
1057         for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
1058             box = fz_transform_rect (fz_rotate (p->rotate + state.rotate),
1059                                      p->mediabox);
1060             w = box.x1 - box.x0;
1061             maxw = MAX (w, maxw);
1062         }
1063     }
1064
1065     p = state.pagedims;
1066     for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
1067         fz_bbox bbox;
1068
1069         ctm = fz_rotate (state.rotate);
1070         box = fz_transform_rect (fz_rotate (p->rotate + state.rotate),
1071                                  p->mediabox);
1072         w = box.x1 - box.x0;
1073
1074         if (state.proportional) {
1075             double scale = w / maxw;
1076             zoom = (state.w / w) * scale;
1077         }
1078         else {
1079             zoom = state.w / w;
1080         }
1081
1082         p->zoomctm = fz_scale (zoom, zoom);
1083         ctm = fz_concat (p->zoomctm, ctm);
1084
1085         p->pagebox = fz_transform_rect (fz_rotate (p->rotate), p->mediabox);
1086         p->pagebox.x1 -= p->pagebox.x0;
1087         p->pagebox.y1 -= p->pagebox.y0;
1088         p->pagebox.x0 = 0;
1089         p->pagebox.y0 = 0;
1090         bbox = fz_round_rect (fz_transform_rect (ctm, p->pagebox));
1091
1092         p->bounds = bbox;
1093         p->left = state.proportional ? ((maxw - w) * zoom) / 2.0 : 0;
1094         p->ctm = ctm;
1095
1096         ctm = fz_identity;
1097         ctm = fz_concat (ctm, fz_translate (0, -p->mediabox.y1));
1098         ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
1099         ctm = fz_concat (ctm, fz_rotate (p->rotate + state.rotate));
1100         p->lctm = ctm;
1101
1102         p->tctmready = 0;
1103     }
1104
1105     while (p-- != state.pagedims)  {
1106         int w = p->bounds.x1 - p->bounds.x0;
1107         int h = p->bounds.y1 - p->bounds.y0;
1108
1109         printd ("pdim %d %d %d %d", p->pageno, w, h, p->left);
1110     }
1111 }
1112
1113 static void recurse_outline (fz_outline *outline, int level)
1114 {
1115     while (outline) {
1116         fz_link_dest *dest;
1117         int i, top = 0;
1118         struct pagedim *pdim = state.pagedims;
1119
1120         dest = &outline->dest;
1121         for (i = 0; i < state.pagedimcount; ++i) {
1122             if (state.pagedims[i].pageno > dest->ld.gotor.page)
1123                 break;
1124             pdim = &state.pagedims[i];
1125         }
1126         if (dest->ld.gotor.flags & fz_link_flag_t_valid) {
1127             fz_point p;
1128             p.x = 0;
1129             p.y = dest->ld.gotor.lt.y;
1130             p = fz_transform_point (pdim->lctm, p);
1131             top = p.y;
1132         }
1133         if (dest->ld.gotor.page >= 0 && dest->ld.gotor.page < 1<<30) {
1134             int h;
1135             double y0, y1;
1136
1137             y0 = MIN (pdim->bounds.y0, pdim->bounds.y1);
1138             y1 = MAX (pdim->bounds.y0, pdim->bounds.y1);
1139             h = y1 - y0;
1140             printd ("o %d %d %d %d %s",
1141                     level, dest->ld.gotor.page, top, h, outline->title);
1142         }
1143         if (outline->down) {
1144             recurse_outline (outline->down, level + 1);
1145         }
1146         outline = outline->next;
1147     }
1148 }
1149
1150 static void process_outline (void)
1151 {
1152     fz_outline *outline;
1153
1154     if (!state.needoutline) return;
1155
1156     state.needoutline = 0;
1157     switch (state.type) {
1158     case DPDF:
1159         outline = pdf_load_outline (state.u.pdf);
1160         break;
1161     case DXPS:
1162         outline = xps_load_outline (state.u.xps);
1163         break;
1164     default:
1165         outline = NULL;
1166         break;
1167     }
1168     if (outline) {
1169         recurse_outline (outline, 0);
1170         fz_free_outline (state.ctx, outline);
1171     }
1172 }
1173
1174 static int comparespans (const void *l, const void *r)
1175 {
1176     fz_text_span const *const*ls = l;
1177     fz_text_span const *const*rs = r;
1178     return (*ls)->text->bbox.y0 - (*rs)->text->bbox.y0;
1179 }
1180
1181 /* wishful thinking function */
1182 static void search (regex_t *re, int pageno, int y, int forward)
1183 {
1184     int i, j;
1185     int ret;
1186     char *p;
1187     char buf[256];
1188     fz_matrix ctm;
1189     fz_device *tdev;
1190     union { void *ptr; pdf_page *pdfpage; xps_page *xpspage; } u;
1191     fz_text_span *text, *span, **pspan;
1192     struct pagedim *pdim, *pdimprev;
1193     int stop = 0;
1194     int niters = 0;
1195     int nspans;
1196     double start, end;
1197
1198     if (!(state.type == DPDF || state.type == DXPS))
1199         return;
1200
1201     start = now ();
1202     while (pageno >= 0 && pageno < state.pagecount && !stop) {
1203         if (niters++ == 5) {
1204             niters = 0;
1205             if (hasdata ()) {
1206                 printd ("progress 1 attention requested aborting search at %d",
1207                         pageno);
1208                 stop = 1;
1209             }
1210             else {
1211                 printd ("progress %f searching in page %d",
1212                         (double) (pageno + 1) / state.pagecount,
1213                         pageno);
1214             }
1215         }
1216         pdimprev = NULL;
1217         for (i = 0; i < state.pagedimcount; ++i) {
1218             pdim = &state.pagedims[i];
1219             if (pdim->pageno == pageno)  {
1220                 goto found;
1221             }
1222             if (pdim->pageno > pageno) {
1223                 pdim = pdimprev;
1224                 goto found;
1225             }
1226             pdimprev = pdim;
1227         }
1228         pdim = pdimprev;
1229     found:
1230
1231         text = fz_new_text_span (state.ctx);
1232         tdev = fz_new_text_device (state.ctx, text);
1233
1234         switch (state.type) {
1235         case DPDF:
1236             u.pdfpage = pdf_load_page (state.u.pdf, pageno);
1237             pdf_run_page (state.u.pdf, u.pdfpage, tdev, fz_identity, NULL);
1238             break;
1239
1240         case DXPS:
1241             u.xpspage = xps_load_page (state.u.xps, pageno);
1242             xps_run_page (state.u.xps, u.xpspage, tdev, fz_identity, NULL);
1243             break;
1244
1245         default:
1246             ARSERT (0 && state.type);
1247         }
1248
1249         fz_free_device (tdev);
1250
1251         nspans = 0;
1252         for (span = text; span; span = span->next) {
1253             nspans++;
1254         }
1255         pspan = malloc (sizeof (void *) * nspans);
1256         if (!pspan) {
1257             err (1, "malloc span pointers %" FMT_s, sizeof (void *) * nspans);
1258         }
1259         for (i = 0, span = text; span; span = span->next, ++i) {
1260             pspan[i] = span;
1261         }
1262         qsort (pspan, nspans, sizeof (fz_text_span *), comparespans);
1263
1264         j = forward ? 0 : nspans - 1;
1265         while (nspans--) {
1266             regmatch_t rm;
1267
1268             span = pspan[j];
1269             j += forward ? 1 : -1;
1270             p = buf;
1271             for (i = 0; i < MIN (span->len, (int) sizeof (buf) - 1); ++i) {
1272                 if (forward) {
1273                     if (span->text[i].bbox.y0 < y + 1) {
1274                         continue;
1275                     }
1276                 }
1277                 else {
1278                     if (span->text[i].bbox.y0 > y - 1) {
1279                         continue;
1280                     }
1281                 }
1282                 if (span->text[i].c < 256) {
1283                     *p++ = span->text[i].c;
1284                 }
1285                 else  {
1286                     *p++ = '?';
1287                 }
1288             }
1289             if (p == buf) {
1290                 continue;
1291             }
1292             *p++ = 0;
1293
1294             ret = regexec (re, buf, 1, &rm, 0);
1295             if (ret)  {
1296                 if (ret != REG_NOMATCH) {
1297                     size_t size;
1298                     char errbuf[80];
1299                     size = regerror (ret, re, errbuf, sizeof (errbuf));
1300                     printd ("msg regexec error `%.*s'",
1301                             (int) size, errbuf);
1302                     fz_free_text_span (state.ctx, text);
1303                     state.freepage (u.ptr);
1304                     free (pspan);
1305                     return;
1306                 }
1307             }
1308             else  {
1309                 fz_bbox *sb, *eb;
1310                 fz_point p1, p2, p3, p4;
1311
1312                 sb = &span->text[rm.rm_so].bbox;
1313                 eb = &span->text[rm.rm_eo - 1].bbox;
1314
1315                 p1.x = sb->x0;
1316                 p1.y = sb->y0;
1317                 p2.x = eb->x1;
1318                 p2.y = sb->y0;
1319                 p3.x = eb->x1;
1320                 p3.y = eb->y1;
1321                 p4.x = sb->x0;
1322                 p4.y = eb->y1;
1323
1324                 switch (state.type) {
1325                 case DPDF:
1326                     trimctm (u.pdfpage, pdim - state.pagedims);
1327                     ctm = fz_concat (pdim->tctm, pdim->zoomctm);
1328                     break;
1329
1330                 case DXPS:
1331                     ctm = pdim->ctm;
1332                     break;
1333                 }
1334
1335                 p1 = fz_transform_point (ctm, p1);
1336                 p2 = fz_transform_point (ctm, p2);
1337                 p3 = fz_transform_point (ctm, p3);
1338                 p4 = fz_transform_point (ctm, p4);
1339
1340                 if (!stop) {
1341                     printd ("firstmatch %d %d %f %f %f %f %f %f %f %f",
1342                             pageno, 1,
1343                             p1.x, p1.y,
1344                             p2.x, p2.y,
1345                             p3.x, p3.y,
1346                             p4.x, p4.y);
1347
1348                     printd ("progress 1 found at %d `%.*s' in %f sec",
1349                             pageno, (int) (rm.rm_eo - rm.rm_so), &buf[rm.rm_so],
1350                             now () - start);
1351                 }
1352                 else  {
1353                     printd ("match %d %d %f %f %f %f %f %f %f %f",
1354                             pageno, 2,
1355                             p1.x, p1.y,
1356                             p2.x, p2.y,
1357                             p3.x, p3.y,
1358                             p4.x, p4.y);
1359                 }
1360                 stop = 1;
1361             }
1362         }
1363         if (forward) {
1364             pageno += 1;
1365             y = 0;
1366         }
1367         else {
1368             pageno -= 1;
1369             y = INT_MAX;
1370         }
1371         fz_free_text_span (state.ctx, text);
1372         state.freepage (u.ptr);
1373         free (pspan);
1374     }
1375     end = now ();
1376     if (!stop)  {
1377         printd ("progress 1 no matches %f sec", end - start);
1378     }
1379     printd ("clearrects");
1380 }
1381
1382 static void set_tex_params (int colorspace)
1383 {
1384     switch (colorspace) {
1385     case 0:
1386         state.texiform = GL_RGBA8;
1387         state.texform = GL_RGBA;
1388         state.texty = GL_UNSIGNED_BYTE;
1389         state.colorspace = fz_device_rgb;
1390         break;
1391     case 1:
1392         state.texiform = GL_RGBA8;
1393         state.texform = GL_BGRA;
1394         state.texty = fz_is_big_endian ()
1395             ? GL_UNSIGNED_INT_8_8_8_8
1396             : GL_UNSIGNED_INT_8_8_8_8_REV;
1397         state.colorspace = fz_device_bgr;
1398         break;
1399     case 2:
1400         state.texiform = GL_LUMINANCE_ALPHA;
1401         state.texform = GL_LUMINANCE_ALPHA;
1402         state.texty = GL_UNSIGNED_BYTE;
1403         state.colorspace = fz_device_gray;
1404         break;
1405     default:
1406         errx (1, "invalid colorspce %d", colorspace);
1407     }
1408 }
1409
1410 static void realloctexts (int texcount)
1411 {
1412     size_t size;
1413
1414     if (texcount == state.texcount) return;
1415
1416     if (texcount < state.texcount) {
1417         glDeleteTextures (state.texcount - texcount,
1418                           state.texids + texcount);
1419     }
1420
1421     size = texcount * sizeof (*state.texids);
1422     state.texids = realloc (state.texids, size);
1423     if (!state.texids) {
1424         err (1, "realloc texids %" FMT_s, size);
1425     }
1426
1427     size = texcount * sizeof (*state.texowners);
1428     state.texowners = realloc (state.texowners, size);
1429     if (!state.texowners) {
1430         err (1, "realloc texowners %" FMT_s, size);
1431     }
1432     if (texcount > state.texcount) {
1433         int i;
1434
1435         glGenTextures (texcount - state.texcount,
1436                        state.texids + state.texcount);
1437         for (i = state.texcount; i < texcount; ++i) {
1438             state.texowners[i].w = -1;
1439             state.texowners[i].slice = NULL;
1440         }
1441     }
1442     state.texcount = texcount;
1443     state.texindex = 0;
1444 }
1445
1446 static
1447 #ifdef _WIN32
1448 DWORD _stdcall
1449 #else
1450 void *
1451 #endif
1452 mainloop (void *unused)
1453 {
1454     char *p = NULL;
1455     int len, ret, oldlen = 0;
1456
1457     for (;;) {
1458         len = readlen ();
1459         if (len == 0) {
1460             errx (1, "readlen returned 0");
1461         }
1462
1463         if (oldlen < len + 1) {
1464             p = realloc (p, len + 1);
1465             if (!p) {
1466                 err (1, "realloc %d failed", len + 1);
1467             }
1468             oldlen = len + 1;
1469         }
1470         readdata (p, len);
1471         p[len] = 0;
1472
1473         if (!strncmp ("open", p, 4)) {
1474             size_t filenamelen;
1475             char *password;
1476             char *filename = p + 5;
1477
1478             filenamelen = strlen (filename);
1479             password = filename + filenamelen + 1;
1480
1481             openxref (filename, password);
1482             pdfinfo ();
1483             initpdims ();
1484             printd ("msg Opened %s (press h/F1 to get help)", filename);
1485             state.needoutline = 1;
1486         }
1487         else if (!strncmp ("cs", p, 2)) {
1488             int i, colorspace;
1489
1490             ret = sscanf (p + 2, " %d", &colorspace);
1491             if (ret != 1) {
1492                 errx (1, "malformed cs `%.*s' ret=%d", len, p, ret);
1493             }
1494             lock ("cs");
1495             set_tex_params (colorspace);
1496             for (i = 0; i < state.texcount; ++i)  {
1497                 state.texowners[i].w = -1;
1498                 state.texowners[i].slice = NULL;
1499             }
1500             unlock ("cs");
1501         }
1502         else if (!strncmp ("freepage", p, 8)) {
1503             void *ptr;
1504
1505             ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1506             if (ret != 1) {
1507                 errx (1, "malformed freepage `%.*s' ret=%d", len, p, ret);
1508             }
1509             freepage (ptr);
1510         }
1511         else if (!strncmp ("freetile", p, 8)) {
1512             void *ptr;
1513
1514             ret = sscanf (p + 8, " %" FMT_ptr, FMT_ptr_cast (&ptr));
1515             if (ret != 1) {
1516                 errx (1, "malformed freetile `%.*s' ret=%d", len, p, ret);
1517             }
1518             freetile (ptr);
1519         }
1520         else if (!strncmp ("search", p, 6)) {
1521             int icase, pageno, y, ret, len2, forward;
1522             char *pattern;
1523             regex_t re;
1524
1525             ret = sscanf (p + 6, " %d %d %d %d,%n",
1526                           &icase, &pageno, &y, &forward, &len2);
1527             if (ret != 4) {
1528                 errx (1, "malformed search `%s' ret=%d", p, ret);
1529             }
1530
1531             pattern = p + 6 + len2;
1532             ret = regcomp (&re, pattern,
1533                            REG_EXTENDED | (icase ? REG_ICASE : 0));
1534             if (ret) {
1535                 char errbuf[80];
1536                 size_t size;
1537
1538                 size = regerror (ret, &re, errbuf, sizeof (errbuf));
1539                 printd ("msg regcomp failed `%.*s'", (int) size, errbuf);
1540             }
1541             else  {
1542                 search (&re, pageno, y, forward);
1543                 regfree (&re);
1544             }
1545         }
1546         else if (!strncmp ("geometry", p, 8)) {
1547             int w, h;
1548
1549             printd ("clear");
1550             ret = sscanf (p + 8, " %d %d", &w, &h);
1551             if (ret != 2) {
1552                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
1553             }
1554
1555             lock ("geometry");
1556             state.h = h;
1557             if (w != state.w) {
1558                 int i;
1559                 state.w = w;
1560                 for (i = 0; i < state.texcount; ++i)  {
1561                     state.texowners[i].slice = NULL;
1562                 }
1563             }
1564             layout ();
1565             process_outline ();
1566             state.gen++;
1567             unlock ("geometry");
1568             printd ("continue %d", state.pagecount);
1569         }
1570         else if (!strncmp ("reqlayout", p, 9)) {
1571             int rotate, proportional;
1572
1573             printd ("clear");
1574             ret = sscanf (p + 9, " %d %d", &rotate, &proportional);
1575             if (ret != 2) {
1576                 errx (1, "bad reqlayout line `%.*s' ret=%d", len, p, ret);
1577             }
1578             lock ("reqlayout");
1579             state.rotate = rotate;
1580             state.proportional = proportional;
1581             layout ();
1582             unlock ("reqlayout");
1583             printd ("continue %d", state.pagecount);
1584         }
1585         else if (!strncmp ("page", p, 4)) {
1586             double a, b;
1587             struct page *page;
1588             int pageno, pindex, ret;
1589
1590             ret = sscanf (p + 4, " %d %d", &pageno, &pindex);
1591             if (ret != 2) {
1592                 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
1593             }
1594
1595             lock ("page");
1596             a = now ();
1597             page = loadpage (pageno, pindex);
1598             b = now ();
1599             unlock ("page");
1600
1601             printd ("page %" FMT_ptr " %f", FMT_ptr_cast2 (page), b - a);
1602         }
1603         else if (!strncmp ("tile", p, 4)) {
1604             int x, y, w, h, ret;
1605             struct page *page;
1606             struct tile *tile;
1607             double a, b;
1608
1609             ret = sscanf (p + 4, " %" FMT_ptr " %d %d %d %d",
1610                           FMT_ptr_cast (&page), &x, &y, &w, &h);
1611             if (ret != 5) {
1612                 errx (1, "bad tile line `%.*s' ret=%d", len, p, ret);
1613             }
1614
1615             lock ("tile");
1616             a = now ();
1617             tile = rendertile (page, x, y, w, h);
1618             b = now ();
1619             unlock ("tile");
1620
1621             printd ("tile %d %d %" FMT_ptr " %u %f",
1622                     x, y,
1623                     FMT_ptr_cast2 (tile),
1624                     tile->w * tile->h * tile->pixmap->n,
1625                     b - a);
1626         }
1627         else if (!strncmp ("settrim", p, 7))  {
1628             int trimmargins;
1629             fz_bbox fuzz;
1630
1631             ret = sscanf (p + 7, " %d %d %d %d %d", &trimmargins,
1632                           &fuzz.x0, &fuzz.y0, &fuzz.x1, &fuzz.y1);
1633             if (ret != 5) {
1634                 errx (1, "malformed settrim `%.*s' ret=%d", len, p, ret);
1635             }
1636             printd ("clear");
1637             lock ("settrim");
1638             state.trimmargins = trimmargins;
1639             state.needoutline = 1;
1640             if (memcmp (&fuzz, &state.trimfuzz, sizeof (fuzz))) {
1641                 state.trimanew = 1;
1642                 state.trimfuzz = fuzz;
1643             }
1644             state.pagedimcount = 0;
1645             free (state.pagedims);
1646             state.pagedims = NULL;
1647             initpdims ();
1648             layout ();
1649             process_outline ();
1650             unlock ("settrim");
1651             printd ("continue %d", state.pagecount);
1652         }
1653         else if (!strncmp ("sliceh", p, 6)) {
1654             int h;
1655
1656             ret = sscanf (p + 6, " %d", &h);
1657             if (ret != 1) {
1658                 errx (1, "malformed sliceh `%.*s' ret=%d", len, p, ret);
1659             }
1660             if (h != state.sliceheight) {
1661                 int i;
1662
1663                 state.sliceheight = h;
1664                 for (i = 0; i < state.texcount; ++i) {
1665                     state.texowners[i].w = -1;
1666                     state.texowners[i].h = -1;
1667                     state.texowners[i].slice = NULL;
1668                 }
1669             }
1670         }
1671         else if (!strncmp ("interrupt", p, 9)) {
1672             printd ("vmsg interrupted");
1673         }
1674         else if (!strncmp ("quit", p, 4)) {
1675             return 0;
1676         }
1677         else {
1678             errx (1, "unknown command %.*s", len, p);
1679         }
1680     }
1681     return 0;
1682 }
1683
1684 CAMLprim value ml_realloctexts (value texcount_v)
1685 {
1686     CAMLparam1 (texcount_v);
1687     int ok;
1688
1689     if (trylock ("ml_realloctexts")) {
1690         ok = 0;
1691         goto done;
1692     }
1693     realloctexts (Int_val (texcount_v));
1694     ok = 1;
1695     unlock ("ml_realloctexts");
1696
1697  done:
1698     CAMLreturn (Val_bool (ok));
1699 }
1700
1701 static void showsel (struct page *page, int ox, int oy)
1702 {
1703     fz_bbox bbox;
1704     fz_text_span *span;
1705     struct mark first, last;
1706
1707     first = page->fmark;
1708     last = page->lmark;
1709
1710     if (!first.span || !last.span) return;
1711
1712     glEnable (GL_BLEND);
1713     glBlendFunc (GL_SRC_ALPHA, GL_SRC_ALPHA);
1714     glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
1715
1716     ox -= state.pagedims[page->pdimno].bounds.x0;
1717     oy -= state.pagedims[page->pdimno].bounds.y0;
1718     for (span = first.span; span; span = span->next) {
1719         int i, j, k;
1720
1721         bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0;
1722
1723         j = 0;
1724         k = span->len - 1;
1725
1726         if (span == page->fmark.span && span == page->lmark.span) {
1727             j = MIN (first.i, last.i);
1728             k = MAX (first.i, last.i);
1729         }
1730         else if (span == first.span) {
1731             j = first.i;
1732         }
1733         else if (span == last.span) {
1734             k = last.i;
1735         }
1736
1737         for (i = j; i <= k; ++i) {
1738             bbox = fz_union_bbox (bbox, span->text[i].bbox);
1739         }
1740         lprintf ("%d %d %d %d oy=%d ox=%d\n",
1741                  bbox.x0,
1742                  bbox.y0,
1743                  bbox.x1,
1744                  bbox.y1,
1745                  oy, ox);
1746
1747         glRecti (bbox.x0 + ox, bbox.y0 + oy, bbox.x1 + ox, bbox.y1 + oy);
1748
1749         if (span == last.span) break;
1750     }
1751     glDisable (GL_BLEND);
1752 }
1753
1754 static void highlightlinks (struct page *page, int xoff, int yoff)
1755 {
1756     fz_matrix ctm;
1757     fz_link *link, *links;
1758
1759     switch (page->type) {
1760     case DPDF:
1761         links = page->u.pdfpage->links;
1762         break;
1763
1764     case DXPS:
1765         links = page->u.xpspage->links;
1766         break;
1767
1768     default:
1769         return;
1770     }
1771
1772     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1773     glEnable (GL_LINE_STIPPLE);
1774     glLineStipple (0.5, 0xcccc);
1775
1776     ctm = fz_concat (pagectm (page), fz_translate (xoff, yoff));
1777
1778     glBegin (GL_QUADS);
1779     for (link = links; link; link = link->next) {
1780         fz_point p1, p2, p3, p4;
1781
1782         p1.x = link->rect.x0;
1783         p1.y = link->rect.y0;
1784
1785         p2.x = link->rect.x1;
1786         p2.y = link->rect.y0;
1787
1788         p3.x = link->rect.x1;
1789         p3.y = link->rect.y1;
1790
1791         p4.x = link->rect.x0;
1792         p4.y = link->rect.y1;
1793
1794         p1 = fz_transform_point (ctm, p1);
1795         p2 = fz_transform_point (ctm, p2);
1796         p3 = fz_transform_point (ctm, p3);
1797         p4 = fz_transform_point (ctm, p4);
1798
1799         switch (link->dest.kind) {
1800         case FZ_LINK_GOTO: glColor3ub (255, 0, 0); break;
1801         case FZ_LINK_URI: glColor3ub (0, 0, 255); break;
1802         default: glColor3ub (0, 0, 0); break;
1803         }
1804
1805         glVertex2f (p1.x, p1.y);
1806         glVertex2f (p2.x, p2.y);
1807         glVertex2f (p3.x, p3.y);
1808         glVertex2f (p4.x, p4.y);
1809     }
1810     glEnd ();
1811
1812     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1813     glDisable (GL_LINE_STIPPLE);
1814 }
1815
1816 static void uploadslice (struct tile *tile, struct slice *slice)
1817 {
1818     int offset;
1819     struct slice *slice1;
1820
1821     offset = 0;
1822     for (slice1 = tile->slices; slice != slice1; slice1++) {
1823         offset += slice1->h * tile->w * tile->pixmap->n;
1824     }
1825     if (slice->texindex != -1 && slice->texindex < state.texcount
1826         && state.texowners[slice->texindex].slice == slice) {
1827         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
1828     }
1829     else {
1830         int subimage = 0;
1831         int texindex = state.texindex++ % state.texcount;
1832
1833         if (state.texowners[texindex].w == tile->w) {
1834             if (state.texowners[texindex].h >= slice->h) {
1835                 subimage = 1;
1836             }
1837             else {
1838                 state.texowners[texindex].h = slice->h;
1839             }
1840         }
1841         else  {
1842             state.texowners[texindex].h = slice->h;
1843         }
1844
1845         state.texowners[texindex].w = tile->w;
1846         state.texowners[texindex].slice = slice;
1847         slice->texindex = texindex;
1848
1849         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[texindex]);
1850         if (subimage) {
1851             glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
1852                              0,
1853                              0,
1854                              0,
1855                              tile->w,
1856                              slice->h,
1857                              state.texform,
1858                              state.texty,
1859                              tile->pixmap->samples+offset
1860                 );
1861         }
1862         else {
1863             glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
1864                           0,
1865                           state.texiform,
1866                           tile->w,
1867                           slice->h,
1868                           0,
1869                           state.texform,
1870                           state.texty,
1871                           tile->pixmap->samples+offset
1872                 );
1873         }
1874     }
1875 }
1876
1877 CAMLprim value ml_drawtile (value args_v, value ptr_v)
1878 {
1879     CAMLparam2 (args_v, ptr_v);
1880     int dispx = Int_val (Field (args_v, 0));
1881     int dispy = Int_val (Field (args_v, 1));
1882     int dispw = Int_val (Field (args_v, 2));
1883     int disph = Int_val (Field (args_v, 3));
1884     int tilex = Int_val (Field (args_v, 4));
1885     int tiley = Int_val (Field (args_v, 5));
1886     char *s = String_val (ptr_v);
1887     struct tile *tile = parse_pointer ("ml_drawtile", s);
1888
1889     glEnable (GL_TEXTURE_RECTANGLE_ARB);
1890     {
1891         int slicey, firstslice;
1892         struct slice *slice;
1893
1894         firstslice = tiley / tile->sliceheight;
1895         slice = &tile->slices[firstslice];
1896         slicey = tiley % tile->sliceheight;
1897
1898         while (disph > 0) {
1899             int dh;
1900
1901             dh = slice->h - slicey;
1902             dh = MIN (disph, dh);
1903             uploadslice (tile, slice);
1904
1905             glBegin (GL_QUADS);
1906             {
1907                 glTexCoord2i (tilex, slicey);
1908                 glVertex2i (dispx, dispy);
1909
1910                 glTexCoord2i (tilex+dispw, slicey);
1911                 glVertex2i (dispx+dispw, dispy);
1912
1913                 glTexCoord2i (tilex+dispw, slicey+dh);
1914                 glVertex2i (dispx+dispw, dispy+dh);
1915
1916                 glTexCoord2i (tilex, slicey+dh);
1917                 glVertex2i (dispx, dispy+dh);
1918             }
1919             glEnd ();
1920
1921             dispy += dh;
1922             disph -= dh;
1923             slice++;
1924             ARSERT (!(slice - tile->slices >= tile->slicecount && disph > 0));
1925             slicey = 0;
1926         }
1927     }
1928     glDisable (GL_TEXTURE_RECTANGLE_ARB);
1929     CAMLreturn (Val_unit);
1930 }
1931
1932 CAMLprim value ml_postprocess (value ptr_v, value hlinks_v,
1933                                value xoff_v, value yoff_v)
1934 {
1935     CAMLparam4 (ptr_v, hlinks_v, xoff_v, yoff_v);
1936     int xoff = Int_val (xoff_v);
1937     int yoff = Int_val (yoff_v);
1938     char *s = String_val (ptr_v);
1939     struct page *page = parse_pointer ("ml_postprocess", s);
1940
1941     if (Bool_val (hlinks_v)) highlightlinks (page, xoff, yoff);
1942
1943     if (trylock ("ml_postprocess")) {
1944         goto done;
1945     }
1946     showsel (page, xoff, yoff);
1947     unlock ("ml_postprocess");
1948
1949  done:
1950     CAMLreturn (Val_unit);
1951 }
1952
1953 static fz_link *getlink (struct page *page, int x, int y)
1954 {
1955     fz_point p;
1956     fz_matrix ctm;
1957     fz_link *link, *links;
1958
1959     switch (page->type) {
1960     case DPDF:
1961         links = page->u.pdfpage->links;
1962         break;
1963
1964     case DXPS:
1965         links = page->u.xpspage->links;
1966         break;
1967
1968     default:
1969         return NULL;
1970     }
1971     p.x = x;
1972     p.y = y;
1973
1974     ctm = fz_concat (trimctm (page->u.pdfpage, page->pdimno),
1975                      state.pagedims[page->pdimno].ctm);
1976     ctm = fz_invert_matrix (ctm);
1977     p = fz_transform_point (ctm, p);
1978
1979     for (link = links; link; link = link->next) {
1980         if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1981             if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1982                 return link;
1983             }
1984         }
1985     }
1986     return NULL;
1987 }
1988
1989 static void droptext (struct page *page)
1990 {
1991     if (page->text) {
1992         fz_free_text_span (state.ctx, page->text);
1993         page->fmark.i = -1;
1994         page->lmark.i = -1;
1995         page->fmark.span = NULL;
1996         page->lmark.span = NULL;
1997         page->text = NULL;
1998     }
1999 }
2000
2001 static void ensuretext (struct page *page)
2002 {
2003     if (state.gen != page->gen) {
2004         droptext (page);
2005         page->gen = state.gen;
2006     }
2007     if (!page->text) {
2008         fz_device *tdev;
2009
2010         page->text = fz_new_text_span (state.ctx);
2011         tdev = fz_new_text_device (state.ctx, page->text);
2012         fz_run_display_list (page->dlist,
2013                              tdev,
2014                              pagectm (page),
2015                              fz_infinite_bbox, NULL);
2016         fz_free_device (tdev);
2017     }
2018 }
2019
2020 CAMLprim value ml_whatsunder (value ptr_v, value x_v, value y_v)
2021 {
2022     CAMLparam3 (ptr_v, x_v, y_v);
2023     CAMLlocal3 (ret_v, tup_v, str_v);
2024     int pageno;
2025     fz_link *link;
2026     struct page *page;
2027     char *s = String_val (ptr_v);
2028     int x = Int_val (x_v), y = Int_val (y_v);
2029     struct pagedim *pdim;
2030
2031     ret_v = Val_int (0);
2032     if (trylock ("ml_whatsunder")) {
2033         goto done;
2034     }
2035
2036     page = parse_pointer ("ml_whatsunder", s);
2037     pdim = &state.pagedims[page->pdimno];
2038     x += pdim->bounds.x0;
2039     y += pdim->bounds.y0;
2040     link = getlink (page, x, y);
2041     if (link) {
2042         switch (link->dest.kind) {
2043         case FZ_LINK_GOTO:
2044             {
2045                 fz_point p;
2046
2047                 pageno = link->dest.ld.gotor.page;
2048                 p.x = 0;
2049                 p.y = 0;
2050
2051                 if (link->dest.ld.gotor.flags & fz_link_flag_t_valid) {
2052                     p.y = link->dest.ld.gotor.lt.y;
2053                     p = fz_transform_point (pdim->lctm, p);
2054                 }
2055                 tup_v = caml_alloc_tuple (2);
2056                 ret_v = caml_alloc_small (1, 1);
2057                 Field (tup_v, 0) = Val_int (pageno);
2058                 Field (tup_v, 1) = Val_int (p.y);
2059                 Field (ret_v, 0) = tup_v;
2060             }
2061             break;
2062
2063         case FZ_LINK_URI:
2064             str_v = caml_copy_string (link->dest.ld.uri.uri);
2065             ret_v = caml_alloc_small (1, 0);
2066             Field (ret_v, 0) = str_v;
2067             break;
2068
2069         case FZ_LINK_LAUNCH:
2070             str_v = caml_copy_string (link->dest.ld.launch.file_spec);
2071             ret_v = caml_alloc_small (1, 4);
2072             Field (ret_v, 0) = str_v;
2073             break;
2074
2075         case FZ_LINK_NAMED:
2076             str_v = caml_copy_string (link->dest.ld.named.named);
2077             ret_v = caml_alloc_small (1, 5);
2078             Field (ret_v, 0) = str_v;
2079             break;
2080
2081         case FZ_LINK_GOTOR:
2082             str_v = caml_copy_string (link->dest.ld.gotor.file_spec);
2083             pageno = link->dest.ld.gotor.page;
2084             tup_v = caml_alloc_tuple (2);
2085             ret_v = caml_alloc_small (1, 6);
2086             Field (tup_v, 0) = str_v;
2087             Field (tup_v, 1) = Val_int (pageno);
2088             Field (ret_v, 0) = tup_v;
2089             break;
2090
2091         default:
2092             {
2093                 char buf[80];
2094
2095                 snprintf (buf, sizeof (buf),
2096                           "unhandled link kind %d", link->dest.kind);
2097                 str_v = caml_copy_string (buf);
2098                 ret_v = caml_alloc_small (1, 3);
2099                 Field (ret_v, 0) = str_v;
2100             }
2101             break;
2102         }
2103     }
2104     else {
2105         int i;
2106         fz_text_span *span;
2107
2108         ensuretext (page);
2109         for (span = page->text; span; span = span->next) {
2110             for (i = 0; i < span->len; ++i) {
2111                 fz_bbox *b;
2112                 b = &span->text[i].bbox;
2113                 if ((x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1)) {
2114                     const char *n2 =
2115                         span->font && span->font->name
2116                         ? span->font->name
2117                         : "Span has no font name"
2118                         ;
2119                     FT_FaceRec *face = span->font->ft_face;
2120                     if (face && face->family_name) {
2121                         char *s;
2122                         char *n1 = face->family_name;
2123                         size_t l1 = strlen (n1);
2124                         size_t l2 = strlen (n2);
2125
2126                         if (l1 != l2 || memcmp (n1, n2, l1)) {
2127                             s = malloc (l1 + l2 + 2);
2128                             if (s) {
2129                                 memcpy (s, n2, l2);
2130                                 s[l2] = '=';
2131                                 memcpy (s + l2 + 1, n1, l1 + 1);
2132                                 str_v = caml_copy_string (s);
2133                                 free (s);
2134                             }
2135                         }
2136                     }
2137                     if (str_v == 0) {
2138                         str_v = caml_copy_string (n2);
2139                     }
2140                     ret_v = caml_alloc_small (1, 2);
2141                     Field (ret_v, 0) = str_v;
2142                     goto unlock;
2143                 }
2144             }
2145         }
2146     }
2147  unlock:
2148     unlock ("ml_whatsunder");
2149
2150  done:
2151     CAMLreturn (ret_v);
2152 }
2153
2154 CAMLprim value ml_seltext (value ptr_v, value rect_v)
2155 {
2156     CAMLparam2 (ptr_v, rect_v);
2157     fz_bbox *b;
2158     struct page *page;
2159     fz_text_span *span;
2160     struct mark first, last;
2161     int i, x0, x1, y0, y1;
2162     struct pagedim *pdim;
2163     char *s = String_val (ptr_v);
2164
2165     if (trylock ("ml_seltext")) {
2166         goto done;
2167     }
2168
2169     page = parse_pointer ("ml_seltext", s);
2170     ensuretext (page);
2171
2172     pdim = &state.pagedims[page->pdimno];
2173
2174     x0 = Int_val (Field (rect_v, 0)) + pdim->bounds.x0;
2175     y0 = Int_val (Field (rect_v, 1)) + pdim->bounds.y0;
2176     x1 = Int_val (Field (rect_v, 2)) + pdim->bounds.x0;
2177     y1 = Int_val (Field (rect_v, 3)) + pdim->bounds.y0;
2178
2179     if (0) {
2180         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
2181         glColor3ub (128, 128, 128);
2182         glRecti (x0, y0, x1, y1);
2183         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
2184     }
2185
2186     first.span = NULL;
2187     last.span = NULL;
2188
2189     last.i = first.i = 0;
2190     first.span = page->text;
2191     for (span = page->text; span; span = span->next) {
2192         for (i = 0; i < span->len; ++i) {
2193             b = &span->text[i].bbox;
2194             int selected = 0;
2195
2196             if (x0 >= b->x0 && x0 <= b->x1 && y0 >= b->y0 && y0 <= b->y1) {
2197                 first.i = i;
2198                 first.span = span;
2199                 selected = 1;
2200             }
2201             if (x1 >= b->x0 && x1 <= b->x1 && y1 >= b->y0 && y1 <= b->y1) {
2202                 last.i = i;
2203                 last.span = span;
2204                 selected = 1;
2205             }
2206             if (0 && selected) {
2207                 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
2208                 glColor3ub (128, 128, 128);
2209                 glRecti (b->x0, b->y0, b->x1, b->y1);
2210                 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
2211             }
2212         }
2213     }
2214
2215     if (y1 < y0 || x1 < x0) {
2216         int swap = 0;
2217
2218         if (first.span == last.span)  {
2219             swap = 1;
2220         }
2221         else {
2222             if (y1 < y0) {
2223                 for (span = first.span; span && span != last.span;
2224                      span = span->next) {
2225                     if (span->eol) {
2226                         swap = 1;
2227                         break;
2228                     }
2229                 }
2230             }
2231         }
2232
2233         if (swap) {
2234             i = first.i;
2235             span = first.span;
2236             first.i = last.i;
2237             first.span = last.span;
2238             last.i = i;
2239             last.span = span;
2240         }
2241     }
2242
2243     page->fmark = first;
2244     page->lmark = last;
2245
2246     unlock ("ml_seltext");
2247
2248  done:
2249     CAMLreturn (Val_unit);
2250 }
2251
2252 static int pipespan (FILE *f, fz_text_span *span, int a, int b)
2253 {
2254     char buf[4];
2255     int i, len, ret;
2256
2257     for (i = a; i <= b; ++i) {
2258         len = runetochar (buf, &span->text[i].c);
2259         ret = fwrite (buf, len, 1, f);
2260
2261         if (ret != 1) {
2262             fprintf (stderr, "failed to write %d bytes ret=%d: %s\n",
2263                      len, ret, strerror (errno));
2264             return -1;
2265         }
2266     }
2267     return 0;
2268 }
2269
2270 CAMLprim value ml_copysel (value command_v, value ptr_v)
2271 {
2272     CAMLparam1 (ptr_v);
2273     FILE *f;
2274     struct page *page;
2275     fz_text_span *span;
2276     char *s = String_val (ptr_v);
2277     char *command = String_val (command_v);
2278
2279     if (trylock ("ml_copysel")) {
2280         goto done;
2281     }
2282
2283
2284     page = parse_pointer ("ml_sopysel", s);
2285
2286     if (!page->fmark.span || !page->lmark.span) {
2287         fprintf (stderr, "nothing to copy\n");
2288         goto unlock;
2289     }
2290
2291     f = popen (command, "w");
2292     if (!f) {
2293         fprintf (stderr, "failed to open sel pipe: %s\n",
2294                  strerror (errno));
2295         f = stdout;
2296     }
2297
2298     for (span = page->fmark.span;
2299          span && span != page->lmark.span->next;
2300          span = span->next) {
2301         int a = span == page->fmark.span ? page->fmark.i : 0;
2302         int b = span == page->lmark.span ? page->lmark.i : span->len - 1;
2303         if (pipespan (f, span, a, b))  {
2304             goto close;
2305         }
2306         if (span->eol)  {
2307             if (putc ('\n', f) == EOF) {
2308                 fprintf (stderr, "failed break line on sel pipe: %s\n",
2309                          strerror (errno));
2310                 goto close;
2311             }
2312         }
2313     }
2314     page->lmark.span = NULL;
2315     page->fmark.span = NULL;
2316
2317  close:
2318     if (f != stdout) {
2319         int ret = pclose (f);
2320         if (ret == -1)  {
2321             if (errno != ECHILD) {
2322                 fprintf (stderr, "failed to close sel pipe: %s\n",
2323                          strerror (errno));
2324             }
2325         }
2326     }
2327  unlock:
2328     unlock ("ml_copysel");
2329
2330  done:
2331     CAMLreturn (Val_unit);
2332 }
2333
2334 CAMLprim value ml_getpdimrect (value pagedimno_v)
2335 {
2336     CAMLparam1 (pagedimno_v);
2337     CAMLlocal1 (ret_v);
2338     int pagedimno = Int_val (pagedimno_v);
2339     fz_rect box;
2340
2341     ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
2342     if (trylock ("ml_getpdimrect")) {
2343         box = fz_empty_rect;
2344     }
2345     else {
2346         box = state.pagedims[pagedimno].mediabox;
2347         unlock ("ml_getpdimrect");
2348     }
2349
2350     Store_double_field (ret_v, 0, box.x0);
2351     Store_double_field (ret_v, 1, box.x1);
2352     Store_double_field (ret_v, 2, box.y0);
2353     Store_double_field (ret_v, 3, box.y1);
2354
2355     CAMLreturn (ret_v);
2356 }
2357
2358 static double getmaxw (void)
2359 {
2360     int i;
2361     struct pagedim *p;
2362     double maxw = 0.0;
2363
2364     for (i = 0, p = state.pagedims; i < state.pagedimcount; ++i, ++p) {
2365         double x0, x1, w;
2366
2367         x0 = MIN (p->mediabox.x0, p->mediabox.x1);
2368         x1 = MAX (p->mediabox.x0, p->mediabox.x1);
2369
2370         w = x1 - x0;
2371         maxw = MAX (w, maxw);
2372     }
2373     return maxw;
2374 }
2375
2376 CAMLprim value ml_getmaxw (value unit_v)
2377 {
2378     CAMLparam1 (unit_v);
2379     CAMLlocal1 (ret_v);
2380     double maxw = 0.0;
2381
2382     if (trylock ("ml_getmaxw")) {
2383         goto done;
2384     }
2385     maxw = getmaxw ();
2386     unlock ("ml_getmaxw");
2387  done:
2388     ret_v = caml_copy_double (maxw);
2389     CAMLreturn (ret_v);
2390 }
2391
2392 CAMLprim value ml_zoom_for_height (value winw_v, value winh_v, value dw_v)
2393 {
2394     CAMLparam3 (winw_v, winh_v, dw_v);
2395     CAMLlocal1 (ret_v);
2396     int i;
2397     double zoom = 1.0;
2398     double maxw = 0.0, maxh = 0.0;
2399     struct pagedim *p;
2400     double winw = Int_val (winw_v);
2401     double winh = Int_val (winh_v);
2402     double dw = Int_val (dw_v);
2403     double pw = 1.0, ph = 1.0, num, den;
2404
2405     if (trylock ("ml_zoom_for_height")) {
2406         goto done;
2407     }
2408
2409     if (state.proportional) {
2410         maxw = getmaxw ();
2411     }
2412
2413     for (i = 0, p = state.pagedims; i < state.pagedimcount; ++i, ++p) {
2414         double x0, x1, y0, y1, w, h, scaledh, scale;
2415
2416         x0 = MIN (p->mediabox.x0, p->mediabox.x1);
2417         x1 = MAX (p->mediabox.x0, p->mediabox.x1);
2418         y0 = MIN (p->mediabox.y0, p->mediabox.y1);
2419         y1 = MAX (p->mediabox.y0, p->mediabox.y1);
2420
2421         w = x1 - x0;
2422         h = y1 - y0;
2423
2424         if (state.proportional) {
2425             scale = w / maxw;
2426             scaledh = h * scale;
2427         }
2428         else  {
2429             scale = 1.0;
2430             scaledh = h;
2431         }
2432
2433         if (scaledh > maxh) {
2434             maxh = scaledh;
2435             ph = scaledh;
2436             pw = w * scale;
2437         }
2438     }
2439
2440     num = (winh * pw) + (ph * dw);
2441     den = ph * winw;
2442     zoom = num / den;
2443
2444     unlock ("ml_zoom_for_height");
2445  done:
2446     ret_v = caml_copy_double (zoom);
2447     CAMLreturn (ret_v);
2448 }
2449
2450 #include "glfont.c"
2451
2452 CAMLprim value ml_draw_string (value pt_v, value x_v, value y_v, value string_v)
2453 {
2454     CAMLparam4 (pt_v, x_v, y_v, string_v);
2455     CAMLlocal1 (ret_v);
2456     int pt = Int_val(pt_v);
2457     int x = Int_val (x_v);
2458     int y = Int_val (y_v);
2459     double w;
2460
2461     w = draw_string (state.face, pt, x, y, String_val (string_v));
2462     ret_v = caml_copy_double (w);
2463     CAMLreturn (ret_v);
2464 }
2465
2466 CAMLprim value ml_measure_string (value pt_v, value string_v)
2467 {
2468     CAMLparam2 (pt_v, string_v);
2469     CAMLlocal1 (ret_v);
2470     int pt = Int_val (pt_v);
2471     double w;
2472
2473     w = measure_string (state.face, pt, String_val (string_v));
2474     ret_v = caml_copy_double (w);
2475     CAMLreturn (ret_v);
2476 }
2477
2478 CAMLprim value ml_getpagebox (value opaque_v)
2479 {
2480     CAMLparam1 (opaque_v);
2481     CAMLlocal1 (ret_v);
2482     fz_bbox bbox;
2483     fz_device *dev;
2484     char *s = String_val (opaque_v);
2485     struct page *page = parse_pointer ("ml_getpagebox", s);
2486
2487     ret_v = caml_alloc_tuple (4);
2488     dev = fz_new_bbox_device (state.ctx, &bbox);
2489     dev->hints |= FZ_IGNORE_SHADE;
2490
2491     switch (page->type) {
2492     case DPDF:
2493         pdf_run_page (state.u.pdf, page->u.pdfpage, dev, pagectm (page), NULL);
2494         break;
2495
2496     case DXPS:
2497         xps_run_page (state.u.xps, page->u.xpspage, dev, pagectm (page), NULL);
2498         break;
2499
2500     default:
2501         bbox = fz_infinite_bbox;
2502         break;
2503     }
2504
2505     fz_free_device (dev);
2506     Field (ret_v, 0) = Val_int (bbox.x0);
2507     Field (ret_v, 1) = Val_int (bbox.y0);
2508     Field (ret_v, 2) = Val_int (bbox.x1);
2509     Field (ret_v, 3) = Val_int (bbox.y1);
2510
2511     CAMLreturn (ret_v);
2512 }
2513
2514 CAMLprim value ml_setaalevel (value level_v)
2515 {
2516     CAMLparam1 (level_v);
2517
2518     state.aalevel = Int_val (level_v);
2519     CAMLreturn (Val_unit);
2520 }
2521
2522 #if !defined _WIN32 && !defined __APPLE__
2523 #undef pixel
2524 #include <X11/X.h>
2525 #include <X11/Xlib.h>
2526 #include <X11/Xutil.h>
2527 #include <GL/glx.h>
2528
2529 static void set_wm_class (int hack)
2530 {
2531     if (hack) {
2532         Display *dpy;
2533         Window win;
2534         XClassHint hint;
2535         char *display;
2536
2537         display = getenv ("DISPLAY");
2538         dpy = XOpenDisplay (display);
2539         if (!dpy) {
2540             fprintf (stderr, "XOpenDisplay `%s' failed\n",
2541                      display ? display : "null");
2542             return;
2543         }
2544         hint.res_name = "llpp";
2545         hint.res_class = "llpp";
2546         win = glXGetCurrentDrawable ();
2547         if (win == None) {
2548             fprintf (stderr, "glXGetCurrentDrawable returned None\n");
2549             XCloseDisplay (dpy);
2550             return;
2551         }
2552         XSetClassHint (dpy, win, &hint);
2553         XCloseDisplay (dpy);
2554     }
2555 }
2556 #else
2557 #define set_wm_class(h) (void) (h)
2558 #endif
2559
2560 enum { piunknown, pilinux, piwindows, piosx,
2561        pisun, pifreebsd, pidragonflybsd,
2562        piopenbsd, pinetbsd, pimingw, picygwin };
2563
2564 #define NOZOMBIESPLEASE
2565
2566 CAMLprim value ml_platform (value unit_v)
2567 {
2568     CAMLparam1 (unit_v);
2569     int platid = piunknown;
2570
2571 #if defined __linux__
2572     platid = pilinux;
2573 #elif defined __CYGWIN__
2574 #undef NOZOMBIESPLEASE
2575     platid = picygwin;
2576 #elif defined __MINGW32__
2577 #undef NOZOMBIESPLEASE
2578     platid = pimingw;
2579 #elif defined _WIN32
2580 #undef NOZOMBIESPLEASE
2581     platid = piwindows;
2582 #elif defined __DragonFly__
2583     platid = pidragonflybsd;
2584 #elif defined __FreeBSD__
2585     platid = pifreebsd;
2586 #elif defined __OpenBSD__
2587     platid = piopenbsd;
2588 #elif defined __NetBSD__
2589     platid = pinetbsd;
2590 #elif defined __sun__
2591     platid = pisun;
2592 #elif defined __APPLE__
2593     platid = piosx;
2594 #endif
2595     CAMLreturn (Val_int (platid));
2596 }
2597
2598 #ifdef NOZOMBIESPLEASE
2599 #include <signal.h>
2600
2601 static void nozombies (void)
2602 {
2603     struct sigaction sa;
2604
2605     sa.sa_handler = SIG_DFL;
2606     if (sigemptyset (&sa.sa_mask)) {
2607         err (1, "sigemptyset");
2608     }
2609     sa.sa_flags = SA_RESTART | SA_NOCLDSTOP | SA_NOCLDWAIT;
2610     if (sigaction (SIGCHLD, &sa, NULL)) {
2611         err (1, "sigaction");
2612     }
2613 }
2614 #else
2615 #define nozombies()
2616 #endif
2617
2618 CAMLprim value ml_init (value pipe_v, value params_v)
2619 {
2620     CAMLparam2 (pipe_v, params_v);
2621     CAMLlocal2 (trim_v, fuzz_v);
2622     char *fontpath;
2623     int texcount;
2624     int wmclasshack;
2625     int colorspace;
2626     int mustoresize;
2627
2628 #ifdef _WIN32
2629     state.cr = Handle_val (Field (pipe_v, 0));
2630     state.cw = Handle_val (Field (pipe_v, 1));
2631 #else
2632     state.cr = Int_val (Field (pipe_v, 0));
2633     state.cw = Int_val (Field (pipe_v, 1));
2634 #endif
2635     state.rotate = Int_val (Field (params_v, 0));
2636     state.proportional = Bool_val (Field (params_v, 1));
2637     trim_v = Field (params_v, 2);
2638     texcount = Int_val (Field (params_v, 3));
2639     state.sliceheight = Int_val (Field (params_v, 4));
2640     mustoresize = Int_val (Field (params_v, 5));
2641     state.ctx = fz_new_context (NULL, NULL, mustoresize);
2642     colorspace = Int_val (Field (params_v, 6));
2643     wmclasshack = Bool_val (Field (params_v, 7));
2644     fontpath = String_val (Field (params_v, 8));
2645
2646     state.trimmargins = Bool_val (Field (trim_v, 0));
2647     fuzz_v = Field (trim_v, 1);
2648     state.trimfuzz.x0 = Int_val (Field (fuzz_v, 0));
2649     state.trimfuzz.y0 = Int_val (Field (fuzz_v, 1));
2650     state.trimfuzz.x1 = Int_val (Field (fuzz_v, 2));
2651     state.trimfuzz.y1 = Int_val (Field (fuzz_v, 3));
2652
2653     set_tex_params (colorspace);
2654     set_wm_class (wmclasshack);
2655
2656     if (*fontpath) {
2657         state.face = load_font (fontpath);
2658     }
2659     else {
2660         unsigned int len;
2661         void *base = pdf_find_substitute_font (0, 0, 0, 0, &len);
2662
2663         state.face = load_builtin_font (base, len);
2664     }
2665     if (!state.face) _exit (1);
2666
2667     realloctexts (texcount);
2668
2669     nozombies ();
2670
2671 #ifdef _WIN32
2672     InitializeCriticalSection (&critsec);
2673     state.thread = CreateThread (NULL, 0, mainloop, NULL, 0, NULL);
2674     if (state.thread == INVALID_HANDLE_VALUE) {
2675         errx (1, "CreateThread failed: %lx", GetLastError ());
2676     }
2677 #else
2678     {
2679         int ret = pthread_create (&state.thread, NULL, mainloop, NULL);
2680         if (ret) {
2681             errx (1, "pthread_create: %s", strerror (ret));
2682         }
2683     }
2684 #endif
2685
2686     CAMLreturn (Val_unit);
2687 }