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