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()