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