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