1 /* lot's of code c&p-ed directly from mupdf */
16 /* fugly as hell and GCC specific but... */
18 #define GL_GLEXT_PROTOTYPES
24 #include <caml/fail.h>
25 #include <caml/alloc.h>
26 #include <caml/memory.h>
27 #include <caml/unixsupport.h>
33 #define lprintf printf
38 #define ARSERT(cond) for (;;) { \
40 errx (1, "%s:%d " #cond, __FILE__, __LINE__); \
56 struct pagedim
*pagedim
;
58 struct slice slices
[];
74 struct pagedim
*pagedims
;
99 static pthread_mutex_t mutex
= PTHREAD_MUTEX_INITIALIZER
;
101 static void lock (const char *cap
)
103 int ret
= pthread_mutex_lock (&mutex
);
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
);
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
));
127 static void *parse_pointer (const char *cap
, const char *s
)
132 ret
= sscanf (s
, "%p", &ptr
);
134 errx (1, "%s: cannot parse pointer in `%s'", cap
, s
);
139 static int hasdata (int sock
)
146 ret
= poll (&pfd
, 1, 0);
153 return pfd
.revents
& POLLIN
;
156 static double now (void)
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
)
170 n
= read (fd
, p
, size
);
172 err (1, "read (req %d, ret %zd)", size
, n
);
176 static void writedata (int fd
, char *p
, int size
)
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);
188 err (1, "write %zd", n
);
191 n
= write (fd
, p
, 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
, ...)
205 len
= vsnprintf (buf
, sizeof (buf
), fmt
, ap
);
207 writedata (fd
, buf
, len
);
210 static void die (fz_error error
)
212 fz_catch (error
, "aborting");
214 pdf_closexref (state
.xref
);
218 static void openxref (char *filename
)
223 fd
= open (filename
, O_BINARY
| O_RDONLY
, 0666);
225 die (fz_throw ("cannot open file '%s'", filename
));
227 file
= fz_openfile (fd
);
228 state
.xref
= pdf_openxref (file
);
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
)
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
)
259 fz_droppixmap (page
->pixmap
);
260 for (p
= state
.pages
; p
; p
= p
->prev
) {
261 if (p
->prev
== page
) {
262 p
->prev
= page
->prev
;
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
);
277 fz_freetextspan (page
->text
);
279 if (page
->drawpage
) {
280 pdf_droppage (page
->drawpage
);
286 static void subdivide (struct page
*p
)
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
];
301 static void *render (int pageno
, int pindex
)
309 fz_displaylist
*list
;
310 fz_device
*idev
, *mdev
;
311 struct pagedim
*pagedim
;
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);
325 err (1, "calloc page %d\n", pageno
);
327 page
->slicecount
= slicecount
;
328 page
->prev
= state
.pages
;
331 pageobj
= pdf_getpageobject (state
.xref
, pageno
);
333 die (fz_throw ("cannot retrieve info from page %d", pageno
));
335 error
= pdf_loadpage (&drawpage
, state
.xref
, pageobj
);
339 page
->pixmap
= fz_newpixmapwithrect (pdf_devicergb
, pagedim
->bbox
);
342 fz_clearpixmap (page
->pixmap
, 0xFF);
344 list
= fz_newdisplaylist ();
346 die (fz_throw ("fz_newdisplaylist failed"));
348 mdev
= fz_newlistdevice (list
);
349 error
= pdf_runcontentstream (mdev
, fz_identity (), state
.xref
,
354 fz_freedevice (mdev
);
356 idev
= fz_newdrawdevice (state
.cache
, page
->pixmap
);
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
;
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); */
379 /* almost verbatim copy of pdf_getpagecountimp */
389 recurse_page (fz_obj
*node
, int bias
, int *pagesp
, struct stuff inherit
)
398 if (!fz_isdict(node
))
400 fz_warn("pagetree node is missing, igoring missing pages...");
404 type
= fz_dictgets(node
, "Type");
405 kids
= fz_dictgets(node
, "Kids");
406 count
= fz_dictgets(node
, "Count");
409 typestr
= fz_toname(type
);
412 fz_warn("pagetree node (%d %d R) lacks required type", fz_tonum(node
), fz_togen(node
));
414 kids
= fz_dictgets(node
, "Kids");
417 fz_warn("guessing it may be a pagetree node, continuing...");
422 fz_warn("guessing it may be a page, continuing...");
427 if (!strcmp(typestr
, "Page")) {
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
);
458 p
= &state
.pagedims
[state
.pagedimcount
- 1];
459 if ((state
.pagedimcount
== 0)
460 || (p
->rotate
!= rotate
|| memcmp (&p
->box
, &box
, sizeof (box
)))) {
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
++];
472 p
->pageno
= pageno
+ bias
;
476 else if (!strcmp(typestr
, "Pages"))
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 */
504 fz_warn("cyclic page tree");
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
);
519 pdf_logpage("%d pages\n", pages
);
527 static void initpdims (void)
533 struct stuff inherit
;
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
;
545 recurse_page (pages
, 0, &count
, inherit
);
547 printd (state
.sock
, "T Processed %d pages in %f seconds",
551 static void layout (void)
557 struct pagedim
*p
= state
.pagedims
;
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
)
598 if (!outline
->link
) goto next
;
600 obj
= outline
->link
->dest
;
601 if (fz_isindirect (obj
)) {
602 num
= fz_tonum (obj
);
604 for (i
= 0; i
< state
.pagecount
; ++i
) {
605 if (state
.pagetbl
[i
] == num
) {
611 else if (fz_isarray (obj
)) {
614 obj2
= fz_arrayget (obj
, 0);
615 if (fz_isint (obj2
)) {
616 pageno
= fz_toint (obj2
);
619 num
= fz_tonum (obj2
);
620 for (i
= 0; i
< state
.pagecount
; ++i
) {
621 if (state
.pagetbl
[i
] == num
) {
628 if (fz_arraylen (obj
) > 3) {
630 struct pagedim
*pagedim
= state
.pagedims
;
632 for (i
= 0; i
< state
.pagedimcount
; ++i
) {
633 if (state
.pagedims
[i
].pageno
> pageno
)
635 pagedim
= &state
.pagedims
[i
];
638 p
.x
= fz_toint (fz_arrayget (obj
, 2));
639 p
.y
= fz_toint (fz_arrayget (obj
, 3));
640 p
= fz_transformpoint (pagedim
->ctm
, p
);
645 lprintf ("%*c%s %d\n", level
, ' ', outline
->title
, pageno
);
646 printd (state
.sock
, "o %d %d %d %s",
647 level
, pageno
, top
, outline
->title
);
649 if (outline
->child
) {
650 recurse_outline (outline
->child
, level
+ 1);
652 outline
= outline
->next
;
656 static void process_outline (void)
658 pdf_outline
*outline
;
660 outline
= pdf_loadoutline (state
.xref
);
662 recurse_outline (outline
, 0);
663 pdf_dropoutline (outline
);
667 static int comparespans (const void *l
, const void *r
)
669 fz_textspan
*const*ls
= l
;
670 fz_textspan
*const*rs
= r
;
672 return (*ls
)->text
->bbox
.y0
- (*rs
)->text
->bbox
.y0
;
675 /* wishful thinking function */
676 static void search (regex_t
*re
, int pageno
, int y
, int forward
)
686 fz_textspan
*text
, *span
, **pspan
;
687 struct pagedim
*pdim
, *pdimprev
;
694 while (pageno
>= 0 && pageno
< state
.pagecount
&& !stop
) {
696 if (!state
.lotsamemory
) {
697 pdf_agestoreditems (state
.xref
->store
);
698 pdf_evictageditems (state
.xref
->store
);
701 if (hasdata (state
.sock
)) {
702 printd (state
.sock
, "T attention requested aborting search at %d",
707 printd (state
.sock
, "T searching in page %d", pageno
);
711 for (i
= 0; i
< state
.pagedimcount
; ++i
) {
712 pdim
= &state
.pagedims
[i
];
713 if (pdim
->pageno
== pageno
) {
716 if (pdim
->pageno
> pageno
) {
725 pageobj
= pdf_getpageobject (state
.xref
, pageno
+ 1);
727 die (fz_throw ("cannot retrieve info from page %d", pageno
));
729 error
= pdf_loadpage (&drawpage
, state
.xref
, pageobj
);
733 text
= fz_newtextspan ();
734 tdev
= fz_newtextdevice (text
);
735 error
= pdf_runcontentstream (tdev
, pdim
->ctm
, state
.xref
,
738 if (error
) die (error
);
739 fz_freedevice (tdev
);
742 for (span
= text
; span
; span
= span
->next
) {
745 pspan
= malloc (sizeof (void *) * nspans
);
747 err (1, "malloc span pointers %zu", sizeof (void *) * nspans
);
749 for (i
= 0, span
= text
; span
; span
= span
->next
, ++i
) {
752 qsort (pspan
, nspans
, sizeof (fz_textspan
*), comparespans
);
754 j
= forward
? 0 : nspans
- 1;
759 j
+= forward
? 1 : -1;
761 /* XXX: spans are not sorted "visually" */
762 for (i
= 0; i
< MIN (span
->len
, sizeof (buf
) - 1); ++i
) {
764 if (span
->text
[i
].bbox
.y0
< y
+ 1) {
769 if (span
->text
[i
].bbox
.y0
> y
- 1) {
773 if (span
->text
[i
].c
< 256) {
774 *p
++ = span
->text
[i
].c
;
785 ret
= regexec (re
, buf
, 1, &rm
, 0);
787 if (ret
!= REG_NOMATCH
) {
790 size
= regerror (ret
, re
, errbuf
, sizeof (errbuf
));
792 "T regexec error `%.*s'",
794 fz_freetextspan (text
);
795 pdf_droppage (drawpage
);
803 r
.x0
= span
->text
[rm
.rm_so
].bbox
.x0
- pdim
->bbox
.x0
;
804 r
.y0
= span
->text
[rm
.rm_so
].bbox
.y0
;
805 r
.x1
= span
->text
[rm
.rm_eo
- 1].bbox
.x1
- pdim
->bbox
.x0
;
806 r
.y1
= span
->text
[rm
.rm_eo
- 1].bbox
.y1
;
809 printd (state
.sock
, "F %d %d %f %f %f %f",
815 printd (state
.sock
, "R %d %d %f %f %f %f",
820 printd (state
.sock
, "T found at %d `%.*s' %f in %f sec",
821 pageno
, rm
.rm_eo
- rm
.rm_so
, &buf
[rm
.rm_so
],
822 span
->text
[0].bbox
.y0
- drawpage
->mediabox
.y0
,
835 fz_freetextspan (text
);
836 pdf_droppage (drawpage
);
841 printd (state
.sock
, "T no matches %f sec", end
- start
);
843 printd (state
.sock
, "D");
846 static void *mainloop (void *unused
)
849 int len
, ret
, oldlen
= 0;
852 len
= readlen (state
.sock
);
854 errx (1, "readlen returned 0");
857 if (oldlen
< len
+ 1) {
858 p
= realloc (p
, len
+ 1);
860 err (1, "realloc %d failed", len
+ 1);
864 readdata (state
.sock
, p
, len
);
867 if (!strncmp ("open", p
, 4)) {
868 char *filename
= p
+ 5;
873 else if (!strncmp ("free", p
, 4)) {
876 ret
= sscanf (p
+ 4, " %p", &ptr
);
878 errx (1, "malformed free `%.*s' ret=%d", len
, p
, ret
);
883 printd (state
.sock
, "d");
885 else if (!strncmp ("search", p
, 6)) {
886 int icase
, pageno
, y
, ret
, len2
, forward
;
890 ret
= sscanf (p
+ 6, " %d %d %d %d,%n",
891 &icase
, &pageno
, &y
, &forward
, &len2
);
893 errx (1, "malformed search `%s' ret=%d", p
, ret
);
896 pattern
= p
+ 6 + len2
;
897 ret
= regcomp (&re
, pattern
,
898 REG_EXTENDED
| (icase
? REG_ICASE
: 0));
903 size
= regerror (ret
, &re
, errbuf
, sizeof (errbuf
));
904 printd (state
.sock
, "T regcomp failed `%.*s'",
908 search (&re
, pageno
, y
, forward
);
912 else if (!strncmp ("geometry", p
, 8)) {
915 ret
= sscanf (p
+ 8, " %d %d", &w
, &h
);
917 errx (1, "malformed geometry `%.*s' ret=%d", len
, p
, ret
);
923 for (i
= 0; i
< state
.texcount
; ++i
) {
924 state
.texowners
[i
].slice
= NULL
;
931 printd (state
.sock
, "d");
933 else if (!strncmp ("render", p
, 6)) {
934 int pageno
, pindex
, w
, h
, ret
;
937 ret
= sscanf (p
+ 6, " %d %d %d %d", &pageno
, &pindex
, &w
, &h
);
939 errx (1, "bad render line `%.*s' ret=%d", len
, p
, ret
);
942 page
= render (pageno
, pindex
);
943 printd (state
.sock
, "r %d %d %d %p\n",
950 errx (1, "unknown command %.*s", len
, p
);
956 static void upload2 (struct page
*page
, int slicenum
, const char *cap
)
961 struct slice
*slice
= &page
->slices
[slicenum
];
966 ARSERT (w
== slice
->w
);
967 if (slice
->texindex
!= -1
968 && state
.texowners
[slice
->texindex
].slice
== slice
) {
969 glBindTexture (GL_TEXTURE_RECTANGLE_ARB
, state
.texids
[slice
->texindex
]);
973 int index
= (state
.texindex
++ % state
.texcount
);
976 for (i
= 0; i
< slicenum
; ++i
) {
977 offset
+= w
* page
->slices
[i
].h
* 4;
980 if (state
.texowners
[index
].w
== slice
->w
) {
981 if (state
.texowners
[index
].h
>= slice
->h
) {
985 state
.texowners
[index
].h
= slice
->h
;
989 state
.texowners
[index
].h
= slice
->h
;
992 state
.texowners
[index
].slice
= slice
;
993 state
.texowners
[index
].w
= slice
->w
;
994 slice
->texindex
= index
;
996 glBindTexture (GL_TEXTURE_RECTANGLE_ARB
, state
.texids
[slice
->texindex
]);
1000 GLenum err
= glGetError ();
1001 if (err
!= GL_NO_ERROR
) {
1002 printf ("\e[0;31mERROR1 %d %d %#x\e[0m\n", w
, slice
->h
, err
);
1006 glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB
,
1014 page
->pixmap
->samples
+ offset
1017 GLenum err
= glGetError ();
1018 if (err
!= GL_NO_ERROR
) {
1019 printf ("\e[0;31mERROR %d %d %#x\e[0m\n", w
, slice
->h
, err
);
1025 glTexImage2D (GL_TEXTURE_RECTANGLE_ARB
,
1033 page
->pixmap
->samples
+ offset
1038 lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1039 subimage
? "sub" : "img",
1040 page
->pageno
, slicenum
,
1042 state
.texids
[slice
->texindex
],
1047 CAMLprim value
ml_draw (value dispy_v
, value w_v
, value h_v
,
1048 value py_v
, value ptr_v
)
1050 CAMLparam5 (dispy_v
, w_v
, h_v
, py_v
, ptr_v
);
1051 int dispy
= Int_val (dispy_v
);
1052 int w
= Int_val (w_v
);
1053 int h
= Int_val (h_v
);
1054 int py
= Int_val (py_v
);
1055 char *s
= String_val (ptr_v
);
1061 if (trylock ("ml_draw")) {
1065 ret
= sscanf (s
, "%p", &ptr
);
1067 errx (1, "cannot parse pointer `%s'", s
);
1071 w
= page
->pixmap
->w
;
1073 ARSERT (h
>= 0 && "ml_draw wrong h");
1075 glEnable (GL_TEXTURE_RECTANGLE_ARB
);
1076 if (state
.useatifs
) {
1077 glEnable (GL_FRAGMENT_SHADER_ATI
);
1080 for (slicenum
= 0; slicenum
< page
->slicecount
; ++slicenum
) {
1081 struct slice
*slice
= &page
->slices
[slicenum
];
1082 if (slice
->h
> py
) {
1088 h
= MIN (state
.h
, h
);
1091 struct slice
*slice
= &page
->slices
[slicenum
];
1093 ARSERT (slicenum
< page
->slicecount
&& "ml_draw wrong slicenum");
1095 th
= MIN (h
, slice
->h
- py
);
1096 upload2 (page
, slicenum
, "upload");
1100 glTexCoord2i (0, py
);
1101 glVertex2i (0, dispy
);
1103 glTexCoord2i (w
, py
);
1104 glVertex2i (w
, dispy
);
1106 glTexCoord2i (w
, py
+th
);
1107 glVertex2i (w
, dispy
+ th
);
1109 glTexCoord2i (0, py
+th
);
1110 glVertex2i (0, dispy
+ th
);
1120 glDisable (GL_TEXTURE_RECTANGLE_ARB
);
1121 if (state
.useatifs
) {
1122 glDisable (GL_FRAGMENT_SHADER_ATI
);
1127 CAMLreturn (Val_unit
);
1130 static pdf_link
*getlink (struct page
*page
, int x
, int y
)
1139 ctm
= fz_invertmatrix (page
->pagedim
->ctm
);
1140 p
= fz_transformpoint (ctm
, p
);
1142 for (link
= page
->drawpage
->links
; link
; link
= link
->next
) {
1143 if (p
.x
>= link
->rect
.x0
&& p
.x
<= link
->rect
.x1
) {
1144 if (p
.y
>= link
->rect
.y0
&& p
.y
<= link
->rect
.y1
) {
1145 if (link
->kind
== PDF_LGOTO
) {
1154 CAMLprim value
ml_checklink (value ptr_v
, value x_v
, value y_v
)
1156 CAMLparam3 (ptr_v
, x_v
, y_v
);
1157 char *s
= String_val (ptr_v
);
1160 if (trylock ("ml_checklink")) {
1164 ret
= NULL
!= getlink (parse_pointer ("ml_checklink", s
),
1165 Int_val (x_v
), Int_val (y_v
));
1166 unlock ("ml_checklink");
1168 CAMLreturn (Val_bool (ret
));
1171 CAMLprim value
ml_getlink (value ptr_v
, value x_v
, value y_v
)
1173 CAMLparam3 (ptr_v
, x_v
, y_v
);
1174 CAMLlocal2 (ret_v
, tup_v
);
1177 char *s
= String_val (ptr_v
);
1179 if (trylock ("ml_gettext")) {
1180 ret_v
= Val_int (0);
1184 page
= parse_pointer ("ml_getlink", s
);
1186 link
= getlink (page
, Int_val (x_v
), Int_val (y_v
));
1193 obj
= fz_arrayget (link
->dest
, 0);
1194 if (fz_isindirect (obj
)) {
1195 pageno
= pdf_findpageobject (state
.xref
, obj
) - 1;
1197 else if (fz_isint (obj
)) {
1198 pageno
= fz_toint (obj
);
1201 if (fz_arraylen (link
->dest
) > 3) {
1202 p
.x
= fz_toint (fz_arrayget (link
->dest
, 2));
1203 p
.y
= fz_toint (fz_arrayget (link
->dest
, 3));
1204 p
= fz_transformpoint (page
->pagedim
->ctm
, p
);
1211 tup_v
= caml_alloc_tuple (2);
1212 ret_v
= caml_alloc_small (1, 1);
1213 Field (tup_v
, 0) = Val_int (pageno
);
1214 Field (tup_v
, 1) = Val_int (p
.y
);
1215 Field (ret_v
, 0) = tup_v
;
1218 ret_v
= Val_int (0);
1220 unlock ("ml_getlink");
1226 CAMLprim value
ml_gettext (value ptr_v
, value rect_v
, value oy_v
, value rectsel_v
)
1228 CAMLparam4 (ptr_v
, rect_v
, oy_v
, rect_v
);
1233 char *s
= String_val (ptr_v
);
1234 int rectsel
= Bool_val (rectsel_v
);
1235 int i
, bx0
, bx1
, by0
, by1
, x0
, x1
, y0
, y1
, oy
;
1237 /* stop GCC from complaining about uninitialized variables */
1238 int rx0
= rx0
, rx1
= rx1
, ry0
= ry0
, ry1
= ry1
;
1240 if (trylock ("ml_gettext")) {
1244 page
= parse_pointer ("ml_gettext", s
);
1246 oy
= Int_val (oy_v
);
1247 p1
.x
= Int_val (Field (rect_v
, 0));
1248 p1
.y
= Int_val (Field (rect_v
, 1));
1249 p2
.x
= Int_val (Field (rect_v
, 2));
1250 p2
.y
= Int_val (Field (rect_v
, 3));
1253 glEnable (GL_BLEND
);
1254 glPolygonMode (GL_FRONT_AND_BACK
, GL_LINE
);
1255 glBlendFunc (GL_DST_ALPHA
, GL_SRC_ALPHA
);
1256 glColor4f (0, 0, 0, 0.2);
1257 glRecti (p1
.x
, p1
.y
, p2
.x
, p2
.y
);
1258 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1259 glDisable (GL_BLEND
);
1262 ctm
= page
->pagedim
->ctm
;
1267 page
->text
= fz_newtextspan ();
1268 tdev
= fz_newtextdevice (page
->text
);
1269 error
= pdf_runcontentstream (tdev
, page
->pagedim
->ctm
, state
.xref
,
1270 page
->drawpage
->resources
,
1271 page
->drawpage
->contents
);
1272 if (error
) die (error
);
1273 fz_freedevice (tdev
);
1278 printf ("BBox %f %f %f %f\n", p1
.x
, p1
.y
, p2
.x
, p2
.y
);
1279 p1
.x
+= page
->pixmap
->x
;
1280 p1
.y
+= page
->pixmap
->y
;
1281 p2
.x
+= page
->pixmap
->x
;
1282 p2
.y
+= page
->pixmap
->y
;
1287 printf ("BBox %d %d %d %d %d %d\n", x0
, y0
, x1
, y1
, oy
, page
->pageno
);
1289 for (span
= page
->text
; span
; span
= span
->next
) {
1292 /* fz_debugtextspanxml (span); */
1293 for (i
= 0; i
< span
->len
; ++i
) {
1296 bx0
= span
->text
[i
].bbox
.x0
;
1297 bx1
= span
->text
[i
].bbox
.x1
;
1298 by0
= span
->text
[i
].bbox
.y0
+ oy
;
1299 by1
= span
->text
[i
].bbox
.y1
+ oy
;
1301 if ((bx1
>= x0
&& bx0
<= x1
&& by1
>= y0
&& by0
<= y1
)) {
1303 rx0
= bx0
- page
->pixmap
->x
;
1304 rx1
= bx1
- page
->pixmap
->x
;
1310 c
= span
->text
[i
].c
;
1312 if ((isprint (c
) && !isspace (c
))) {
1314 bx0
-= page
->pixmap
->x
;
1315 bx1
-= page
->pixmap
->x
;
1316 glEnable (GL_BLEND
);
1317 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1318 glBlendFunc (GL_DST_ALPHA
, GL_SRC_ALPHA
);
1319 glColor4f (0.5, 0.5, 0.0, 0.6);
1320 glRecti (bx0
, by0
, bx1
, by1
);
1321 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1322 glDisable (GL_BLEND
);
1324 if (isprint (c
) || c
==' ') {
1339 glEnable (GL_BLEND
);
1340 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1341 glBlendFunc (GL_DST_ALPHA
, GL_SRC_ALPHA
);
1342 glColor4f (0.5, 0.5, 0.0, 0.6);
1343 glRecti (rx0
, ry0
, rx1
, ry1
);
1344 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1345 glDisable (GL_BLEND
);
1349 if (seen
&& span
->eol
) {
1350 x0
= page
->pixmap
->x
;
1351 putc ('\n', stdout
);
1354 unlock ("ml_gettext");
1357 CAMLreturn (Val_unit
);
1360 CAMLprim value
ml_getpagewh (value pagedimno_v
)
1362 CAMLparam1 (pagedimno_v
);
1364 int pagedimno
= Int_val (pagedimno_v
);
1366 ret_v
= caml_alloc_small (4 * Double_wosize
, Double_array_tag
);
1367 Store_double_field (ret_v
, 0, state
.pagedims
[pagedimno
].box
.x0
);
1368 Store_double_field (ret_v
, 1, state
.pagedims
[pagedimno
].box
.x1
);
1369 Store_double_field (ret_v
, 2, state
.pagedims
[pagedimno
].box
.y0
);
1370 Store_double_field (ret_v
, 3, state
.pagedims
[pagedimno
].box
.y1
);
1374 CAMLprim value
ml_gettitle (value unit_v
)
1376 CAMLparam1 (unit_v
);
1377 CAMLlocal1 (title_v
);
1380 obj
= fz_dictgets (state
.xref
->trailer
, "Info");
1381 title_v
= Val_int (0);
1383 obj
= fz_dictgets (obj
, "Title");
1385 char *utf8
= pdf_toutf8 (obj
);
1387 title_v
= caml_alloc_small (1, 1);
1388 Store_field (title_v
, 0, caml_copy_string (utf8
));
1392 CAMLreturn (title_v
);
1395 static void initgl (void)
1398 if (strstr ((char *) glGetString (GL_EXTENSIONS
),
1399 "GL_ATI_fragment_shader")) {
1400 /* Here, with MESA, rv280, powerpc32: BGRA(rev) is slow while
1401 ABGR is fast, so fix things in the shader */
1402 state
.texform
= GL_ABGR_EXT
;
1403 state
.texty
= GL_UNSIGNED_INT_8_8_8_8
;
1405 glBindFragmentShaderATI (1);
1406 glBeginFragmentShaderATI ();
1408 glSampleMapATI (GL_REG_0_ATI
, GL_TEXTURE0_ARB
, GL_SWIZZLE_STR_ATI
);
1410 glColorFragmentOp1ATI (GL_MOV_ATI
,
1411 GL_REG_1_ATI
, GL_RED_BIT_ATI
, GL_NONE
,
1412 GL_REG_0_ATI
, GL_BLUE
, GL_NONE
);
1413 glColorFragmentOp1ATI (GL_MOV_ATI
,
1414 GL_REG_1_ATI
, GL_BLUE_BIT_ATI
, GL_NONE
,
1415 GL_REG_0_ATI
, GL_RED
, GL_NONE
);
1416 glColorFragmentOp1ATI (
1418 GL_REG_0_ATI
, GL_RED_BIT_ATI
| GL_BLUE_BIT_ATI
, GL_NONE
,
1419 GL_REG_1_ATI
, GL_NONE
, GL_NONE
1422 glEndFragmentShaderATI ();
1426 state
.texform
= GL_BGRA_EXT
;
1427 state
.texty
= GL_UNSIGNED_INT_8_8_8_8_REV
;
1430 state
.texform
= GL_BGRA_EXT
;
1431 state
.texty
= GL_UNSIGNED_INT_8_8_8_8
;
1435 CAMLprim value
ml_init (value sock_v
)
1438 CAMLparam1 (sock_v
);
1440 state
.texcount
= 128;
1441 state
.sliceheight
= 64;
1443 state
.texids
= calloc (state
.texcount
* sizeof (*state
.texids
), 1);
1444 if (!state
.texids
) {
1445 err (1, "calloc texids %zu", state
.texcount
* sizeof (*state
.texids
));
1448 state
.texowners
= calloc (state
.texcount
* sizeof (*state
.texowners
), 1);
1449 if (!state
.texowners
) {
1450 err (1, "calloc texowners %zu",
1451 state
.texcount
* sizeof (*state
.texowners
));
1454 glGenTextures (state
.texcount
, state
.texids
);
1456 state
.sock
= Int_val (sock_v
);
1459 state
.cache
= fz_newglyphcache ();
1461 errx (1, "fz_newglyphcache failed");
1464 ret
= pthread_create (&state
.thread
, NULL
, mainloop
, NULL
);
1466 errx (1, "pthread_create: %s", strerror (errno
));
1469 CAMLreturn (Val_unit
);