func Decode(s []byte, to *CharMapperT) (r []byte) {
util.Logf("Decode %02x\n", s)
r = make([]byte, len(s)*6)
p := 0
for k := 0; k < len(s); {
l := to.Ranges.Code(int(s[k]))
a := ps.StrInt(s[k : k+l])
k += l
p += utf8.EncodeRune(r[p:len(r)], rune(to.Uni.Code(a)))
}
return r[0:p]
}
func (pd *PdfDrawerT) Interpret(rdr fancy.Reader) {
for {
t, _ := ps.Token(rdr)
if len(t) == 0 {
break
}
if f, ok := pd.Ops[string(t)]; ok {
util.Logf("%v %#v %s", string(t), *pd.ConfigD, pd.Stack.Dump())
f(pd)
} else {
pd.Stack.Push(t)
}
}
}
// xrefReadStream() reads the xref stream(s) of a PDF file. This is not recursive
// in favour of not to have to keep track of already used starting points
// for xrefs.
func xrefReadStream(f fancy.Reader, p int) (xr map[int]int, r [][2]int, trailer DictionaryT) {
s := _Bytes
xr = map[int]int{}
r = [][2]int{}
for ok := true; ok; {
f.Seek(int64(p), 0)
ps.Token(f) // skip "xref"
//for {
m := tuple(f, 2)
if string(m[1]) != "obj" {
util.Logf("unexpected %q\n", m)
return nil, nil, nil
}
s, _ = ps.Token(f)
dic := Dictionary(s)
if trailer == nil {
trailer = dic
}
s, ok = dic["/Prev"]
p = num(s)
s, _ = ps.Token(f)
if string(s) != "stream" {
util.Log("not a stream", s)
return nil, nil, nil
}
ps.SkipLE(f)
for k, v := range dic {
util.Logf("%s %s", k, v)
}
size := num(dic["/Size"])
index := []int{0, size}
if _, ok := dic["/Index"]; ok {
a := Array(dic["/Index"])
index[0] = num(a[0])
index[1] = num(a[1])
// can len(index) be != 2 ?
}
l := num(dic["/Length"])
xref := f.Slice(l)
w := Array(dic["/W"])
if len(w) != 3 {
util.Log("unexpected /W", w)
}
fl1 := num(w[0])
fl2 := num(w[1])
fl3 := num(w[2])
width := fl1 + fl2 + fl3
xref = decodeStream(dic, xref)
s, _ = ps.Token(f) // endstream
s, _ = ps.Token(f) // endobj
pos := index[0]
for i := 0; i < len(xref); i += width {
ent := xref[i : i+width]
f1 := bnum(ent[0:fl1])
f2 := bnum(ent[fl1 : fl1+fl2])
f3 := bnum(ent[fl1+fl2:])
switch f1 {
case 0:
// free object
util.Log("free", f2, f3)
// delete(r, f2)
case 1:
// regular object
util.Log("ref", pos, f3, f2)
xr[pos] = f2
case 2:
// compressed object
util.Log("cref", pos, f2, f3)
r = append(r, [2]int{f2, f3})
}
pos += 1
}
//}
}
return xr, r, trailer
}
func (t *TiffBuilder) WriteIFD(data []byte, next bool) {
util.Logf("offset: %08x\n", t.offset)
n := len(t.ifd)
t.offset += 6 + (12 * uint32(n))
t.Write(uint16(n))
padding := false
for _, e := range t.ifd {
if e.Tag == TAG_STRIP_OFFSETS || e.Type == IFD_RATIONAL {
e.ValueOffset = t.offset
if e.Tag == TAG_STRIP_OFFSETS {
util.Log("offset:", t.offset)
t.offset += uint32(len(data)) + 4
padding = (t.offset & 1) == 1
if padding {
t.offset += 1
}
} else {
util.Log("offset:", t.offset)
t.offset += 8 // 4 + 4
}
}
util.Logf("tag:%v type:%v count:%v value:%v\n", e.Tag, e.Type, e.Count, e.ValueOffset)
t.Write(e.Tag)
t.Write(e.Type)
t.Write(e.Count)
if e.Count != 1 {
t.Write(e.ValueOffset)
} else if e.Type == IFD_LONG {
t.Write(e.ValueOffset)
} else if e.Type == IFD_RATIONAL {
t.Write(e.ValueOffset)
} else if e.Type == IFD_SHORT {
t.Write(uint16(e.ValueOffset))
t.Write(uint16(0))
} else {
log.Fatal("unsupported type")
}
}
if next {
util.Log("next:", t.offset)
t.Write(uint32(t.offset))
} else {
util.Log("next:0")
t.Write(uint32(0))
}
util.Log("datalen:", len(data))
t.WriteBytes(data)
if padding {
t.WriteBytes([]byte{0})
util.Log("padding:", t.offset)
}
for _, e := range t.ifd {
if e.Type != IFD_RATIONAL {
continue
}
t.Write(e.Num)
t.Write(e.Den)
}
t.ifd = []IFDEntry{}
}
