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_text_span *text;
 133     fz_pixmap *pixmap;
 134     pdf_page *drawpage;
 135     struct pagedim pagedim;
 136     struct mark {
 137         int i;
 138         fz_text_span *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_glyph_cache *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_free_xref (state.xref);
 334     exit (1);
 335 }
 336
 337 static void openxref (char *filename)
 338 {
 339     fz_error error;
 340     fz_stream *file;
 341
 342     state.pig = NULL;
 343     if (state.xref) {
 344         pdf_free_xref (state.xref);
 345         state.xref = NULL;
 346     }
 347     if (state.pagedims) {
 348         free (state.pagedims);
 349         state.pagedims = NULL;
 350     }
 351     state.pagedimcount = 0;
 352
 353     file = fz_open_file (filename);
 354     error = pdf_open_xref_with_stream (&state.xref, file, NULL);
 355     if (error)
 356         die (fz_rethrow(error, "cannot open document '%s'", filename));
 357     fz_close (file);
 358
 359     if (pdf_needs_password (state.xref)) {
 360         die (fz_throw ("password protected"));
 361     }
 362
 363     error = pdf_load_page_tree (state.xref);
 364     if (error) {
 365         die (fz_throw ("cannot load page tree"));
 366     }
 367
 368     state.pagecount = pdf_count_pages (state.xref);
 369 }
 370
 371 static int readlen (int fd)
 372 {
 373     ssize_t n;
 374     unsigned char p[4];
 375
 376     n = recv (fd, p, 4, 0);
 377     if (n != 4) {
 378         if (!n) errx (1, "EOF while reading length");
 379         sockerr (1, "recv " FMT_ss, n);
 380     }
 381
 382     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 383 }
 384
 385 static void unlinkpage (struct page *page)
 386 {
 387     int i;
 388
 389     for (i = 0; i < page->slicecount; ++i) {
 390         struct slice *s = &page->slices[i];
 391         if (s->texindex != -1) {
 392             if (state.texowners[s->texindex].slice == s) {
 393                 state.texowners[s->texindex].slice = NULL;
 394                 ARSERT (state.texowners[s->texindex].w == s->w);
 395                 ARSERT (state.texowners[s->texindex].h >= s->h);
 396             }
 397         }
 398     }
 399 }
 400
 401 static void freepage (struct page *page)
 402 {
 403     fz_drop_pixmap (page->pixmap);
 404
 405     unlinkpage (page);
 406
 407     if (page->text) {
 408         fz_free_text_span (page->text);
 409     }
 410     if (page->drawpage) {
 411         pdf_free_page (page->drawpage);
 412     }
 413
 414     free (page);
 415 }
 416
 417 static void subdivide (struct page *p)
 418 {
 419     int i;
 420     int h = p->pixmap->h;
 421     int th = MIN (h, state.sliceheight);
 422
 423     for (i = 0; i < p->slicecount; ++i) {
 424         struct slice *s = &p->slices[i];
 425         s->texindex = -1;
 426         s->h = MIN (th, h);
 427         s->w = p->pixmap->w;
 428         h -= th;
 429     }
 430 }
 431
 432 static int compatpdims (struct pagedim *p1, struct pagedim *p2)
 433 {
 434     return p1->rotate == p2->rotate
 435         && !memcmp (&p1->bbox, &p2->bbox, sizeof (p1->bbox))
 436         && !memcmp (&p1->ctm, &p2->ctm, sizeof (p1->ctm));
 437 }
 438
 439 #ifdef __ALTIVEC__
 440 #include <altivec.h>
 441
 442 static int cacheline32bytes;
 443
 444 static void __attribute__ ((constructor)) clcheck (void)
 445 {
 446     char **envp = environ;
 447     unsigned long *auxv;
 448
 449     while (*envp++);
 450
 451     for (auxv = (unsigned long *) envp; *auxv != 0; auxv += 2) {
 452         if (*auxv == 19) {
 453             cacheline32bytes = auxv[1] == 32;
 454             return;
 455         }
 456     }
 457 }
 458
 459 static void __attribute__ ((optimize ("O"))) clearpixmap (fz_pixmap *pixmap)
 460 {
 461     if (cacheline32bytes) {
 462         intptr_t a1, a2, diff;
 463         size_t sizea, i, size = pixmap->w * pixmap->h * pixmap->n;
 464         vector unsigned char v = vec_splat_u8 (-1);
 465         vector unsigned char *p;
 466
 467         a1 = a2 = (intptr_t) pixmap->samples;
 468         a2 = (a1 + 31) & ~31;
 469         diff = a2 - a1;
 470         sizea = size - diff;
 471         p = (void *) a2;
 472
 473         while (a1 != a2) *(char *) a1++ = 0xff;
 474         for (i = 0; i < (sizea & ~31); i += 32)  {
 475             __asm volatile ("dcbz %0, %1"::"b"(a2),"r"(i));
 476             vec_st (v, i, p);
 477             vec_st (v, i + 16, p);
 478         }
 479         while (i < sizea) *((char *) a1 + i++) = 0xff;
 480     }
 481     else fz_clear_pixmap_with_color (pixmap, 0xff);
 482 }
 483 #else
 484 #define clearpixmap(p) fz_clear_pixmap_with_color (p, 0xff)
 485 #endif
 486
 487 static void *render (int pageno, int pindex)
 488 {
 489     fz_error error;
 490     int slicecount;
 491     struct page *page = NULL;
 492     double start, end;
 493     pdf_page *drawpage;
 494     fz_device *idev;
 495     struct pagedim *pagedim;
 496
 497     start = now ();
 498     printd (state.sock, "V rendering %d", pageno);
 499
 500     pagedim = &state.pagedims[pindex];
 501     slicecount = (pagedim->bbox.y1 - pagedim->bbox.y0
 502                   + state.sliceheight - 1) / state.sliceheight;
 503     slicecount += slicecount == 0;
 504
 505     if (state.pig) {
 506         if (compatpdims (&state.pig->pagedim, pagedim)) {
 507             page = state.pig;
 508             if (page->text) {
 509                 fz_free_text_span (page->text);
 510                 page->text = NULL;
 511             }
 512             if (page->drawpage) {
 513                 pdf_free_page (page->drawpage);
 514                 page->drawpage = NULL;
 515             }
 516         }
 517         else {
 518             freepage (state.pig);
 519         }
 520     }
 521     if (!page) {
 522         page = calloc (sizeof (*page)
 523                        + (slicecount * sizeof (struct slice)), 1);
 524         if (!page) {
 525             err (1, "calloc page %d\n", pageno);
 526         }
 527         page->pixmap = fz_new_pixmap_with_rect (fz_device_rgb, pagedim->bbox);
 528     }
 529
 530     page->slicecount = slicecount;
 531
 532     error = pdf_load_page (&drawpage, state.xref, pageno - 1);
 533     if (error)
 534         die (error);
 535
 536     clearpixmap (page->pixmap);
 537
 538     idev = fz_new_draw_device (state.cache, page->pixmap);
 539     if (!idev)
 540         die (fz_throw ("fz_newdrawdevice failed"));
 541     error = pdf_run_page (state.xref, drawpage, idev, pagedim->ctm);
 542     if (error)
 543         die (fz_rethrow (error, "pdf_runpage failed"));
 544     fz_free_device (idev);
 545
 546     page->drawpage = drawpage;
 547     page->pagedim = *pagedim;
 548     page->pageno = pageno;
 549     subdivide (page);
 550     end = now ();
 551
 552     pdf_age_store(state.xref->store, 3);
 553
 554     printd (state.sock, "V rendering %d took %f sec", pageno, end - start);
 555     state.pig = NULL;
 556     return page;
 557 }
 558
 559 static void initpdims (void)
 560 {
 561     int pageno;
 562     double start, end;
 563
 564     start = now ();
 565     for (pageno = 0; pageno < state.pagecount; ++pageno) {
 566         int rotate;
 567         fz_rect box;
 568         struct pagedim *p;
 569         fz_obj *obj, *pageobj;
 570
 571         pageobj = state.xref->page_objs[pageno];
 572
 573         obj = fz_dict_gets (pageobj, "CropBox");
 574         if (!fz_is_array (obj)) {
 575             obj = fz_dict_gets (pageobj, "MediaBox");
 576             if (!fz_is_array (obj)) {
 577                 die (fz_throw ("cannot find page bounds %d (%d Rd)",
 578                                fz_to_num (pageobj), fz_to_gen (pageobj)));
 579             }
 580         }
 581         box = pdf_to_rect (obj);
 582
 583         obj = fz_dict_gets (pageobj, "Rotate");
 584         if (fz_is_int (obj)) {
 585             rotate = fz_to_int (obj);
 586         }
 587         else  {
 588             rotate = 0;
 589         }
 590         rotate += state.rotate;
 591
 592         p = &state.pagedims[state.pagedimcount - 1];
 593         if ((state.pagedimcount == 0)
 594             || (p->rotate != rotate || memcmp (&p->box, &box, sizeof (box)))) {
 595             size_t size;
 596
 597             size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
 598             state.pagedims = realloc (state.pagedims, size);
 599             if (!state.pagedims) {
 600                 err (1, "realloc pagedims to " FMT_s " (%d elems)",
 601                      size, state.pagedimcount + 1);
 602             }
 603             p = &state.pagedims[state.pagedimcount++];
 604             p->rotate = rotate;
 605             p->box = box;
 606             p->pageno = pageno;
 607         }
 608     }
 609     end = now ();
 610     printd (state.sock, "T Processed %d pages in %f seconds",
 611             state.pagecount, end - start);
 612 }
 613
 614 static void layout (void)
 615 {
 616     int pindex;
 617     fz_matrix ctm;
 618     fz_rect box, box2;
 619     double zoom, w;
 620     struct pagedim *p = state.pagedims;
 621
 622     pindex = 0;
 623     for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
 624         box.x0 = MIN (p->box.x0, p->box.x1);
 625         box.y0 = MIN (p->box.y0, p->box.y1);
 626         box.x1 = MAX (p->box.x0, p->box.x1);
 627         box.y1 = MAX (p->box.y0, p->box.y1);
 628
 629         ctm = fz_identity;
 630         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 631         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 632         box2 = fz_transform_rect (ctm, box);
 633         w = box2.x1 - box2.x0;
 634
 635         zoom = (state.w / w);
 636         ctm = fz_identity;
 637         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 638         ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
 639         memcpy (&p->ctm1, &ctm, sizeof (ctm));
 640         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 641         p->bbox = fz_round_rect (fz_transform_rect (ctm, box));
 642         memcpy (&p->ctm, &ctm, sizeof (ctm));
 643     }
 644
 645     while (p-- != state.pagedims)  {
 646         printd (state.sock, "l %d %d %d",
 647                 p->pageno, p->bbox.x1 - p->bbox.x0, p->bbox.y1 - p->bbox.y0);
 648     }
 649 }
 650
 651 static void recurse_outline (pdf_outline *outline, int level)
 652 {
 653     while (outline) {
 654         int i;
 655         fz_obj *obj;
 656         int pageno = -1;
 657         int top = 0, h = 0;
 658
 659         if (!outline->link) goto next;
 660
 661         obj = outline->link->dest;
 662         if (fz_is_indirect (obj)) {
 663             obj = fz_resolve_indirect (obj);
 664         }
 665         if (fz_is_array (obj)) {
 666             fz_obj *obj2;
 667
 668             obj2 = fz_array_get (obj, 0);
 669             if (fz_is_int (obj2)) {
 670                 pageno = fz_to_int (obj2);
 671             }
 672             else {
 673                 pageno = pdf_find_page_number (state.xref, obj2);
 674             }
 675
 676             if (fz_array_len (obj) > 3) {
 677                 fz_point p;
 678                 fz_obj *xo, *yo;
 679
 680                 xo = fz_array_get (obj, 2);
 681                 yo = fz_array_get (obj, 3);
 682                 if (!fz_is_null (xo) && !fz_is_null (yo)) {
 683                     struct pagedim *pagedim = state.pagedims;
 684
 685                     for (i = 0; i < state.pagedimcount; ++i) {
 686                         if (state.pagedims[i].pageno > pageno)
 687                             break;
 688                         pagedim = &state.pagedims[i];
 689                     }
 690                     p.x = fz_to_int (xo);
 691                     p.y = fz_to_int (yo);
 692                     p = fz_transform_point (pagedim->ctm, p);
 693                     h = pagedim->bbox.y1 - pagedim->bbox.y0;
 694                     top = p.y;
 695                 }
 696             }
 697         }
 698         else {
 699             pageno = pdf_find_page_number (state.xref, outline->link->dest);
 700         }
 701
 702         lprintf ("%*c%s %d\n", level, ' ', outline->title, pageno);
 703         printd (state.sock, "o %d %d %d %d %s",
 704                 level, pageno, top, h, outline->title);
 705     next:
 706         if (outline->child) {
 707             recurse_outline (outline->child, level + 1);
 708         }
 709         outline = outline->next;
 710     }
 711 }
 712
 713 static void process_outline (void)
 714 {
 715     pdf_outline *outline;
 716
 717     if (!state.needoutline) return;
 718
 719     state.needoutline = 0;
 720     outline = pdf_load_outline (state.xref);
 721     if (outline) {
 722         recurse_outline (outline, 0);
 723         pdf_free_outline (outline);
 724     }
 725 }
 726
 727 static int comparespans (const void *l, const void *r)
 728 {
 729     fz_text_span const *const*ls = l;
 730     fz_text_span const *const*rs = r;
 731     return (*ls)->text->bbox.y0 - (*rs)->text->bbox.y0;
 732 }
 733
 734 /* wishful thinking function */
 735 static void search (regex_t *re, int pageno, int y, int forward)
 736 {
 737     int i, j;
 738     int ret;
 739     char *p;
 740     char buf[256];
 741     fz_matrix ctm;
 742     fz_error error;
 743     fz_device *tdev;
 744     pdf_page *drawpage;
 745     fz_text_span *text, *span, **pspan;
 746     struct pagedim *pdim, *pdimprev;
 747     int stop = 0;
 748     int niters = 0;
 749     int nspans;
 750     double start, end;
 751
 752     start = now ();
 753     while (pageno >= 0 && pageno < state.pagecount && !stop) {
 754         if (niters++ == 5) {
 755             pdf_age_store(state.xref->store, 3);
 756             niters = 0;
 757             if (hasdata (state.sock)) {
 758                 printd (state.sock, "T attention requested aborting search at %d",
 759                         pageno);
 760                 stop = 1;
 761             }
 762             else {
 763                 printd (state.sock, "T searching in page %d", pageno);
 764             }
 765         }
 766         pdimprev = NULL;
 767         for (i = 0; i < state.pagedimcount; ++i) {
 768             pdim = &state.pagedims[i];
 769             if (pdim->pageno == pageno)  {
 770                 goto found;
 771             }
 772             if (pdim->pageno > pageno) {
 773                 pdim = pdimprev;
 774                 goto found;
 775             }
 776             pdimprev = pdim;
 777         }
 778         pdim = pdimprev;
 779     found:
 780
 781         error = pdf_load_page (&drawpage, state.xref, pageno);
 782         if (error)
 783             die (error);
 784
 785         ctm = fz_rotate (pdim->rotate);
 786
 787         text = fz_new_text_span ();
 788         tdev = fz_new_text_device (text);
 789         error = pdf_run_page (state.xref, drawpage, tdev, pdim->ctm1);
 790         if (error) die (error);
 791         fz_free_device (tdev);
 792
 793         nspans = 0;
 794         for (span = text; span; span = span->next) {
 795             nspans++;
 796         }
 797         pspan = malloc (sizeof (void *) * nspans);
 798         if (!pspan) {
 799             err (1, "malloc span pointers " FMT_s, sizeof (void *) * nspans);
 800         }
 801         for (i = 0, span = text; span; span = span->next, ++i) {
 802             pspan[i] = span;
 803         }
 804         qsort (pspan, nspans, sizeof (fz_text_span *), comparespans);
 805
 806         j = forward ? 0 : nspans - 1;
 807         while (nspans--) {
 808             regmatch_t rm;
 809
 810             span = pspan[j];
 811             j += forward ? 1 : -1;
 812             p = buf;
 813             for (i = 0; i < MIN (span->len, (int) sizeof (buf) - 1); ++i) {
 814                 if (forward) {
 815                     if (span->text[i].bbox.y0 < y + 1) {
 816                         continue;
 817                     }
 818                 }
 819                 else {
 820                     if (span->text[i].bbox.y0 > y - 1) {
 821                         continue;
 822                     }
 823                 }
 824                 if (span->text[i].c < 256) {
 825                     *p++ = span->text[i].c;
 826                 }
 827                 else  {
 828                     *p++ = '?';
 829                 }
 830             }
 831             if (p == buf) {
 832                 continue;
 833             }
 834             *p++ = 0;
 835
 836             ret = regexec (re, buf, 1, &rm, 0);
 837             if (ret)  {
 838                 if (ret != REG_NOMATCH) {
 839                     size_t size;
 840                     char errbuf[80];
 841                     size = regerror (ret, re, errbuf, sizeof (errbuf));
 842                     printd (state.sock,
 843                             "T regexec error `%.*s'",
 844                             (int) size, errbuf);
 845                     fz_free_text_span (text);
 846                     pdf_free_page (drawpage);
 847                     free (pspan);
 848                     return;
 849                 }
 850             }
 851             else  {
 852                 int xoff, yoff;
 853                 fz_bbox *sb, *eb;
 854                 fz_point p1, p2, p3, p4;
 855
 856                 xoff = -pdim->bbox.x0;
 857                 yoff = -pdim->bbox.y0;
 858
 859                 sb = &span->text[rm.rm_so].bbox;
 860                 eb = &span->text[rm.rm_eo - 1].bbox;
 861
 862                 p1.x = sb->x0;
 863                 p1.y = sb->y0;
 864                 p2.x = eb->x1;
 865                 p2.y = sb->y0;
 866                 p3.x = eb->x1;
 867                 p3.y = eb->y1;
 868                 p4.x = sb->x0;
 869                 p4.y = eb->y1;
 870
 871                 p1 = fz_transform_point (ctm, p1);
 872                 p2 = fz_transform_point (ctm, p2);
 873                 p3 = fz_transform_point (ctm, p3);
 874                 p4 = fz_transform_point (ctm, p4);
 875
 876                 if (!stop) {
 877                     printd (state.sock, "F %d %d %f %f %f %f %f %f %f %f",
 878                             pageno, 1,
 879                             p1.x + xoff, p1.y + yoff,
 880                             p2.x + xoff, p2.y + yoff,
 881                             p3.x + xoff, p3.y + yoff,
 882                             p4.x + xoff, p4.y + yoff);
 883
 884                     printd (state.sock, "T found at %d `%.*s' in %f sec",
 885                             pageno, rm.rm_eo - rm.rm_so, &buf[rm.rm_so],
 886                             now () - start);
 887                 }
 888                 else  {
 889                     printd (state.sock, "R %d %d %f %f %f %f %f %f %f %f",
 890                             pageno, 2,
 891                             p1.x + xoff, p1.y + yoff,
 892                             p2.x + xoff, p2.y + yoff,
 893                             p3.x + xoff, p3.y + yoff,
 894                             p4.x + xoff, p4.y + yoff);
 895                 }
 896                 stop = 1;
 897             }
 898         }
 899         if (forward) {
 900             pageno += 1;
 901             y = 0;
 902         }
 903         else {
 904             pageno -= 1;
 905             y = INT_MAX;
 906         }
 907         fz_free_text_span (text);
 908         pdf_free_page (drawpage);
 909         free (pspan);
 910     }
 911     end = now ();
 912     if (!stop)  {
 913         printd (state.sock, "T no matches %f sec", end - start);
 914     }
 915     printd (state.sock, "D");
 916 }
 917
 918 static
 919 #ifdef _WIN32
 920 DWORD _stdcall
 921 #else
 922 void *
 923 #endif
 924 mainloop (void *unused)
 925 {
 926     char *p = NULL;
 927     int len, ret, oldlen = 0;
 928
 929     for (;;) {
 930         len = readlen (state.sock);
 931         if (len == 0) {
 932             errx (1, "readlen returned 0");
 933         }
 934
 935         if (oldlen < len + 1) {
 936             p = realloc (p, len + 1);
 937             if (!p) {
 938                 err (1, "realloc %d failed", len + 1);
 939             }
 940             oldlen = len + 1;
 941         }
 942         readdata (state.sock, p, len);
 943         p[len] = 0;
 944
 945         if (!strncmp ("open", p, 4)) {
 946             fz_obj *obj;
 947             char *filename = p + 5;
 948
 949             openxref (filename);
 950             initpdims ();
 951
 952             obj = fz_dict_gets (state.xref->trailer, "Info");
 953             if (obj) {
 954                 char *s;
 955
 956                 obj = fz_dict_gets (obj, "Title");
 957                 s = pdf_to_utf8 (obj);
 958                 if (*s) {
 959                     printd (state.sock, "t %s", s);
 960                 }
 961                 fz_free (s);
 962             }
 963             state.needoutline = 1;
 964         }
 965         else if (!strncmp ("free", p, 4)) {
 966             void *ptr;
 967
 968             ret = sscanf (p + 4, " %p", &ptr);
 969             if (ret != 1) {
 970                 errx (1, "malformed free `%.*s' ret=%d", len, p, ret);
 971             }
 972             unlinkpage (ptr);
 973             state.pig = ptr;
 974         }
 975         else if (!strncmp ("search", p, 6)) {
 976             int icase, pageno, y, ret, len2, forward;
 977             char *pattern;
 978             regex_t re;
 979
 980             ret = sscanf (p + 6, " %d %d %d %d,%n",
 981                           &icase, &pageno, &y, &forward, &len2);
 982             if (ret != 4) {
 983                 errx (1, "malformed search `%s' ret=%d", p, ret);
 984             }
 985
 986             pattern = p + 6 + len2;
 987             ret = regcomp (&re, pattern,
 988                            REG_EXTENDED | (icase ? REG_ICASE : 0));
 989             if (ret) {
 990                 char errbuf[80];
 991                 size_t size;
 992
 993                 size = regerror (ret, &re, errbuf, sizeof (errbuf));
 994                 printd (state.sock, "T regcomp failed `%.*s'",
 995                         (int) size, errbuf);
 996             }
 997             else  {
 998                 search (&re, pageno, y, forward);
 999                 regfree (&re);
1000             }
1001         }
1002         else if (!strncmp ("geometry", p, 8)) {
1003             int w, h;
1004
1005             printd (state.sock, "c");
1006             ret = sscanf (p + 8, " %d %d", &w, &h);
1007             if (ret != 2) {
1008                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
1009             }
1010
1011             lock ("geometry");
1012             state.h = h;
1013             if (w != state.w) {
1014                 int i;
1015                 state.w = w;
1016                 for (i = 0; i < state.texcount; ++i)  {
1017                     state.texowners[i].slice = NULL;
1018                 }
1019             }
1020             layout ();
1021             process_outline ();
1022             unlock ("geometry");
1023             printd (state.sock, "C %d", state.pagecount);
1024         }
1025         else if (!strncmp ("rotate", p, 6)) {
1026             float rotate;
1027
1028             printd (state.sock, "c");
1029             ret = sscanf (p + 6, " %f", &rotate);
1030             if (ret != 1) {
1031                 errx (1, "bad rotate line `%.*s' ret=%d", len, p, ret);
1032             }
1033             lock ("rotate");
1034             state.rotate = rotate;
1035             state.pagedimcount = 0;
1036             free (state.pagedims);
1037             state.pagedims = NULL;
1038             initpdims ();
1039             layout ();
1040             process_outline ();
1041             if (state.pig) {
1042                 freepage (state.pig);
1043                 state.pig = NULL;
1044             }
1045             unlock ("rotate");
1046             printd (state.sock, "C %d", state.pagecount);
1047         }
1048         else if (!strncmp ("render", p, 6)) {
1049             int pageno, pindex, w, h, ret;
1050             struct page *page;
1051
1052             ret = sscanf (p + 6, " %d %d %d %d", &pageno, &pindex, &w, &h);
1053             if (ret != 4) {
1054                 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
1055             }
1056
1057             lock ("render");
1058             page = render (pageno, pindex);
1059             unlock ("render");
1060
1061             printd (state.sock, "r %d %d %d %d %p",
1062                     pageno,
1063                     state.w,
1064                     state.h,
1065                     state.rotate,
1066                     page);
1067         }
1068         else if (!strncmp ("interrupt", p, 9)) {
1069             printd (state.sock, "V interrupted");
1070         }
1071         else {
1072             errx (1, "unknown command %.*s", len, p);
1073         }
1074     }
1075     return 0;
1076 }
1077
1078 static void showsel (struct page *page, int oy)
1079 {
1080     int ox;
1081     fz_bbox bbox;
1082     fz_text_span *span;
1083     struct mark first, last;
1084
1085     first = page->fmark;
1086     last = page->lmark;
1087
1088     if (!first.span || !last.span) return;
1089
1090     glEnable (GL_BLEND);
1091     glBlendFunc (GL_SRC_ALPHA, GL_SRC_ALPHA);
1092     glColor4f (0.5f, 0.5f, 0.0f, 0.6f);
1093
1094     ox = -page->pixmap->x;
1095     oy = -page->pixmap->y + oy;
1096     for (span = first.span; span; span = span->next) {
1097         int i, j, k;
1098
1099         bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0;
1100
1101         j = 0;
1102         k = span->len - 1;
1103
1104         if (span == page->fmark.span && span == page->lmark.span) {
1105             j = MIN (first.i, last.i);
1106             k = MAX (first.i, last.i);
1107         }
1108         else if (span == first.span) {
1109             j = first.i;
1110         }
1111         else if (span == last.span) {
1112             k = last.i;
1113         }
1114
1115         for (i = j; i <= k; ++i) {
1116             bbox = fz_union_bbox (bbox, span->text[i].bbox);
1117         }
1118         lprintf ("%d %d %d %d oy=%d ox=%d\n",
1119                  bbox.x0,
1120                  bbox.y0,
1121                  bbox.x1,
1122                  bbox.y1,
1123                  oy, ox);
1124
1125         glRecti (bbox.x0 + ox, bbox.y0 + oy, bbox.x1 + ox, bbox.y1 + oy);
1126
1127         if (span == last.span) break;
1128     }
1129     glDisable (GL_BLEND);
1130 }
1131
1132 static void highlightlinks (struct page *page, int yoff)
1133 {
1134     pdf_link *link;
1135     int xoff;
1136
1137     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1138     glEnable (GL_LINE_STIPPLE);
1139     glLineStipple (0.5, 0xcccc);
1140
1141     xoff = -page->pixmap->x;
1142     yoff -= page->pixmap->y;
1143
1144     glBegin (GL_QUADS);
1145     for (link = page->drawpage->links; link; link = link->next) {
1146         fz_point p1, p2, p3, p4;
1147         fz_matrix ctm = page->pagedim.ctm;
1148
1149         p1.x = link->rect.x0;
1150         p1.y = link->rect.y0;
1151
1152         p2.x = link->rect.x1;
1153         p2.y = link->rect.y0;
1154
1155         p3.x = link->rect.x1;
1156         p3.y = link->rect.y1;
1157
1158         p4.x = link->rect.x0;
1159         p4.y = link->rect.y1;
1160
1161         p1 = fz_transform_point (ctm, p1);
1162         p2 = fz_transform_point (ctm, p2);
1163         p3 = fz_transform_point (ctm, p3);
1164         p4 = fz_transform_point (ctm, p4);
1165
1166         switch (link->kind) {
1167         case PDF_LINK_GOTO: glColor3ub (255, 0, 0); break;
1168         case PDF_LINK_URI: glColor3ub (0, 0, 255); break;
1169         default: glColor3ub (0, 0, 0); break;
1170         }
1171
1172         glVertex2f (p1.x + xoff, p1.y + yoff);
1173         glVertex2f (p2.x + xoff, p2.y + yoff);
1174         glVertex2f (p3.x + xoff, p3.y + yoff);
1175         glVertex2f (p4.x + xoff, p4.y + yoff);
1176     }
1177     glEnd ();
1178
1179     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1180     glDisable (GL_LINE_STIPPLE);
1181 }
1182
1183 static void upload2 (struct page *page, int slicenum, const char *cap)
1184 {
1185     int i;
1186     int w, h;
1187     double start, end;
1188     struct slice *slice = &page->slices[slicenum];
1189
1190     w = page->pixmap->w;
1191     h = page->pixmap->h;
1192
1193     ARSERT (w == slice->w);
1194     if (slice->texindex != -1
1195         && state.texowners[slice->texindex].slice == slice) {
1196         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
1197     }
1198     else  {
1199         int subimage = 0;
1200         int index = (state.texindex++ % state.texcount);
1201         size_t offset = 0;
1202
1203         for (i = 0; i < slicenum; ++i) {
1204             offset += w * page->slices[i].h * 4;
1205         }
1206
1207         if (state.texowners[index].w == slice->w) {
1208             if (state.texowners[index].h >= slice->h ) {
1209                 subimage = 1;
1210             }
1211             else {
1212                 state.texowners[index].h = slice->h;
1213             }
1214         }
1215         else  {
1216             state.texowners[index].h = slice->h;
1217         }
1218
1219         state.texowners[index].slice = slice;
1220         state.texowners[index].w = slice->w;
1221         slice->texindex = index;
1222
1223         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
1224         start = now ();
1225         if (subimage) {
1226             {
1227                 GLenum err = glGetError ();
1228                 if (err != GL_NO_ERROR) {
1229                     printf ("\033[0;31mERROR1 %d %d %#x\033[0m\n", w, slice->h, err);
1230                     abort ();
1231                 }
1232             }
1233             glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
1234                              0,
1235                              0,
1236                              0,
1237                              w,
1238                              slice->h,
1239                              state.texform,
1240                              state.texty,
1241                              page->pixmap->samples + offset
1242                 );
1243             {
1244                 GLenum err = glGetError ();
1245                 if (err != GL_NO_ERROR) {
1246                     printf ("\033[0;31mERROR %d %d %#x\033[0m\n", w, slice->h, err);
1247                     abort ();
1248                 }
1249             }
1250         }
1251         else {
1252             glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
1253                           0,
1254                           GL_RGBA8,
1255                           w,
1256                           slice->h,
1257                           0,
1258                           state.texform,
1259                           state.texty,
1260                           page->pixmap->samples + offset
1261                 );
1262         }
1263
1264         end = now ();
1265         lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1266                  subimage ? "sub" : "img",
1267                  page->pageno, slicenum,
1268                  slice->w, slice->h,
1269                  state.texids[slice->texindex],
1270                  end - start);
1271     }
1272 }
1273
1274 CAMLprim value ml_draw (value args_v, value ptr_v)
1275 {
1276     CAMLparam2 (args_v, ptr_v);
1277     int dispy = Int_val (Field (args_v, 0));
1278     int w = Int_val (Field (args_v, 1));
1279     int h = Int_val (Field (args_v, 2));
1280     int py = Int_val (Field (args_v, 3));
1281     int hlinks = Bool_val (Field (args_v, 4));
1282     char *s = String_val (ptr_v);
1283     int ret;
1284     void *ptr;
1285     struct page *page;
1286     int slicenum = 0;
1287     int yoff = dispy - py;
1288
1289     ret = sscanf (s, "%p", &ptr);
1290     if (ret != 1) {
1291         errx (1, "cannot parse pointer `%s'", s);
1292     }
1293     page = ptr;
1294
1295     w = page->pixmap->w;
1296
1297     ARSERT (h >= 0 && "ml_draw wrong h");
1298     ARSERT (py <= page->pixmap->h && "ml_draw wrong py");
1299
1300     glEnable (GL_TEXTURE_RECTANGLE_ARB);
1301
1302     for (slicenum = 0; slicenum < page->slicecount; ++slicenum) {
1303         struct slice *slice = &page->slices[slicenum];
1304         if (slice->h > py) {
1305             break;
1306         }
1307         py -= slice->h;
1308     }
1309
1310     h = MIN (state.h, h);
1311     while (h) {
1312         int th;
1313         struct slice *slice = &page->slices[slicenum];
1314
1315         ARSERT (slicenum < page->slicecount && "ml_draw wrong slicenum");
1316
1317         th = MIN (h, slice->h - py);
1318         upload2 (page, slicenum, "upload");
1319
1320         glBegin (GL_QUADS);
1321         {
1322             glTexCoord2i (0, py);
1323             glVertex2i (0, dispy);
1324
1325             glTexCoord2i (w, py);
1326             glVertex2i (w, dispy);
1327
1328             glTexCoord2i (w, py+th);
1329             glVertex2i (w, dispy + th);
1330
1331             glTexCoord2i (0, py+th);
1332             glVertex2i (0, dispy + th);
1333         }
1334         glEnd ();
1335
1336         h -= th;
1337         py = 0;
1338         dispy += th;
1339         slicenum += 1;
1340     }
1341
1342     showsel (page, yoff);
1343     if (hlinks) highlightlinks (page, yoff);
1344     glDisable (GL_TEXTURE_RECTANGLE_ARB);
1345
1346     CAMLreturn (Val_unit);
1347 }
1348
1349 static pdf_link *getlink (struct page *page, int x, int y)
1350 {
1351     fz_point p;
1352     fz_matrix ctm;
1353     pdf_link *link;
1354
1355     p.x = x + page->pixmap->x;
1356     p.y = y + page->pixmap->y;
1357
1358     ctm = fz_invert_matrix (page->pagedim.ctm);
1359     p = fz_transform_point (ctm, p);
1360
1361     for (link = page->drawpage->links; link; link = link->next) {
1362         if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1363             if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1364                 return link;
1365             }
1366         }
1367     }
1368     return NULL;
1369 }
1370
1371 static void ensuretext (struct page *page)
1372 {
1373     if (!page->text) {
1374         fz_error error;
1375         fz_device *tdev;
1376
1377         page->text = fz_new_text_span ();
1378         tdev = fz_new_text_device (page->text);
1379         error = pdf_run_page (state.xref, page->drawpage, tdev,
1380                              page->pagedim.ctm);
1381         if (error) die (error);
1382         fz_free_device (tdev);
1383     }
1384 }
1385
1386 CAMLprim value ml_whatsunder (value ptr_v, value x_v, value y_v)
1387 {
1388     CAMLparam3 (ptr_v, x_v, y_v);
1389     CAMLlocal3 (ret_v, tup_v, str_v);
1390     pdf_link *link;
1391     struct page *page;
1392     char *s = String_val (ptr_v);
1393
1394     ret_v = Val_int (0);
1395     if (trylock ("ml_whatsunder")) {
1396         goto done;
1397     }
1398
1399     page = parse_pointer ("ml_whatsunder", s);
1400     link = getlink (page, Int_val (x_v), Int_val (y_v));
1401     if (link) {
1402         switch (link->kind) {
1403         case PDF_LINK_GOTO:
1404             {
1405                 int pageno;
1406                 fz_point p;
1407                 fz_obj *obj;
1408
1409                 pageno = -1;
1410                 p.x = 0;
1411                 p.y = 0;
1412
1413                 if (fz_is_array (link->dest)) {
1414                     obj = fz_array_get (link->dest, 0);
1415                     if (fz_is_indirect (obj)) {
1416                         pageno = pdf_find_page_number (state.xref, obj);
1417                     }
1418                     else if (fz_is_int (obj)) {
1419                         pageno = fz_to_int (obj);
1420                     }
1421
1422                     if (fz_array_len (link->dest) > 3) {
1423                         fz_obj *xo, *yo;
1424
1425                         xo = fz_array_get (link->dest, 2);
1426                         yo = fz_array_get (link->dest, 3);
1427                         if (!fz_is_null (xo) && !fz_is_null (yo)) {
1428                             p.x = fz_to_int (xo);
1429                             p.y = fz_to_int (yo);
1430                             p = fz_transform_point (page->pagedim.ctm, p);
1431                         }
1432                     }
1433                 }
1434                 else {
1435                     pageno = pdf_find_page_number (state.xref, link->dest);
1436                 }
1437                 tup_v = caml_alloc_tuple (2);
1438                 ret_v = caml_alloc_small (1, 1);
1439                 Field (tup_v, 0) = Val_int (pageno);
1440                 Field (tup_v, 1) = Val_int (p.y);
1441                 Field (ret_v, 0) = tup_v;
1442             }
1443             break;
1444
1445         case PDF_LINK_URI:
1446             str_v = caml_copy_string (fz_to_str_buf (link->dest));
1447             ret_v = caml_alloc_small (1, 0);
1448             Field (ret_v, 0) = str_v;
1449             break;
1450
1451         default:
1452             printd (state.sock, "T unhandled link kind %d", link->kind);
1453             break;
1454         }
1455     }
1456     else {
1457         int i, x, y;
1458         fz_text_span *span;
1459
1460         ensuretext (page);
1461         x = Int_val (x_v) + page->pixmap->x;
1462         y = Int_val (y_v) + page->pixmap->y;
1463
1464         for (span = page->text; span; span = span->next) {
1465             for (i = 0; i < span->len; ++i) {
1466                 fz_bbox *b;
1467                 b = &span->text[i].bbox;
1468                 if ((x >= b->x0 && x <= b->x1 && y >= b->y0 && y <= b->y1)) {
1469                     const char *n2 =
1470                         span->font && span->font->name
1471                         ? span->font->name
1472                         : "Span has no font name"
1473                         ;
1474 #ifdef FT_FREETYPE_H
1475                     FT_FaceRec *face = span->font->ft_face;
1476                     if (face && face->family_name) {
1477                         char *s;
1478                         char *n1 = face->family_name;
1479                         size_t l1 = strlen (n1);
1480                         size_t l2 = strlen (n2);
1481
1482                         if (l1 != l2 || memcmp (n1, n2, l1)) {
1483                             s = malloc (l1 + l2 + 2);
1484                             if (s) {
1485                                 memcpy (s, n2, l2);
1486                                 s[l2] = '=';
1487                                 memcpy (s + l2 + 1, n1, l1 + 1);
1488                                 str_v = caml_copy_string (s);
1489                                 free (s);
1490                             }
1491                         }
1492                     }
1493                     if (str_v == 0) {
1494                         str_v = caml_copy_string (n2);
1495                     }
1496 #else
1497                     str_v = caml_copy_string (n2);
1498 #endif
1499                     ret_v = caml_alloc_small (1, 2);
1500                     Field (ret_v, 0) = str_v;
1501                     goto unlock;
1502                 }
1503             }
1504         }
1505     }
1506  unlock:
1507     unlock ("ml_whatsunder");
1508
1509  done:
1510     CAMLreturn (ret_v);
1511 }
1512
1513 CAMLprim value ml_seltext (value ptr_v, value rect_v, value oy_v)
1514 {
1515     CAMLparam4 (ptr_v, rect_v, oy_v, rect_v);
1516     fz_bbox *b;
1517     struct page *page;
1518     fz_text_span *span;
1519     struct mark first, last;
1520     int i, x0, x1, y0, y1, oy;
1521     char *s = String_val (ptr_v);
1522
1523     if (trylock ("ml_seltext")) {
1524         goto done;
1525     }
1526
1527     page = parse_pointer ("ml_seltext", s);
1528     ensuretext (page);
1529
1530     oy = Int_val (oy_v);
1531     x0 = Int_val (Field (rect_v, 0));
1532     y0 = Int_val (Field (rect_v, 1));
1533     x1 = Int_val (Field (rect_v, 2));
1534     y1 = Int_val (Field (rect_v, 3));
1535
1536     if (0) {
1537         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1538         glColor3ub (128, 128, 128);
1539         glRecti (x0, y0, x1, y1);
1540         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1541     }
1542
1543     x0 += page->pixmap->x;
1544     y0 += page->pixmap->y - oy;
1545     x1 += page->pixmap->x;
1546     y1 += page->pixmap->y - oy;
1547
1548     first.span = NULL;
1549     last.span = NULL;
1550
1551     last.i = first.i = 0;
1552     first.span = page->text;
1553     for (span = page->text; span; span = span->next) {
1554         for (i = 0; i < span->len; ++i) {
1555             b = &span->text[i].bbox;
1556             if (x0 >= b->x0 && x0 <= b->x1 && y0 >= b->y0 && y0 <= b->y1) {
1557                 first.i = i;
1558                 first.span = span;
1559             }
1560             if (x1 >= b->x0 && x1 <= b->x1 && y1 >= b->y0 && y1 <= b->y1) {
1561                 last.i = i;
1562                 last.span = span;
1563             }
1564         }
1565     }
1566
1567     if (y1 < y0 || x1 < x0) {
1568         int swap = 0;
1569
1570         if (first.span == last.span)  {
1571             swap = 1;
1572         }
1573         else {
1574             if (y1 < y0) {
1575                 for (span = first.span; span && span != last.span;
1576                      span = span->next) {
1577                     if (span->eol) {
1578                         swap = 1;
1579                         break;
1580                     }
1581                 }
1582             }
1583         }
1584
1585         if (swap) {
1586             i = first.i;
1587             span = first.span;
1588             first.i = last.i;
1589             first.span = last.span;
1590             last.i = i;
1591             last.span = span;
1592         }
1593     }
1594
1595     page->fmark = first;
1596     page->lmark = last;
1597
1598     unlock ("ml_seltext");
1599
1600  done:
1601     CAMLreturn (Val_unit);
1602 }
1603
1604 static int pipespan (FILE *f, fz_text_span *span, int a, int b)
1605 {
1606     char buf[4];
1607     int i, len, ret;
1608
1609     for (i = a; i <= b; ++i) {
1610         len = runetochar (buf, &span->text[i].c);
1611         ret = fwrite (buf, len, 1, f);
1612
1613         if (ret != 1) {
1614             printd (state.sock, "T failed to write %d bytes ret=%d: %s",
1615                     len, ret, strerror (errno));
1616             return -1;
1617         }
1618     }
1619     return 0;
1620 }
1621
1622 CAMLprim value ml_copysel (value ptr_v)
1623 {
1624     CAMLparam1 (ptr_v);
1625     FILE *f;
1626     struct page *page;
1627     char *s = String_val (ptr_v);
1628
1629     if (trylock ("ml_copysel")) {
1630         goto done;
1631     }
1632
1633     if (!*s)  {
1634     close:
1635 #ifdef USE_XSEL
1636         if (state.xselpipe) {
1637             int ret = pclose (state.xselpipe);
1638             if (ret)  {
1639                 printd (state.sock, "T failed to close xsel pipe `%s'",
1640                         strerror (errno));
1641             }
1642             state.xselpipe = NULL;
1643         }
1644 #else
1645         printf ("========================================\n");
1646 #endif
1647     }
1648     else {
1649         fz_text_span *span;
1650
1651         page = parse_pointer ("ml_sopysel", s);
1652
1653         if (!page->fmark.span || !page->lmark.span) {
1654             printd (state.sock, "T nothing to copy");
1655             goto unlock;
1656         }
1657
1658         f = stdout;
1659 #ifdef USE_XSEL
1660         if (!state.xselpipe) {
1661             state.xselpipe = popen ("xsel -i", "w");
1662             if (!state.xselpipe) {
1663                 printd (state.sock, "T failed to open xsel pipe `%s'",
1664                         strerror (errno));
1665             }
1666             else {
1667                 f = state.xselpipe;
1668             }
1669         }
1670         else  {
1671             f = state.xselpipe;
1672         }
1673 #endif
1674
1675         for (span = page->fmark.span;
1676              span && span != page->lmark.span->next;
1677              span = span->next) {
1678             int a = span == page->fmark.span ? page->fmark.i : 0;
1679             int b = span == page->lmark.span ? page->lmark.i : span->len - 1;
1680             if (pipespan (f, span, a, b))  {
1681                 goto close;
1682             }
1683             if (span->eol)  {
1684                 if (putc ('\n', f) == EOF) {
1685                     printd (state.sock, "T failed break line on xsel pipe `%s'",
1686                             strerror (errno));
1687                     goto close;
1688                 }
1689             }
1690         }
1691         page->lmark.span = NULL;
1692         page->fmark.span = NULL;
1693     }
1694
1695  unlock:
1696     unlock ("ml_copysel");
1697
1698  done:
1699     CAMLreturn (Val_unit);
1700 }
1701
1702 CAMLprim value ml_getpagewh (value pagedimno_v)
1703 {
1704     CAMLparam1 (pagedimno_v);
1705     CAMLlocal1 (ret_v);
1706     int pagedimno = Int_val (pagedimno_v);
1707
1708     ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
1709     Store_double_field (ret_v, 0, state.pagedims[pagedimno].box.x0);
1710     Store_double_field (ret_v, 1, state.pagedims[pagedimno].box.x1);
1711     Store_double_field (ret_v, 2, state.pagedims[pagedimno].box.y0);
1712     Store_double_field (ret_v, 3, state.pagedims[pagedimno].box.y1);
1713     CAMLreturn (ret_v);
1714 }
1715
1716 CAMLprim value ml_init (value sock_v)
1717 {
1718 #ifndef _WIN32
1719     int ret;
1720 #endif
1721     CAMLparam1 (sock_v);
1722
1723     state.texcount = 256;
1724     state.sliceheight = 24;
1725     state.texform = GL_RGBA;
1726     state.texty = GL_UNSIGNED_BYTE;
1727
1728     fz_accelerate ();
1729     state.texids = calloc (state.texcount * sizeof (*state.texids), 1);
1730     if (!state.texids) {
1731         err (1, "calloc texids " FMT_s,
1732              state.texcount * sizeof (*state.texids));
1733     }
1734
1735     state.texowners = calloc (state.texcount * sizeof (*state.texowners), 1);
1736     if (!state.texowners) {
1737         err (1, "calloc texowners " FMT_s,
1738              state.texcount * sizeof (*state.texowners));
1739     }
1740
1741     glGenTextures (state.texcount, state.texids);
1742
1743 #ifdef _WIN32
1744     state.sock = Socket_val (sock_v);
1745 #else
1746     state.sock = Int_val (sock_v);
1747 #endif
1748
1749     state.cache = fz_new_glyph_cache ();
1750     if (!state.cache) {
1751         errx (1, "fz_newglyph_cache failed");
1752     }
1753
1754 #ifdef _WIN32
1755     InitializeCriticalSection (&critsec);
1756     state.thread = CreateThread (NULL, 0, mainloop, NULL, 0, NULL);
1757     if (state.thread == INVALID_HANDLE_VALUE) {
1758         errx (1, "CreateThread failed: %lx", GetLastError ());
1759     }
1760 #else
1761     ret = pthread_create (&state.thread, NULL, mainloop, NULL);
1762     if (ret) {
1763         errx (1, "pthread_create: %s", strerror (errno));
1764     }
1765 #endif
1766
1767     CAMLreturn (Val_unit);
1768 }