int32_t get_unsigned_num (FILE *file, unsigned char num)
{
int32_t val = get_unsigned_byte (file);
switch (num) {
case 3: if (val > 0x7f)
val -= 0x100;
val = (val << 8) | get_unsigned_byte (file);
case 2: val = (val << 8) | get_unsigned_byte (file);
case 1: val = (val << 8) | get_unsigned_byte (file);
default: break;
}
return val;
}
static int
scan_jp2h (ximage_info *info, int *smask, FILE *fp, unsigned int size)
{
int error = 0, have_ihdr = 0;
unsigned int len, lbox, tbox;
while (size > 0 && !error) {
len = read_box_hdr(fp, &lbox, &tbox);
if (lbox == 0) {
WARN("JPEG2000: Unexpected lbox value 0 in JP2 Header box...");
error = -1;
break;
}
switch (tbox) {
case JP2_BOX_IHDR:
info->height = get_unsigned_quad(fp);
info->width = get_unsigned_quad(fp);
info->num_components = get_unsigned_pair(fp);
/* c = */ get_unsigned_byte(fp); /* BPC - 1 */
/* c = */ get_unsigned_byte(fp); /* C: Compression type */
/* c = */ get_unsigned_byte(fp); /* UnkC */
/* c = */ get_unsigned_byte(fp); /* IPR */
have_ihdr = 1;
break;
case JP2_BOX_RES_:
error = scan_res_(info, fp, lbox - len);
break;
case JP2_BOX_CDEF:
error = scan_cdef(info, smask, fp, lbox - len);
break;
case JP2_BOX_BPCC: case JP2_BOX_COLR: case JP2_BOX_PCLR:
case JP2_BOX_CMAP:
case JPX_BOX_LBL_:
seek_relative(fp, lbox - len);
break;
default:
WARN("JPEG2000: Unknown JPEG 2000 box in JP2 Header box.");
seek_relative(fp, lbox - len);
error = -1;
}
size -= lbox;
}
if (!have_ihdr)
WARN("JPEG2000: Expecting JPEG 2000 Image Header box but could not find.");
return (!error && have_ihdr && size == 0) ? 0 : -1;
}
signed char get_signed_byte (FILE *file)
{
int byte;
byte = get_unsigned_byte(file);
if (byte >= 0x80)
byte -= 0x100;
return (signed char) byte;
}
int32_t get_signed_quad(FILE *file)
{
int i;
int32_t quad = get_signed_byte(file);
for (i=0; i<3; i++) {
quad = (quad << 8) | get_unsigned_byte(file);
}
return quad;
}
signed int get_signed_triple(FILE *file)
{
int i;
signed int triple = get_signed_byte(file);
for (i=0; i<2; i++) {
triple = (triple << 8) | get_unsigned_byte(file);
}
return triple;
}
static void read_header(FILE *vf_file, int thisfont)
{
/* Check for usual signature */
if (get_unsigned_byte (vf_file) == PRE &&
get_unsigned_byte (vf_file) == VF_ID) {
/* If here, assume it's a legitimate vf file */
/* skip comment */
skip_bytes (get_unsigned_byte (vf_file), vf_file);
/* Skip checksum */
skip_bytes (4, vf_file);
vf_fonts[thisfont].design_size = get_positive_quad(vf_file, "VF", "design_size");
} else { /* Try to fail gracefully and return an error to caller */
fprintf (stderr, "VF file may be corrupt\n");
}
}
static void
read_res__data (ximage_info *info, FILE *fp, unsigned int size)
{
unsigned int VR_N, VR_D, HR_N, HR_D;
unsigned char VR_E, HR_E;
VR_N = get_unsigned_pair(fp);
VR_D = get_unsigned_pair(fp);
HR_N = get_unsigned_pair(fp);
HR_D = get_unsigned_pair(fp);
VR_E = get_unsigned_byte(fp);
HR_E = get_unsigned_byte(fp);
if (dpx_conf.compat_mode == dpx_mode_compat_mode)
info->xdensity = info->ydensity = 72.0 / 100.0;
else {
info->xdensity = 72.0/(((double) HR_N / HR_D) * pow(10.0, HR_E) * 0.0254);
info->ydensity = 72.0/(((double) VR_N / VR_D) * pow(10.0, VR_E) * 0.0254);
}
}
static void
do_preamble (FILE *fp)
{
/* Check for id byte */
if (fgetc(fp) == 89) {
/* Skip comment */
do_skip(fp, get_unsigned_byte(fp));
/* Skip other header info. It's normally used for verifying this
is the file wethink it is */
do_skip(fp, 16);
} else {
ERROR("embed_pk_font: PK ID byte is incorrect. Are you sure this is a PK file?");
}
return;
}
static int
read_pk_char_header (struct pk_header_ *h, unsigned char opcode, FILE *fp)
{
ASSERT(h);
if ((opcode & 4) == 0) { /* short */
h->pkt_len = (opcode & 3) * 0x100U + get_unsigned_byte(fp);
h->chrcode = get_unsigned_byte(fp);
h->wd = get_unsigned_triple(fp); /* TFM width */
h->dx = get_unsigned_byte(fp) << 16; /* horizontal escapement */
h->dy = 0L;
h->bm_wd = get_unsigned_byte(fp);
h->bm_ht = get_unsigned_byte(fp);
h->bm_hoff = get_signed_byte(fp);
h->bm_voff = get_signed_byte(fp);
h->pkt_len -= 8;
} else if ((opcode & 7) == 7) { /* long */
h->pkt_len = get_unsigned_quad(fp);
h->chrcode = get_signed_quad(fp);
h->wd = get_signed_quad(fp);
h->dx = get_signed_quad(fp); /* 16.16 fixed point number in pixels */
h->dy = get_signed_quad(fp);
h->bm_wd = get_signed_quad(fp);
h->bm_ht = get_signed_quad(fp);
h->bm_hoff = get_signed_quad(fp);
h->bm_voff = get_signed_quad(fp);
h->pkt_len -= 28;
} else { /* extended short */
h->pkt_len = (opcode & 3) * 0x10000UL + get_unsigned_pair(fp);
h->chrcode = get_unsigned_byte(fp);
h->wd = get_unsigned_triple(fp);
h->dx = get_unsigned_pair(fp) << 16;
h->dy = 0x0L;
h->bm_wd = get_unsigned_pair(fp);
h->bm_ht = get_unsigned_pair(fp);
h->bm_hoff = get_signed_pair(fp);
h->bm_voff = get_signed_pair(fp);
h->pkt_len -= 13;
}
h->dyn_f = opcode / 16;
h->run_color = (opcode & 8) ? 1 : 0;
if (h->chrcode > 0xff)
{
WARN("Unable to handle long characters in PK files: code=0x%04x", h->chrcode);
return -1;
}
return 0;
}
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;
}
}
}
signed short get_signed_pair (FILE *file)
{
signed short pair = get_signed_byte(file);
pair = (pair << 8) | get_unsigned_byte(file);
return pair;
}
void skip_bytes (unsigned int n, FILE *file)
{
while (n-- > 0)
get_unsigned_byte(file);
}
unsigned short get_unsigned_pair (FILE *file)
{
unsigned short pair = get_unsigned_byte(file);
pair = pair*0x100u + get_unsigned_byte(file);
return pair;
}