Do not continue searching after encountering (undefined) regexec error
[llpp.git] / link.c
bloba4d4a096ed87b6fdbc6232078bbdb930a88668f6
1 /* lot's of code c&p-ed directly from mupdf */
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>
16 /* fugly as hell and GCC specific but... */
17 #ifdef _BIG_ENDIAN
18 #define GL_GLEXT_PROTOTYPES
19 #endif
21 #include <GL/gl.h>
22 #include <GL/glext.h>
24 #include <caml/fail.h>
25 #include <caml/alloc.h>
26 #include <caml/memory.h>
27 #include <caml/unixsupport.h>
29 #include <fitz.h>
30 #include <mupdf.h>
32 #if 0
33 #define lprintf printf
34 #else
35 #define lprintf(...)
36 #endif
38 #define ARSERT(cond) for (;;) { \
39 if (!(cond)) { \
40 errx (1, "%s:%d " #cond, __FILE__, __LINE__); \
41 } \
42 break; \
45 struct slice {
46 int texindex;
47 int w, h;
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[];
61 struct pagedim {
62 int pageno;
63 int rotate;
64 fz_rect box;
65 fz_bbox bbox;
66 fz_matrix ctm;
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;
81 int useatifs;
83 int texindex;
84 int texcount;
85 GLuint *texids;
87 GLenum texform;
88 GLenum texty;
90 int lotsamemory;
92 int *pagetbl;
93 struct {
94 int w, h;
95 struct slice *slice;
96 } *texowners;
97 } state;
99 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
101 static void lock (const char *cap)
103 int ret = pthread_mutex_lock (&mutex);
104 if (ret) {
105 errx (1, "%s: pthread_mutex_lock: %s", cap, strerror (ret));
109 static void unlock (const char *cap)
111 int ret = pthread_mutex_unlock (&mutex);
112 if (ret) {
113 errx (1, "%s: pthread_mutex_unlock: %s", cap, strerror (ret));
117 static int trylock (const char *cap)
119 int ret = pthread_mutex_trylock (&mutex);
121 if (ret && ret != EBUSY) {
122 errx (1, "%s: pthread_mutex_trylock: %s", cap, strerror (ret));
124 return ret == EBUSY;
127 static void *parse_pointer (const char *cap, const char *s)
129 int ret;
130 void *ptr;
132 ret = sscanf (s, "%p", &ptr);
133 if (ret != 1) {
134 errx (1, "%s: cannot parse pointer in `%s'", cap, s);
136 return ptr;
139 static int hasdata (int sock)
141 int ret;
142 struct pollfd pfd;
144 pfd.fd = sock;
145 pfd.events = POLLIN;
146 ret = poll (&pfd, 1, 0);
147 if (ret == 0) {
148 return 0;
150 if (ret != 1) {
151 err (1, "poll");
153 return pfd.revents & POLLIN;
156 static double now (void)
158 struct timeval tv;
160 if (gettimeofday (&tv, NULL)) {
161 err (1, "gettimeofday");
163 return tv.tv_sec + tv.tv_usec*1e-6;
166 static void readdata (int fd, char *p, int size)
168 ssize_t n;
170 n = read (fd, p, size);
171 if (n - size) {
172 err (1, "read (req %d, ret %zd)", size, n);
176 static void writedata (int fd, char *p, int size)
178 char buf[4];
179 ssize_t n;
181 buf[0] = (size >> 24) & 0xff;
182 buf[1] = (size >> 16) & 0xff;
183 buf[2] = (size >> 8) & 0xff;
184 buf[3] = (size >> 0) & 0xff;
186 n = write (fd, buf, 4);
187 if (n != 4) {
188 err (1, "write %zd", n);
191 n = write (fd, p, size);
192 if (n - size) {
193 err (1, "write (req %d, ret %zd)", size, n);
197 static void __attribute__ ((format (printf, 2, 3)))
198 printd (int fd, const char *fmt, ...)
200 int len;
201 va_list ap;
202 char buf[200];
204 va_start (ap, fmt);
205 len = vsnprintf (buf, sizeof (buf), fmt, ap);
206 va_end (ap);
207 writedata (fd, buf, len);
210 static void die (fz_error error)
212 fz_catch (error, "aborting");
213 if (state.xref)
214 pdf_closexref (state.xref);
215 exit (1);
218 static void openxref (char *filename)
220 int fd;
221 fz_stream *file;
223 fd = open (filename, O_BINARY | O_RDONLY, 0666);
224 if (fd < 0)
225 die (fz_throw ("cannot open file '%s'", filename));
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);
233 if (pdf_needspassword (state.xref)) {
234 die (fz_throw ("password protected"));
237 state.pagecount = pdf_getpagecount (state.xref);
238 state.pagetbl = stat_alloc (state.pagecount * sizeof (*state.pagetbl));
241 static int readlen (int fd)
243 ssize_t n;
244 char p[4];
246 n = read (fd, p, 4);
247 if (n != 4) {
248 err (1, "read %zd", n);
251 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
254 static void freepage (struct page *page)
256 int i;
257 struct page *p;
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;
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);
276 if (page->text) {
277 fz_freetextspan (page->text);
279 if (page->drawpage) {
280 pdf_droppage (page->drawpage);
283 free (page);
286 static void subdivide (struct page *p)
288 int i;
289 int h = p->pixmap->h;
290 int th = MIN (h, state.sliceheight);
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;
301 static void *render (int pageno, int pindex)
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;
313 start = now ();
314 /* printd (state.sock, "T rendering %d", pageno); */
315 pdf_flushxref (state.xref, 0);
317 pagedim = &state.pagedims[pindex];
318 slicecount = (pagedim->bbox.y1 - pagedim->bbox.y0
319 + state.sliceheight - 1) / state.sliceheight;
320 slicecount += slicecount == 0;
322 page = calloc (sizeof (*page)
323 + (slicecount * sizeof (struct slice)), 1);
324 if (!page) {
325 err (1, "calloc page %d\n", pageno);
327 page->slicecount = slicecount;
328 page->prev = state.pages;
329 state.pages = page;
331 pageobj = pdf_getpageobject (state.xref, pageno);
332 if (!pageobj)
333 die (fz_throw ("cannot retrieve info from page %d", pageno));
335 error = pdf_loadpage (&drawpage, state.xref, pageobj);
336 if (error)
337 die (error);
339 page->pixmap = fz_newpixmapwithrect (pdf_devicergb, pagedim->bbox);
340 if (error)
341 die (error);
342 fz_clearpixmap (page->pixmap, 0xFF);
344 list = fz_newdisplaylist ();
345 if (!list)
346 die (fz_throw ("fz_newdisplaylist failed"));
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);
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);
362 fz_freedisplaylist (list);
364 page->drawpage = drawpage;
365 page->pagedim = pagedim;
366 page->pageno = pageno;
367 subdivide (page);
368 end = now ();
370 if (!state.lotsamemory) {
371 pdf_agestoreditems (state.xref->store);
372 pdf_evictageditems (state.xref->store);
375 /* printd (state.sock, "T rendering %d took %f sec", pageno, end - start); */
376 return page;
379 /* almost verbatim copy of pdf_getpagecountimp */
380 struct stuff
382 fz_obj *resources;
383 fz_obj *mediabox;
384 fz_obj *cropbox;
385 fz_obj *rotate;
388 static void
389 recurse_page (fz_obj *node, int bias, int *pagesp, struct stuff inherit)
391 fz_obj *type;
392 fz_obj *kids;
393 fz_obj *count;
394 char *typestr;
395 int pages = 0;
396 int i;
398 if (!fz_isdict(node))
400 fz_warn("pagetree node is missing, igoring missing pages...");
401 return;
404 type = fz_dictgets(node, "Type");
405 kids = fz_dictgets(node, "Kids");
406 count = fz_dictgets(node, "Count");
408 if (fz_isname(type))
409 typestr = fz_toname(type);
410 else
412 fz_warn("pagetree node (%d %d R) lacks required type", fz_tonum(node), fz_togen(node));
414 kids = fz_dictgets(node, "Kids");
415 if (kids)
417 fz_warn("guessing it may be a pagetree node, continuing...");
418 typestr = "Pages";
420 else
422 fz_warn("guessing it may be a page, continuing...");
423 typestr = "Page";
427 if (!strcmp(typestr, "Page")) {
428 int rotate;
429 fz_obj *obj;
430 fz_rect box;
431 struct pagedim *p;
432 int pageno = *pagesp;
434 state.pagetbl[pageno + bias] = fz_tonum (node);
436 obj = fz_dictgets (node, "CropBox");
437 if (!obj) obj = inherit.cropbox;
438 if (!fz_isarray (obj)) {
439 obj = fz_dictgets (node, "MediaBox");
440 if (!obj) obj = inherit.mediabox;
442 if (!fz_isarray (obj)) {
443 die (fz_throw ("cannot find page bounds %d (%d Rd)",
444 fz_tonum (node), fz_togen (node)));
447 box = pdf_torect (obj);
449 obj = fz_dictgets (node, "Rotate");
450 if (!obj) obj = inherit.rotate;
451 if (fz_isint (obj)) {
452 rotate = fz_toint (obj);
454 else {
455 rotate = 0;
458 p = &state.pagedims[state.pagedimcount - 1];
459 if ((state.pagedimcount == 0)
460 || (p->rotate != rotate || memcmp (&p->box, &box, sizeof (box)))) {
461 size_t size;
463 size = (state.pagedimcount + 1) * sizeof (*state.pagedims);
464 state.pagedims = realloc (state.pagedims, size);
465 if (!state.pagedims) {
466 err (1, "realloc pagedims to %zu (%d elems)",
467 size, state.pagedimcount + 1);
469 p = &state.pagedims[state.pagedimcount++];
470 p->rotate = rotate;
471 p->box = box;
472 p->pageno = pageno + bias;
474 (*pagesp)++;
476 else if (!strcmp(typestr, "Pages"))
478 fz_obj *inh;
480 if (!fz_isarray(kids))
481 fz_warn("page tree node contains no pages");
483 pdf_logpage("subtree (%d %d R) {\n", fz_tonum(node), fz_togen(node));
485 inh = fz_dictgets(node, "Resources");
486 if (inh) inherit.resources = inh;
488 inh = fz_dictgets(node, "MediaBox");
489 if (inh) inherit.mediabox = inh;
491 inh = fz_dictgets(node, "CropBox");
492 if (inh) inherit.cropbox = inh;
494 inh = fz_dictgets(node, "Rotate");
495 if (inh) inherit.rotate = inh;
497 for (i = 0; i < fz_arraylen(kids); i++)
499 fz_obj *obj = fz_arrayget(kids, i);
501 /* prevent infinite recursion possible in maliciously crafted PDFs */
502 if (obj == node)
504 fz_warn("cyclic page tree");
505 return;
508 recurse_page (obj, *pagesp + bias, &pages, inherit);
511 if (pages != fz_toint(count))
513 fz_warn("page tree node contains incorrect number of pages, continuing...");
514 count = fz_newint(pages);
515 fz_dictputs(node, "Count", count);
516 fz_dropobj(count);
519 pdf_logpage("%d pages\n", pages);
521 (*pagesp) += pages;
523 pdf_logpage("}\n");
527 static void initpdims (void)
529 fz_obj *catalog;
530 fz_obj *pages;
531 int count;
532 double start, end;
533 struct stuff inherit;
535 start = now ();
536 catalog = fz_dictgets (state.xref->trailer, "Root");
537 pages = fz_dictgets (catalog, "Pages");
539 inherit.resources = nil;
540 inherit.mediabox = nil;
541 inherit.cropbox = nil;
542 inherit.rotate = nil;
544 count = 0;
545 recurse_page (pages, 0, &count, inherit);
546 end = now ();
547 printd (state.sock, "T Processed %d pages in %f seconds",
548 count, end - start);
551 static void layout (void)
553 int pindex;
554 fz_matrix ctm;
555 fz_rect box, box2;
556 double zoom, w;
557 struct pagedim *p = state.pagedims;
559 pindex = 0;
560 printd (state.sock, "c");
561 for (pindex = 0; pindex < state.pagedimcount; ++pindex, ++p) {
562 box.x0 = MIN (p->box.x0, p->box.x1);
563 box.y0 = MIN (p->box.y0, p->box.y1);
564 box.x1 = MAX (p->box.x0, p->box.x1);
565 box.y1 = MAX (p->box.y0, p->box.y1);
567 ctm = fz_identity ();
568 ctm = fz_concat (ctm, fz_translate (0, -box.y1));
569 ctm = fz_concat (ctm, fz_rotate (p->rotate));
570 box2 = fz_transformrect (ctm, box);
571 w = box2.x1 - box2.x0;
573 zoom = (state.w / w);
574 ctm = fz_identity ();
575 ctm = fz_concat (ctm, fz_translate (0, -box.y1));
576 ctm = fz_concat (ctm, fz_scale (zoom, -zoom));
577 ctm = fz_concat (ctm, fz_rotate (p->rotate));
578 p->bbox = fz_roundrect (fz_transformrect (ctm, box));
579 memcpy (&p->ctm, &ctm, sizeof (ctm));
582 while (p-- != state.pagedims) {
583 printd (state.sock, "l %d %d %d",
584 p->pageno, p->bbox.x1 - p->bbox.x0, p->bbox.y1 - p->bbox.y0);
587 printd (state.sock, "C %d", state.pagecount);
590 static void recurse_outline (pdf_outline *outline, int level)
592 while (outline) {
593 fz_obj *obj;
594 int top = 0;
595 int pageno = -1;
597 if (!outline->link) goto next;
599 obj = outline->link->dest;
600 if (fz_isarray (obj)) {
601 int i;
602 int num;
603 fz_obj *obj2;
604 struct pagedim *pagedim = state.pagedims;
606 obj2 = fz_arrayget (obj, 0);
607 if (fz_isint (obj2)) {
608 pageno = fz_toint (obj2);
610 else {
611 num = fz_tonum (obj2);
612 for (i = 0; i < state.pagecount; ++i) {
613 if (state.pagetbl[i] == num) {
614 pageno = i;
615 break;
620 for (i = 0; i < state.pagedimcount; ++i) {
621 if (state.pagedims[i].pageno > pageno)
622 break;
623 pagedim = &state.pagedims[i];
626 if (fz_arraylen (obj) > 3) {
627 fz_point p;
629 p.x = fz_toint (fz_arrayget (obj, 2));
630 p.y = fz_toint (fz_arrayget (obj, 3));
631 p = fz_transformpoint (pagedim->ctm, p);
632 top = p.y;
636 lprintf ("%*c%s %d\n", level, ' ', outline->title, pageno);
637 printd (state.sock, "o %d %d %d %s",
638 level, pageno, top, outline->title);
639 next:
640 if (outline->child) {
641 recurse_outline (outline->child, level + 1);
643 outline = outline->next;
647 static void process_outline (void)
649 pdf_outline *outline;
651 outline = pdf_loadoutline (state.xref);
652 if (outline) {
653 recurse_outline (outline, 0);
654 pdf_dropoutline (outline);
658 static int comparespans (const void *l, const void *r)
660 fz_textspan *const*ls = l;
661 fz_textspan *const*rs = r;
663 return (*ls)->text->bbox.y0 - (*rs)->text->bbox.y0;
666 /* wishful thinking function */
667 static void search (regex_t *re, int pageno, int y, int forward)
669 int i, j;
670 int ret;
671 char *p;
672 char buf[256];
673 fz_error error;
674 fz_obj *pageobj;
675 fz_device *tdev;
676 pdf_page *drawpage;
677 fz_textspan *text, *span, **pspan;
678 struct pagedim *pdim, *pdimprev;
679 int stop = 0;
680 int niters = 0;
681 int nspans;
682 double start, end;
684 start = now ();
685 while (pageno >= 0 && pageno < state.pagecount && !stop) {
686 if (niters++ == 5) {
687 if (!state.lotsamemory) {
688 pdf_agestoreditems (state.xref->store);
689 pdf_evictageditems (state.xref->store);
691 niters = 0;
692 if (hasdata (state.sock)) {
693 printd (state.sock, "T attention requested aborting search at %d",
694 pageno);
695 stop = 1;
697 else {
698 printd (state.sock, "T searching in page %d", pageno);
701 pdimprev = NULL;
702 for (i = 0; i < state.pagedimcount; ++i) {
703 pdim = &state.pagedims[i];
704 if (pdim->pageno == pageno) {
705 goto found;
707 if (pdim->pageno > pageno) {
708 pdim = pdimprev;
709 goto found;
711 pdimprev = pdim;
713 pdim = pdimprev;
714 found:
716 pageobj = pdf_getpageobject (state.xref, pageno + 1);
717 if (!pageobj)
718 die (fz_throw ("cannot retrieve info from page %d", pageno));
720 error = pdf_loadpage (&drawpage, state.xref, pageobj);
721 if (error)
722 die (error);
724 text = fz_newtextspan ();
725 tdev = fz_newtextdevice (text);
726 error = pdf_runcontentstream (tdev, pdim->ctm, state.xref,
727 drawpage->resources,
728 drawpage->contents);
729 if (error) die (error);
730 fz_freedevice (tdev);
732 nspans = 0;
733 for (span = text; span; span = span->next) {
734 nspans++;
736 pspan = malloc (sizeof (void *) * nspans);
737 if (!pspan) {
738 err (1, "malloc span pointers %zu", sizeof (void *) * nspans);
740 for (i = 0, span = text; span; span = span->next, ++i) {
741 pspan[i] = span;
743 qsort (pspan, nspans, sizeof (fz_textspan *), comparespans);
745 j = forward ? 0 : nspans - 1;
746 while (nspans--) {
747 regmatch_t rm;
749 span = pspan[j];
750 j += forward ? 1 : -1;
751 p = buf;
752 /* XXX: spans are not sorted "visually" */
753 for (i = 0; i < MIN (span->len, sizeof (buf) - 1); ++i) {
754 if (forward) {
755 if (span->text[i].bbox.y0 < y + 1) {
756 continue;
759 else {
760 if (span->text[i].bbox.y0 > y - 1) {
761 continue;
764 if (span->text[i].c < 256) {
765 *p++ = span->text[i].c;
767 else {
768 *p++ = '?';
771 if (p == buf) {
772 continue;
774 *p++ = 0;
776 ret = regexec (re, buf, 1, &rm, 0);
777 if (ret) {
778 if (ret != REG_NOMATCH) {
779 size_t size;
780 char errbuf[80];
781 size = regerror (ret, re, errbuf, sizeof (errbuf));
782 printd (state.sock,
783 "T regexec error `%.*s'",
784 (int) size, errbuf);
785 fz_freetextspan (text);
786 pdf_droppage (drawpage);
787 free (pspan);
788 return;
791 else {
792 fz_rect r;
794 r.x0 = span->text[rm.rm_so].bbox.x0 - pdim->bbox.x0;
795 r.y0 = span->text[rm.rm_so].bbox.y0;
796 r.x1 = span->text[rm.rm_eo - 1].bbox.x1 - pdim->bbox.x0;
797 r.y1 = span->text[rm.rm_eo - 1].bbox.y1;
799 if (!stop) {
800 printd (state.sock, "F %d %d %f %f %f %f",
801 pageno, 1,
802 r.x0, r.y0,
803 r.x1, r.y1);
805 else {
806 printd (state.sock, "R %d %d %f %f %f %f",
807 pageno, 2,
808 r.x0, r.y0,
809 r.x1, r.y1);
811 printd (state.sock, "T found at %d `%.*s' %f in %f sec",
812 pageno, rm.rm_eo - rm.rm_so, &buf[rm.rm_so],
813 span->text[0].bbox.y0 - drawpage->mediabox.y0,
814 now () - start);
815 stop = 1;
818 if (forward) {
819 pageno += 1;
820 y = 0;
822 else {
823 pageno -= 1;
824 y = INT_MAX;
826 fz_freetextspan (text);
827 pdf_droppage (drawpage);
828 free (pspan);
830 end = now ();
831 if (!stop) {
832 printd (state.sock, "T no matches %f sec", end - start);
834 printd (state.sock, "D");
837 static void *mainloop (void *unused)
839 char *p = NULL;
840 int len, ret, oldlen = 0;
842 for (;;) {
843 len = readlen (state.sock);
844 if (len == 0) {
845 errx (1, "readlen returned 0");
848 if (oldlen < len + 1) {
849 p = realloc (p, len + 1);
850 if (!p) {
851 err (1, "realloc %d failed", len + 1);
853 oldlen = len + 1;
855 readdata (state.sock, p, len);
856 p[len] = 0;
858 if (!strncmp ("open", p, 4)) {
859 char *filename = p + 5;
861 openxref (filename);
862 initpdims ();
864 else if (!strncmp ("free", p, 4)) {
865 void *ptr;
867 ret = sscanf (p + 4, " %p", &ptr);
868 if (ret != 1) {
869 errx (1, "malformed free `%.*s' ret=%d", len, p, ret);
871 lock ("free");
872 freepage (ptr);
873 unlock ("free");
874 printd (state.sock, "d");
876 else if (!strncmp ("search", p, 6)) {
877 int icase, pageno, y, ret, len2, forward;
878 char *pattern;
879 regex_t re;
881 ret = sscanf (p + 6, " %d %d %d %d,%n",
882 &icase, &pageno, &y, &forward, &len2);
883 if (ret != 4) {
884 errx (1, "malformed search `%s' ret=%d", p, ret);
887 pattern = p + 6 + len2;
888 ret = regcomp (&re, pattern,
889 REG_EXTENDED | (icase ? REG_ICASE : 0));
890 if (ret) {
891 char errbuf[80];
892 size_t size;
894 size = regerror (ret, &re, errbuf, sizeof (errbuf));
895 printd (state.sock, "T regcomp failed `%.*s'",
896 (int) size, errbuf);
898 else {
899 search (&re, pageno, y, forward);
900 regfree (&re);
903 else if (!strncmp ("geometry", p, 8)) {
904 int w, h;
906 ret = sscanf (p + 8, " %d %d", &w, &h);
907 if (ret != 2) {
908 errx (1, "malformed geometry `%.*s' ret=%d", len, p, ret);
910 state.h = h;
911 if (w != state.w) {
912 int i;
913 state.w = w;
914 for (i = 0; i < state.texcount; ++i) {
915 state.texowners[i].slice = NULL;
918 lock ("geometry");
919 layout ();
920 process_outline ();
921 unlock ("geometry");
922 printd (state.sock, "d");
924 else if (!strncmp ("render", p, 6)) {
925 int pageno, pindex, w, h, ret;
926 struct page *page;
928 ret = sscanf (p + 6, " %d %d %d %d", &pageno, &pindex, &w, &h);
929 if (ret != 4) {
930 errx (1, "bad render line `%.*s' ret=%d", len, p, ret);
933 page = render (pageno, pindex);
934 printd (state.sock, "r %d %d %d %p\n",
935 pageno,
936 state.w,
937 state.h,
938 page);
940 else {
941 errx (1, "unknown command %.*s", len, p);
944 return NULL;
947 static void upload2 (struct page *page, int slicenum, const char *cap)
949 int i;
950 int w, h;
951 double start, end;
952 struct slice *slice = &page->slices[slicenum];
954 w = page->pixmap->w;
955 h = page->pixmap->h;
957 ARSERT (w == slice->w);
958 if (slice->texindex != -1
959 && state.texowners[slice->texindex].slice == slice) {
960 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
962 else {
963 int subimage = 0;
964 int index = (state.texindex++ % state.texcount);
965 size_t offset = 0;
967 for (i = 0; i < slicenum; ++i) {
968 offset += w * page->slices[i].h * 4;
971 if (state.texowners[index].w == slice->w) {
972 if (state.texowners[index].h >= slice->h ) {
973 subimage = 1;
975 else {
976 state.texowners[index].h = slice->h;
979 else {
980 state.texowners[index].h = slice->h;
983 state.texowners[index].slice = slice;
984 state.texowners[index].w = slice->w;
985 slice->texindex = index;
987 glBindTexture (GL_TEXTURE_RECTANGLE_ARB, state.texids[slice->texindex]);
988 start = now ();
989 if (subimage) {
991 GLenum err = glGetError ();
992 if (err != GL_NO_ERROR) {
993 printf ("\e[0;31mERROR1 %d %d %#x\e[0m\n", w, slice->h, err);
994 abort ();
997 glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB,
1002 slice->h,
1003 state.texform,
1004 state.texty,
1005 page->pixmap->samples + offset
1008 GLenum err = glGetError ();
1009 if (err != GL_NO_ERROR) {
1010 printf ("\e[0;31mERROR %d %d %#x\e[0m\n", w, slice->h, err);
1011 abort ();
1015 else {
1016 glTexImage2D (GL_TEXTURE_RECTANGLE_ARB,
1018 GL_RGBA8,
1020 slice->h,
1022 state.texform,
1023 state.texty,
1024 page->pixmap->samples + offset
1028 end = now ();
1029 lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1030 subimage ? "sub" : "img",
1031 page->pageno, slicenum,
1032 slice->w, slice->h,
1033 state.texids[slice->texindex],
1034 end - start);
1038 CAMLprim value ml_preload (value ptr_v)
1040 int i;
1041 int ret;
1042 void *ptr;
1043 CAMLparam1 (ptr_v);
1044 char *s = String_val (ptr_v);
1045 struct page *page;
1047 if (trylock ("ml_preload")) {
1048 goto done;
1050 ret = sscanf (s, "%p", &ptr);
1051 if (ret != 1) {
1052 errx (1, "cannot parse pointer `%s'", s);
1055 page = ptr;
1056 for (i = 0; i < page->slicecount; ++i) {
1057 upload2 (ptr, i, "preload");
1060 unlock ("ml_preload");
1061 done:
1062 CAMLreturn (Val_unit);
1065 CAMLprim value ml_draw (value dispy_v, value w_v, value h_v,
1066 value py_v, value ptr_v)
1068 CAMLparam5 (dispy_v, w_v, h_v, py_v, ptr_v);
1069 int dispy = Int_val (dispy_v);
1070 int w = Int_val (w_v);
1071 int h = Int_val (h_v);
1072 int py = Int_val (py_v);
1073 char *s = String_val (ptr_v);
1074 int ret;
1075 void *ptr;
1076 struct page *page;
1077 int slicenum = 0;
1079 if (trylock ("ml_draw")) {
1080 goto done;
1083 ret = sscanf (s, "%p", &ptr);
1084 if (ret != 1) {
1085 errx (1, "cannot parse pointer `%s'", s);
1087 page = ptr;
1089 w = page->pixmap->w;
1091 ARSERT (h >= 0 && "ml_draw wrong h");
1093 glEnable (GL_TEXTURE_RECTANGLE_ARB);
1094 if (state.useatifs) {
1095 glEnable (GL_FRAGMENT_SHADER_ATI);
1098 for (slicenum = 0; slicenum < page->slicecount; ++slicenum) {
1099 struct slice *slice = &page->slices[slicenum];
1100 if (slice->h > py) {
1101 break;
1103 py -= slice->h;
1106 h = MIN (state.h, h);
1107 while (h) {
1108 int th;
1109 struct slice *slice = &page->slices[slicenum];
1111 ARSERT (slicenum < page->slicecount && "ml_draw wrong slicenum");
1113 th = MIN (h, slice->h - py);
1114 upload2 (page, slicenum, "upload");
1116 glBegin (GL_QUADS);
1118 glTexCoord2i (0, py);
1119 glVertex2i (0, dispy);
1121 glTexCoord2i (w, py);
1122 glVertex2i (w, dispy);
1124 glTexCoord2i (w, py+th);
1125 glVertex2i (w, dispy + th);
1127 glTexCoord2i (0, py+th);
1128 glVertex2i (0, dispy + th);
1130 glEnd ();
1132 h -= th;
1133 py = 0;
1134 dispy += th;
1135 slicenum += 1;
1138 glDisable (GL_TEXTURE_RECTANGLE_ARB);
1139 if (state.useatifs) {
1140 glDisable (GL_FRAGMENT_SHADER_ATI);
1143 unlock ("ml_draw");
1144 done:
1145 CAMLreturn (Val_unit);
1148 static pdf_link *getlink (struct page *page, int x, int y)
1150 fz_point p;
1151 fz_matrix ctm;
1152 pdf_link *link;
1154 p.x = x;
1155 p.y = y;
1157 ctm = fz_invertmatrix (page->pagedim->ctm);
1158 p = fz_transformpoint (ctm, p);
1160 for (link = page->drawpage->links; link; link = link->next) {
1161 if (p.x >= link->rect.x0 && p.x <= link->rect.x1) {
1162 if (p.y >= link->rect.y0 && p.y <= link->rect.y1) {
1163 if (link->kind == PDF_LGOTO) {
1164 return link;
1169 return NULL;
1172 CAMLprim value ml_checklink (value ptr_v, value x_v, value y_v)
1174 CAMLparam3 (ptr_v, x_v, y_v);
1175 char *s = String_val (ptr_v);
1176 int ret;
1178 if (trylock ("ml_checklink")) {
1179 ret = 0;
1181 else {
1182 ret = NULL != getlink (parse_pointer ("ml_checklink", s),
1183 Int_val (x_v), Int_val (y_v));
1184 unlock ("ml_checklink");
1186 CAMLreturn (Val_bool (ret));
1189 CAMLprim value ml_getlink (value ptr_v, value x_v, value y_v)
1191 CAMLparam3 (ptr_v, x_v, y_v);
1192 CAMLlocal2 (ret_v, tup_v);
1193 pdf_link *link;
1194 struct page *page;
1195 char *s = String_val (ptr_v);
1197 if (trylock ("ml_gettext")) {
1198 ret_v = Val_int (0);
1199 goto done;
1202 page = parse_pointer ("ml_getlink", s);
1204 link = getlink (page, Int_val (x_v), Int_val (y_v));
1205 if (link) {
1206 int pageno;
1207 fz_point p;
1208 fz_obj *obj;
1210 pageno = -1;
1211 obj = fz_arrayget (link->dest, 0);
1212 if (fz_isindirect (obj)) {
1213 pageno = pdf_findpageobject (state.xref, obj) - 1;
1215 else if (fz_isint (obj)) {
1216 pageno = fz_toint (obj);
1219 if (fz_arraylen (link->dest) > 3) {
1220 p.x = fz_toint (fz_arrayget (link->dest, 2));
1221 p.y = fz_toint (fz_arrayget (link->dest, 3));
1222 p = fz_transformpoint (page->pagedim->ctm, p);
1224 else {
1225 p.x = 0.0;
1226 p.y = 0.0;
1229 tup_v = caml_alloc_tuple (2);
1230 ret_v = caml_alloc_small (1, 1);
1231 Field (tup_v, 0) = Val_int (pageno);
1232 Field (tup_v, 1) = Val_int (p.y);
1233 Field (ret_v, 0) = tup_v;
1235 else {
1236 ret_v = Val_int (0);
1238 unlock ("ml_getlink");
1240 done:
1241 CAMLreturn (ret_v);
1244 CAMLprim value ml_gettext (value ptr_v, value rect_v, value oy_v, value rectsel_v)
1246 CAMLparam4 (ptr_v, rect_v, oy_v, rect_v);
1247 fz_matrix ctm;
1248 fz_point p1, p2;
1249 struct page *page;
1250 fz_textspan *span;
1251 char *s = String_val (ptr_v);
1252 int rectsel = Bool_val (rectsel_v);
1253 int i, bx0, bx1, by0, by1, x0, x1, y0, y1, oy;
1255 /* stop GCC from complaining about uninitialized variables */
1256 int rx0 = rx0, rx1 = rx1, ry0 = ry0, ry1 = ry1;
1258 if (trylock ("ml_gettext")) {
1259 goto done;
1262 page = parse_pointer ("ml_gettext", s);
1264 oy = Int_val (oy_v);
1265 p1.x = Int_val (Field (rect_v, 0));
1266 p1.y = Int_val (Field (rect_v, 1));
1267 p2.x = Int_val (Field (rect_v, 2));
1268 p2.y = Int_val (Field (rect_v, 3));
1270 if (0) {
1271 glEnable (GL_BLEND);
1272 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1273 glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1274 glColor4f (0, 0, 0, 0.2);
1275 glRecti (p1.x, p1.y, p2.x, p2.y);
1276 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1277 glDisable (GL_BLEND);
1280 ctm = page->pagedim->ctm;
1281 if (!page->text) {
1282 fz_error error;
1283 fz_device *tdev;
1285 page->text = fz_newtextspan ();
1286 tdev = fz_newtextdevice (page->text);
1287 error = pdf_runcontentstream (tdev, page->pagedim->ctm, state.xref,
1288 page->drawpage->resources,
1289 page->drawpage->contents);
1290 if (error) die (error);
1291 fz_freedevice (tdev);
1294 printf ("\ec");
1296 printf ("BBox %f %f %f %f\n", p1.x, p1.y, p2.x, p2.y);
1297 p1.x += page->pixmap->x;
1298 p1.y += page->pixmap->y;
1299 p2.x += page->pixmap->x;
1300 p2.y += page->pixmap->y;
1301 x0 = p1.x;
1302 y0 = p1.y;
1303 x1 = p2.x;
1304 y1 = p2.y;
1305 printf ("BBox %d %d %d %d %d %d\n", x0, y0, x1, y1, oy, page->pageno);
1307 for (span = page->text; span; span = span->next) {
1308 int seen = 0;
1310 /* fz_debugtextspanxml (span); */
1311 for (i = 0; i < span->len; ++i) {
1312 long c;
1314 bx0 = span->text[i].bbox.x0;
1315 bx1 = span->text[i].bbox.x1;
1316 by0 = span->text[i].bbox.y0 + oy;
1317 by1 = span->text[i].bbox.y1 + oy;
1319 if ((bx1 >= x0 && bx0 <= x1 && by1 >= y0 && by0 <= y1)) {
1320 if (!seen) {
1321 rx0 = bx0 - page->pixmap->x;
1322 rx1 = bx1 - page->pixmap->x;
1323 ry0 = by0;
1324 ry1 = by1;
1327 seen = 1;
1328 c = span->text[i].c;
1329 if (c < 256) {
1330 if ((isprint (c) && !isspace (c))) {
1331 if (!rectsel) {
1332 bx0 -= page->pixmap->x;
1333 bx1 -= page->pixmap->x;
1334 glEnable (GL_BLEND);
1335 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1336 glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1337 glColor4f (0.5, 0.5, 0.0, 0.6);
1338 glRecti (bx0, by0, bx1, by1);
1339 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1340 glDisable (GL_BLEND);
1342 if (isprint (c) || c ==' ') {
1343 rx1 = bx1;
1344 ry1 = by1;
1347 putc (c, stdout);
1349 else {
1350 putc ('?', stdout);
1355 if (rectsel) {
1356 if (seen) {
1357 glEnable (GL_BLEND);
1358 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1359 glBlendFunc (GL_DST_ALPHA, GL_SRC_ALPHA);
1360 glColor4f (0.5, 0.5, 0.0, 0.6);
1361 glRecti (rx0, ry0, rx1, ry1);
1362 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1363 glDisable (GL_BLEND);
1367 if (seen && span->eol) {
1368 x0 = page->pixmap->x;
1369 putc ('\n', stdout);
1372 unlock ("ml_gettext");
1374 done:
1375 CAMLreturn (Val_unit);
1378 CAMLprim value ml_getpagewh (value pagedimno_v)
1380 CAMLparam1 (pagedimno_v);
1381 CAMLlocal1 (ret_v);
1382 int pagedimno = Int_val (pagedimno_v);
1384 ret_v = caml_alloc_small (4 * Double_wosize, Double_array_tag);
1385 Store_double_field (ret_v, 0, state.pagedims[pagedimno].box.x0);
1386 Store_double_field (ret_v, 1, state.pagedims[pagedimno].box.x1);
1387 Store_double_field (ret_v, 2, state.pagedims[pagedimno].box.y0);
1388 Store_double_field (ret_v, 3, state.pagedims[pagedimno].box.y1);
1389 CAMLreturn (ret_v);
1392 static void initgl (void)
1394 #ifdef _BIG_ENDIAN
1395 if (strstr ((char *) glGetString (GL_EXTENSIONS),
1396 "GL_ATI_fragment_shader")) {
1397 /* Here, with MESA, rv280, powerpc32: BGRA(rev) is slow while
1398 ABGR is fast, so fix things in the shader */
1399 state.texform = GL_ABGR_EXT;
1400 state.texty = GL_UNSIGNED_INT_8_8_8_8;
1402 glBindFragmentShaderATI (1);
1403 glBeginFragmentShaderATI ();
1405 glSampleMapATI (GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI);
1407 glColorFragmentOp1ATI (GL_MOV_ATI,
1408 GL_REG_1_ATI, GL_RED_BIT_ATI, GL_NONE,
1409 GL_REG_0_ATI, GL_BLUE, GL_NONE);
1410 glColorFragmentOp1ATI (GL_MOV_ATI,
1411 GL_REG_1_ATI, GL_BLUE_BIT_ATI, GL_NONE,
1412 GL_REG_0_ATI, GL_RED, GL_NONE);
1413 glColorFragmentOp1ATI (
1414 GL_MOV_ATI,
1415 GL_REG_0_ATI, GL_RED_BIT_ATI | GL_BLUE_BIT_ATI, GL_NONE,
1416 GL_REG_1_ATI, GL_NONE, GL_NONE
1419 glEndFragmentShaderATI ();
1420 state.useatifs = 1;
1422 else {
1423 state.texform = GL_BGRA_EXT;
1424 state.texty = GL_UNSIGNED_INT_8_8_8_8_REV;
1426 #else
1427 state.texform = GL_BGRA_EXT;
1428 state.texty = GL_UNSIGNED_INT_8_8_8_8;
1429 #endif
1432 CAMLprim value ml_init (value sock_v)
1434 int ret;
1435 CAMLparam1 (sock_v);
1437 state.texcount = 128;
1438 state.sliceheight = 64;
1440 state.texids = calloc (state.texcount * sizeof (*state.texids), 1);
1441 if (!state.texids) {
1442 err (1, "calloc texids %zu", state.texcount * sizeof (*state.texids));
1445 state.texowners = calloc (state.texcount * sizeof (*state.texowners), 1);
1446 if (!state.texowners) {
1447 err (1, "calloc texowners %zu",
1448 state.texcount * sizeof (*state.texowners));
1451 glGenTextures (state.texcount, state.texids);
1453 state.sock = Int_val (sock_v);
1454 initgl ();
1456 state.cache = fz_newglyphcache ();
1457 if (!state.cache) {
1458 errx (1, "fz_newglyphcache failed");
1461 ret = pthread_create (&state.thread, NULL, mainloop, NULL);
1462 if (ret) {
1463 errx (1, "pthread_create: %s", strerror (errno));
1466 CAMLreturn (Val_unit);