int pdf_imagebbox(lua_State *L) {
const char* filename = luaL_checkstring(L, 1);
double llx = 0;
double lly = 0;
double urx = 0;
double ury = 0;
FILE* f = MFOPEN(filename, FOPEN_RBIN_MODE);
if (!f) {
return luaL_error(L, "Image file not found %s", filename);
}
if ( get_image_bbox(f, &llx, &lly, &urx, &ury) < 0 ) {
MFCLOSE(f);
return luaL_error(L, "Invalid image file %s", filename);
}
MFCLOSE(f);
lua_pushnumber(L, llx);
lua_pushnumber(L, lly);
lua_pushnumber(L, urx);
lua_pushnumber(L, ury);
return 4;
}
int
pdf_font_open_pkfont (pdf_font *font)
{
char *ident;
double point_size;
int encoding_id;
unsigned dpi;
FILE *fp;
ident = pdf_font_get_ident(font);
point_size = pdf_font_get_param(font, PDF_FONT_PARAM_POINT_SIZE);
encoding_id = pdf_font_get_encoding(font);
if (!ident || point_size <= 0.0)
return -1;
{
char *fontfile = pdf_font_get_fontfile (font);
char *tfmfile = pdf_font_get_tfmfile (font);
if (fontfile)
fp = MFOPEN(fontfile, FOPEN_RBIN_MODE);
else
fp = dpx_open_pk_font_at(ident, dpi);
if (tfmfile)
dpi = truedpi(tfmfile, point_size, base_dpi);
else
dpi = base_dpi;
}
if (!fp)
return -1;
MFCLOSE(fp);
/* Type 3 fonts doesn't have FontName.
* FontFamily is recommended for PDF 1.5.
*/
pdf_font_set_fontname(font, ident);
if (encoding_id >= 0) {
pdf_encoding_used_by_type3(encoding_id);
WARN("PK font is found for font \"%s\" but non built-in encoding \"%s\" is specified.",
ident, pdf_encoding_get_name(encoding_id));
#if ENABLE_GLYPHENC
WARN(">> Assuming this is for glyph name assignment.");
#else
WARN(">> I can't reencode PK font. (not enough information available)");
WARN(">> Maybe you need to install pfb/opentype/truetype font.");
#endif
}
return 0;
}
static FILE *
dpx_open_pk_font_at (const char *ident, unsigned dpi)
{
FILE *fp;
char *fqpn;
kpse_glyph_file_type kpse_file_info;
fqpn = kpse_find_glyph(ident, dpi, kpse_pk_format, &kpse_file_info);
if (!fqpn)
return NULL;
fp = MFOPEN(fqpn, FOPEN_RBIN_MODE);
RELEASE(fqpn);
return fp;
}
static unsigned
truedpi (const char *ident, double point_size, unsigned bdpi)
{
unsigned dpi = bdpi;
double design_size;
int tfm_id;
tfm_id = MFOPEN(ident, FOPEN_RBIN_MODE);
if (tfm_id < 0)
return dpi;
design_size = tfm_get_design_size(tfm_id);
MFCLOSE(tfm_id);
if (design_size <= 0.0)
WARN("DESGIN_SIZE <= 0.0? (TFM=\"%s\")", ident);
else {
dpi = (unsigned) ROUND(base_dpi * point_size / design_size, 1.0);
}
return dpi;
}
int
pdf_font_load_pkfont (pdf_font *font)
{
pdf_obj *fontdict;
char *usedchars;
char *ident;
unsigned dpi;
FILE *fp;
double point_size, pix2charu;
int opcode, code, firstchar, lastchar, prev;
pdf_obj *charprocs, *procset, *encoding, *tmp_array;
double widths[256];
pdf_rect bbox;
char charavail[256];
#if ENABLE_GLYPHENC
int encoding_id;
char **enc_vec;
#endif /* ENABLE_GLYPHENC */
int error = 0;
if (!pdf_font_is_in_use(font)) {
return 0;
}
ident = pdf_font_get_ident(font);
point_size = pdf_font_get_param(font, PDF_FONT_PARAM_POINT_SIZE);
usedchars = pdf_font_get_usedchars(font);
#if ENABLE_GLYPHENC
encoding_id = pdf_font_get_encoding(font);
if (encoding_id < 0)
enc_vec = NULL;
else {
enc_vec = pdf_encoding_get_encoding(encoding_id);
}
#endif /* ENABLE_GLYPHENC */
ASSERT(ident && usedchars && point_size > 0.0);
dpi = truedpi(ident, point_size, base_dpi);
{
char *fontfile = pdf_font_get_fontfile (font);
if (fontfile)
fp = MFOPEN(fontfile, FOPEN_RBIN_MODE);
else
fp = dpx_open_pk_font_at(ident, dpi);
}
if (!fp) {
ERROR("Could not find/open PK font file: %s (at %udpi)", ident, dpi);
}
memset(charavail, 0, 256);
charprocs = pdf_new_dict();
/* Include bitmap as 72dpi image:
* There seems to be problems in "scaled" bitmap glyph
* rendering in several viewers.
*/
pix2charu = 72. * 1000. / ((double) base_dpi) / point_size;
bbox.llx = bbox.lly = HUGE_VAL;
bbox.urx = bbox.ury = -HUGE_VAL;
while ((opcode = fgetc(fp)) >= 0 && opcode != PK_POST) {
if (opcode < 240) {
struct pk_header_ pkh;
error = read_pk_char_header(&pkh, opcode, fp);
if (error)
ERROR("Error in reading PK character header.");
else if (charavail[pkh.chrcode & 0xff])
WARN("More than two bitmap image for single glyph?: font=\"%s\" code=0x%02x",
ident, pkh.chrcode);
if (!usedchars[pkh.chrcode & 0xff])
do_skip(fp, pkh.pkt_len);
else {
char *charname;
pdf_obj *charproc;
unsigned char *pkt_ptr;
size_t bytesread;
double charwidth;
/* Charwidth in PDF units */
charwidth = ROUND(1000.0 * pkh.wd / (((double) (1<<20))*pix2charu), 0.1);
widths[pkh.chrcode & 0xff] = charwidth;
/* Update font BBox info */
bbox.llx = MIN(bbox.llx, -pkh.bm_hoff);
bbox.lly = MIN(bbox.lly, pkh.bm_voff - pkh.bm_ht);
bbox.urx = MAX(bbox.urx, pkh.bm_wd - pkh.bm_hoff);
bbox.ury = MAX(bbox.ury, pkh.bm_voff);
pkt_ptr = NEW(pkh.pkt_len, unsigned char);
if ((bytesread = fread(pkt_ptr, 1, pkh.pkt_len, fp))!= pkh.pkt_len) {
ERROR("Only %ld bytes PK packet read. (expected %ld bytes)",
bytesread, pkh.pkt_len);
}
charproc = create_pk_CharProc_stream(&pkh, charwidth, pkt_ptr, bytesread);
RELEASE(pkt_ptr);
if (!charproc)
ERROR("Unpacking PK character data failed.");
#if ENABLE_GLYPHENC
if (encoding_id >= 0 && enc_vec) {
charname = (char *) enc_vec[pkh.chrcode & 0xff];
if (!charname) {
WARN("\".notdef\" glyph used in font (code=0x%02x): %s", pkh.chrcode, ident);
charname = work_buffer;
pk_char2name(charname, pkh.chrcode);
}
}
else
#endif /* ENABLE_GLYPHENC */
{
charname = work_buffer;
pk_char2name(charname, pkh.chrcode);
}
pdf_add_dict(charprocs, pdf_new_name(charname), pdf_ref_obj(charproc)); /* _FIXME_ */
pdf_release_obj(charproc);
}
charavail[pkh.chrcode & 0xff] = 1;
} else { /* A command byte */
switch (opcode) {
case PK_NO_OP: break;
case PK_XXX1: do_skip(fp, get_unsigned_byte(fp)); break;
case PK_XXX2: do_skip(fp, get_unsigned_pair(fp)); break;
case PK_XXX3: do_skip(fp, get_unsigned_triple(fp)); break;
case PK_XXX4: do_skip(fp, get_unsigned_quad(fp)); break;
case PK_YYY: do_skip(fp, 4); break;
case PK_PRE: do_preamble(fp); break;
}
}
}
