link.c

   1 /* lots of code c&p-ed directly from mupdf */
   2 #ifdef _WIN32
   3 #define WIN32_LEAN_AND_MEAN
   4 #include <windows.h>
   5 #include <winsock2.h>
   6 #define fionread_arg long
   7 #define ssize_t int
   8 #define FMT_ss "%d"
   9 #ifdef _WIN64
  10 #define FMT_s "%i64u"
  11 #else
  12 #define FMT_s "%u"
  13 #endif
  14 #pragma warning (disable:4244)
  15 #pragma warning (disable:4996)
  16 #pragma warning (disable:4995)
  17 #endif
  18
  19 #ifdef _MSC_VER
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 static void __declspec (noreturn) err (int exitcode, const char *fmt, ...)
  25 {
  26     va_list ap;
  27     int errcode;
  28
  29     errcode = errno;
  30     va_start (ap, fmt);
  31     vfprintf (stderr, fmt, ap);
  32     va_end (ap);
  33     fprintf (stderr, ": %s\n", strerror (errno));
  34     exit (exitcode);
  35 }
  36 static void __declspec (noreturn) errx (int exitcode, const char *fmt, ...)
  37 {
  38     va_list ap;
  39
  40     va_start (ap, fmt);
  41     vfprintf (stderr, fmt, ap);
  42     va_end (ap);
  43     fputc ('\n', stderr);
  44     exit (exitcode);
  45 }
  46 static void __declspec (noreturn) sockerr (int exitcode, const char *fmt, ...)
  47 {
  48     va_list ap;
  49
  50     va_start (ap, fmt);
  51     vfprintf (stderr, fmt, ap);
  52     va_end (ap);
  53     fprintf (stderr, ": wsaerror 0x%x\n", WSAGetLastError ());
  54     exit (exitcode);
  55 }
  56 #else
  57 #define FMT_ss "%zd"
  58 #define FMT_s "%zu"
  59 #define fionread_arg int
  60 #define ioctlsocket ioctl
  61 #define _GNU_SOURCE
  62 #include <err.h>
  63 #define sockerr err
  64 #endif
  65 #include <regex.h>
  66 #include <errno.h>
  67 #include <ctype.h>
  68 #include <stdio.h>
  69 #include <stdarg.h>
  70 #include <stdlib.h>
  71 #include <string.h>
  72 #include <limits.h>
  73 #ifndef _WIN32
  74 #include <pthread.h>
  75 #include <sys/time.h>
  76 #include <sys/types.h>
  77 #include <sys/socket.h>
  78 #include <sys/ioctl.h>
  79 #endif
  80
  81 #ifdef __APPLE__
  82 #include <OpenGL/gl.h>
  83 #else
  84 #include <GL/gl.h>
  85 #endif
  86
  87 #ifndef GL_TEXTURE_RECTANGLE_ARB
  88 #define GL_TEXTURE_RECTANGLE_ARB          0x84F5
  89 #endif
  90
  91 #include <caml/fail.h>
  92 #include <caml/alloc.h>
  93 #include <caml/memory.h>
  94 #include <caml/unixsupport.h>
  95
  96 #include <fitz.h>
  97 #include <mupdf.h>
  98
  99 #if 0
 100 #define lprintf printf
 101 #else
 102 #define lprintf(...)
 103 #endif
 104
 105 #ifdef FT_FREETYPE_H
 106 #include FT_FREETYPE_H
 107 #endif
 108
 109 #define ARSERT(cond) for (;;) {                         \
 110     if (!(cond)) {                                      \
 111         errx (1, "%s:%d " #cond, __FILE__, __LINE__);   \
 112     }                                                   \
 113     break;                                              \
 114 }
 115
 116 struct slice {
 117     int texindex;
 118     int w, h;
 119 };
 120
 121 struct pagedim {
 122     int pageno;
 123     int rotate;
 124     fz_rect box;
 125     fz_bbox bbox;
 126     fz_matrix ctm, ctm1;
 127 };
 128
 129 struct page {
 130     int pageno;
 131     int slicecount;
 132     fz_textspan *text;
 133     fz_pixmap *pixmap;
 134     pdf_page *drawpage;
 135     struct pagedim pagedim;
 136     struct mark {
 137         int i;
 138         fz_textspan *span;
 139     } fmark, lmark;
 140     struct slice slices[];
 141 };
 142
 143 #if !defined _WIN32 && !defined __APPLE__
 144 #define USE_XSEL
 145 #endif
 146
 147 struct {
 148     int sock;
 149     int sliceheight;
 150     struct page *pig;
 151     struct pagedim *pagedims;
 152     int pagecount;
 153     int pagedimcount;
 154     pdf_xref *xref;
 155     fz_glyphcache *cache;
 156     int w, h;
 157
 158     int texindex;
 159     int texcount;
 160     GLuint *texids;
 161
 162     GLenum texform;
 163     GLenum texty;
 164
 165     struct {
 166         int w, h;
 167         struct slice *slice;
 168     } *texowners;
 169
 170     int rotate;
 171     int needoutline;
 172
 173 #ifdef _WIN32
 174     HANDLE thread;
 175 #else
 176     pthread_t thread;
 177 #endif
 178     FILE *xselpipe;
 179 } state;
 180
 181 #ifdef _WIN32
 182 static CRITICAL_SECTION critsec;
 183
 184 static void lock (void *unused)
 185 {
 186     (void) unused;
 187     EnterCriticalSection (&critsec);
 188 }
 189
 190 static void unlock (void *unused)
 191 {
 192     (void) unused;
 193     LeaveCriticalSection (&critsec);
 194 }
 195
 196 static int trylock (void *unused)
 197 {
 198     return TryEnterCriticalSection (&critsec) == 0;
 199 }
 200 #else
 201 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 202
 203 static void lock (const char *cap)
 204 {
 205     int ret = pthread_mutex_lock (&mutex);
 206     if (ret) {
 207         errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
 208     }
 209 }
 210
 211 static void unlock (const char *cap)
 212 {
 213     int ret = pthread_mutex_unlock (&mutex);
 214     if (ret) {
 215         errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
 216     }
 217 }
 218
 219 static int trylock (const char *cap)
 220 {
 221     int ret = pthread_mutex_trylock (&mutex);
 222
 223     if (ret && ret != EBUSY) {
 224         errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
 225     }
 226     return ret == EBUSY;
 227 }
 228 #endif
 229
 230 static void *parse_pointer (const char *cap, const char *s)
 231 {
 232     int ret;
 233     void *ptr;
 234
 235     ret = sscanf (s, "%p", &ptr);
 236     if (ret != 1) {
 237         errx (1, "%s: cannot parse pointer in `%s'", cap, s);
 238     }
 239     return ptr;
 240 }
 241
 242 static int hasdata (int sock)
 243 {
 244     int ret;
 245     fionread_arg avail;
 246     ret = ioctlsocket (sock, FIONREAD, &avail);
 247     if (ret) sockerr (1, "hasdata: FIONREAD error ret=%d", ret);
 248     return avail > 0;
 249 }
 250
 251 static double now (void)
 252 {
 253     struct timeval tv;
 254
 255     if (gettimeofday (&tv, NULL)) {
 256         err (1, "gettimeofday");
 257     }
 258     return tv.tv_sec + tv.tv_usec*1e-6;
 259 }
 260
 261 static void readdata (int fd, char *p, int size)
 262 {
 263     ssize_t n;
 264
 265     n = recv (fd, p, size, 0);
 266     if (n - size) {
 267         if (!n) errx (1, "EOF while reading");
 268         sockerr (1, "recv (req %d, ret " FMT_ss ")", size, n);
 269     }
 270 }
 271
 272 static void writedata (int fd, char *p, int size)
 273 {
 274     char buf[4];
 275     ssize_t n;
 276
 277     buf[0] = (size >> 24) & 0xff;
 278     buf[1] = (size >> 16) & 0xff;
 279     buf[2] = (size >>  8) & 0xff;
 280     buf[3] = (size >>  0) & 0xff;
 281
 282     n = send (fd, buf, 4, 0);
 283     if (n != 4) {
 284         if (!n) errx (1, "EOF while writing length");
 285         sockerr (1, "send " FMT_ss, n);
 286     }
 287
 288     n = send (fd, p, size, 0);
 289     if (n - size) {
 290         if (!n) errx (1, "EOF while writing data");
 291         sockerr (1, "send (req %d, ret " FMT_ss ")", size, n);
 292     }
 293 }
 294
 295 static void
 296 #ifdef __GNUC__
 297 __attribute__ ((format (printf, 2, 3)))
 298 #endif
 299     printd (int fd, const char *fmt, ...)
 300 {
 301     int size = 200, len;
 302     va_list ap;
 303     char *buf;
 304
 305     va_start (ap, fmt);
 306     buf = malloc (size);
 307     for (;;) {
 308         if (!buf) err (errno, "malloc for temp buf (%d bytes) failed", size);
 309
 310         len = vsnprintf (buf, size, fmt, ap);
 311
 312         if (len > -1 && len < size) {
 313             writedata (fd, buf, len);
 314             break;
 315         }
 316
 317         if (len > -1) {
 318             size = len + 1;
 319         }
 320         else  {
 321             size *= 2;
 322         }
 323         buf = realloc (buf, size);
 324     }
 325     va_end (ap);
 326     free (buf);
 327 }
 328
 329 static void die (fz_error error)
 330 {
 331     fz_catch (error, "aborting");
 332     if (state.xref)
 333        pdf_freexref (state.xref);
 334     exit (1);
 335 }
 336
 337 static void openxref (char *filename)
 338 {
 339     int fd;
 340     fz_error error;
 341     fz_stream *file;
 342
 343     state.pig = NULL;
 344     if (state.xref) {
 345         pdf_freexref (state.xref);
 346         state.xref = NULL;
 347     }
 348     if (state.pagedims) {
 349         free (state.pagedims);
 350         state.pagedims = NULL;
 351     }
 352     state.pagedimcount = 0;
 353
 354     fd = open (filename, O_BINARY | O_RDONLY, 0666);
 355     if (fd < 0)
 356         die (fz_throw ("cannot open file '%s'", filename));
 357
 358     file = fz_openfile (fd);
 359     error = pdf_openxrefwithstream (&state.xref, file, NULL);
 360     if (error)
 361         die (fz_rethrow(error, "cannot open document '%s'", filename));
 362     fz_close (file);
 363
 364     if (pdf_needspassword (state.xref)) {
 365         die (fz_throw ("password protected"));
 366     }
 367
 368     error = pdf_loadpagetree (state.xref);
 369     if (error) {
 370         die (fz_throw ("cannot load page tree"));
 371     }
 372
 373     state.pagecount = pdf_getpagecount (state.xref);
 374 }
 375
 376 static int readlen (int fd)
 377 {
 378     ssize_t n;
 379     unsigned char p[4];
 380
 381     n = recv (fd, p, 4, 0);
 382     if (n != 4) {
 383         if (!n) errx (1, "EOF while reading length");
 384         sockerr (1, "recv " FMT_ss, n);
 385     }
 386
 387     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 388 }
 389
 390 static void unlinkpage (struct page *page)
 391 {
 392     int i;
 393
 394     for (i = 0; i < page->slicecount; ++i) {
 395         struct slice *s = &page->slices[i];
 396         if (s->texindex != -1) {
 397             if (state.texowners[s->texindex].slice == s) {
 398                 state.texowners[s->texindex].slice = NULL;
 399                 ARSERT (state.texowners[s->texindex].w == s->w);
 400                 ARSERT (state.texowners[s->texindex].h >= s->h);
 401             }
 402         }
 403     }
 404 }
 405
 406 static void freepage (struct page *page)
 407 {
 408     fz_droppixmap (page->pixmap);
 409
 410     unlinkpage (page);
 411
 412     if (page->text) {
 413         fz_freetextspan (page->text);
 414     }
 415     if (page->drawpage) {
 416         pdf_freepage (page->drawpage);
 417     }
 418
 419     free (page);
 420 }
 421
 422 static void subdivide (struct page *p)
 423 {
 424     int i;
 425     int h = p->pixmap->h;
 426     int th = MIN (h, state.sliceheight);
 427
 428     for (i = 0; i < p->slicecount; ++i) {
 429         struct slice *s = &p->slices[i];
 430         s->texindex = -1;
 431         s->h = MIN (th, h);
 432         s->w = p->pixmap->w;
 433         h -= th;
 434     }
 435 }
 436
 437 static int compatpdims (struct pagedim *p1, struct pagedim *p2)
 438 {
 439     return p1->rotate == p2->rotate
 440         && !memcmp (&p1->bbox, &p2->bbox, sizeof (p1->bbox))
 441         && !memcmp (&p1->ctm, &p2->ctm, sizeof (p1->ctm));
 442 }
 443
 444 #ifdef __ALTIVEC__
 445 #include <altivec.h>
 446
 447 static int cacheline32bytes;
 448
 449 static void __attribute__ ((constructor)) clcheck (void)
 450 {
 451     char **envp = environ;
 452     unsigned long *auxv;
 453
 454     while (*envp++);
 455
 456     for (auxv = (unsigned long *) envp; *auxv != 0; auxv += 2) {
 457         if (*auxv == 19) {
 458             cacheline32bytes = auxv[1] == 32;
 459             return;
 460         }
 461     }
 462 }
 463
 464 static void __attribute__ ((optimize ("O"))) clearpixmap (fz_pixmap *pixmap)
 465 {
 466     if (cacheline32bytes) {
 467         intptr_t a1, a2, diff;
 468         size_t sizea, i, size = pixmap->w * pixmap->h * pixmap->n;
 469         vector unsigned char v = vec_splat_u8 (-1);
 470         vector unsigned char *p;
 471
 472         a1 = a2 = (intptr_t) pixmap->samples;
 473         a2 = (a1 + 31) & ~31;
 474         diff = a2 - a1;
 475         sizea = size - diff;
 476         p = (void *) a2;
 477
 478         while (a1 != a2) *(char *) a1++ = 0xff;
 479         for (i = 0; i < (sizea & ~31); i += 32)  {
 480             __asm volatile ("dcbz %0, %1"::"b"(a2),"r"(i));
 481             vec_st (v, i, p);
 482             vec_st (v, i + 16, p);
 483         }
 484         while (i < sizea) *((char *) a1 + i++) = 0xff;
 485     }
 486     else fz_clearpixmapwithcolor (pixmap, 0xff);
 487 }
 488 #else
 489 #define clearpixmap(p) fz_clearpixmapwithcolor (p, 0xff)
 490 #endif
 491
 492 static void *render (int pageno, int pindex)
 493 {
 494     fz_error error;
 495     int slicecount;
 496     fz_obj *pageobj;
 497     struct page *page = NULL;
 498     double start, end;
 499     pdf_page *drawpage;
 500     fz_device *idev;
 501     struct pagedim *pagedim;
 502
 503     start = now ();
 504     printd (state.sock, "V rendering %d", pageno);
 505
 506     pagedim = &state.pagedims[pindex];
 507     slicecount = (pagedim->bbox.y1 - pagedim->bbox.y0
 508                   + state.sliceheight - 1) / state.sliceheight;
 509     slicecount += slicecount == 0;
 510
 511     if (state.pig) {
 512         if (compatpdims (&state.pig->pagedim, pagedim)) {
 513             page = state.pig;
 514             if (page->text) {
 515                 fz_freetextspan (page->text);
 516                 page->text = NULL;
 517             }
 518             if (page->drawpage) {
 519                 pdf_freepage (page->drawpage);
 520                 page->drawpage = NULL;
 521             }
 522         }
 523         else {
 524             freepage (state.pig);
 525         }
 526     }
 527     if (!page) {
 528         page = calloc (sizeof (*page)
 529                        + (slicecount * sizeof (struct slice)), 1);
 530         if (!page) {
 531             err (1, "calloc page %d\n", pageno);
 532         }
 533         page->pixmap = fz_newpixmapwithrect (fz_devicergb, pagedim->bbox);
 534     }
 535
 536     page->slicecount = slicecount;
 537
 538     pageobj = pdf_getpageobject (state.xref, pageno);
 539     if (!pageobj)
 540         die (fz_throw ("cannot retrieve info from page %d", pageno));
 541
 542     error = pdf_loadpage (&drawpage, state.xref, pageobj);
 543     if (error)
 544         die (error);
 545
 546     clearpixmap (page->pixmap);
 547
 548     idev = fz_newdrawdevice (state.cache, page->pixmap);
 549     if (!idev)
 550         die (fz_throw ("fz_newdrawdevice failed"));
 551     error = pdf_runpage (state.xref, drawpage, idev, pagedim->ctm);
 552     if (error)
 553         die (fz_rethrow (error, "pdf_runpage failed"));
 554     fz_freedevice (idev);
 555
 556     page->drawpage = drawpage;
 557     page->pagedim = *pagedim;
 558     page->pageno = pageno;
 559     subdivide (page);
 560     end = now ();
 561
 562     pdf_agestore(state.xref->store, 3);
 563
 564     printd (state.sock, "V rendering %d took %f sec", pageno, end - start);
 565     state.pig = NULL;
 566     return page;
 567 }
 568
 569 static void initpdims (void)
 570 {
 571     int pageno;
 572     double start, end;
 573
 574     start = now ();
 575     for (pageno = 0; pageno < state.pagecount; ++pageno) {
 576         int rotate;
 577         fz_rect box;
 578         struct pagedim *p;
 579         fz_obj *obj, *pageobj;
 580
 581         pageobj = pdf_getpageobject (state.xref, pageno + 1);
 582
 583         obj = fz_dictgets (pageobj, "CropBox");
 584         if (!fz_isarray (obj)) {
 585             obj = fz_dictgets (pageobj, "MediaBox");
 586             if (!fz_isarray (obj)) {
 587                 die (fz_throw ("cannot find page bounds %d (%d Rd)",
 588                                fz_tonum (pageobj), fz_togen (pageobj)));
 589             }
 590         }
 591         box = pdf_torect (obj);
 592
 593         obj = fz_dictgets (pageobj, "Rotate");
 594         if (fz_isint (obj)) {
 595             rotate = fz_toint (obj);
 596         }
 597         else  {
 598             rotate = 0;
 599         }
 600         rotate += state.rotate;
 601
 602         p = &state.pagedims[state.pagedimcount - 1];
 603         if ((state.pagedimcount == 0)
 604             || (p->rotate != rotate || memcmp (&p->box, &box, sizeof (box)))) {
 605             size_t size;
 606
 607             size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
 608             state.pagedims = realloc (state.pagedims, size);
 609             if (!state.pagedims) {
 610                 err (1, "realloc pagedims to " FMT_s " (%d elems)",
 611                      size, state.pagedimcount + 1);
 612             }
 613             p = &state.pagedims[state.pagedimcount++];
 614             p->rotate = rotate;
 615             p->box = box;
 616             p->pageno = pageno;
 617         }
 618     }
 619     end = now ();
 620     printd (state.sock, "T Processed %d pages in %f seconds",
 621             state.pagecount, end - start);
 622 }
 623
 624 static void layout (void)
 625 {
 626     int pindex;
 627     fz_matrix ctm;
 628     fz_rect box, box2;
 629     double zoom, w;
 630     struct pagedim *p = state.pagedims;
 631
 632     pindex = 0;
 633     for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
 634         box.x0 = MIN (p->box.x0, p->box.x1);
 635         box.y0 = MIN (p->box.y0, p->box.y1);
 636         box.x1 = MAX (p->box.x0, p->box.x1);
 637         box.y1 = MAX (p->box.y0, p->box.y1);
 638
 639         ctm = fz_identity;
 640         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 641         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 642         box2 = fz_transformrect (ctm, box);
 643         w = box2.x1 - box2.x0;
 644
 645         zoom = (state.w / w);
 646         ctm = fz_identity;
 647         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 648         ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
 649         memcpy (&p->ctm1, &ctm, sizeof (ctm));
 650         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 651         p->bbox = fz_roundrect (fz_transformrect (ctm, box));
 652         memcpy (&p->ctm, &ctm, sizeof (ctm));
 653     }
 654
 655     while (p-- != state.pagedims)  {
 656         printd (state.sock, "l %d %d %d",
 657                 p->pageno, p->bbox.x1 - p->bbox.x0, p->bbox.y1 - p->bbox.y0);
 658     }
 659 }
 660
 661 static void recurse_outline (pdf_outline *outline, int level)
 662 {
 663     while (outline) {
 664         int i;
 665         fz_obj *obj;
 666         int pageno = -1;
 667         int top = 0, h = 0;
 668
 669         if (!outline->link) goto next;
 670
 671         obj = outline->link->dest;
 672         if (fz_isindirect (obj)) {
 673             obj = fz_resolveindirect (obj);
 674         }
 675         if (fz_isarray (obj)) {
 676             fz_obj *obj2;
 677
 678             obj2 = fz_arrayget (obj, 0);
 679             if (fz_isint (obj2)) {
 680                 pageno = fz_toint (obj2);
 681             }
 682             else {
 683                 pageno = pdf_findpageobject (state.xref, obj2) - 1;
 684             }
 685
 686             if (fz_arraylen (obj) > 3) {
 687                 fz_point p;
 688                 fz_obj *xo, *yo;
 689
 690                 xo = fz_arrayget (obj, 2);
 691                 yo = fz_arrayget (obj, 3);
 692                 if (!fz_isnull (xo) && !fz_isnull (yo)) {
 693                     struct pagedim *pagedim = state.pagedims;
 694
 695                     for (i = 0; i < state.pagedimcount; ++i) {
 696                         if (state.pagedims[i].pageno > pageno)
 697                             break;
 698                         pagedim = &state.pagedims[i];
 699                     }
 700                     p.x = fz_toint (xo);
 701                     p.y = fz_toint (yo);
 702                     p = fz_transformpoint (pagedim->ctm, p);
 703                     h = pagedim->bbox.y1 - pagedim->bbox.y0;
 704                     top = p.y;
 705                 }
 706             }
 707         }
 708         else {
 709             pageno = pdf_findpageobject (state.xref, outline->link->dest) - 1;
 710         }
 711
 712         lprintf ("%*c%s %d\n", level, ' ', outline->title, pageno);
 713         printd (state.sock, "o %d %d %d %d %s",
 714                 level, pageno, top, h, outline->title);
 715     next:
 716         if (outline->child) {
 717             recurse_outline (outline->child, level + 1);
 718         }
 719         outline = outline->next;
 720     }
 721 }
 722
 723 static void process_outline (void)
 724 {
 725     pdf_outline *outline;
 726
 727     if (!state.needoutline) return;
 728
 729     state.needoutline = 0;
 730     outline = pdf_loadoutline (state.xref);
 731     if (outline) {
 732         recurse_outline (outline, 0);
 733         pdf_freeoutline (outline);
 734     }
 735 }
 736
 737 static int comparespans (const void *l, const void *r)
 738 {
 739     fz_textspan const *const*ls = l;
 740     fz_textspan const *const*rs = r;
 741     return (*ls)->text->bbox.y0 - (*rs)->text->bbox.y0;
 742 }
 743
 744 /* wishful thinking function */
 745 static void search (regex_t *re, int pageno, int y, int forward)
 746 {
 747     int i, j;
 748     int ret;
 749     char *p;
 750     char buf[256];
 751     fz_matrix ctm;
 752     fz_error error;
 753     fz_obj *pageobj;
 754     fz_device *tdev;
 755     pdf_page *drawpage;
 756     fz_textspan *text, *span, **pspan;
 757     struct pagedim *pdim, *pdimprev;
 758     int stop = 0;
 759     int niters = 0;
 760     int nspans;
 761     double start, end;
 762
 763     start = now ();
 764     while (pageno >= 0 && pageno < state.pagecount && !stop) {
 765         if (niters++ == 5) {
 766             pdf_agestore(state.xref->store, 3);
 767             niters = 0;
 768             if (hasdata (state.sock)) {
 769                 printd (state.sock, "T attention requested aborting search at %d",
 770                         pageno);
 771                 stop = 1;
 772             }
 773             else {
 774                 printd (state.sock, "T searching in page %d", pageno);
 775             }
 776         }
 777         pdimprev = NULL;
 778         for (i = 0; i < state.pagedimcount; ++i) {
 779             pdim = &state.pagedims[i];
 780             if (pdim->pageno == pageno)  {
 781                 goto found;
 782             }
 783             if (pdim->pageno > pageno) {
 784                 pdim = pdimprev;
 785                 goto found;
 786             }
 787             pdimprev = pdim;
 788         }
 789         pdim = pdimprev;
 790     found:
 791
 792         pageobj = pdf_getpageobject (state.xref, pageno + 1);
 793         if (!pageobj)
 794             die (fz_throw ("cannot retrieve info from page %d", pageno));
 795
 796         error = pdf_loadpage (&drawpage, state.xref, pageobj);
 797         if (error)
 798             die (error);
 799
 800         ctm = fz_rotate (pdim->rotate);
 801
 802         text = fz_newtextspan ();
 803         tdev = fz_newtextdevice (text);
 804         error = pdf_runpage (state.xref, drawpage, tdev, pdim->ctm1);
 805         if (error) die (error);
 806         fz_freedevice (tdev);
 807
 808         nspans = 0;
 809         for (span = text; span; span = span->next) {
 810             nspans++;
 811         }
 812         pspan = malloc (sizeof (void *) * nspans);
 813         if (!pspan) {
 814             err (1, "malloc span pointers " FMT_s, sizeof (void *) * nspans);
 815         }
 816         for (i = 0, span = text; span; span = span->next, ++i) {
 817             pspan[i] = span;
 818         }
 819         qsort (pspan, nspans, sizeof (fz_textspan *), comparespans);
 820
 821         j = forward ? 0 : nspans - 1;
 822         while (nspans--) {
 823             regmatch_t rm;
 824
 825             span = pspan[j];
 826             j += forward ? 1 : -1;
 827             p = buf;
 828             for (i = 0; i < MIN (span->len, (int) sizeof (buf) - 1); ++i) {
 829                 if (forward) {
 830                     if (span->text[i].bbox.y0 < y + 1) {
 831                         continue;
 832                     }
 833                 }
 834                 else {
 835                     if (span->text[i].bbox.y0 > y - 1) {
 836                         continue;
 837                     }
 838                 }
 839                 if (span->text[i].c < 256) {
 840                     *p++ = span->text[i].c;
 841                 }
 842                 else  {
 843                     *p++ = '?';
 844                 }
 845             }
 846             if (p == buf) {
 847                 continue;
 848             }
 849             *p++ = 0;
 850
 851             ret = regexec (re, buf, 1, &rm, 0);
 852             if (ret)  {
 853                 if (ret != REG_NOMATCH) {
 854                     size_t size;
 855                     char errbuf[80];
 856                     size = regerror (ret, re, errbuf, sizeof (errbuf));
 857                     printd (state.sock,
 858                             "T regexec error `%.*s'",
 859                             (int) size, errbuf);
 860                     fz_freetextspan (text);
 861                     pdf_freepage (drawpage);
 862                     free (pspan);
 863                     return;
 864                 }
 865             }
 866             else  {
 867                 int xoff, yoff;
 868                 fz_bbox *sb, *eb;
 869                 fz_point p1, p2, p3, p4;
 870
 871                 xoff = -pdim->bbox.x0;
 872                 yoff = -pdim->bbox.y0;
 873
 874                 sb = &span->text[rm.rm_so].bbox;
 875                 eb = &span->text[rm.rm_eo - 1].bbox;
 876
 877                 p1.x = sb->x0;
 878                 p1.y = sb->y0;
 879                 p2.x = eb->x1;
 880                 p2.y = sb->y0;
 881                 p3.x = eb->x1;
 882                 p3.y = eb->y1;
 883                 p4.x = sb->x0;
 884                 p4.y = eb->y1;
 885
 886                 p1 = fz_transformpoint (ctm, p1);
 887                 p2 = fz_transformpoint (ctm, p2);
 888                 p3 = fz_transformpoint (ctm, p3);
 889                 p4 = fz_transformpoint (ctm, p4);
 890
 891                 if (!stop) {
 892                     printd (state.sock, "F %d %d %f %f %f %f %f %f %f %f",
 893                             pageno, 1,
 894                             p1.x + xoff, p1.y + yoff,
 895                             p2.x + xoff, p2.y + yoff,
 896                             p3.x + xoff, p3.y + yoff,
 897                             p4.x + xoff, p4.y + yoff);
 898
 899                     printd (state.sock, "T found at %d `%.*s' in %f sec",
 900                             pageno, rm.rm_eo - rm.rm_so, &buf[rm.rm_so],
 901                             now () - start);
 902                 }
 903                 else  {
 904                     printd (state.sock, "R %d %d %f %f %f %f %f %f %f %f",
 905                             pageno, 2,
 906                             p1.x + xoff, p1.y + yoff,
 907                             p2.x + xoff, p2.y + yoff,
 908                             p3.x + xoff, p3.y + yoff,
 909                             p4.x + xoff, p4.y + yoff);
 910                 }
 911                 stop = 1;
 912             }
 913         }
 914         if (forward) {
 915             pageno += 1;
 916             y = 0;
 917         }
 918         else {
 919             pageno -= 1;
 920             y = INT_MAX;
 921         }
 922         fz_freetextspan (text);
 923         pdf_freepage (drawpage);
 924         free (pspan);
 925     }
 926     end = now ();
 927     if (!stop)  {
 928         printd (state.sock, "T no matches %f sec", end - start);
 929     }
 930     printd (state.sock, "D");
 931 }
 932
 933 static
 934 #ifdef _WIN32
 935 DWORD _stdcall
 936 #else
 937 void *
 938 #endif
 939 mainloop (void *unused)
 940 {
 941     char *p = NULL;
 942     int len, ret, oldlen = 0;
 943
 944     for (;;) {
 945         len = readlen (state.sock);
 946         if (len == 0) {
 947             errx (1, "readlen returned 0");
 948         }
 949
 950         if (oldlen < len + 1) {
 951             p = realloc (p, len + 1);
 952             if (!p) {
 953                 err (1, "realloc %d failed", len + 1);
 954             }
 955             oldlen = len + 1;
 956         }
 957         readdata (state.sock, p, len);
 958         p[len] = 0;
 959
 960         if (!strncmp ("open", p, 4)) {
 961             fz_obj *obj;
 962             char *filename = p + 5;
 963
 964             openxref (filename);
 965             initpdims ();
 966
 967             obj = fz_dictgets (state.xref->trailer, "Info");
 968             if (obj) {
 969                 char *s;
 970
 971                 obj = fz_dictgets (obj, "Title");
 972                 s = pdf_toutf8 (obj);
 973                 if (*s) {
 974                     printd (state.sock, "t %s", s);
 975                 }
 976                 fz_free (s);
 977             }
 978             state.needoutline = 1;
 979         }
 980         else if (!strncmp ("free", p, 4)) {
 981             void *ptr;
 982
 983             ret = sscanf (p + 4, " %p", &ptr);
 984             if (ret != 1) {
 985                 errx (1, "malformed free `%.*s' ret=%d", len, p, ret);
 986             }
 987             unlinkpage (ptr);
 988             state.pig = ptr;
 989         }
 990         else if (!strncmp ("search", p, 6)) {
 991             int icase, pageno, y, ret, len2, forward;
 992             char *pattern;
 993             regex_t re;
 994
 995             ret = sscanf (p + 6, " %d %d %d %d,%n",
 996                           &icase, &pageno, &y, &forward, &len2);
 997             if (ret != 4) {
 998                 errx (1, "malformed search `%s' ret=%d", p, ret);
 999             }
1000
1001             pattern = p + 6 + len2;
1002             ret = regcomp (&re, pattern,
1003                            REG_EXTENDED | (icase ? REG_ICASE : 0));
1004             if (ret) {
1005                 char errbuf[80];
1006                 size_t size;
1007
1008                 size = regerror (ret, &re, errbuf, sizeof (errbuf));
1009                 printd (state.sock, "T regcomp failed `%.*s'",
1010                         (int) size, errbuf);
1011             }
1012             else  {
1013                 search (&re, pageno, y, forward);
1014                 regfree (&re);
1015             }
1016         }
1017         else if (!strncmp ("geometry", p, 8)) {
1018             int w, h;
1019
1020             printd (state.sock, "c");
1021             ret = sscanf (p + 8, " %d %d", &w, &h);
1022             if (ret != 2) {
1023                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
1024             }
1025
1026             lock ("geometry");
1027             state.h = h;
1028             if (w != state.w) {
1029                 int i;
1030                 state.w = w;
1031                 for (i = 0; i < state.texcount; ++i)  {
1032                     state.texowners[i].slice = NULL;
1033                 }
1034             }
1035             layout ();
1036             process_outline ();
1037             unlock ("geometry");
1038             printd (state.sock, "C %d", state.pagecount);
1039         }
1040         else if (!strncmp ("rotate", p, 6)) {
1041             float rotate;
1042
1043             printd (state.sock, "c");
1044             ret = sscanf (p + 6, " %f", &rotate);
1045             if (ret != 1) {
1046                 errx (1, "bad rotate line `%.*s' ret=%d", len, p, ret);
1047             }
1048             lock ("rotate");
1049             state.rotate = rotate;
1050             state.pagedimcount = 0;
1051             free (state.pagedims);
1052             state.pagedims = NULL;
1053             initpdims ();
1054             layout ();
1055             process_outline ();
1056             if (state.pig) {
1057                 freepage (state.pig);
1058                 state.pig = NULL;
1059             }
1060             unlock ("rotate");
1061             printd (state.sock, "C %d", state.pagecount);
1062         }
1063         else if (!strncmp ("render", p, 6)) {
1064             int pageno, pindex, w, h, ret;
1065             struct page *page;
1066
1067             ret = sscanf (p + 6, " %d %d %d %d", &pageno, &pindex, &w, &h);
1068             if (ret != 4) {
1069                 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
1070             }
1071
1072             lock ("render");
1073             page = render (pageno, pindex);
1074             unlock ("render");
1075
1076             printd (state.sock, "r %d %d %d %d %p",
1077                     pageno,
1078                     state.w,
1079                     state.h,
1080                     state.rotate,
1081                     page);
1082         }
1083         else if (!strncmp ("interrupt", p, 9)) {
1084             printd (state.sock, "V interrupted");
1085         }
1086         else {
1087             errx (1, "unknown command %.*s", len, p);
1088         }
1089     }
1090     return 0;
1091 }
1092
1093 static void showsel (struct page *page, int oy)
1094 {
1095     int ox;
1096     fz_bbox bbox;
1097     fz_textspan *span;
1098     struct mark first, last;
1099
1100     first = page->fmark;
1101     last = page->lmark;
1102
1103     if (!first.span || !last.span) return;
1104
1105     glEnable (GL_BLEND);
1106     glBlendFunc (GL_SRC_ALPHA, GL_SRC_ALPHA);
1107     glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
1108
1109     ox = -page->pixmap->x;
1110     oy = -page->pixmap->y + oy;
1111     for (span = first.span; span; span = span->next) {
1112         int i, j, k;
1113
1114         bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0;
1115
1116         j = 0;
1117         k = span->len - 1;
1118
1119         if (span == page->fmark.span && span == page->lmark.span) {
1120             j = MIN (first.i, last.i);
1121             k = MAX (first.i, last.i);
1122         }
1123         else if (span == first.span) {
1124             j = first.i;
1125         }
1126         else if (span == last.span) {
1127             k = last.i;
1128         }
1129
1130         for (i = j; i <= k; ++i) {
1131             bbox = fz_unionbbox (bbox, span->text[i].bbox);
1132         }
1133         lprintf ("%d %d %d %d oy=%d ox=%d\n",
1134                  bbox.x0,
1135                  bbox.y0,
1136                  bbox.x1,
1137                  bbox.y1,
1138                  oy, ox);
1139
1140         glRecti (bbox.x0 + ox, bbox.y0 + oy, bbox.x1 + ox, bbox.y1 + oy);
1141
1142         if (span == last.span) break;
1143     }
1144     glDisable (GL_BLEND);
1145 }
1146
1147 static void highlightlinks (struct page *page, int yoff)
1148 {
1149     pdf_link *link;
1150     int xoff;
1151
1152     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1153     glEnable (GL_LINE_STIPPLE);
1154     glLineStipple (0.5, 0xcccc);
1155
1156     xoff = -page->pixmap->x;
1157     yoff -= page->pixmap->y;
1158
1159     glBegin (GL_QUADS);
1160     for (link = page->drawpage->links; link; link = link->next) {
1161         fz_point p1, p2, p3, p4;
1162         fz_matrix ctm = page->pagedim.ctm;
1163
1164         p1.x = link->rect.x0;
1165         p1.y = link->rect.y0;
1166
1167         p2.x = link->rect.x1;
1168         p2.y = link->rect.y0;
1169
1170         p3.x = link->rect.x1;
1171         p3.y = link->rect.y1;
1172
1173         p4.x = link->rect.x0;
1174         p4.y = link->rect.y1;
1175
1176         p1 = fz_transformpoint (ctm, p1);
1177         p2 = fz_transformpoint (ctm, p2);
1178         p3 = fz_transformpoint (ctm, p3);
1179         p4 = fz_transformpoint (ctm, p4);
1180
1181         switch (link->kind) {
1182         case PDF_LGOTO: glColor3ub (255, 0, 0); break;
1183         case PDF_LURI: glColor3ub (0, 0, 255); break;
1184         default: glColor3ub (0, 0, 0); break;
1185         }
1186
1187         glVertex2f (p1.x + xoff, p1.y + yoff);
1188         glVertex2f (p2.x + xoff, p2.y + yoff);
1189         glVertex2f (p3.x + xoff, p3.y + yoff);
1190         glVertex2f (p4.x + xoff, p4.y + yoff);
1191     }
1192     glEnd ();
1193
1194     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1195     glDisable (GL_LINE_STIPPLE);
1196 }
1197
1198 static void upload2 (struct page *page, int slicenum, const char *cap)
1199 {
1200     int i;
1201     int w, h;
1202     double start, end;
1203     struct slice *slice = &page->slices[slicenum];
1204
1205     w = page->pixmap->w;
1206     h = page->pixmap->h;
1207
1208     ARSERT (w == slice->w);
1209     if (slice->texindex != -1
1210         && state.texowners[slice->texindex].slice == slice) {
1211         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
1212     }
1213     else  {
1214         int subimage = 0;
1215         int index = (state.texindex++ % state.texcount);
1216         size_t offset = 0;
1217
1218         for (i = 0; i < slicenum; ++i) {
1219             offset += w * page->slices[i].h * 4;
1220         }
1221
1222         if (state.texowners[index].w == slice->w) {
1223             if (state.texowners[index].h >= slice->h ) {
1224                 subimage = 1;
1225             }
1226             else {
1227                 state.texowners[index].h = slice->h;
1228             }
1229         }
1230         else  {
1231             state.texowners[index].h = slice->h;
1232         }
1233
1234         state.texowners[index].slice = slice;
1235         state.texowners[index].w = slice->w;
1236         slice->texindex = index;
1237
1238         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
1239         start = now ();
1240         if (subimage) {
1241             {
1242                 GLenum err = glGetError ();
1243                 if (err != GL_NO_ERROR) {
1244                     printf ("\033[0;31mERROR1 %d %d %#x\033[0m\n", w, slice->h, err);
1245                     abort ();
1246                 }
1247             }
1248             glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
1249                              0,
1250                              0,
1251                              0,
1252                              w,
1253                              slice->h,
1254                              state.texform,
1255                              state.texty,
1256                              page->pixmap->samples + offset
1257                 );
1258             {
1259                 GLenum err = glGetError ();
1260                 if (err != GL_NO_ERROR) {
1261                     printf ("\033[0;31mERROR %d %d %#x\033[0m\n", w, slice->h, err);
1262                     abort ();
1263                 }
1264             }
1265         }
1266         else {
1267             glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
1268                           0,
1269                           GL_RGBA8,
1270                           w,
1271                           slice->h,
1272                           0,
1273                           state.texform,
1274                           state.texty,
1275                           page->pixmap->samples + offset
1276                 );
1277         }
1278
1279         end = now ();
1280         lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1281                  subimage ? "sub" : "img",
1282                  page->pageno, slicenum,
1283                  slice->w, slice->h,
1284                  state.texids[slice->texindex],
1285                  end - start);
1286     }
1287 }
1288
1289 CAMLprim value ml_draw (value args_v, value ptr_v)
1290 {
1291     CAMLparam2 (args_v, ptr_v);
1292     int dispy = Int_val (Field (args_v, 0));
1293     int w = Int_val (Field (args_v, 1));
1294     int h = Int_val (Field (args_v, 2));
1295     int py = Int_val (Field (args_v, 3));
1296     int hlinks = Bool_val (Field (args_v, 4));
1297     char *s = String_val (ptr_v);
1298     int ret;
1299     void *ptr;
1300     struct page *page;
1301     int slicenum = 0;
1302     int yoff = dispy - py;
1303
1304     ret = sscanf (s, "%p", &ptr);
1305     if (ret != 1) {
1306         errx (1, "cannot parse pointer `%s'", s);
1307     }
1308     page = ptr;
1309
1310     w = page->pixmap->w;
1311
1312     ARSERT (h >= 0 && "ml_draw wrong h");
1313     ARSERT (py <= page->pixmap->h && "ml_draw wrong py");
1314
1315     glEnable (GL_TEXTURE_RECTANGLE_ARB);
1316
1317     for (slicenum = 0; slicenum < page->slicecount; ++slicenum) {
1318         struct slice *slice = &page->slices[slicenum];
1319         if (slice->h > py) {
1320             break;
1321         }
1322         py -= slice->h;
1323     }
1324
1325     h = MIN (state.h, h);
1326     while (h) {
1327         int th;
1328         struct slice *slice = &page->slices[slicenum];
1329
1330         ARSERT (slicenum < page->slicecount && "ml_draw wrong slicenum");
1331
1332         th = MIN (h, slice->h - py);
1333         upload2 (page, slicenum, "upload");
1334
1335         glBegin (GL_QUADS);
1336         {
1337             glTexCoord2i (0, py);
1338             glVertex2i (0, dispy);
1339
1340             glTexCoord2i (w, py);
1341             glVertex2i (w, dispy);
1342
1343             glTexCoord2i (w, py+th);
1344             glVertex2i (w, dispy + th);
1345
1346             glTexCoord2i (0, py+th);
1347             glVertex2i (0, dispy + th);
1348         }
1349         glEnd ();
1350
1351         h -= th;
1352         py = 0;
1353         dispy += th;
1354         slicenum += 1;
1355     }
1356
1357     showsel (page, yoff);
1358     if (hlinks) highlightlinks (page, yoff);
1359     glDisable (GL_TEXTURE_RECTANGLE_ARB);
1360
1361     CAMLreturn (Val_unit);
1362 }
1363
1364 static pdf_link *getlink (struct page *page, int x, int y)
1365 {
1366     fz_point p;
1367     fz_matrix ctm;
1368     pdf_link *link;
1369
1370     p.x = x + page->pixmap->x;
1371     p.y = y + page->pixmap->y;
1372
1373     ctm = fz_invertmatrix (page->pagedim.ctm);
1374     p = fz_transformpoint (ctm, p);
1375
1376     for (link = page->drawpage->links; link; link = link->next) {
1377         if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1378             if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1379                 return link;
1380             }
1381         }
1382     }
1383     return NULL;
1384 }
1385
1386 static void ensuretext (struct page *page)
1387 {
1388     if (!page->text) {
1389         fz_error error;
1390         fz_device *tdev;
1391
1392         page->text = fz_newtextspan ();
1393         tdev = fz_newtextdevice (page->text);
1394         error = pdf_runpage (state.xref, page->drawpage, tdev,
1395                              page->pagedim.ctm);
1396         if (error) die (error);
1397         fz_freedevice (tdev);
1398     }
1399 }
1400
1401 CAMLprim value ml_whatsunder (value ptr_v, value x_v, value y_v)
1402 {
1403     CAMLparam3 (ptr_v, x_v, y_v);
1404     CAMLlocal3 (ret_v, tup_v, str_v);
1405     pdf_link *link;
1406     struct page *page;
1407     char *s = String_val (ptr_v);
1408
1409     ret_v = Val_int (0);
1410     if (trylock ("ml_whatsunder")) {
1411         goto done;
1412     }
1413
1414     page = parse_pointer ("ml_whatsunder", s);
1415     link = getlink (page, Int_val (x_v), Int_val (y_v));
1416     if (link) {
1417         switch (link->kind) {
1418         case PDF_LGOTO:
1419             {
1420                 int pageno;
1421                 fz_point p;
1422                 fz_obj *obj;
1423
1424                 pageno = -1;
1425                 p.x = 0;
1426                 p.y = 0;
1427
1428                 if (fz_isarray (link->dest)) {
1429                     obj = fz_arrayget (link->dest, 0);
1430                     if (fz_isindirect (obj)) {
1431                         pageno = pdf_findpageobject (state.xref, obj) - 1;
1432                     }
1433                     else if (fz_isint (obj)) {
1434                         pageno = fz_toint (obj);
1435                     }
1436
1437                     if (fz_arraylen (link->dest) > 3) {
1438                         fz_obj *xo, *yo;
1439
1440                         xo = fz_arrayget (link->dest, 2);
1441                         yo = fz_arrayget (link->dest, 3);
1442                         if (!fz_isnull (xo) && !fz_isnull (yo)) {
1443                             p.x = fz_toint (xo);
1444                             p.y = fz_toint (yo);
1445                             p = fz_transformpoint (page->pagedim.ctm, p);
1446                         }
1447                     }
1448                 }
1449                 else {
1450                     pageno = pdf_findpageobject (state.xref, link->dest) - 1;
1451                 }
1452                 tup_v = caml_alloc_tuple (2);
1453                 ret_v = caml_alloc_small (1, 1);
1454                 Field (tup_v, 0) = Val_int (pageno);
1455                 Field (tup_v, 1) = Val_int (p.y);
1456                 Field (ret_v, 0) = tup_v;
1457             }
1458             break;
1459
1460         case PDF_LURI:
1461             str_v = caml_copy_string (fz_tostrbuf (link->dest));
1462             ret_v = caml_alloc_small (1, 0);
1463             Field (ret_v, 0) = str_v;
1464             break;
1465
1466         default:
1467             printd (state.sock, "T unhandled link kind %d", link->kind);
1468             break;
1469         }
1470     }
1471     else {
1472         int i, x, y;
1473         fz_textspan *span;
1474
1475         ensuretext (page);
1476         x = Int_val (x_v) + page->pixmap->x;
1477         y = Int_val (y_v) + page->pixmap->y;
1478
1479         for (span = page->text; span; span = span->next) {
1480             for (i = 0; i < span->len; ++i) {
1481                 fz_bbox *b;
1482                 b = &span->text[i].bbox;
1483                 if ((x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1)) {
1484                     const char *n2 =
1485                         span->font && span->font->name
1486                         ? span->font->name
1487                         : "Span has no font name"
1488                         ;
1489 #ifdef FT_FREETYPE_H
1490                     FT_FaceRec *face = span->font->ftface;
1491                     if (face && face->family_name) {
1492                         char *s;
1493                         char *n1 = face->family_name;
1494                         size_t l1 = strlen (n1);
1495                         size_t l2 = strlen (n2);
1496
1497                         if (l1 != l2 || memcmp (n1, n2, l1)) {
1498                             s = malloc (l1 + l2 + 2);
1499                             if (s) {
1500                                 memcpy (s, n2, l2);
1501                                 s[l2] = '=';
1502                                 memcpy (s + l2 + 1, n1, l1 + 1);
1503                                 str_v = caml_copy_string (s);
1504                                 free (s);
1505                             }
1506                         }
1507                     }
1508                     if (str_v == 0) {
1509                         str_v = caml_copy_string (n2);
1510                     }
1511 #else
1512                     str_v = caml_copy_string (n2);
1513 #endif
1514                     ret_v = caml_alloc_small (1, 2);
1515                     Field (ret_v, 0) = str_v;
1516                     goto unlock;
1517                 }
1518             }
1519         }
1520     }
1521  unlock:
1522     unlock ("ml_whatsunder");
1523
1524  done:
1525     CAMLreturn (ret_v);
1526 }
1527
1528 CAMLprim value ml_seltext (value ptr_v, value rect_v, value oy_v)
1529 {
1530     CAMLparam4 (ptr_v, rect_v, oy_v, rect_v);
1531     fz_bbox *b;
1532     struct page *page;
1533     fz_textspan *span;
1534     struct mark first, last;
1535     int i, x0, x1, y0, y1, oy;
1536     char *s = String_val (ptr_v);
1537
1538     if (trylock ("ml_seltext")) {
1539         goto done;
1540     }
1541
1542     page = parse_pointer ("ml_seltext", s);
1543     ensuretext (page);
1544
1545     oy = Int_val (oy_v);
1546     x0 = Int_val (Field (rect_v, 0));
1547     y0 = Int_val (Field (rect_v, 1));
1548     x1 = Int_val (Field (rect_v, 2));
1549     y1 = Int_val (Field (rect_v, 3));
1550
1551     if (0) {
1552         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1553         glColor3ub (128, 128, 128);
1554         glRecti (x0, y0, x1, y1);
1555         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1556     }
1557
1558     x0 += page->pixmap->x;
1559     y0 += page->pixmap->y - oy;
1560     x1 += page->pixmap->x;
1561     y1 += page->pixmap->y - oy;
1562
1563     first.span = NULL;
1564     last.span = NULL;
1565
1566     last.i = first.i = 0;
1567     first.span = page->text;
1568     for (span = page->text; span; span = span->next) {
1569         for (i = 0; i < span->len; ++i) {
1570             b = &span->text[i].bbox;
1571             if (x0 >= b->x0 && x0 <= b->x1 && y0 >= b->y0 && y0 <= b->y1) {
1572                 first.i = i;
1573                 first.span = span;
1574             }
1575             if (x1 >= b->x0 && x1 <= b->x1 && y1 >= b->y0 && y1 <= b->y1) {
1576                 last.i = i;
1577                 last.span = span;
1578             }
1579         }
1580     }
1581
1582     if (y1 < y0 || x1 < x0) {
1583         int swap = 0;
1584
1585         if (first.span == last.span)  {
1586             swap = 1;
1587         }
1588         else {
1589             if (y1 < y0) {
1590                 for (span = first.span; span && span != last.span;
1591                      span = span->next) {
1592                     if (span->eol) {
1593                         swap = 1;
1594                         break;
1595                     }
1596                 }
1597             }
1598         }
1599
1600         if (swap) {
1601             i = first.i;
1602             span = first.span;
1603             first.i = last.i;
1604             first.span = last.span;
1605             last.i = i;
1606             last.span = span;
1607         }
1608     }
1609
1610     page->fmark = first;
1611     page->lmark = last;
1612
1613     unlock ("ml_seltext");
1614
1615  done:
1616     CAMLreturn (Val_unit);
1617 }
1618
1619 static int pipespan (FILE *f, fz_textspan *span, int a, int b)
1620 {
1621     char buf[4];
1622     int i, len, ret;
1623
1624     for (i = a; i <= b; ++i) {
1625         len = runetochar (buf, &span->text[i].c);
1626         ret = fwrite (buf, len, 1, f);
1627
1628         if (ret != 1) {
1629             printd (state.sock, "T failed to write %d bytes ret=%d: %s",
1630                     len, ret, strerror (errno));
1631             return -1;
1632         }
1633     }
1634     return 0;
1635 }
1636
1637 CAMLprim value ml_copysel (value ptr_v)
1638 {
1639     CAMLparam1 (ptr_v);
1640     FILE *f;
1641     struct page *page;
1642     char *s = String_val (ptr_v);
1643
1644     if (trylock ("ml_copysel")) {
1645         goto done;
1646     }
1647
1648     if (!*s)  {
1649     close:
1650 #ifdef USE_XSEL
1651         if (state.xselpipe) {
1652             int ret = pclose (state.xselpipe);
1653             if (ret)  {
1654                 printd (state.sock, "T failed to close xsel pipe `%s'",
1655                         strerror (errno));
1656             }
1657             state.xselpipe = NULL;
1658         }
1659 #else
1660         printf ("========================================\n");
1661 #endif
1662     }
1663     else {
1664         fz_textspan *span;
1665
1666         page = parse_pointer ("ml_sopysel", s);
1667
1668         if (!page->fmark.span || !page->lmark.span) {
1669             printd (state.sock, "T nothing to copy");
1670             goto unlock;
1671         }
1672
1673         f = stdout;
1674 #ifdef USE_XSEL
1675         if (!state.xselpipe) {
1676             state.xselpipe = popen ("xsel -i", "w");
1677             if (!state.xselpipe) {
1678                 printd (state.sock, "T failed to open xsel pipe `%s'",
1679                         strerror (errno));
1680             }
1681             else {
1682                 f = state.xselpipe;
1683             }
1684         }
1685         else  {
1686             f = state.xselpipe;
1687         }
1688 #endif
1689
1690         for (span = page->fmark.span;
1691              span && span != page->lmark.span->next;
1692              span = span->next) {
1693             int a = span == page->fmark.span ? page->fmark.i : 0;
1694             int b = span == page->lmark.span ? page->lmark.i : span->len - 1;
1695             if (pipespan (f, span, a, b))  {
1696                 goto close;
1697             }
1698             if (span->eol)  {
1699                 if (putc ('\n', f) == EOF) {
1700                     printd (state.sock, "T failed break line on xsel pipe `%s'",
1701                             strerror (errno));
1702                     goto close;
1703                 }
1704             }
1705         }
1706         page->lmark.span = NULL;
1707         page->fmark.span = NULL;
1708     }
1709
1710  unlock:
1711     unlock ("ml_copysel");
1712
1713  done:
1714     CAMLreturn (Val_unit);
1715 }
1716
1717 CAMLprim value ml_getpagewh (value pagedimno_v)
1718 {
1719     CAMLparam1 (pagedimno_v);
1720     CAMLlocal1 (ret_v);
1721     int pagedimno = Int_val (pagedimno_v);
1722
1723     ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
1724     Store_double_field (ret_v, 0, state.pagedims[pagedimno].box.x0);
1725     Store_double_field (ret_v, 1, state.pagedims[pagedimno].box.x1);
1726     Store_double_field (ret_v, 2, state.pagedims[pagedimno].box.y0);
1727     Store_double_field (ret_v, 3, state.pagedims[pagedimno].box.y1);
1728     CAMLreturn (ret_v);
1729 }
1730
1731 CAMLprim value ml_init (value sock_v)
1732 {
1733 #ifndef _WIN32
1734     int ret;
1735 #endif
1736     CAMLparam1 (sock_v);
1737
1738     state.texcount = 256;
1739     state.sliceheight = 24;
1740     state.texform = GL_RGBA;
1741     state.texty = GL_UNSIGNED_BYTE;
1742
1743     fz_accelerate ();
1744     state.texids = calloc (state.texcount * sizeof (*state.texids), 1);
1745     if (!state.texids) {
1746         err (1, "calloc texids " FMT_s,
1747              state.texcount * sizeof (*state.texids));
1748     }
1749
1750     state.texowners = calloc (state.texcount * sizeof (*state.texowners), 1);
1751     if (!state.texowners) {
1752         err (1, "calloc texowners " FMT_s,
1753              state.texcount * sizeof (*state.texowners));
1754     }
1755
1756     glGenTextures (state.texcount, state.texids);
1757
1758 #ifdef _WIN32
1759     state.sock = Socket_val (sock_v);
1760 #else
1761     state.sock = Int_val (sock_v);
1762 #endif
1763
1764     state.cache = fz_newglyphcache ();
1765     if (!state.cache) {
1766         errx (1, "fz_newglyphcache failed");
1767     }
1768
1769 #ifdef _WIN32
1770     InitializeCriticalSection (&critsec);
1771     state.thread = CreateThread (NULL, 0, mainloop, NULL, 0, NULL);
1772     if (state.thread == INVALID_HANDLE_VALUE) {
1773         errx (1, "CreateThread failed: %lx", GetLastError ());
1774     }
1775 #else
1776     ret = pthread_create (&state.thread, NULL, mainloop, NULL);
1777     if (ret) {
1778         errx (1, "pthread_create: %s", strerror (errno));
1779     }
1780 #endif
1781
1782     CAMLreturn (Val_unit);
1783 }