link.c

   1 /* lot's of code c&p-ed directly from mupdf */
   2
   3 #define _GNU_SOURCE
   4 #include <err.h>
   5 #include <regex.h>
   6 #include <errno.h>
   7 #include <ctype.h>
   8 #include <stdio.h>
   9 #include <stdarg.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <pthread.h>
  13 #include <sys/poll.h>
  14 #include <sys/time.h>
  15
  16 /* fugly as hell and GCC specific but... */
  17 #ifdef _BIG_ENDIAN
  18 #define GL_GLEXT_PROTOTYPES
  19 #endif
  20
  21 #include <GL/gl.h>
  22 #include <GL/glext.h>
  23
  24 #include <caml/fail.h>
  25 #include <caml/alloc.h>
  26 #include <caml/memory.h>
  27 #include <caml/unixsupport.h>
  28
  29 #include <fitz.h>
  30 #include <mupdf.h>
  31
  32 #if 0
  33 #define lprintf printf
  34 #else
  35 #define lprintf(...)
  36 #endif
  37
  38 #define ARSERT(cond) for (;;) {                         \
  39     if (!(cond)) {                                      \
  40         errx (1, "%s:%d " #cond, __FILE__, __LINE__);   \
  41     }                                                   \
  42     break;                                              \
  43 }
  44
  45 struct slice {
  46     int texindex;
  47     int w, h;
  48 };
  49
  50 struct page {
  51     int pageno;
  52     int slicecount;
  53     fz_textspan *text;
  54     fz_pixmap *pixmap;
  55     pdf_page *drawpage;
  56     struct pagedim *pagedim;
  57     struct page *prev;
  58     struct slice slices[];
  59 };
  60
  61 struct pagedim {
  62     int pageno;
  63     int rotate;
  64     fz_rect box;
  65     fz_bbox bbox;
  66     fz_matrix ctm;
  67 };
  68
  69 struct {
  70     int sock;
  71     int sliceheight;
  72     pthread_t thread;
  73     struct page *pages;
  74     struct pagedim *pagedims;
  75     int pagecount;
  76     int pagedimcount;
  77     pdf_xref *xref;
  78     fz_glyphcache *cache;
  79     int w, h;
  80
  81     int useatifs;
  82
  83     int texindex;
  84     int texcount;
  85     GLuint *texids;
  86
  87     GLenum texform;
  88     GLenum texty;
  89
  90     int lotsamemory;
  91
  92     int *pagetbl;
  93     struct {
  94         int w, h;
  95         struct slice *slice;
  96     } *texowners;
  97 } state;
  98
  99 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 100
 101 static void lock (const char *cap)
 102 {
 103     int ret = pthread_mutex_lock (&mutex);
 104     if (ret) {
 105         errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
 106     }
 107 }
 108
 109 static void unlock (const char *cap)
 110 {
 111     int ret = pthread_mutex_unlock (&mutex);
 112     if (ret) {
 113         errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
 114     }
 115 }
 116
 117 static int trylock (const char *cap)
 118 {
 119     int ret = pthread_mutex_trylock (&mutex);
 120
 121     if (ret && ret != EBUSY) {
 122         errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
 123     }
 124     return ret == EBUSY;
 125 }
 126
 127 static void *parse_pointer (const char *cap, const char *s)
 128 {
 129     int ret;
 130     void *ptr;
 131
 132     ret = sscanf (s, "%p", &ptr);
 133     if (ret != 1) {
 134         errx (1, "%s: cannot parse pointer in `%s'", cap, s);
 135     }
 136     return ptr;
 137 }
 138
 139 static int hasdata (int sock)
 140 {
 141     int ret;
 142     struct pollfd pfd;
 143
 144     pfd.fd = sock;
 145     pfd.events = POLLIN;
 146     ret = poll (&pfd, 1, 0);
 147     if (ret == 0) {
 148         return 0;
 149     }
 150     if (ret != 1) {
 151         err (1, "poll");
 152     }
 153     return pfd.revents & POLLIN;
 154 }
 155
 156 static double now (void)
 157 {
 158     struct timeval tv;
 159
 160     if (gettimeofday (&tv, NULL)) {
 161         err (1, "gettimeofday");
 162     }
 163     return tv.tv_sec + tv.tv_usec*1e-6;
 164 }
 165
 166 static void readdata (int fd, char *p, int size)
 167 {
 168     ssize_t n;
 169
 170     n = read (fd, p, size);
 171     if (n - size) {
 172         err (1, "read (req %d, ret %zd)", size, n);
 173     }
 174 }
 175
 176 static void writedata (int fd, char *p, int size)
 177 {
 178     char buf[4];
 179     ssize_t n;
 180
 181     buf[0] = (size >> 24) & 0xff;
 182     buf[1] = (size >> 16) & 0xff;
 183     buf[2] = (size >>  8) & 0xff;
 184     buf[3] = (size >>  0) & 0xff;
 185
 186     n = write (fd, buf, 4);
 187     if (n != 4) {
 188         err (1, "write %zd", n);
 189     }
 190
 191     n = write (fd, p, size);
 192     if (n - size) {
 193         err (1, "write (req %d, ret %zd)", size, n);
 194     }
 195 }
 196
 197 static void __attribute__ ((format (printf, 2, 3)))
 198     printd (int fd, const char *fmt, ...)
 199 {
 200     int len;
 201     va_list ap;
 202     char buf[200];
 203
 204     va_start (ap, fmt);
 205     len = vsnprintf (buf, sizeof (buf), fmt, ap);
 206     va_end (ap);
 207     writedata (fd, buf, len);
 208 }
 209
 210 static void die (fz_error error)
 211 {
 212     fz_catch (error, "aborting");
 213     if (state.xref)
 214        pdf_closexref (state.xref);
 215     exit (1);
 216 }
 217
 218 void openxref (char *filename)
 219 {
 220     int fd;
 221     fz_stream *file;
 222
 223     fd = open (filename, O_BINARY | O_RDONLY, 0666);
 224     if (fd < 0)
 225         die (fz_throw ("cannot open file '%s'", filename));
 226
 227     file = fz_openfile (fd);
 228     state.xref = pdf_openxref (file);
 229     if (!state.xref)
 230         die (fz_throw ("cannot open PDF file '%s'", filename));
 231     fz_dropstream (file);
 232
 233     if (pdf_needspassword (state.xref)) {
 234         die (fz_throw ("password protected"));
 235     }
 236
 237     state.pagecount = pdf_getpagecount (state.xref);
 238     state.pagetbl = stat_alloc (state.pagecount * sizeof (*state.pagetbl));
 239 }
 240
 241 static int readlen (int fd)
 242 {
 243     ssize_t n;
 244     char p[4];
 245
 246     n = read (fd, p, 4);
 247     if (n != 4) {
 248         err (1, "read %zd", n);
 249     }
 250
 251     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 252 }
 253
 254 static void freepage (struct page *page)
 255 {
 256     int i;
 257     struct page *p;
 258
 259     fz_droppixmap (page->pixmap);
 260     for (p = state.pages; p; p = p->prev) {
 261         if (p->prev == page) {
 262             p->prev = page->prev;
 263             break;
 264         }
 265     }
 266     for (i = 0; i < page->slicecount; ++i) {
 267         struct slice *s = &page->slices[i];
 268         if (s->texindex != -1) {
 269             if (state.texowners[s->texindex].slice == s) {
 270                 state.texowners[s->texindex].slice = NULL;
 271                 ARSERT (state.texowners[s->texindex].w == s->w);
 272                 ARSERT (state.texowners[s->texindex].h >= s->h);
 273             }
 274         }
 275     }
 276     if (page->text) {
 277         fz_freetextspan (page->text);
 278     }
 279     if (page->drawpage) {
 280         pdf_droppage (page->drawpage);
 281     }
 282
 283     free (page);
 284 }
 285
 286 static void subdivide (struct page *p)
 287 {
 288     int i;
 289     int h = p->pixmap->h;
 290     int th = MIN (h, state.sliceheight);
 291
 292     for (i = 0; i < p->slicecount; ++i) {
 293         struct slice *s = &p->slices[i];
 294         s->texindex = -1;
 295         s->h = MIN (th, h);
 296         s->w = p->pixmap->w;
 297         h -= th;
 298     }
 299 }
 300
 301 static void *render (int pageno, int pindex)
 302 {
 303     fz_error error;
 304     int slicecount;
 305     fz_obj *pageobj;
 306     struct page *page;
 307     double start, end;
 308     pdf_page *drawpage;
 309     fz_displaylist *list;
 310     fz_device *idev, *mdev;
 311     struct pagedim *pagedim;
 312
 313     start = now ();
 314     /* printd (state.sock, "T \"rendering %d\"", pageno); */
 315     pdf_flushxref (state.xref, 0);
 316
 317     pagedim = &state.pagedims[pindex];
 318     slicecount = (pagedim->bbox.y1 - pagedim->bbox.y0
 319                   + state.sliceheight - 1) / state.sliceheight;
 320     slicecount += slicecount == 0;
 321
 322     page = calloc (sizeof (*page)
 323                    + (slicecount * sizeof (struct slice)), 1);
 324     if (!page) {
 325         err (1, "calloc page %d\n", pageno);
 326     }
 327     page->slicecount = slicecount;
 328     page->prev = state.pages;
 329     state.pages = page;
 330
 331     pageobj = pdf_getpageobject (state.xref, pageno);
 332     if (!pageobj)
 333         die (fz_throw ("cannot retrieve info from page %d", pageno));
 334
 335     error = pdf_loadpage (&drawpage, state.xref, pageobj);
 336     if (error)
 337         die (error);
 338
 339     page->pixmap = fz_newpixmapwithrect (pdf_devicergb, pagedim->bbox);
 340     if (error)
 341         die (error);
 342     fz_clearpixmap (page->pixmap, 0xFF);
 343
 344     list = fz_newdisplaylist ();
 345     if (!list)
 346         die (fz_throw ("fz_newdisplaylist failed"));
 347
 348     mdev = fz_newlistdevice (list);
 349     error = pdf_runcontentstream (mdev, fz_identity (), state.xref,
 350                                   drawpage->resources,
 351                                   drawpage->contents);
 352     if (error)
 353         die (error);
 354     fz_freedevice (mdev);
 355
 356     idev = fz_newdrawdevice (state.cache, page->pixmap);
 357     if (!idev)
 358         die (fz_throw ("fz_newdrawdevice failed"));
 359     fz_executedisplaylist (list, idev, pagedim->ctm);
 360     fz_freedevice (idev);
 361
 362     fz_freedisplaylist (list);
 363
 364     page->drawpage = drawpage;
 365     page->pagedim = pagedim;
 366     page->pageno = pageno;
 367     subdivide (page);
 368     end = now ();
 369
 370     if (!state.lotsamemory) {
 371         pdf_agestoreditems (state.xref->store);
 372         pdf_evictageditems (state.xref->store);
 373     }
 374
 375     /* printd (state.sock, "T \"rendering %d took %f sec\"", pageno, end - start); */
 376     return page;
 377 }
 378
 379 static void initpdims (void)
 380 {
 381     int pageno;
 382     int pindex;
 383     size_t size;
 384     struct pagedim *p;
 385     double a, b, c, d;
 386
 387     size = 0;
 388     pindex = 0;
 389     a = now ();
 390     c = 0.0;
 391     for (pageno = 1; pageno <= state.pagecount; ++pageno) {
 392         int rotate;
 393         fz_obj *obj;
 394         fz_rect box;
 395         fz_obj *pageobj;
 396
 397         if (!(pageno & 31)) {
 398             if (!c) {
 399                 c = a;
 400             }
 401             d = now ();
 402             printd (state.sock, "T \"processing page %d %f\"", pageno, d - c);
 403             c = d;
 404         }
 405
 406         pageobj = pdf_getpageobject (state.xref, pageno);
 407         if (!pageobj) {
 408             die (fz_throw ("cannot retrieve info from page %d", pageno));
 409         }
 410
 411         state.pagetbl[pageno - 1] = fz_tonum (pageobj);
 412         obj = fz_dictgets (pageobj, "CropBox");
 413         if (!fz_isarray (obj)) {
 414             obj = fz_dictgets (pageobj, "MediaBox");
 415             if (!fz_isarray (obj)) {
 416                 die (fz_throw ("cannot find page bounds %d (%d R)",
 417                                fz_tonum (obj), fz_togen (obj)));
 418             }
 419         }
 420
 421         box = pdf_torect (obj);
 422         obj = fz_dictgets (pageobj, "Rotate");
 423         if (fz_isint (obj))
 424             rotate = fz_toint (obj);
 425         else
 426             rotate = 0;
 427
 428         if (pageno != 1
 429             && (p->rotate == rotate
 430                 && !memcmp (&p->box, &box, sizeof (box)))) {
 431             continue;
 432         }
 433
 434         size += sizeof (*state.pagedims);
 435         state.pagedims = realloc (state.pagedims, size);
 436         if (!state.pagedims)  {
 437             err (1, "realloc pagedims %zu", size);
 438         }
 439
 440         p = &state.pagedims[pindex++];
 441         memcpy (&p->box, &box, sizeof (box));
 442         p->rotate = rotate;
 443
 444         p->pageno = pageno - 1;
 445     }
 446
 447     state.pagedimcount = pindex;
 448     b = now ();
 449     printd (state.sock, "T \"Processed %d pages in %f seconds\"",
 450             state.pagecount, b - a);
 451 }
 452
 453 static void layout (void)
 454 {
 455     int pindex;
 456     fz_matrix ctm;
 457     fz_rect box, box2;
 458     double zoom, w;
 459     struct pagedim *p = state.pagedims;
 460
 461     pindex = 0;
 462     printd (state.sock, "c");
 463     for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
 464         box.x0 = MIN (p->box.x0, p->box.x1);
 465         box.y0 = MIN (p->box.y0, p->box.y1);
 466         box.x1 = MAX (p->box.x0, p->box.x1);
 467         box.y1 = MAX (p->box.y0, p->box.y1);
 468
 469         ctm = fz_identity ();
 470         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 471         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 472         box2 = fz_transformrect (ctm, box);
 473         w = box2.x1 - box2.x0;
 474
 475         zoom = (state.w / w);
 476         ctm = fz_identity ();
 477         ctm = fz_concat (ctm, fz_translate (0, -box.y1));
 478         ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
 479         ctm = fz_concat (ctm, fz_rotate (p->rotate));
 480         p->bbox = fz_roundrect (fz_transformrect (ctm, box));
 481         memcpy (&p->ctm, &ctm, sizeof (ctm));
 482     }
 483
 484     while (p-- != state.pagedims)  {
 485         printd (state.sock, "l %d %d %d",
 486                 p->pageno, p->bbox.x1 - p->bbox.x0, p->bbox.y1 - p->bbox.y0);
 487     }
 488
 489     printd (state.sock, "C %d", state.pagecount);
 490 }
 491
 492 static void recurse_outline (pdf_outline *outline, int level)
 493 {
 494     while (outline) {
 495         fz_obj *obj;
 496         int top = 0;
 497         int pageno = -1;
 498
 499         if (!outline->link) goto next;
 500
 501         obj = outline->link->dest;
 502         if (fz_isarray (obj)) {
 503             int i;
 504             int num;
 505             fz_obj *obj2;
 506             struct pagedim *pagedim = state.pagedims;
 507
 508             obj2 = fz_arrayget (obj, 0);
 509             if (fz_isint (obj2)) {
 510                 pageno = fz_toint (obj2);
 511             }
 512             else {
 513                 num = fz_tonum (obj2);
 514                 for (i = 0; i < state.pagecount; ++i)  {
 515                     if (state.pagetbl[i] == num) {
 516                         pageno = i;
 517                         break;
 518                     }
 519                 }
 520             }
 521
 522             for (i = 0; i < state.pagedimcount; ++i) {
 523                 if (state.pagedims[i].pageno > pageno)
 524                     break;
 525                 pagedim = &state.pagedims[i];
 526             }
 527
 528             if (fz_arraylen (obj) > 3) {
 529                 fz_point p;
 530
 531                 p.x = fz_toint (fz_arrayget (obj, 2));
 532                 p.y = fz_toint (fz_arrayget (obj, 3));
 533                 p = fz_transformpoint (pagedim->ctm, p);
 534                 top = p.y;
 535             }
 536         }
 537
 538         lprintf ("%*c%s %d\n", level, ' ', outline->title, pageno);
 539         printd (state.sock, "o %d %d %d %s",
 540                 level, pageno, top, outline->title);
 541     next:
 542         if (outline->child) {
 543             recurse_outline (outline->child, level + 1);
 544         }
 545         outline = outline->next;
 546     }
 547 }
 548
 549 static void process_outline (void)
 550 {
 551     pdf_outline *outline;
 552
 553     outline = pdf_loadoutline (state.xref);
 554     if (outline) {
 555         recurse_outline (outline, 0);
 556         pdf_dropoutline (outline);
 557     }
 558 }
 559
 560 /* wishful thinking function */
 561 static void search (regex_t *re, int pageno, int y, int forward)
 562 {
 563     int i;
 564     int ret;
 565     char *p;
 566     char buf[256];
 567     fz_error error;
 568     fz_obj *pageobj;
 569     fz_device *tdev;
 570     pdf_page *drawpage;
 571     fz_textspan *text, *span;
 572     struct pagedim *pdim, *pdimprev;
 573     int stop = 0;
 574     int niters = 0;
 575     double start, end;
 576
 577     start = now ();
 578     while (pageno >= 0 && pageno < state.pagecount && !stop) {
 579         if (niters++ == 5) {
 580             niters = 0;
 581             if (hasdata (state.sock)) {
 582                 printd (state.sock, "T \"attention requested aborting search at %d\"",
 583                         pageno);
 584                 stop = 1;
 585             }
 586             else {
 587                 printd (state.sock, "T \"searching in page %d\"", pageno);
 588             }
 589         }
 590         pdimprev = NULL;
 591         for (i = 0; i < state.pagedimcount; ++i) {
 592             pdim = &state.pagedims[i];
 593             if (pdim->pageno == pageno)  {
 594                 goto found;
 595             }
 596             if (pdim->pageno > pageno) {
 597                 pdim = pdimprev;
 598                 goto found;
 599             }
 600             pdimprev = pdim;
 601         }
 602         pdim = pdimprev;
 603     found:
 604
 605         pageobj = pdf_getpageobject (state.xref, pageno + 1);
 606         if (!pageobj)
 607             die (fz_throw ("cannot retrieve info from page %d", pageno));
 608
 609         error = pdf_loadpage (&drawpage, state.xref, pageobj);
 610         if (error)
 611             die (error);
 612
 613         text = fz_newtextspan ();
 614         tdev = fz_newtextdevice (text);
 615         error = pdf_runcontentstream (tdev, pdim->ctm, state.xref,
 616                                       drawpage->resources,
 617                                       drawpage->contents);
 618         if (error) die (error);
 619         fz_freedevice (tdev);
 620
 621         for (span = text; span; span = span->next) {
 622             regmatch_t rm;
 623
 624             p = buf;
 625             /* XXX: spans are not sorted "visually" */
 626             for (i = 0; i < MIN (span->len, sizeof (buf) - 1); ++i) {
 627                 if (forward) {
 628                     if (span->text[i].bbox.y0 < y + 1) {
 629                         continue;
 630                     }
 631                 }
 632                 else {
 633                     if (span->text[i].bbox.y0 > y - 1) {
 634                         continue;
 635                     }
 636                 }
 637                 if (span->text[i].c < 256) {
 638                     *p++ = span->text[i].c;
 639                 }
 640                 else  {
 641                     *p++ = '?';
 642                 }
 643             }
 644             if (p == buf) {
 645                 continue;
 646             }
 647             *p++ = 0;
 648
 649             ret = regexec (re, buf, 1, &rm, 0);
 650             if (ret)  {
 651                 if (ret != REG_NOMATCH) {
 652                     size_t size;
 653                     char errbuf[80];
 654                     size = regerror (ret, re, errbuf, sizeof (errbuf));
 655                     printd (state.sock,
 656                             "T \"regexec error `%.*s'\"",
 657                             (int) size, errbuf);
 658                 }
 659             }
 660             else  {
 661                 fz_rect r;
 662
 663                 r.x0 = span->text[rm.rm_so].bbox.x0 - pdim->bbox.x0;
 664                 r.y0 = span->text[rm.rm_so].bbox.y0;
 665                 r.x1 = span->text[rm.rm_eo - 1].bbox.x1 - pdim->bbox.x0;
 666                 r.y1 = span->text[rm.rm_eo - 1].bbox.y1;
 667
 668                 if (!stop) {
 669                     printd (state.sock, "F %d %d %f %f %f %f",
 670                             pageno, 1,
 671                             r.x0, r.y0,
 672                             r.x1, r.y1);
 673                 }
 674                 else  {
 675                     printd (state.sock, "R %d %d %f %f %f %f",
 676                             pageno, 2,
 677                             r.x0, r.y0,
 678                             r.x1, r.y1);
 679                 }
 680                 printd (state.sock, "T \"found at %d `%.*s' %f in %f sec\"",
 681                         pageno, rm.rm_eo - rm.rm_so, &buf[rm.rm_so],
 682                         span->text[0].bbox.y0 - drawpage->mediabox.y0,
 683                         now () - start);
 684                 stop = 1;
 685             }
 686         }
 687         if (forward) {
 688             pageno += 1;
 689             y = 0;
 690         }
 691         else {
 692             pageno -= 1;
 693             y = INT_MAX;
 694         }
 695         fz_freetextspan (text);
 696         pdf_droppage (drawpage);
 697     }
 698     end = now ();
 699     if (!stop)  {
 700         printd (state.sock, "T \"no matches %f sec\"", end - start);
 701     }
 702     printd (state.sock, "d");
 703 }
 704
 705 static void *mainloop (void *unused)
 706 {
 707     char *p = NULL;
 708     int len, ret, oldlen = 0;
 709
 710     for (;;) {
 711         len = readlen (state.sock);
 712         if (len == 0) {
 713             errx (1, "readlen returned 0");
 714         }
 715
 716         if (oldlen < len + 1) {
 717             p = realloc (p, len + 1);
 718             if (!p) {
 719                 err (1, "realloc %d failed", len + 1);
 720             }
 721             oldlen = len + 1;
 722         }
 723         readdata (state.sock, p, len);
 724         p[len] = 0;
 725
 726         if (!strncmp ("open", p, 4)) {
 727             char *filename = p + 5;
 728
 729             openxref (filename);
 730             initpdims ();
 731         }
 732         else if (!strncmp ("free", p, 4)) {
 733             void *ptr;
 734
 735             ret = sscanf (p + 4, " %p", &ptr);
 736             if (ret != 1) {
 737                 errx (1, "malformed free `%.*s' ret=%d", len, p, ret);
 738             }
 739             lock ("free");
 740             freepage (ptr);
 741             unlock ("free");
 742             printd (state.sock, "d");
 743         }
 744         else if (!strncmp ("search", p, 6)) {
 745             int icase, pageno, y, ret, len2, forward;
 746             char *pattern;
 747             regex_t re;
 748
 749             ret = sscanf (p + 6, " %d %d %d %d %n",
 750                           &icase, &pageno, &y, &forward, &len2);
 751             if (ret != 4) {
 752                 errx (1, "malformed search `%s' ret=%d", p, ret);
 753             }
 754
 755             pattern = p + 6 + len2;
 756             ret = regcomp (&re, pattern,
 757                            REG_EXTENDED | (icase ? REG_ICASE : 0));
 758             if (ret) {
 759                 char errbuf[80];
 760                 size_t size;
 761
 762                 size = regerror (ret, &re, errbuf, sizeof (errbuf));
 763                 printd (state.sock, "T \"regcomp failed `%.*s'\"", (int) size, errbuf);
 764             }
 765             else  {
 766                 search (&re, pageno, y, forward);
 767                 regfree (&re);
 768             }
 769         }
 770         else if (!strncmp ("geometry", p, 8)) {
 771             int w, h;
 772
 773             ret = sscanf (p + 8, " %d %d", &w, &h);
 774             if (ret != 2) {
 775                 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
 776             }
 777             state.h = h;
 778             if (w != state.w) {
 779                 int i;
 780                 state.w = w;
 781                 for (i = 0; i < state.texcount; ++i)  {
 782                     state.texowners[i].slice = NULL;
 783                 }
 784             }
 785             lock ("geometry");
 786             layout ();
 787             process_outline ();
 788             unlock ("geometry");
 789             printd (state.sock, "d");
 790         }
 791         else if (!strncmp ("render", p, 6)) {
 792             int pageno, pindex, w, h, ret;
 793             struct page *page;
 794
 795             ret = sscanf (p + 6, " %d %d %d %d", &pageno, &pindex, &w, &h);
 796             if (ret != 4) {
 797                 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
 798             }
 799
 800             page = render (pageno, pindex);
 801             printd (state.sock, "r %d %d %d %p\n",
 802                     pageno,
 803                     state.w,
 804                     state.h,
 805                     page);
 806         }
 807         else {
 808             errx (1, "unknown command %.*s", len, p);
 809         }
 810     }
 811     return NULL;
 812 }
 813
 814 static void upload2 (struct page *page, int slicenum, const char *cap)
 815 {
 816     int i;
 817     int w, h;
 818     double start, end;
 819     struct slice *slice = &page->slices[slicenum];
 820
 821     w = page->pixmap->w;
 822     h = page->pixmap->h;
 823
 824     ARSERT (w == slice->w);
 825     if (slice->texindex != -1
 826         && state.texowners[slice->texindex].slice == slice) {
 827         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
 828     }
 829     else  {
 830         int subimage = 0;
 831         int index = (state.texindex++ % state.texcount);
 832         size_t offset = 0;
 833
 834         for (i = 0; i < slicenum; ++i) {
 835             offset += w * page->slices[i].h * 4;
 836         }
 837
 838         if (state.texowners[index].w == slice->w) {
 839             if (state.texowners[index].h >= slice->h ) {
 840                 subimage = 1;
 841             }
 842             else {
 843                 state.texowners[index].h = slice->h;
 844             }
 845         }
 846         else  {
 847             state.texowners[index].h = slice->h;
 848         }
 849
 850         state.texowners[index].slice = slice;
 851         state.texowners[index].w = slice->w;
 852         slice->texindex = index;
 853
 854         glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
 855         start = now ();
 856         if (subimage) {
 857             {
 858                 GLenum err = glGetError ();
 859                 if (err != GL_NO_ERROR) {
 860                     printf ("\e[0;31mERROR1 %d %d %#x\e[0m\n", w, slice->h, err);
 861                     abort ();
 862                 }
 863             }
 864             glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
 865                              0,
 866                              0,
 867                              0,
 868                              w,
 869                              slice->h,
 870                              state.texform,
 871                              state.texty,
 872                              page->pixmap->samples + offset
 873                 );
 874             {
 875                 GLenum err = glGetError ();
 876                 if (err != GL_NO_ERROR) {
 877                     printf ("\e[0;31mERROR %d %d %#x\e[0m\n", w, slice->h, err);
 878                     abort ();
 879                 }
 880             }
 881         }
 882         else {
 883             glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
 884                           0,
 885                           GL_RGBA8,
 886                           w,
 887                           slice->h,
 888                           0,
 889                           state.texform,
 890                           state.texty,
 891                           page->pixmap->samples + offset
 892                 );
 893         }
 894
 895         end = now ();
 896         lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
 897                  subimage ? "sub" : "img",
 898                  page->pageno, slicenum,
 899                  slice->w, slice->h,
 900                  state.texids[slice->texindex],
 901                  end - start);
 902     }
 903 }
 904
 905 CAMLprim value ml_preload (value ptr_v)
 906 {
 907     int i;
 908     int ret;
 909     void *ptr;
 910     CAMLparam1 (ptr_v);
 911     char *s = String_val (ptr_v);
 912     struct page *page;
 913
 914     if (trylock ("ml_preload")) {
 915         goto done;
 916     }
 917     ret = sscanf (s, "%p", &ptr);
 918     if (ret != 1) {
 919         errx (1, "cannot parse pointer `%s'", s);
 920     }
 921
 922     page = ptr;
 923     for (i = 0; i < page->slicecount; ++i) {
 924         upload2 (ptr, i, "preload");
 925     }
 926
 927     unlock ("ml_preload");
 928  done:
 929     CAMLreturn (Val_unit);
 930 }
 931
 932 CAMLprim value ml_draw (value dispy_v, value w_v, value h_v,
 933                         value py_v, value ptr_v)
 934 {
 935     CAMLparam5 (dispy_v, w_v, h_v, py_v, ptr_v);
 936     int dispy = Int_val (dispy_v);
 937     int w = Int_val (w_v);
 938     int h = Int_val (h_v);
 939     int py = Int_val (py_v);
 940     char *s = String_val (ptr_v);
 941     int ret;
 942     void *ptr;
 943     struct page *page;
 944     int slicenum = 0;
 945
 946     if (trylock ("ml_draw")) {
 947         goto done;
 948     }
 949
 950     ret = sscanf (s, "%p", &ptr);
 951     if (ret != 1) {
 952         errx (1, "cannot parse pointer `%s'", s);
 953     }
 954     page = ptr;
 955
 956     w = page->pixmap->w;
 957
 958     ARSERT (h >= 0 && "ml_draw wrong h");
 959
 960     glEnable (GL_TEXTURE_RECTANGLE_ARB);
 961     if (state.useatifs) {
 962         glEnable (GL_FRAGMENT_SHADER_ATI);
 963     }
 964
 965     for (slicenum = 0; slicenum < page->slicecount; ++slicenum) {
 966         struct slice *slice = &page->slices[slicenum];
 967         if (slice->h > py) {
 968             break;
 969         }
 970         py -= slice->h;
 971     }
 972
 973     h = MIN (state.h, h);
 974     while (h) {
 975         int th;
 976         struct slice *slice = &page->slices[slicenum];
 977
 978         ARSERT (slicenum < page->slicecount && "ml_draw wrong slicenum");
 979
 980         th = MIN (h, slice->h - py);
 981         upload2 (page, slicenum, "upload");
 982
 983         glBegin (GL_QUADS);
 984         {
 985             glTexCoord2i (0, py);
 986             glVertex2i (0, dispy);
 987
 988             glTexCoord2i (w, py);
 989             glVertex2i (w, dispy);
 990
 991             glTexCoord2i (w, py+th);
 992             glVertex2i (w, dispy + th);
 993
 994             glTexCoord2i (0, py+th);
 995             glVertex2i (0, dispy + th);
 996         }
 997         glEnd ();
 998
 999         h -= th;
1000         py = 0;
1001         dispy += th;
1002         slicenum += 1;
1003     }
1004
1005     glDisable (GL_TEXTURE_RECTANGLE_ARB);
1006     if (state.useatifs) {
1007         glDisable (GL_FRAGMENT_SHADER_ATI);
1008     }
1009
1010     unlock ("ml_draw");
1011  done:
1012     CAMLreturn (Val_unit);
1013 }
1014
1015 static pdf_link *getlink (struct page *page, int x, int y)
1016 {
1017     fz_point p;
1018     fz_matrix ctm;
1019     pdf_link *link;
1020
1021     p.x = x;
1022     p.y = y;
1023
1024     ctm = fz_invertmatrix (page->pagedim->ctm);
1025     p = fz_transformpoint (ctm, p);
1026
1027     for (link = page->drawpage->links; link; link = link->next) {
1028         if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1029             if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1030                 if (link->kind == PDF_LGOTO) {
1031                     return link;
1032                 }
1033             }
1034         }
1035     }
1036     return NULL;
1037 }
1038
1039 CAMLprim value ml_checklink (value ptr_v, value x_v, value y_v)
1040 {
1041     CAMLparam3 (ptr_v, x_v, y_v);
1042     char *s = String_val (ptr_v);
1043     int ret;
1044
1045     if (trylock ("ml_checklink")) {
1046         ret = 0;
1047     }
1048     else {
1049         ret = NULL != getlink (parse_pointer ("ml_checklink", s),
1050                                Int_val (x_v), Int_val (y_v));
1051         unlock ("ml_checklink");
1052     }
1053     CAMLreturn (Val_bool (ret));
1054 }
1055
1056 CAMLprim value ml_getlink (value ptr_v, value x_v, value y_v)
1057 {
1058     CAMLparam3 (ptr_v, x_v, y_v);
1059     CAMLlocal2 (ret_v, tup_v);
1060     pdf_link *link;
1061     struct page *page;
1062     char *s = String_val (ptr_v);
1063
1064     if (trylock ("ml_gettext")) {
1065         ret_v = Val_int (0);
1066         goto done;
1067     }
1068
1069     page = parse_pointer ("ml_getlink", s);
1070
1071     link = getlink (page, Int_val (x_v), Int_val (y_v));
1072     if (link) {
1073         int pageno;
1074         fz_point p;
1075         fz_obj *obj;
1076
1077         pageno = -1;
1078         obj = fz_arrayget (link->dest, 0);
1079         if (fz_isindirect (obj)) {
1080             pageno = pdf_findpageobject (state.xref, obj) - 1;
1081         }
1082         else if (fz_isint (obj)) {
1083             pageno = fz_toint (obj);
1084         }
1085
1086         if (fz_arraylen (link->dest) > 3) {
1087             p.x = fz_toint (fz_arrayget (link->dest, 2));
1088             p.y = fz_toint (fz_arrayget (link->dest, 3));
1089             p = fz_transformpoint (page->pagedim->ctm, p);
1090         }
1091         else  {
1092             p.x = 0.0;
1093             p.y = 0.0;
1094         }
1095
1096         tup_v = caml_alloc_tuple (2);
1097         ret_v = caml_alloc_small (1, 1);
1098         Field (tup_v, 0) = Val_int (pageno);
1099         Field (tup_v, 1) = Val_int (p.y);
1100         Field (ret_v, 0) = tup_v;
1101     }
1102     else {
1103         ret_v = Val_int (0);
1104     }
1105     unlock ("ml_getlink");
1106
1107  done:
1108     CAMLreturn (ret_v);
1109 }
1110
1111 CAMLprim value ml_gettext (value ptr_v, value rect_v, value oy_v, value rectsel_v)
1112 {
1113     CAMLparam4 (ptr_v, rect_v, oy_v, rect_v);
1114     fz_matrix ctm;
1115     fz_point p1, p2;
1116     struct page *page;
1117     fz_textspan *span;
1118     char *s = String_val (ptr_v);
1119     int rectsel = Bool_val (rectsel_v);
1120     int i, bx0, bx1, by0, by1, x0, x1, y0, y1, oy;
1121
1122     /* stop GCC from complaining about uninitialized variables */
1123     int rx0 = rx0, rx1 = rx1, ry0 = ry0, ry1 = ry1;
1124
1125     if (trylock ("ml_gettext")) {
1126         goto done;
1127     }
1128
1129     page = parse_pointer ("ml_gettext", s);
1130
1131     oy = Int_val (oy_v);
1132     p1.x = Int_val (Field (rect_v, 0));
1133     p1.y = Int_val (Field (rect_v, 1));
1134     p2.x = Int_val (Field (rect_v, 2));
1135     p2.y = Int_val (Field (rect_v, 3));
1136
1137     if (0) {
1138         glEnable (GL_BLEND);
1139         glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1140         glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1141         glColor4f (0, 0, 0, 0.2);
1142         glRecti (p1.x, p1.y, p2.x, p2.y);
1143         glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1144         glDisable (GL_BLEND);
1145     }
1146
1147     ctm = page->pagedim->ctm;
1148     if (!page->text) {
1149         fz_error error;
1150         fz_device *tdev;
1151
1152         page->text = fz_newtextspan ();
1153         tdev = fz_newtextdevice (page->text);
1154         error = pdf_runcontentstream (tdev, page->pagedim->ctm, state.xref,
1155                                       page->drawpage->resources,
1156                                       page->drawpage->contents);
1157         if (error) die (error);
1158         fz_freedevice (tdev);
1159     }
1160
1161     printf ("\ec");
1162
1163     printf ("BBox %f %f %f %f\n", p1.x, p1.y, p2.x, p2.y);
1164     p1.x += page->pixmap->x;
1165     p1.y += page->pixmap->y;
1166     p2.x += page->pixmap->x;
1167     p2.y += page->pixmap->y;
1168     x0 = p1.x;
1169     y0 = p1.y;
1170     x1 = p2.x;
1171     y1 = p2.y;
1172     printf ("BBox %d %d %d %d %d %d\n", x0, y0, x1, y1, oy, page->pageno);
1173
1174     for (span = page->text; span; span = span->next) {
1175         int seen = 0;
1176
1177         /* fz_debugtextspanxml (span); */
1178         for (i = 0; i < span->len; ++i) {
1179             long c;
1180
1181             bx0 = span->text[i].bbox.x0;
1182             bx1 = span->text[i].bbox.x1;
1183             by0 = span->text[i].bbox.y0 + oy;
1184             by1 = span->text[i].bbox.y1 + oy;
1185
1186             if ((bx1 >= x0 && bx0 <= x1 && by1 >= y0 && by0 <= y1)) {
1187                 if (!seen) {
1188                     rx0 = bx0 - page->pixmap->x;
1189                     rx1 = bx1 - page->pixmap->x;
1190                     ry0 = by0;
1191                     ry1 = by1;
1192                 }
1193
1194                 seen = 1;
1195                 c = span->text[i].c;
1196                 if (c < 256) {
1197                     if ((isprint (c) && !isspace (c))) {
1198                         if (!rectsel) {
1199                             bx0 -= page->pixmap->x;
1200                             bx1 -= page->pixmap->x;
1201                             glEnable (GL_BLEND);
1202                             glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1203                             glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1204                             glColor4f (0.5, 0.5, 0.0, 0.6);
1205                             glRecti (bx0, by0, bx1, by1);
1206                             glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1207                             glDisable (GL_BLEND);
1208                         }
1209                         if (isprint (c) || c ==' ') {
1210                             rx1 = bx1;
1211                             ry1 = by1;
1212                         }
1213                     }
1214                     putc (c, stdout);
1215                 }
1216                 else  {
1217                     putc ('?', stdout);
1218                 }
1219             }
1220         }
1221
1222         if (rectsel) {
1223             if (seen) {
1224                 glEnable (GL_BLEND);
1225                 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1226                 glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1227                 glColor4f (0.5, 0.5, 0.0, 0.6);
1228                 glRecti (rx0, ry0, rx1, ry1);
1229                 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1230                 glDisable (GL_BLEND);
1231             }
1232         }
1233
1234         if (seen && span->eol) {
1235             x0 = page->pixmap->x;
1236             putc ('\n', stdout);
1237         }
1238     }
1239     unlock ("ml_gettext");
1240
1241  done:
1242     CAMLreturn (Val_unit);
1243 }
1244
1245 static void initgl (void)
1246 {
1247 #ifdef _BIG_ENDIAN
1248     if (strstr ((char *) glGetString (GL_EXTENSIONS),
1249                 "GL_ATI_fragment_shader")) {
1250         /* Here, with MESA, rv280, powerpc32: BGRA(rev) is slow while
1251            ABGR is fast, so fix things in the shader */
1252         state.texform = GL_ABGR_EXT;
1253         state.texty = GL_UNSIGNED_INT_8_8_8_8;
1254
1255         glBindFragmentShaderATI (1);
1256         glBeginFragmentShaderATI ();
1257         {
1258             glSampleMapATI (GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
1259
1260             glColorFragmentOp1ATI (GL_MOV_ATI,
1261                                    GL_REG_1_ATI, GL_RED_BIT_ATI, GL_NONE,
1262                                    GL_REG_0_ATI, GL_BLUE, GL_NONE);
1263             glColorFragmentOp1ATI (GL_MOV_ATI,
1264                                    GL_REG_1_ATI, GL_BLUE_BIT_ATI, GL_NONE,
1265                                    GL_REG_0_ATI, GL_RED, GL_NONE);
1266             glColorFragmentOp1ATI (
1267                 GL_MOV_ATI,
1268                 GL_REG_0_ATI, GL_RED_BIT_ATI | GL_BLUE_BIT_ATI, GL_NONE,
1269                 GL_REG_1_ATI, GL_NONE, GL_NONE
1270                 );
1271         }
1272         glEndFragmentShaderATI ();
1273         state.useatifs = 1;
1274     }
1275     else {
1276         state.texform = GL_BGRA_EXT;
1277         state.texty = GL_UNSIGNED_INT_8_8_8_8_REV;
1278     }
1279 #else
1280     state.texform = GL_BGRA_EXT;
1281     state.texty = GL_UNSIGNED_INT_8_8_8_8;
1282 #endif
1283 }
1284
1285 CAMLprim value ml_init (value sock_v)
1286 {
1287     int ret;
1288     CAMLparam1 (sock_v);
1289
1290     state.texcount = 128;
1291     state.sliceheight = 64;
1292
1293     state.texids = calloc (state.texcount * sizeof (*state.texids), 1);
1294     if (!state.texids) {
1295         err (1, "calloc texids %zu", state.texcount * sizeof (*state.texids));
1296     }
1297
1298     state.texowners = calloc (state.texcount * sizeof (*state.texowners), 1);
1299     if (!state.texowners) {
1300         err (1, "calloc texowners %zu",
1301              state.texcount * sizeof (*state.texowners));
1302     }
1303
1304     glGenTextures (state.texcount, state.texids);
1305
1306     state.sock = Int_val (sock_v);
1307     initgl ();
1308
1309     state.cache = fz_newglyphcache ();
1310     if (!state.cache) {
1311         errx (1, "fz_newglyphcache failed");
1312     }
1313
1314     ret = pthread_create (&state.thread, NULL, mainloop, NULL);
1315     if (ret) {
1316         errx (1, "pthread_create: %s", strerror (errno));
1317     }
1318
1319     CAMLreturn (Val_unit);
1320 }