1 /* lots of code c&p-ed directly from mupdf */
3 #define WIN32_LEAN_AND_MEAN
6 #define fionread_arg long
14 #pragma warning (disable:4244)
15 #pragma warning (disable:4996)
16 #pragma warning (disable:4995)
24 static void __declspec (noreturn
) err (int exitcode
, const char *fmt
, ...)
31 vfprintf (stderr
, fmt
, ap
);
33 fprintf (stderr
, ": %s\n", strerror (errno
));
36 static void __declspec (noreturn
) errx (int exitcode
, const char *fmt
, ...)
41 vfprintf (stderr
, fmt
, ap
);
46 static void __declspec (noreturn
) sockerr (int exitcode
, const char *fmt
, ...)
51 vfprintf (stderr
, fmt
, ap
);
53 fprintf (stderr
, ": wsaerror 0x%x\n", WSAGetLastError ());
59 #define fionread_arg int
60 #define ioctlsocket ioctl
76 #include <sys/types.h>
77 #include <sys/socket.h>
78 #include <sys/ioctl.h>
82 #include <OpenGL/gl.h>
87 #ifndef GL_TEXTURE_RECTANGLE_ARB
88 #define GL_TEXTURE_RECTANGLE_ARB 0x84F5
91 #include <caml/fail.h>
92 #include <caml/alloc.h>
93 #include <caml/memory.h>
94 #include <caml/unixsupport.h>
100 #define lprintf printf
106 #include FT_FREETYPE_H
109 #define ARSERT(cond) for (;;) { \
111 errx (1, "%s:%d " #cond, __FILE__, __LINE__); \
135 struct pagedim pagedim
;
140 struct slice slices
[];
143 #if !defined _WIN32 && !defined __APPLE__
151 struct pagedim
*pagedims
;
155 fz_glyph_cache
*cache
;
182 static CRITICAL_SECTION critsec
;
184 static void lock (void *unused
)
187 EnterCriticalSection (&critsec
);
190 static void unlock (void *unused
)
193 LeaveCriticalSection (&critsec
);
196 static int trylock (void *unused
)
198 return TryEnterCriticalSection (&critsec
) == 0;
201 static pthread_mutex_t mutex
= PTHREAD_MUTEX_INITIALIZER
;
203 static void lock (const char *cap
)
205 int ret
= pthread_mutex_lock (&mutex
);
207 errx (1, "%s: pthread_mutex_lock: %s", cap
, strerror (ret
));
211 static void unlock (const char *cap
)
213 int ret
= pthread_mutex_unlock (&mutex
);
215 errx (1, "%s: pthread_mutex_unlock: %s", cap
, strerror (ret
));
219 static int trylock (const char *cap
)
221 int ret
= pthread_mutex_trylock (&mutex
);
223 if (ret
&& ret
!= EBUSY
) {
224 errx (1, "%s: pthread_mutex_trylock: %s", cap
, strerror (ret
));
230 static void *parse_pointer (const char *cap
, const char *s
)
235 ret
= sscanf (s
, "%p", &ptr
);
237 errx (1, "%s: cannot parse pointer in `%s'", cap
, s
);
242 static int hasdata (int sock
)
246 ret
= ioctlsocket (sock
, FIONREAD
, &avail
);
247 if (ret
) sockerr (1, "hasdata: FIONREAD error ret=%d", ret
);
251 static double now (void)
255 if (gettimeofday (&tv
, NULL
)) {
256 err (1, "gettimeofday");
258 return tv
.tv_sec
+ tv
.tv_usec
*1e-6;
261 static void readdata (int fd
, char *p
, int size
)
265 n
= recv (fd
, p
, size
, 0);
267 if (!n
) errx (1, "EOF while reading");
268 sockerr (1, "recv (req %d, ret " FMT_ss
")", size
, n
);
272 static void writedata (int fd
, char *p
, int size
)
277 buf
[0] = (size
>> 24) & 0xff;
278 buf
[1] = (size
>> 16) & 0xff;
279 buf
[2] = (size
>> 8) & 0xff;
280 buf
[3] = (size
>> 0) & 0xff;
282 n
= send (fd
, buf
, 4, 0);
284 if (!n
) errx (1, "EOF while writing length");
285 sockerr (1, "send " FMT_ss
, n
);
288 n
= send (fd
, p
, size
, 0);
290 if (!n
) errx (1, "EOF while writing data");
291 sockerr (1, "send (req %d, ret " FMT_ss
")", size
, n
);
297 __attribute__ ((format (printf
, 2, 3)))
299 printd (int fd
, const char *fmt
, ...)
307 if (!buf
) err (errno
, "malloc for temp buf (%d bytes) failed", size
);
310 len
= vsnprintf (buf
, size
, fmt
, ap
);
313 if (len
> -1 && len
< size
) {
314 writedata (fd
, buf
, len
);
324 buf
= realloc (buf
, size
);
329 static void die (fz_error error
)
331 fz_catch (error
, "aborting");
333 pdf_free_xref (state
.xref
);
337 static void openxref (char *filename
, char *password
)
342 for (i
= 0; i
< state
.texcount
; ++i
) {
343 state
.texowners
[i
].slice
= NULL
;
347 fz_free_glyph_cache (state
.cache
);
350 state
.cache
= fz_new_glyph_cache ();
352 errx (1, "fz_newglyph_cache failed");
356 if (state
.xref
->store
) {
357 pdf_free_store (state
.xref
->store
);
358 state
.xref
->store
= NULL
;
360 pdf_free_xref (state
.xref
);
364 if (state
.pagedims
) {
365 free (state
.pagedims
);
366 state
.pagedims
= NULL
;
368 state
.pagedimcount
= 0;
370 error
= pdf_open_xref (&state
.xref
, filename
, password
);
375 error
= pdf_load_page_tree (state
.xref
);
380 state
.pagecount
= pdf_count_pages (state
.xref
);
383 static int readlen (int fd
)
388 n
= recv (fd
, p
, 4, 0);
390 if (!n
) errx (1, "EOF while reading length");
391 sockerr (1, "recv " FMT_ss
, n
);
394 return (p
[0] << 24) | (p
[1] << 16) | (p
[2] << 8) | p
[3];
397 static void unlinkpage (struct page
*page
)
401 for (i
= 0; i
< page
->slicecount
; ++i
) {
402 struct slice
*s
= &page
->slices
[i
];
403 if (s
->texindex
!= -1) {
404 if (state
.texowners
[s
->texindex
].slice
== s
) {
405 state
.texowners
[s
->texindex
].slice
= NULL
;
406 ARSERT (state
.texowners
[s
->texindex
].w
== s
->w
);
407 ARSERT (state
.texowners
[s
->texindex
].h
>= s
->h
);
413 static void freepage (struct page
*page
)
415 fz_drop_pixmap (page
->pixmap
);
420 fz_free_text_span (page
->text
);
422 if (page
->drawpage
) {
423 pdf_free_page (page
->drawpage
);
429 static void subdivide (struct page
*p
)
432 int h
= p
->pixmap
->h
;
433 int th
= MIN (h
, state
.sliceheight
);
435 for (i
= 0; i
< p
->slicecount
; ++i
) {
436 struct slice
*s
= &p
->slices
[i
];
444 static int compatpdims (struct pagedim
*p1
, struct pagedim
*p2
)
446 return p1
->rotate
== p2
->rotate
447 && !memcmp (&p1
->bbox
, &p2
->bbox
, sizeof (p1
->bbox
))
448 && !memcmp (&p1
->ctm
, &p2
->ctm
, sizeof (p1
->ctm
));
454 static int cacheline32bytes
;
456 static void __attribute__ ((constructor
)) clcheck (void)
458 char **envp
= environ
;
463 for (auxv
= (unsigned long *) envp
; *auxv
!= 0; auxv
+= 2) {
465 cacheline32bytes
= auxv
[1] == 32;
471 static void __attribute__ ((optimize ("O"))) clearpixmap (fz_pixmap
*pixmap
)
473 if (cacheline32bytes
) {
474 intptr_t a1
, a2
, diff
;
475 size_t sizea
, i
, size
= pixmap
->w
* pixmap
->h
* pixmap
->n
;
476 vector
unsigned char v
= vec_splat_u8 (-1);
477 vector
unsigned char *p
;
479 a1
= a2
= (intptr_t) pixmap
->samples
;
480 a2
= (a1
+ 31) & ~31;
485 while (a1
!= a2
) *(char *) a1
++ = 0xff;
486 for (i
= 0; i
< (sizea
& ~31); i
+= 32) {
487 __asm
volatile ("dcbz %0, %1"::"b"(a2
),"r"(i
));
489 vec_st (v
, i
+ 16, p
);
491 while (i
< sizea
) *((char *) a1
+ i
++) = 0xff;
493 else fz_clear_pixmap_with_color (pixmap
, 0xff);
496 #define clearpixmap(p) fz_clear_pixmap_with_color (p, 0xff)
499 static void *render (int pageno
, int pindex
)
503 struct page
*page
= NULL
;
507 struct pagedim
*pagedim
;
510 printd (state
.sock
, "V rendering %d", pageno
);
512 pagedim
= &state
.pagedims
[pindex
];
513 slicecount
= (pagedim
->bbox
.y1
- pagedim
->bbox
.y0
514 + state
.sliceheight
- 1) / state
.sliceheight
;
515 slicecount
+= slicecount
== 0;
518 if (compatpdims (&state
.pig
->pagedim
, pagedim
)) {
521 fz_free_text_span (page
->text
);
524 if (page
->drawpage
) {
525 pdf_free_page (page
->drawpage
);
526 page
->drawpage
= NULL
;
530 freepage (state
.pig
);
534 page
= calloc (sizeof (*page
)
535 + (slicecount
* sizeof (struct slice
)), 1);
537 err (1, "calloc page %d\n", pageno
);
539 page
->pixmap
= fz_new_pixmap_with_rect (fz_device_rgb
, pagedim
->bbox
);
542 page
->slicecount
= slicecount
;
544 error
= pdf_load_page (&drawpage
, state
.xref
, pageno
- 1);
548 clearpixmap (page
->pixmap
);
550 idev
= fz_new_draw_device (state
.cache
, page
->pixmap
);
552 die (fz_throw ("fz_newdrawdevice failed"));
553 error
= pdf_run_page (state
.xref
, drawpage
, idev
, pagedim
->ctm
);
555 die (fz_rethrow (error
, "pdf_runpage failed"));
556 fz_free_device (idev
);
558 page
->drawpage
= drawpage
;
559 page
->pagedim
= *pagedim
;
560 page
->pageno
= pageno
;
564 pdf_age_store (state
.xref
->store
, 3);
566 printd (state
.sock
, "V rendering %d took %f sec", pageno
, end
- start
);
571 static void initpdims (void)
577 for (pageno
= 0; pageno
< state
.pagecount
; ++pageno
) {
581 fz_obj
*obj
, *pageobj
;
583 pageobj
= state
.xref
->page_objs
[pageno
];
585 obj
= fz_dict_gets (pageobj
, "CropBox");
586 if (!fz_is_array (obj
)) {
587 obj
= fz_dict_gets (pageobj
, "MediaBox");
588 if (!fz_is_array (obj
)) {
589 die (fz_throw ("cannot find page bounds %d (%d Rd)",
590 fz_to_num (pageobj
), fz_to_gen (pageobj
)));
593 box
= pdf_to_rect (obj
);
595 obj
= fz_dict_gets (pageobj
, "Rotate");
596 if (fz_is_int (obj
)) {
597 rotate
= fz_to_int (obj
);
602 rotate
+= state
.rotate
;
604 p
= &state
.pagedims
[state
.pagedimcount
- 1];
605 if ((state
.pagedimcount
== 0)
606 || (p
->rotate
!= rotate
|| memcmp (&p
->box
, &box
, sizeof (box
)))) {
609 size
= (state
.pagedimcount
+ 1) * sizeof (*state
.pagedims
);
610 state
.pagedims
= realloc (state
.pagedims
, size
);
611 if (!state
.pagedims
) {
612 err (1, "realloc pagedims to " FMT_s
" (%d elems)",
613 size
, state
.pagedimcount
+ 1);
615 p
= &state
.pagedims
[state
.pagedimcount
++];
622 printd (state
.sock
, "T Processed %d pages in %f seconds",
623 state
.pagecount
, end
- start
);
626 static void layout (void)
632 struct pagedim
*p
= state
.pagedims
;
635 for (pindex
= 0; pindex
< state
.pagedimcount
; ++pindex
, ++p
) {
636 box
.x0
= MIN (p
->box
.x0
, p
->box
.x1
);
637 box
.y0
= MIN (p
->box
.y0
, p
->box
.y1
);
638 box
.x1
= MAX (p
->box
.x0
, p
->box
.x1
);
639 box
.y1
= MAX (p
->box
.y0
, p
->box
.y1
);
642 ctm
= fz_concat (ctm
, fz_translate (0, -box
.y1
));
643 ctm
= fz_concat (ctm
, fz_rotate (p
->rotate
));
644 box2
= fz_transform_rect (ctm
, box
);
645 w
= box2
.x1
- box2
.x0
;
647 zoom
= (state
.w
/ w
);
649 ctm
= fz_concat (ctm
, fz_translate (0, -box
.y1
));
650 ctm
= fz_concat (ctm
, fz_scale (zoom
, -zoom
));
651 memcpy (&p
->ctm1
, &ctm
, sizeof (ctm
));
652 ctm
= fz_concat (ctm
, fz_rotate (p
->rotate
));
653 p
->bbox
= fz_round_rect (fz_transform_rect (ctm
, box
));
654 memcpy (&p
->ctm
, &ctm
, sizeof (ctm
));
657 while (p
-- != state
.pagedims
) {
658 printd (state
.sock
, "l %d %d %d",
659 p
->pageno
, p
->bbox
.x1
- p
->bbox
.x0
, p
->bbox
.y1
- p
->bbox
.y0
);
663 static void recurse_outline (pdf_outline
*outline
, int level
)
671 if (!outline
->link
) goto next
;
673 obj
= outline
->link
->dest
;
674 if (fz_is_indirect (obj
)) {
675 obj
= fz_resolve_indirect (obj
);
677 if (fz_is_array (obj
)) {
680 obj2
= fz_array_get (obj
, 0);
681 if (fz_is_int (obj2
)) {
682 pageno
= fz_to_int (obj2
);
685 pageno
= pdf_find_page_number (state
.xref
, obj2
);
688 if (fz_array_len (obj
) > 3) {
692 xo
= fz_array_get (obj
, 2);
693 yo
= fz_array_get (obj
, 3);
694 if (!fz_is_null (xo
) && !fz_is_null (yo
)) {
695 struct pagedim
*pagedim
= state
.pagedims
;
697 for (i
= 0; i
< state
.pagedimcount
; ++i
) {
698 if (state
.pagedims
[i
].pageno
> pageno
)
700 pagedim
= &state
.pagedims
[i
];
702 p
.x
= fz_to_int (xo
);
703 p
.y
= fz_to_int (yo
);
704 p
= fz_transform_point (pagedim
->ctm
, p
);
705 h
= pagedim
->bbox
.y1
- pagedim
->bbox
.y0
;
711 pageno
= pdf_find_page_number (state
.xref
, outline
->link
->dest
);
714 lprintf ("%*c%s %d\n", level
, ' ', outline
->title
, pageno
);
715 printd (state
.sock
, "o %d %d %d %d %s",
716 level
, pageno
, top
, h
, outline
->title
);
718 if (outline
->child
) {
719 recurse_outline (outline
->child
, level
+ 1);
721 outline
= outline
->next
;
725 static void process_outline (void)
727 pdf_outline
*outline
;
729 if (!state
.needoutline
) return;
731 state
.needoutline
= 0;
732 outline
= pdf_load_outline (state
.xref
);
734 recurse_outline (outline
, 0);
735 pdf_free_outline (outline
);
739 static int comparespans (const void *l
, const void *r
)
741 fz_text_span
const *const*ls
= l
;
742 fz_text_span
const *const*rs
= r
;
743 return (*ls
)->text
->bbox
.y0
- (*rs
)->text
->bbox
.y0
;
746 /* wishful thinking function */
747 static void search (regex_t
*re
, int pageno
, int y
, int forward
)
757 fz_text_span
*text
, *span
, **pspan
;
758 struct pagedim
*pdim
, *pdimprev
;
765 while (pageno
>= 0 && pageno
< state
.pagecount
&& !stop
) {
767 pdf_age_store (state
.xref
->store
, 3);
769 if (hasdata (state
.sock
)) {
770 printd (state
.sock
, "T attention requested aborting search at %d",
775 printd (state
.sock
, "T searching in page %d", pageno
);
779 for (i
= 0; i
< state
.pagedimcount
; ++i
) {
780 pdim
= &state
.pagedims
[i
];
781 if (pdim
->pageno
== pageno
) {
784 if (pdim
->pageno
> pageno
) {
793 error
= pdf_load_page (&drawpage
, state
.xref
, pageno
);
797 ctm
= fz_rotate (pdim
->rotate
);
799 text
= fz_new_text_span ();
800 tdev
= fz_new_text_device (text
);
801 error
= pdf_run_page (state
.xref
, drawpage
, tdev
, pdim
->ctm1
);
802 if (error
) die (error
);
803 fz_free_device (tdev
);
806 for (span
= text
; span
; span
= span
->next
) {
809 pspan
= malloc (sizeof (void *) * nspans
);
811 err (1, "malloc span pointers " FMT_s
, sizeof (void *) * nspans
);
813 for (i
= 0, span
= text
; span
; span
= span
->next
, ++i
) {
816 qsort (pspan
, nspans
, sizeof (fz_text_span
*), comparespans
);
818 j
= forward
? 0 : nspans
- 1;
823 j
+= forward
? 1 : -1;
825 for (i
= 0; i
< MIN (span
->len
, (int) sizeof (buf
) - 1); ++i
) {
827 if (span
->text
[i
].bbox
.y0
< y
+ 1) {
832 if (span
->text
[i
].bbox
.y0
> y
- 1) {
836 if (span
->text
[i
].c
< 256) {
837 *p
++ = span
->text
[i
].c
;
848 ret
= regexec (re
, buf
, 1, &rm
, 0);
850 if (ret
!= REG_NOMATCH
) {
853 size
= regerror (ret
, re
, errbuf
, sizeof (errbuf
));
855 "T regexec error `%.*s'",
857 fz_free_text_span (text
);
858 pdf_free_page (drawpage
);
866 fz_point p1
, p2
, p3
, p4
;
868 xoff
= -pdim
->bbox
.x0
;
869 yoff
= -pdim
->bbox
.y0
;
871 sb
= &span
->text
[rm
.rm_so
].bbox
;
872 eb
= &span
->text
[rm
.rm_eo
- 1].bbox
;
883 p1
= fz_transform_point (ctm
, p1
);
884 p2
= fz_transform_point (ctm
, p2
);
885 p3
= fz_transform_point (ctm
, p3
);
886 p4
= fz_transform_point (ctm
, p4
);
889 printd (state
.sock
, "F %d %d %f %f %f %f %f %f %f %f",
891 p1
.x
+ xoff
, p1
.y
+ yoff
,
892 p2
.x
+ xoff
, p2
.y
+ yoff
,
893 p3
.x
+ xoff
, p3
.y
+ yoff
,
894 p4
.x
+ xoff
, p4
.y
+ yoff
);
896 printd (state
.sock
, "T found at %d `%.*s' in %f sec",
897 pageno
, rm
.rm_eo
- rm
.rm_so
, &buf
[rm
.rm_so
],
901 printd (state
.sock
, "R %d %d %f %f %f %f %f %f %f %f",
903 p1
.x
+ xoff
, p1
.y
+ yoff
,
904 p2
.x
+ xoff
, p2
.y
+ yoff
,
905 p3
.x
+ xoff
, p3
.y
+ yoff
,
906 p4
.x
+ xoff
, p4
.y
+ yoff
);
919 fz_free_text_span (text
);
920 pdf_free_page (drawpage
);
925 printd (state
.sock
, "T no matches %f sec", end
- start
);
927 printd (state
.sock
, "D");
936 mainloop (void *unused
)
939 int len
, ret
, oldlen
= 0;
942 len
= readlen (state
.sock
);
944 errx (1, "readlen returned 0");
947 if (oldlen
< len
+ 1) {
948 p
= realloc (p
, len
+ 1);
950 err (1, "realloc %d failed", len
+ 1);
954 readdata (state
.sock
, p
, len
);
957 if (!strncmp ("open", p
, 4)) {
962 char *filename
= p
+ 5;
964 filenamelen
= strlen (filename
);
965 password
= filename
+ filenamelen
+ 1;
966 anglestr
= password
+ strlen (password
) + 1;
970 int ret
= sscanf (anglestr
, "%d", &angle
);
972 errx (1, "malformed angle `%.*s' ret=%d",
973 strlen (anglestr
), anglestr
, ret
);
975 state
.rotate
= angle
;
978 openxref (filename
, password
);
981 obj
= fz_dict_gets (state
.xref
->trailer
, "Info");
985 obj
= fz_dict_gets (obj
, "Title");
986 s
= pdf_to_utf8 (obj
);
988 printd (state
.sock
, "t %s", s
);
993 state
.needoutline
= 1;
995 else if (!strncmp ("free", p
, 4)) {
998 ret
= sscanf (p
+ 4, " %p", &ptr
);
1000 errx (1, "malformed free `%.*s' ret=%d", len
, p
, ret
);
1005 else if (!strncmp ("search", p
, 6)) {
1006 int icase
, pageno
, y
, ret
, len2
, forward
;
1010 ret
= sscanf (p
+ 6, " %d %d %d %d,%n",
1011 &icase
, &pageno
, &y
, &forward
, &len2
);
1013 errx (1, "malformed search `%s' ret=%d", p
, ret
);
1016 pattern
= p
+ 6 + len2
;
1017 ret
= regcomp (&re
, pattern
,
1018 REG_EXTENDED
| (icase
? REG_ICASE
: 0));
1023 size
= regerror (ret
, &re
, errbuf
, sizeof (errbuf
));
1024 printd (state
.sock
, "T regcomp failed `%.*s'",
1025 (int) size
, errbuf
);
1028 search (&re
, pageno
, y
, forward
);
1032 else if (!strncmp ("geometry", p
, 8)) {
1035 printd (state
.sock
, "c");
1036 ret
= sscanf (p
+ 8, " %d %d", &w
, &h
);
1038 errx (1, "malformed geometry `%.*s' ret=%d", len
, p
, ret
);
1046 for (i
= 0; i
< state
.texcount
; ++i
) {
1047 state
.texowners
[i
].slice
= NULL
;
1052 unlock ("geometry");
1053 printd (state
.sock
, "C %d", state
.pagecount
);
1055 else if (!strncmp ("rotate", p
, 6)) {
1058 printd (state
.sock
, "c");
1059 ret
= sscanf (p
+ 6, " %f", &rotate
);
1061 errx (1, "bad rotate line `%.*s' ret=%d", len
, p
, ret
);
1064 state
.rotate
= rotate
;
1065 state
.pagedimcount
= 0;
1066 free (state
.pagedims
);
1067 state
.pagedims
= NULL
;
1072 freepage (state
.pig
);
1076 printd (state
.sock
, "C %d", state
.pagecount
);
1078 else if (!strncmp ("render", p
, 6)) {
1079 int pageno
, pindex
, w
, h
, ret
;
1082 ret
= sscanf (p
+ 6, " %d %d %d %d", &pageno
, &pindex
, &w
, &h
);
1084 errx (1, "bad render line `%.*s' ret=%d", len
, p
, ret
);
1088 page
= render (pageno
, pindex
);
1091 printd (state
.sock
, "r %d %d %d %d %p",
1098 else if (!strncmp ("interrupt", p
, 9)) {
1099 printd (state
.sock
, "V interrupted");
1102 errx (1, "unknown command %.*s", len
, p
);
1108 static void showsel (struct page
*page
, int oy
)
1113 struct mark first
, last
;
1115 first
= page
->fmark
;
1118 if (!first
.span
|| !last
.span
) return;
1120 glEnable (GL_BLEND
);
1121 glBlendFunc (GL_SRC_ALPHA
, GL_SRC_ALPHA
);
1122 glColor4f (0.5f
, 0.5f
, 0.0f
, 0.6f
);
1124 ox
= -page
->pixmap
->x
;
1125 oy
= -page
->pixmap
->y
+ oy
;
1126 for (span
= first
.span
; span
; span
= span
->next
) {
1129 bbox
.x0
= bbox
.y0
= bbox
.x1
= bbox
.y1
= 0;
1134 if (span
== page
->fmark
.span
&& span
== page
->lmark
.span
) {
1135 j
= MIN (first
.i
, last
.i
);
1136 k
= MAX (first
.i
, last
.i
);
1138 else if (span
== first
.span
) {
1141 else if (span
== last
.span
) {
1145 for (i
= j
; i
<= k
; ++i
) {
1146 bbox
= fz_union_bbox (bbox
, span
->text
[i
].bbox
);
1148 lprintf ("%d %d %d %d oy=%d ox=%d\n",
1155 glRecti (bbox
.x0
+ ox
, bbox
.y0
+ oy
, bbox
.x1
+ ox
, bbox
.y1
+ oy
);
1157 if (span
== last
.span
) break;
1159 glDisable (GL_BLEND
);
1162 static void highlightlinks (struct page
*page
, int yoff
)
1167 glPolygonMode (GL_FRONT_AND_BACK
, GL_LINE
);
1168 glEnable (GL_LINE_STIPPLE
);
1169 glLineStipple (0.5, 0xcccc);
1171 xoff
= -page
->pixmap
->x
;
1172 yoff
-= page
->pixmap
->y
;
1175 for (link
= page
->drawpage
->links
; link
; link
= link
->next
) {
1176 fz_point p1
, p2
, p3
, p4
;
1177 fz_matrix ctm
= page
->pagedim
.ctm
;
1179 p1
.x
= link
->rect
.x0
;
1180 p1
.y
= link
->rect
.y0
;
1182 p2
.x
= link
->rect
.x1
;
1183 p2
.y
= link
->rect
.y0
;
1185 p3
.x
= link
->rect
.x1
;
1186 p3
.y
= link
->rect
.y1
;
1188 p4
.x
= link
->rect
.x0
;
1189 p4
.y
= link
->rect
.y1
;
1191 p1
= fz_transform_point (ctm
, p1
);
1192 p2
= fz_transform_point (ctm
, p2
);
1193 p3
= fz_transform_point (ctm
, p3
);
1194 p4
= fz_transform_point (ctm
, p4
);
1196 switch (link
->kind
) {
1197 case PDF_LINK_GOTO
: glColor3ub (255, 0, 0); break;
1198 case PDF_LINK_URI
: glColor3ub (0, 0, 255); break;
1199 default: glColor3ub (0, 0, 0); break;
1202 glVertex2f (p1
.x
+ xoff
, p1
.y
+ yoff
);
1203 glVertex2f (p2
.x
+ xoff
, p2
.y
+ yoff
);
1204 glVertex2f (p3
.x
+ xoff
, p3
.y
+ yoff
);
1205 glVertex2f (p4
.x
+ xoff
, p4
.y
+ yoff
);
1209 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1210 glDisable (GL_LINE_STIPPLE
);
1213 static void upload2 (struct page
*page
, int slicenum
, const char *cap
)
1218 struct slice
*slice
= &page
->slices
[slicenum
];
1220 w
= page
->pixmap
->w
;
1222 ARSERT (w
== slice
->w
);
1223 if (slice
->texindex
!= -1
1224 && state
.texowners
[slice
->texindex
].slice
== slice
) {
1225 glBindTexture (GL_TEXTURE_RECTANGLE_ARB
, state
.texids
[slice
->texindex
]);
1229 int index
= (state
.texindex
++ % state
.texcount
);
1232 for (i
= 0; i
< slicenum
; ++i
) {
1233 offset
+= w
* page
->slices
[i
].h
* 4;
1236 if (state
.texowners
[index
].w
== slice
->w
) {
1237 if (state
.texowners
[index
].h
>= slice
->h
) {
1241 state
.texowners
[index
].h
= slice
->h
;
1245 state
.texowners
[index
].h
= slice
->h
;
1248 state
.texowners
[index
].slice
= slice
;
1249 state
.texowners
[index
].w
= slice
->w
;
1250 slice
->texindex
= index
;
1252 glBindTexture (GL_TEXTURE_RECTANGLE_ARB
, state
.texids
[slice
->texindex
]);
1256 GLenum err
= glGetError ();
1257 if (err
!= GL_NO_ERROR
) {
1258 printf ("\033[0;31mERROR1 %d %d %#x\033[0m\n", w
, slice
->h
, err
);
1262 glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB
,
1270 page
->pixmap
->samples
+ offset
1273 GLenum err
= glGetError ();
1274 if (err
!= GL_NO_ERROR
) {
1275 printf ("\033[0;31mERROR %d %d %#x\033[0m\n", w
, slice
->h
, err
);
1281 glTexImage2D (GL_TEXTURE_RECTANGLE_ARB
,
1289 page
->pixmap
->samples
+ offset
1296 lprintf ("%s[%d] slice=%d(%d,%d) texid=%d %f sec\n",
1297 subimage
? "sub" : "img",
1298 page
->pageno
, slicenum
,
1300 state
.texids
[slice
->texindex
],
1305 CAMLprim value
ml_draw (value args_v
, value ptr_v
)
1307 CAMLparam2 (args_v
, ptr_v
);
1308 int dispy
= Int_val (Field (args_v
, 0));
1309 int w
= Int_val (Field (args_v
, 1));
1310 int h
= Int_val (Field (args_v
, 2));
1311 int py
= Int_val (Field (args_v
, 3));
1312 int hlinks
= Bool_val (Field (args_v
, 4));
1313 char *s
= String_val (ptr_v
);
1318 int yoff
= dispy
- py
;
1320 ret
= sscanf (s
, "%p", &ptr
);
1322 errx (1, "cannot parse pointer `%s'", s
);
1326 w
= page
->pixmap
->w
;
1328 ARSERT (h
>= 0 && "ml_draw wrong h");
1329 ARSERT (py
<= page
->pixmap
->h
&& "ml_draw wrong py");
1331 glEnable (GL_TEXTURE_RECTANGLE_ARB
);
1333 for (slicenum
= 0; slicenum
< page
->slicecount
; ++slicenum
) {
1334 struct slice
*slice
= &page
->slices
[slicenum
];
1335 if (slice
->h
> py
) {
1341 h
= MIN (state
.h
, h
);
1344 struct slice
*slice
= &page
->slices
[slicenum
];
1346 ARSERT (slicenum
< page
->slicecount
&& "ml_draw wrong slicenum");
1348 th
= MIN (h
, slice
->h
- py
);
1349 upload2 (page
, slicenum
, "upload");
1353 glTexCoord2i (0, py
);
1354 glVertex2i (0, dispy
);
1356 glTexCoord2i (w
, py
);
1357 glVertex2i (w
, dispy
);
1359 glTexCoord2i (w
, py
+th
);
1360 glVertex2i (w
, dispy
+ th
);
1362 glTexCoord2i (0, py
+th
);
1363 glVertex2i (0, dispy
+ th
);
1373 showsel (page
, yoff
);
1374 if (hlinks
) highlightlinks (page
, yoff
);
1375 glDisable (GL_TEXTURE_RECTANGLE_ARB
);
1377 CAMLreturn (Val_unit
);
1380 static pdf_link
*getlink (struct page
*page
, int x
, int y
)
1386 p
.x
= x
+ page
->pixmap
->x
;
1387 p
.y
= y
+ page
->pixmap
->y
;
1389 ctm
= fz_invert_matrix (page
->pagedim
.ctm
);
1390 p
= fz_transform_point (ctm
, p
);
1392 for (link
= page
->drawpage
->links
; link
; link
= link
->next
) {
1393 if (p
.x
>= link
->rect
.x0
&& p
.x
<= link
->rect
.x1
) {
1394 if (p
.y
>= link
->rect
.y0
&& p
.y
<= link
->rect
.y1
) {
1402 static void ensuretext (struct page
*page
)
1408 page
->text
= fz_new_text_span ();
1409 tdev
= fz_new_text_device (page
->text
);
1410 error
= pdf_run_page (state
.xref
, page
->drawpage
, tdev
,
1412 if (error
) die (error
);
1413 fz_free_device (tdev
);
1417 CAMLprim value
ml_whatsunder (value ptr_v
, value x_v
, value y_v
)
1419 CAMLparam3 (ptr_v
, x_v
, y_v
);
1420 CAMLlocal3 (ret_v
, tup_v
, str_v
);
1423 char *s
= String_val (ptr_v
);
1425 ret_v
= Val_int (0);
1426 if (trylock ("ml_whatsunder")) {
1430 page
= parse_pointer ("ml_whatsunder", s
);
1431 link
= getlink (page
, Int_val (x_v
), Int_val (y_v
));
1433 switch (link
->kind
) {
1444 if (fz_is_array (link
->dest
)) {
1445 obj
= fz_array_get (link
->dest
, 0);
1446 if (fz_is_indirect (obj
)) {
1447 pageno
= pdf_find_page_number (state
.xref
, obj
);
1449 else if (fz_is_int (obj
)) {
1450 pageno
= fz_to_int (obj
);
1453 if (fz_array_len (link
->dest
) > 3) {
1456 xo
= fz_array_get (link
->dest
, 2);
1457 yo
= fz_array_get (link
->dest
, 3);
1458 if (!fz_is_null (xo
) && !fz_is_null (yo
)) {
1459 p
.x
= fz_to_int (xo
);
1460 p
.y
= fz_to_int (yo
);
1461 p
= fz_transform_point (page
->pagedim
.ctm
, p
);
1466 pageno
= pdf_find_page_number (state
.xref
, link
->dest
);
1468 tup_v
= caml_alloc_tuple (2);
1469 ret_v
= caml_alloc_small (1, 1);
1470 Field (tup_v
, 0) = Val_int (pageno
);
1471 Field (tup_v
, 1) = Val_int (p
.y
);
1472 Field (ret_v
, 0) = tup_v
;
1477 str_v
= caml_copy_string (fz_to_str_buf (link
->dest
));
1478 ret_v
= caml_alloc_small (1, 0);
1479 Field (ret_v
, 0) = str_v
;
1483 printd (state
.sock
, "T unhandled link kind %d", link
->kind
);
1492 x
= Int_val (x_v
) + page
->pixmap
->x
;
1493 y
= Int_val (y_v
) + page
->pixmap
->y
;
1495 for (span
= page
->text
; span
; span
= span
->next
) {
1496 for (i
= 0; i
< span
->len
; ++i
) {
1498 b
= &span
->text
[i
].bbox
;
1499 if ((x
>= b
->x0
&& x
<= b
->x1
&& y
>= b
->y0
&& y
<= b
->y1
)) {
1501 span
->font
&& span
->font
->name
1503 : "Span has no font name"
1505 #ifdef FT_FREETYPE_H
1506 FT_FaceRec
*face
= span
->font
->ft_face
;
1507 if (face
&& face
->family_name
) {
1509 char *n1
= face
->family_name
;
1510 size_t l1
= strlen (n1
);
1511 size_t l2
= strlen (n2
);
1513 if (l1
!= l2
|| memcmp (n1
, n2
, l1
)) {
1514 s
= malloc (l1
+ l2
+ 2);
1518 memcpy (s
+ l2
+ 1, n1
, l1
+ 1);
1519 str_v
= caml_copy_string (s
);
1525 str_v
= caml_copy_string (n2
);
1528 str_v
= caml_copy_string (n2
);
1530 ret_v
= caml_alloc_small (1, 2);
1531 Field (ret_v
, 0) = str_v
;
1538 unlock ("ml_whatsunder");
1544 CAMLprim value
ml_seltext (value ptr_v
, value rect_v
, value oy_v
)
1546 CAMLparam4 (ptr_v
, rect_v
, oy_v
, rect_v
);
1550 struct mark first
, last
;
1551 int i
, x0
, x1
, y0
, y1
, oy
;
1552 char *s
= String_val (ptr_v
);
1554 if (trylock ("ml_seltext")) {
1558 page
= parse_pointer ("ml_seltext", s
);
1561 oy
= Int_val (oy_v
);
1562 x0
= Int_val (Field (rect_v
, 0));
1563 y0
= Int_val (Field (rect_v
, 1));
1564 x1
= Int_val (Field (rect_v
, 2));
1565 y1
= Int_val (Field (rect_v
, 3));
1568 glPolygonMode (GL_FRONT_AND_BACK
, GL_LINE
);
1569 glColor3ub (128, 128, 128);
1570 glRecti (x0
, y0
, x1
, y1
);
1571 glPolygonMode (GL_FRONT_AND_BACK
, GL_FILL
);
1574 x0
+= page
->pixmap
->x
;
1575 y0
+= page
->pixmap
->y
- oy
;
1576 x1
+= page
->pixmap
->x
;
1577 y1
+= page
->pixmap
->y
- oy
;
1582 last
.i
= first
.i
= 0;
1583 first
.span
= page
->text
;
1584 for (span
= page
->text
; span
; span
= span
->next
) {
1585 for (i
= 0; i
< span
->len
; ++i
) {
1586 b
= &span
->text
[i
].bbox
;
1587 if (x0
>= b
->x0
&& x0
<= b
->x1
&& y0
>= b
->y0
&& y0
<= b
->y1
) {
1591 if (x1
>= b
->x0
&& x1
<= b
->x1
&& y1
>= b
->y0
&& y1
<= b
->y1
) {
1598 if (y1
< y0
|| x1
< x0
) {
1601 if (first
.span
== last
.span
) {
1606 for (span
= first
.span
; span
&& span
!= last
.span
;
1607 span
= span
->next
) {
1620 first
.span
= last
.span
;
1626 page
->fmark
= first
;
1629 unlock ("ml_seltext");
1632 CAMLreturn (Val_unit
);
1635 static int pipespan (FILE *f
, fz_text_span
*span
, int a
, int b
)
1640 for (i
= a
; i
<= b
; ++i
) {
1641 len
= runetochar (buf
, &span
->text
[i
].c
);
1642 ret
= fwrite (buf
, len
, 1, f
);
1645 printd (state
.sock
, "T failed to write %d bytes ret=%d: %s",
1646 len
, ret
, strerror (errno
));
1653 CAMLprim value
ml_copysel (value ptr_v
)
1658 char *s
= String_val (ptr_v
);
1660 if (trylock ("ml_copysel")) {
1667 if (state
.xselpipe
) {
1668 int ret
= pclose (state
.xselpipe
);
1670 printd (state
.sock
, "T failed to close xsel pipe `%s'",
1673 state
.xselpipe
= NULL
;
1676 printf ("========================================\n");
1682 page
= parse_pointer ("ml_sopysel", s
);
1684 if (!page
->fmark
.span
|| !page
->lmark
.span
) {
1685 printd (state
.sock
, "T nothing to copy");
1691 if (!state
.xselpipe
) {
1692 state
.xselpipe
= popen ("xsel -i", "w");
1693 if (!state
.xselpipe
) {
1694 printd (state
.sock
, "T failed to open xsel pipe `%s'",
1706 for (span
= page
->fmark
.span
;
1707 span
&& span
!= page
->lmark
.span
->next
;
1708 span
= span
->next
) {
1709 int a
= span
== page
->fmark
.span
? page
->fmark
.i
: 0;
1710 int b
= span
== page
->lmark
.span
? page
->lmark
.i
: span
->len
- 1;
1711 if (pipespan (f
, span
, a
, b
)) {
1715 if (putc ('\n', f
) == EOF
) {
1716 printd (state
.sock
, "T failed break line on xsel pipe `%s'",
1722 page
->lmark
.span
= NULL
;
1723 page
->fmark
.span
= NULL
;
1727 unlock ("ml_copysel");
1730 CAMLreturn (Val_unit
);
1733 CAMLprim value
ml_getpdimrect (value pagedimno_v
)
1735 CAMLparam1 (pagedimno_v
);
1737 int pagedimno
= Int_val (pagedimno_v
);
1739 ret_v
= caml_alloc_small (4 * Double_wosize
, Double_array_tag
);
1740 Store_double_field (ret_v
, 0, state
.pagedims
[pagedimno
].box
.x0
);
1741 Store_double_field (ret_v
, 1, state
.pagedims
[pagedimno
].box
.x1
);
1742 Store_double_field (ret_v
, 2, state
.pagedims
[pagedimno
].box
.y0
);
1743 Store_double_field (ret_v
, 3, state
.pagedims
[pagedimno
].box
.y1
);
1747 CAMLprim value
ml_init (value sock_v
)
1752 CAMLparam1 (sock_v
);
1754 state
.texcount
= 256;
1755 state
.sliceheight
= 24;
1756 state
.texform
= GL_RGBA
;
1757 state
.texty
= GL_UNSIGNED_BYTE
;
1760 state
.texids
= calloc (state
.texcount
* sizeof (*state
.texids
), 1);
1761 if (!state
.texids
) {
1762 err (1, "calloc texids " FMT_s
,
1763 state
.texcount
* sizeof (*state
.texids
));
1766 state
.texowners
= calloc (state
.texcount
* sizeof (*state
.texowners
), 1);
1767 if (!state
.texowners
) {
1768 err (1, "calloc texowners " FMT_s
,
1769 state
.texcount
* sizeof (*state
.texowners
));
1772 glGenTextures (state
.texcount
, state
.texids
);
1775 state
.sock
= Socket_val (sock_v
);
1777 state
.sock
= Int_val (sock_v
);
1781 InitializeCriticalSection (&critsec
);
1782 state
.thread
= CreateThread (NULL
, 0, mainloop
, NULL
, 0, NULL
);
1783 if (state
.thread
== INVALID_HANDLE_VALUE
) {
1784 errx (1, "CreateThread failed: %lx", GetLastError ());
1787 ret
= pthread_create (&state
.thread
, NULL
, mainloop
, NULL
);
1789 errx (1, "pthread_create: %s", strerror (ret
));
1793 CAMLreturn (Val_unit
);