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