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