def read_TLM(self):
self._new_marker("TLM", "Tile-part length")
if self.size < 4:
raise InvalidSizedMarker("TLM")
self.print_header("Index", str(ordb(self.buffer[self.pos + 2])))
stlm = ordb(self.buffer[self.pos + 3]) >> 4
st = stlm & 0x03
sp = (stlm >> 2) & 0x1
if st == 3:
raise InvalidMarkerField("TLM", "Stlm")
if st == 0:
if sp == 0:
if (self.size - 4) % 2 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 2
else:
if (self.size - 4) % 4 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 4
elif st == 1:
if sp == 0:
if (self.size - 4) % 3 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 3
else:
if (self.size - 4) % 5 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 5
else:
if sp == 0:
if (self.size - 4) % 4 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 4
else:
if (self.size - 4) % 6 != 0:
raise InvalidSizedMarker("TLM")
tileparts = (self.size - 4) / 6
self.pos += 4
ttlm = ""
for i in range(tileparts):
if st == 0:
ttlm = "in order"
if st == 1:
ttlm = str(ordb(self.buffer[self.pos + 0]))
self.pos += 1
elif st == 2:
ttlm = str(ordw(self.buffer[self.pos + 0:self.pos + 2]))
self.pos += 2
self.print_header("Tile index #%d" % i, ttlm)
if sp == 0:
length = ordw(self.buffer[self.pos + 0:self.pos + 2])
self.pos += 2
else:
length = ordl(self.buffer[self.pos + 0:self.pos + 4])
self.pos += 4
self.print_header("Length #%d" % i, str(length))
self._end_marker()
def read_CRG(self):
self._new_marker("CRG", "Component registration")
if self.size != self.csiz * 4 + 2:
raise InvalidSizedMarker("CRG")
self.pos += 2
for i in range(self.csiz):
x = ordw(self.buffer[self.pos + 0:self.pos + 2])
y = ordw(self.buffer[self.pos + 2:self.pos + 4])
self.print_header("Offset #%d" % i, "%dx%d" % (x, y))
self.pos += 4
self._end_marker()
def stream_parse(self, file, startpos):
self.pos = 0
self.datacount = 0
self.bytecount = 0
self.offset = startpos
self.load_buffer(file)
if ordw(self.buffer) != 0xff10:
raise RequiredMarkerMissing("SOI marker missing")
while len(self.buffer) >= 2:
marker_value = ordw(self.buffer[0:2])
if marker_value == 0xff11:
break
if marker_value == 0xff10:
self._new_marker("SOC", "Start of Codestream")
self._end_marker()
elif marker_value == 0xff12:
self.parse_PIH()
elif marker_value == 0xff13:
self.parse_CDT()
elif marker_value == 0xff14:
self.parse_WGT()
elif marker_value == 0xff15:
self.parse_COM()
elif marker_value == 0xff16:
self.parse_NLT()
elif marker_value == 0xff17:
self.parse_CWD()
elif marker_value == 0xff18:
self.parse_CTS()
elif marker_value == 0xff19:
self.parse_CRG()
elif marker_value == 0xff20:
self.parse_SLC()
self.parse_Slice(file)
elif marker_value == 0xff50:
self.parse_CAP()
else:
self._new_marker("???", "Unknown marker %04x" % marker_value)
if len(self.buffer) < self.buffer_print_limit:
print_hex(self.buffer)
self._end_marker()
self.load_buffer(file)
if len(self.buffer) >= 2:
self._new_marker("EOI", "End of image")
self._end_marker()
oh = self.bytecount - self.datacount
self.check_sublevel(self.bytecount)
self._print_indent("Size : %d bytes" % self.bytecount)
self._print_indent("Data Size : %d bytes" % self.datacount)
self._print_indent("Overhead : %d bytes (%d%%)" % (oh, 100 * oh / self.bytecount))
def parse_CRG(self):
self._new_marker("CRG", "Component Registration Marker")
self.pos = 4
c = 0
while self.pos < len(self.buffer):
xc = ordw(self.buffer[self.pos:self.pos + 2])
yc = ordw(self.buffer[self.pos + 2:self.pos + 4])
self._print_indent("Component %s position : (0x%04x,0x%04x) = (%3d%%,%3d%%)" % (
c, xc, yc, xc * 100 / 65536, yc * 100 / 65536))
self.pos = self.pos + 4
c += 1
self._end_marker()
def print_mluc(buf, indent):
count = ordl(buf[0:4])
recs = ordl(buf[4:8])
offs = 8
for i in range(count):
code = ordw(buf[offs:offs + 2])
cntr = ordw(buf[offs + 2:offs + 4])
lnth = ordl(buf[offs + 4:offs + 8])
disp = ordl(buf[offs + 8:offs + 12])
offs = offs + recs
print_indent(
"Entry %d for language %c%c, country %c%c :" %
(i, code >> 8, code & 0xff, cntr >> 8, cntr & 0xff), indent)
print_hex(buf[disp - 8:disp - 8 + lnth], indent + 2)
def print_clut(buf, ic, oc, indent):
of = 0
prod = 1
for i in range(ic):
gp = ordb(buf[of])
print_indent("Entries in channel %d : %d" % (i, gp), indent)
prod = prod * gp
of += 1
print_indent("Total number of entries: %d" % prod, indent)
prec = ordb(buf[16])
print_indent("Precision : %d" % prec, indent)
of = 20
v = 0
for j in range(prod):
entry = ""
for k in range(oc):
if prec == 1:
v = ordb(buf[of])
of += 1
elif prec == 2:
v = ordw(buf[of:of + 2])
of += 2
if entry == "":
entry = "%5d" % v
else:
entry = "%s, %5d" % (entry, v)
print_indent("Entry %4d : %s" % (j, entry), indent)
def read_RGN(self):
self._new_marker("RGN", "Region-of-interest")
# Print Crgn
if self.csiz <= 256:
cmp = ordb(self.buffer[self.pos + 2])
self.pos += 3
else:
cmp = ordw(self.buffer[self.pos + 2:self.pos + 4])
self.pos += 4
self.print_header("Component", str(cmp))
method = ordb(self.buffer[self.pos + 0])
if method == 0:
s = "implicit"
elif method == 1:
s = "rectangle"
elif method == 2:
s = "ellipse"
else:
s = str(method)
self.pos += 1
self.print_header("Style", s)
self.print_header("Implicit ROI Shift",
str(ordb(self.buffer[self.pos + 0])))
self.pos += 1
self._end_marker()
def parse_table(self):
marker = ordw(self.buffer[0:2])
if marker == 0xffc4:
self.parse_DHT()
elif marker == 0xffcc:
self.parse_DAC()
elif marker == 0xffdb:
self.parse_DQT()
elif marker == 0xffdd:
self.parse_DRI()
elif marker == 0xffdf:
self.parse_EXP()
elif marker == 0xffdc:
self.parse_DNL()
elif 0xffe0 <= marker <= 0xffef:
self.parse_APP(marker - 0xffe0)
elif marker == 0xfffe:
self.parse_COM()
elif marker == 0xffd8:
self._new_marker("SOI", "Start of image")
self._end_marker()
elif marker == 0xffd9:
self._new_marker("EOI", "End of image")
self._end_marker()
elif marker >= 0xff01:
self._new_marker("???", "Unknown marker %04x" % marker)
if len(self.buffer) < self.buffer_print_limit:
print_hex(self.buffer)
self._end_marker()
def read_QCC(self):
self._new_marker("QCC", "Quantization component")
if self.size < 4:
raise InvalidSizedMarker("QCC")
if self.csiz <= 256:
index = ordb(self.buffer[self.pos + 2])
self.pos += 3
else:
index = ordw(self.buffer[self.pos + 2:self.pos + 4])
self.pos += 4
self.print_header("Index", str(index))
sqcc = ordb(self.buffer[self.pos + 0])
self.pos += 1
if sqcc & 0x1f == 0:
s = "none"
elif sqcc & 0x1f == 1:
s = "scalar derived"
elif sqcc & 0x1f == 2:
s = "scalar expounded"
else:
s = "unknown"
self.print_header("Quantization Type", s)
self.print_header("Guard Bits", str(sqcc >> 5))
if self.csiz <= 256:
subbands = self.size - 4
else:
subbands = self.size - 5
if sqcc & 0x1f == 1 or sqcc & 0x1f == 2:
if subbands % 2 != 0:
raise InvalidSizedMarker("QCC")
subbands = int(subbands / 2)
for i in range(subbands):
mantissa = 1.0
if sqcc & 0x1f == 1 or sqcc & 0x1f == 2:
spqcd = ordw(self.buffer[self.pos + 0:self.pos + 2])
self.pos += 2
mantissa = 1.0 + ((spqcd & 0x7ff) / 2048.0)
self.print_header("Mantissa #%d" % i, str(spqcd & 0x7ff))
exponent = spqcd >> 11
else:
spqcd = ordb(self.buffer[self.pos + 0])
self.pos += 1
exponent = spqcd >> 3
self.print_header("Exponent #%d" % i, str(exponent))
self.print_header("Delta #%d" % i,
mantissa * pow(2.0, -exponent))
self._end_marker()
def load_marker(self, file, marker):
mrk = ordw(marker)
if 0xff10 <= mrk <= 0xff11:
self.buffer = marker
elif mrk == 0xff12 or mrk == 0xff13 or mrk == 0xff14 or mrk == 0xff15 or mrk == 0xff16 \
or mrk == 0xff17 or mrk == 0xff18 or mrk == 0xff19 or mrk == 0xff20 or mrk == 0xff50:
size = file.read(2)
ln = ordw(size)
if ln < 2:
raise InvalidSizedMarker("Marker too short")
self.buffer = marker + size + file.read(ln - 2)
if len(self.buffer) != ln + 2:
raise UnexpectedEOC()
else:
raise MisplacedData()
self.bytecount += len(self.buffer)
self.pos = 0
def parse_SLC(self):
self._new_marker("SLC", "Slice Header")
if len(self.buffer) != 2 + 4:
raise InvalidSizedMarker("Size of the SLC marker shall be 4 bytes")
self._print_indent("Slice index : %s" % ordw(self.buffer[4:6]))
self.check_profile()
self.check_level()
self._end_marker()
def read_SOP(self):
self._new_marker("SOP", "Start of packet")
if self.size != 4:
raise InvalidSizedMarker("SOP")
self.print_header("Sequence",
str(ordw(self.buffer[self.pos + 2:self.pos + 4])))
self._end_marker()
self.pos += self.size
def load_marker(self, file, marker):
mrk = ordw(marker[0:2])
if 0xffd0 <= mrk <= 0xffd9:
self.buffer = marker
elif mrk >= 0xffc0 or mrk in [
0xffb1, 0xffb2, 0xffb3, 0xffb9, 0xffba, 0xffbb
]:
size = file.read(2)
ln = ordw(size[0:2])
if ln < 2:
raise InvalidSizedMarker("Marker too short")
self.buffer = marker + size + file.read(ln - 2)
if len(self.buffer) != ln + 2:
raise UnexpectedEOC()
else:
raise MisplacedData()
self.bytecount += len(self.buffer)
self.pos = 0
def read_SOT(self):
self._new_marker("SOT", "Start of tile-part")
if len(self.buffer) - self.pos < 10:
raise InvalidSizedMarker("SOT")
size = ordw(self.buffer[self.pos + 0:self.pos + 2])
if size != 10:
raise InvalidSizedMarker("SOT")
self.print_header("Tile",
str(ordw(self.buffer[self.pos + 2:self.pos + 4])))
length = ordl(self.buffer[self.pos + 4:self.pos + 8])
self.print_header("Length", str(length))
self.print_header("Index", str(ordb(self.buffer[self.pos + 8])))
if ordb(self.buffer[self.pos + 9]) == 0:
s = "unknown"
else:
s = str(ordb(self.buffer[self.pos + 9]))
self.print_header("Tile-Parts", s)
self._end_marker()
self.pos += 10
def read_POC(self):
self._new_marker("POC", "Progression order change")
if self.size < 9:
raise InvalidSizedMarker("POC")
if self.csiz <= 256:
if (self.size - 2) % 7 != 0:
raise InvalidSizedMarker("POC")
num = (self.size - 2) / 7
else:
if (self.size - 2) % 9 != 0:
raise InvalidSizedMarker("POC")
num = (self.size - 2) / 9
self.pos += 2
for i in range(num):
self.print_header("Resolution Level Index #%d (Start)" % i,
str(ordb(self.buffer[self.pos])))
if self.csiz <= 256:
rspoc = ordb(self.buffer[self.pos + 1])
self.pos += 2
else:
rspoc = ordw(self.buffer[self.pos + 1:self.pos + 3])
self.pos += 3
self.print_header("Component Index #%d (Start)" % i, str(rspoc))
lyepoc = ordw(self.buffer[self.pos + 0:self.pos + 2])
self.print_header("Layer Index #%d (End)" % i, str(lyepoc))
self.print_header("Resolution Level Index #%d (End)" % i,
str(ordb(self.buffer[self.pos + 2])))
if self.csiz <= 256:
cepoc = ordb(self.buffer[self.pos + 3])
if cepoc == 0:
cepoc = 256
self.pos += 4
else:
cepoc = ordw(self.buffer[self.pos + 3:self.pos + 5])
if cepoc == 0:
cepoc = 16384
self.pos += 5
self.print_header("Component Index #%d (End)" % i, str(cepoc))
po = self.progression_order(ordb(self.buffer[self.pos]))
self.print_header("Progression Order #%d" % i, po)
self.pos += 1
self._end_marker()
def print_lut16(buf, indent):
print_lutheader(buf, indent)
ic = ordb(buf[0])
oc = ordb(buf[1])
g = ordb(buf[2])
n = ordw(buf[40:42])
m = ordw(buf[42:44])
print_indent("Input entries : %d" % ordw(buf[40:42]), indent)
print_indent("Output entries : %d" % ordw(buf[42:44]), indent)
of = 44
for i in range(ic):
print_indent("Input table %d :" % i, indent)
print_hex(buf[of:of + 2 * n], indent + 1)
of += 2 * n
print_indent("CLUT table %d :" % ic, indent)
print_hex(buf[of:of + 2 * pow(g, ic) * oc], indent + 1)
of += 2 * pow(g, ic) * oc
for i in range(oc):
print_indent("Output table %d :" % i, indent)
print_hex(buf[of:of + 2 * m], indent + 1)
of += 2 * m
def print_curve(buffer, indent):
count = ordl(buffer[0:4])
if count == 0:
print_indent("Identity mapping", indent)
elif count == 1:
gamma = ordw(buffer[4:6])
print_indent(
"Gamma mapping, gamma : 0x%04x = %g" %
(gamma, gamma * 1.0 / 256.0), indent)
else:
off = 4
for i in range(count):
value = ordw(buffer[off:off + 2])
if i % 4 == 0:
if i != 0:
print("")
for j in range(indent):
print(" ", end=' ')
print("0x%04x = %g " % (value, value * 1.0 / 65535), end=' ')
off += 2
print("")
def print_datetime(buffer, indent):
print_indent("Year : %d " % ordw(buffer[0:2]), indent)
print_indent("Month : %d " % ordw(buffer[2:4]), indent)
print_indent("Day : %d " % ordw(buffer[4:6]), indent)
print_indent("Hours : %d " % ordw(buffer[6:8]), indent)
print_indent("Minutes: %d " % ordw(buffer[8:10]), indent)
print_indent("Seconds: %d " % ordw(buffer[10:12]), indent)
def read_CAP(self):
self._new_marker("CAP", "Extended Capabilities Marker")
pcap = ordl(self.buffer[self.pos + 2:self.pos + 6])
offs = self.pos + 6
for i in range(32):
if pcap & (1 << (32 - i)):
if offs >= self.pos + self.size:
raise InvalidSizedMarker("CAP")
self.print_header("Extended capabilities for part %d" % i,
"0x%x" % (ordw(self.buffer[offs:offs + 2])))
offs += 2
self._end_marker()
self.pos += self.size
def print_para(buf, indent):
curv = ordw(buf[0:2])
if curv == 0:
print_indent("Gamma mapping", indent)
gamma = s15d(ordl(buf[4:8]))
print_indent("Gamma : %g" % gamma, indent)
elif curv == 1:
print_indent("CIE 122-1966", indent)
gamma = s15d(ordl(buf[4:8]))
a = s15d(ordl(buf[8:12]))
b = s15d(ordl(buf[12:16]))
print_indent("Gamma : %g" % gamma, indent)
print_indent("A : %g" % a, indent)
print_indent("B : %g" % b, indent)
elif curv == 2:
print_indent("IEC 61996-3", indent)
gamma = s15d(ordl(buf[4:8]))
a = s15d(ordl(buf[8:12]))
b = s15d(ordl(buf[12:16]))
c = s15d(ordl(buf[16:20]))
print_indent("Gamma : %g" % gamma, indent)
print_indent("A : %g" % a, indent)
print_indent("B : %g" % b, indent)
print_indent("C : %g" % c, indent)
elif curv == 3:
gamma = s15d(ordl(buf[4:8]))
a = s15d(ordl(buf[8:12]))
b = s15d(ordl(buf[12:16]))
c = s15d(ordl(buf[16:20]))
d = s15d(ordl(buf[20:24]))
print_indent("IEC 61966-2.1 (sRGB)", indent)
print_indent("Gamma : %g" % gamma, indent)
print_indent("A : %g" % a, indent)
print_indent("B : %g" % b, indent)
print_indent("C : %g" % c, indent)
print_indent("D : %g" % d, indent)
elif curv == 4:
print_indent("Affine Gamma with Toe", indent)
gamma = s15d(ordl(buf[4:8]))
a = s15d(ordl(buf[8:12]))
b = s15d(ordl(buf[12:16]))
c = s15d(ordl(buf[16:20]))
d = s15d(ordl(buf[20:24]))
e = s15d(ordl(buf[24:28]))
print_indent("Gamma : %g" % gamma, indent)
print_indent("A : %g" % a, indent)
print_indent("B : %g" % b, indent)
print_indent("C : %g" % c, indent)
print_indent("D : %g" % d, indent)
print_indent("E : %g" % e, indent)
def load_buffer(self, file):
self._markerpos = self.offset
marker = file.read(2)
while len(marker) == 2 and ordw(marker) == 0xffff:
self.offset += 1
self._markerpos += 1
marker = chr(0xff) + file.read(1)
if len(marker) == 0:
self.buffer = []
else:
if len(marker) < 2:
raise UnexpectedEOC()
self.load_marker(file, marker)
self.offset += len(self.buffer)
def __init__(self, buf, offset):
self.offset = offset
self.en = ordw(buf[6:8])
self.seq = ordl(buf[8:12])
self.lbox = ordl(buf[12:16])
if self.lbox != 1 and self.lbox < 8:
raise InvalidBoxSize()
self.type = buf[16:20]
if self.lbox == 1:
self.lbox = ordq(buf[20:28])
self.buffer = buf[28:]
self.body = self.lbox - 4 - 4 - 8
else:
self.buffer = buf[20:]
self.body = self.lbox - 4 - 4
def parse_COM(self):
self._new_marker("COM", "Extensions Marker")
tcom = ordw(self.buffer[4:6])
data = self.buffer[6:]
if tcom == 0:
self._print_indent("Vendor : %s" % data)
elif tcom == 1:
self._print_indent("Copyright : %s" % data)
elif tcom >= 0x8000:
self._print_indent("Vendor 0x%4x information :")
print_hex(data)
else:
self._print_indent("Invalid 0x%4x data :")
print_hex(data)
self._end_marker()
def parse_frame(self, file, process):
if ordw(self.buffer[0:2]) == 0xffde:
self._new_marker("DHP", "Define hierarchical process")
else:
self._new_marker("SOF", "Start of frame, type: %s" % process)
prec = ordb(self.buffer[4])
self._print_indent("Frame bit precision : %d" % prec)
hei = ordw(self.buffer[5:7])
wid = ordw(self.buffer[7:9])
self._print_indent("Frame width : %d" % wid)
self._print_indent("Frame height : %d" % hei)
dep = ordb(self.buffer[9])
self._print_indent("Depth : %d" % dep)
self.pos = 10
for i in range(dep):
ci = ordb(self.buffer[self.pos])
self._print_indent("Component Id : %d" % ci)
mcu = ordb(self.buffer[self.pos + 1])
self._print_indent("MCU Width : %d" % (mcu & 0x0f))
self._print_indent("MCU Height : %d" % (mcu >> 4))
qnt = ordb(self.buffer[self.pos + 2])
self._print_indent("Quantization Table : %d" % qnt)
self.pos += 3
if ordw(self.buffer[0:2]) != 0xffde:
print("")
self.frametype = ordw(self.buffer[0:2])
self.load_buffer(file)
marker = ordw(self.buffer[0:2])
while marker == 0xffc4 or marker == 0xffcc or marker >= 0xffd0:
if marker == 0xffda:
marker = self.parse_scan(file)
if marker == 0xffdc:
self.load_buffer(file)
self.parse_DNL()
marker = ordw(file.read(2))
file.seek(self.offset)
if marker == 0xffdf or marker == 0xffd9:
break
else:
self.parse_table()
self.load_buffer(file)
marker = ordw(self.buffer[0:2])
self._end_marker()
def read_QCD(self):
self._new_marker("QCD", "Quantization default")
if self.size < 4:
raise InvalidSizedMarker("QCD")
sqcd = ordb(self.buffer[self.pos + 2])
if sqcd & 0x1f == 0:
s = "none"
elif sqcd & 0x1f == 1:
s = "scalar derived"
elif sqcd & 0x1f == 2:
s = "scalar expounded"
elif sqcd & 0x1f == 3:
s = "variable deadzone scalar derived"
elif sqcd & 0x1f == 4:
s = "variable deadzone scalar expounded"
elif sqcd & 0x1f == 5:
s = "variable deadzone scalar expounded"
elif sqcd & 0x1f == 9:
s = "trellis quantization derived"
elif sqcd & 0x1f == 10:
s = "trellis quantization expounded"
else:
s = "unknown"
self.print_header("Quantization Type", s)
self.print_header("Guard Bits", str(sqcd >> 5))
subbands = self.size - 3
if sqcd & 0x1f == 1 or sqcd & 0x1f == 2:
if subbands % 2 != 0:
raise InvalidSizedMarker("QCD")
subbands = int(subbands / 2)
for i in range(subbands):
mantissa = 1.0
if sqcd & 0x1f == 1 or sqcd & 0x1f == 2:
spqcd = ordw(self.buffer[self.pos + i * 2 + 3:self.pos +
i * 2 + 5])
mantissa = 1.0 + ((spqcd & 0x7ff) / 2048.0)
self.print_header("Mantissa #%d" % i, str(spqcd & 0x7ff))
exponent = spqcd >> 11
else:
spqcd = ordb(self.buffer[self.pos + i + 3])
exponent = spqcd >> 3
self.print_header("Exponent #%d" % i, str(exponent))
self.print_header("Delta #%d" % i,
str(mantissa * pow(2.0, -exponent)))
self._end_marker()
self.pos += self.size
def load_marker(self, file, marker):
mrk = ordw(marker[0:2])
if 0xff30 <= mrk <= 0xff3f:
self.buffer = marker
elif mrk in [0xff93, 0xff4f, 0xffd9, 0xff92]:
self.buffer = marker
elif 0xff4f <= mrk <= 0xff93:
size = file.read(2)
ln = ((ordb(size[0]) << 8) + (ordb(size[1]) << 0))
if ln < 2:
raise InvalidSizedMarker("Marker too short")
self.buffer = marker + size + file.read(ln - 2)
if len(self.buffer) != ln + 2:
raise UnexpectedEOC()
else:
raise MisplacedData()
self.bytecount += len(self.buffer)
self.pos = 0
def read_CPF(self):
self._new_marker("CPF", "Corresponding Profile Marker")
offs = self.pos + 2
pcan = self.size - 2
if pcan < 0 or pcan & 1:
raise InvalidSizedMarker("CPF")
cpfnum = -1
bpos = 1
for i in range(0, pcan / 2):
cpfnum += ordw(self.buffer[offs:offs + 2]) * bpos
bpos *= 65536
offs += 2
if cpfnum == 4095:
self.print_header("Corresponding Profile",
"to be found in the PRF marker")
else:
self.print_header("Corresponding Profile", "0x%x" % cpfnum)
self._end_marker()
self.pos += self.size
def read_COM(self):
self._new_marker("COM", "Comment")
if self.size < 4:
raise InvalidSizedMarker("COM")
reg = ordw(self.buffer[self.pos + 2:self.pos + 4])
if reg == 0:
s = "binary"
elif reg == 1:
s = "ISO-8859-15"
else:
s = "unknown"
self.print_header("Registration", s)
if reg == 1:
self.print_header(
"Comment",
self.buffer[self.pos + 4:self.pos + self.size].decode('utf-8'))
else:
self.print_header("Comment", "...")
self._end_marker()
self.pos += self.size
def read_NSI(self):
self._new_marker("NSI", "Additional Dimension Image and Tile Size")
size = ordw(self.buffer[self.pos + 0:self.pos + 2])
if size < 20 or size > 16403:
raise InvalidSizedMarker("NSI")
ndim = ordb(self.buffer[self.pos + 2])
zsiz = ordl(self.buffer[self.pos + 3:self.pos + 7])
osiz = ordl(self.buffer[self.pos + 7:self.pos + 11])
tsiz = ordl(self.buffer[self.pos + 11:self.pos + 15])
tosz = ordl(self.buffer[self.pos + 15:self.pos + 19])
self.print_header("Dimensionality", "%d" % ndim)
self.print_header("Image Depth", "%d" % zsiz)
self.print_header("Image Depth Offset", "%d" % osiz)
self.print_header("Tile Depth", "%d" % tsiz)
self.print_header("Tile Depth Offset", "%d" % tosz)
for i in range(size - 19):
self.print_header("Z Sample Separation for component %d" % i,
"%d" % ordb(self.buffer[self.pos + 19 + i]))
self.pos += size
self._end_marker()
def parse_NLT(self):
self._new_marker("NLT", "Nonlinearity Marker")
tnlt = ordb(self.buffer[4])
if tnlt == 1:
self.nlt = "quadratic"
self._print_indent("NLT Type : quadratic")
if len(self.buffer) != 2 + 2 + 1 + 2:
raise InvalidSizedMarker("Size of the NLT marker shall be 5 bytes")
t1 = ordw(self.buffer[5:7])
self._print_indent("DC Offset : %s" % t1)
elif tnlt == 2:
self.nlt = "extended"
self._print_indent("NLT Type : extended")
if len(self.buffer) != 2 + 12:
raise InvalidSizedMarker("Size of NLT marker shall be 12 bytes")
t1 = ordl(self.buffer[5:9])
t2 = ordl(self.buffer[9:13])
e = ordb(self.buffer[13])
self._print_indent("Threshold t1 : %s" % t1)
self._print_indent("Threshold t2 : %s" % t2)
self._print_indent("Slope exponent : %s" % e)
self._end_marker()
