link.c

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