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