kaitai: all formats compiled and included

19 files changed, 5257 insertions, 0 deletions

diff --git a/python/examples/kaitai/kaitai_struct_formats/media/__init__.py b/python/examples/kaitai/kaitai_struct_formats/media/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/__init__.py
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/avi.py b/python/examples/kaitai/kaitai_struct_formats/media/avi.py
new file mode 100644
index 00000000..bf34eb55
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/avi.py
@@ -0,0 +1,292 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Avi(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://msdn.microsoft.com/en-us/library/ms779636.aspx
+    """
+
+    class ChunkType(Enum):
+        idx1 = 829973609
+        junk = 1263424842
+        info = 1330007625
+        isft = 1413894985
+        list = 1414744396
+        strf = 1718776947
+        avih = 1751742049
+        strh = 1752331379
+        movi = 1769369453
+        hdrl = 1819436136
+        strl = 1819440243
+
+    class StreamType(Enum):
+        mids = 1935960429
+        vids = 1935960438
+        auds = 1935963489
+        txts = 1937012852
+
+    class HandlerType(Enum):
+        mp3 = 85
+        ac3 = 8192
+        dts = 8193
+        cvid = 1684633187
+        xvid = 1684633208
+    SEQ_FIELDS = ["magic1", "file_size", "magic2", "data"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic1']['start'] = self._io.pos()
+        self.magic1 = self._io.ensure_fixed_contents(b"\x52\x49\x46\x46")
+        self._debug['magic1']['end'] = self._io.pos()
+        self._debug['file_size']['start'] = self._io.pos()
+        self.file_size = self._io.read_u4le()
+        self._debug['file_size']['end'] = self._io.pos()
+        self._debug['magic2']['start'] = self._io.pos()
+        self.magic2 = self._io.ensure_fixed_contents(b"\x41\x56\x49\x20")
+        self._debug['magic2']['end'] = self._io.pos()
+        self._debug['data']['start'] = self._io.pos()
+        self._raw_data = self._io.read_bytes((self.file_size - 4))
+        io = KaitaiStream(BytesIO(self._raw_data))
+        self.data = self._root.Blocks(io, self, self._root)
+        self.data._read()
+        self._debug['data']['end'] = self._io.pos()
+
+    class ListBody(KaitaiStruct):
+        SEQ_FIELDS = ["list_type", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['list_type']['start'] = self._io.pos()
+            self.list_type = KaitaiStream.resolve_enum(self._root.ChunkType, self._io.read_u4le())
+            self._debug['list_type']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._root.Blocks(self._io, self, self._root)
+            self.data._read()
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class Rect(KaitaiStruct):
+        SEQ_FIELDS = ["left", "top", "right", "bottom"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['left']['start'] = self._io.pos()
+            self.left = self._io.read_s2le()
+            self._debug['left']['end'] = self._io.pos()
+            self._debug['top']['start'] = self._io.pos()
+            self.top = self._io.read_s2le()
+            self._debug['top']['end'] = self._io.pos()
+            self._debug['right']['start'] = self._io.pos()
+            self.right = self._io.read_s2le()
+            self._debug['right']['end'] = self._io.pos()
+            self._debug['bottom']['start'] = self._io.pos()
+            self.bottom = self._io.read_s2le()
+            self._debug['bottom']['end'] = self._io.pos()
+
+
+    class Blocks(KaitaiStruct):
+        SEQ_FIELDS = ["entries"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['entries']['start'] = self._io.pos()
+            self.entries = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['entries']:
+                    self._debug['entries']['arr'] = []
+                self._debug['entries']['arr'].append({'start': self._io.pos()})
+                _t_entries = self._root.Block(self._io, self, self._root)
+                _t_entries._read()
+                self.entries.append(_t_entries)
+                self._debug['entries']['arr'][len(self.entries) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['entries']['end'] = self._io.pos()
+
+
+    class AvihBody(KaitaiStruct):
+        """Main header of an AVI file, defined as AVIMAINHEADER structure.
+        
+        .. seealso::
+           Source - https://msdn.microsoft.com/en-us/library/ms779632.aspx
+        """
+        SEQ_FIELDS = ["micro_sec_per_frame", "max_bytes_per_sec", "padding_granularity", "flags", "total_frames", "initial_frames", "streams", "suggested_buffer_size", "width", "height", "reserved"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['micro_sec_per_frame']['start'] = self._io.pos()
+            self.micro_sec_per_frame = self._io.read_u4le()
+            self._debug['micro_sec_per_frame']['end'] = self._io.pos()
+            self._debug['max_bytes_per_sec']['start'] = self._io.pos()
+            self.max_bytes_per_sec = self._io.read_u4le()
+            self._debug['max_bytes_per_sec']['end'] = self._io.pos()
+            self._debug['padding_granularity']['start'] = self._io.pos()
+            self.padding_granularity = self._io.read_u4le()
+            self._debug['padding_granularity']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u4le()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['total_frames']['start'] = self._io.pos()
+            self.total_frames = self._io.read_u4le()
+            self._debug['total_frames']['end'] = self._io.pos()
+            self._debug['initial_frames']['start'] = self._io.pos()
+            self.initial_frames = self._io.read_u4le()
+            self._debug['initial_frames']['end'] = self._io.pos()
+            self._debug['streams']['start'] = self._io.pos()
+            self.streams = self._io.read_u4le()
+            self._debug['streams']['end'] = self._io.pos()
+            self._debug['suggested_buffer_size']['start'] = self._io.pos()
+            self.suggested_buffer_size = self._io.read_u4le()
+            self._debug['suggested_buffer_size']['end'] = self._io.pos()
+            self._debug['width']['start'] = self._io.pos()
+            self.width = self._io.read_u4le()
+            self._debug['width']['end'] = self._io.pos()
+            self._debug['height']['start'] = self._io.pos()
+            self.height = self._io.read_u4le()
+            self._debug['height']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(16)
+            self._debug['reserved']['end'] = self._io.pos()
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["four_cc", "block_size", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['four_cc']['start'] = self._io.pos()
+            self.four_cc = KaitaiStream.resolve_enum(self._root.ChunkType, self._io.read_u4le())
+            self._debug['four_cc']['end'] = self._io.pos()
+            self._debug['block_size']['start'] = self._io.pos()
+            self.block_size = self._io.read_u4le()
+            self._debug['block_size']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            _on = self.four_cc
+            if _on == self._root.ChunkType.list:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.ListBody(io, self, self._root)
+                self.data._read()
+            elif _on == self._root.ChunkType.avih:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.AvihBody(io, self, self._root)
+                self.data._read()
+            elif _on == self._root.ChunkType.strh:
+                self._raw_data = self._io.read_bytes(self.block_size)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.StrhBody(io, self, self._root)
+                self.data._read()
+            else:
+                self.data = self._io.read_bytes(self.block_size)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class StrhBody(KaitaiStruct):
+        """Stream header (one header per stream), defined as AVISTREAMHEADER structure.
+        
+        .. seealso::
+           Source - https://msdn.microsoft.com/en-us/library/ms779638.aspx
+        """
+        SEQ_FIELDS = ["fcc_type", "fcc_handler", "flags", "priority", "language", "initial_frames", "scale", "rate", "start", "length", "suggested_buffer_size", "quality", "sample_size", "frame"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['fcc_type']['start'] = self._io.pos()
+            self.fcc_type = KaitaiStream.resolve_enum(self._root.StreamType, self._io.read_u4le())
+            self._debug['fcc_type']['end'] = self._io.pos()
+            self._debug['fcc_handler']['start'] = self._io.pos()
+            self.fcc_handler = KaitaiStream.resolve_enum(self._root.HandlerType, self._io.read_u4le())
+            self._debug['fcc_handler']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u4le()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['priority']['start'] = self._io.pos()
+            self.priority = self._io.read_u2le()
+            self._debug['priority']['end'] = self._io.pos()
+            self._debug['language']['start'] = self._io.pos()
+            self.language = self._io.read_u2le()
+            self._debug['language']['end'] = self._io.pos()
+            self._debug['initial_frames']['start'] = self._io.pos()
+            self.initial_frames = self._io.read_u4le()
+            self._debug['initial_frames']['end'] = self._io.pos()
+            self._debug['scale']['start'] = self._io.pos()
+            self.scale = self._io.read_u4le()
+            self._debug['scale']['end'] = self._io.pos()
+            self._debug['rate']['start'] = self._io.pos()
+            self.rate = self._io.read_u4le()
+            self._debug['rate']['end'] = self._io.pos()
+            self._debug['start']['start'] = self._io.pos()
+            self.start = self._io.read_u4le()
+            self._debug['start']['end'] = self._io.pos()
+            self._debug['length']['start'] = self._io.pos()
+            self.length = self._io.read_u4le()
+            self._debug['length']['end'] = self._io.pos()
+            self._debug['suggested_buffer_size']['start'] = self._io.pos()
+            self.suggested_buffer_size = self._io.read_u4le()
+            self._debug['suggested_buffer_size']['end'] = self._io.pos()
+            self._debug['quality']['start'] = self._io.pos()
+            self.quality = self._io.read_u4le()
+            self._debug['quality']['end'] = self._io.pos()
+            self._debug['sample_size']['start'] = self._io.pos()
+            self.sample_size = self._io.read_u4le()
+            self._debug['sample_size']['end'] = self._io.pos()
+            self._debug['frame']['start'] = self._io.pos()
+            self.frame = self._root.Rect(self._io, self, self._root)
+            self.frame._read()
+            self._debug['frame']['end'] = self._io.pos()
+
+
+    class StrfBody(KaitaiStruct):
+        """Stream format description."""
+        SEQ_FIELDS = []
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            pass
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/blender_blend.py b/python/examples/kaitai/kaitai_struct_formats/media/blender_blend.py
new file mode 100644
index 00000000..bda24a08
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/blender_blend.py
@@ -0,0 +1,322 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class BlenderBlend(KaitaiStruct):
+    """Blender is an open source suite for 3D modelling, sculpting,
+    animation, compositing, rendering, preparation of assets for its own
+    game engine and exporting to others, etc. `.blend` is its own binary
+    format that saves whole state of suite: current scene, animations,
+    all software settings, extensions, etc.
+    
+    Internally, .blend format is a hybrid semi-self-descriptive
+    format. On top level, it contains a simple header and a sequence of
+    file blocks, which more or less follow typical [TLV
+    pattern](https://en.wikipedia.org/wiki/Type-length-value). Pre-last
+    block would be a structure with code `DNA1`, which is a essentially
+    a machine-readable schema of all other structures used in this file.
+    """
+
+    class PtrSize(Enum):
+        bits_64 = 45
+        bits_32 = 95
+
+    class Endian(Enum):
+        be = 86
+        le = 118
+    SEQ_FIELDS = ["hdr", "blocks"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['hdr']['start'] = self._io.pos()
+        self.hdr = self._root.Header(self._io, self, self._root)
+        self.hdr._read()
+        self._debug['hdr']['end'] = self._io.pos()
+        self._debug['blocks']['start'] = self._io.pos()
+        self.blocks = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['blocks']:
+                self._debug['blocks']['arr'] = []
+            self._debug['blocks']['arr'].append({'start': self._io.pos()})
+            _t_blocks = self._root.FileBlock(self._io, self, self._root)
+            _t_blocks._read()
+            self.blocks.append(_t_blocks)
+            self._debug['blocks']['arr'][len(self.blocks) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['blocks']['end'] = self._io.pos()
+
+    class DnaStruct(KaitaiStruct):
+        """DNA struct contains a `type` (type name), which is specified as
+        an index in types table, and sequence of fields.
+        """
+        SEQ_FIELDS = ["idx_type", "num_fields", "fields"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['idx_type']['start'] = self._io.pos()
+            self.idx_type = self._io.read_u2le()
+            self._debug['idx_type']['end'] = self._io.pos()
+            self._debug['num_fields']['start'] = self._io.pos()
+            self.num_fields = self._io.read_u2le()
+            self._debug['num_fields']['end'] = self._io.pos()
+            self._debug['fields']['start'] = self._io.pos()
+            self.fields = [None] * (self.num_fields)
+            for i in range(self.num_fields):
+                if not 'arr' in self._debug['fields']:
+                    self._debug['fields']['arr'] = []
+                self._debug['fields']['arr'].append({'start': self._io.pos()})
+                _t_fields = self._root.DnaField(self._io, self, self._root)
+                _t_fields._read()
+                self.fields[i] = _t_fields
+                self._debug['fields']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['fields']['end'] = self._io.pos()
+
+        @property
+        def type(self):
+            if hasattr(self, '_m_type'):
+                return self._m_type if hasattr(self, '_m_type') else None
+
+            self._m_type = self._parent.types[self.idx_type]
+            return self._m_type if hasattr(self, '_m_type') else None
+
+
+    class FileBlock(KaitaiStruct):
+        SEQ_FIELDS = ["code", "len_body", "mem_addr", "sdna_index", "count", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['code']['start'] = self._io.pos()
+            self.code = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['code']['end'] = self._io.pos()
+            self._debug['len_body']['start'] = self._io.pos()
+            self.len_body = self._io.read_u4le()
+            self._debug['len_body']['end'] = self._io.pos()
+            self._debug['mem_addr']['start'] = self._io.pos()
+            self.mem_addr = self._io.read_bytes(self._root.hdr.psize)
+            self._debug['mem_addr']['end'] = self._io.pos()
+            self._debug['sdna_index']['start'] = self._io.pos()
+            self.sdna_index = self._io.read_u4le()
+            self._debug['sdna_index']['end'] = self._io.pos()
+            self._debug['count']['start'] = self._io.pos()
+            self.count = self._io.read_u4le()
+            self._debug['count']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            _on = self.code
+            if _on == u"DNA1":
+                self._raw_body = self._io.read_bytes(self.len_body)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.Dna1Body(io, self, self._root)
+                self.body._read()
+            else:
+                self.body = self._io.read_bytes(self.len_body)
+            self._debug['body']['end'] = self._io.pos()
+
+        @property
+        def sdna_struct(self):
+            if hasattr(self, '_m_sdna_struct'):
+                return self._m_sdna_struct if hasattr(self, '_m_sdna_struct') else None
+
+            if self.sdna_index != 0:
+                self._m_sdna_struct = self._root.sdna_structs[self.sdna_index]
+
+            return self._m_sdna_struct if hasattr(self, '_m_sdna_struct') else None
+
+
+    class Dna1Body(KaitaiStruct):
+        """DNA1, also known as "Structure DNA", is a special block in
+        .blend file, which contains machine-readable specifications of
+        all other structures used in this .blend file.
+        
+        Effectively, this block contains:
+        
+        * a sequence of "names" (strings which represent field names)
+        * a sequence of "types" (strings which represent type name)
+        * a sequence of "type lengths"
+        * a sequence of "structs" (which describe contents of every
+          structure, referring to types and names by index)
+        
+        .. seealso::
+           Source - https://en.blender.org/index.php/Dev:Source/Architecture/File_Format#Structure_DNA
+        """
+        SEQ_FIELDS = ["id", "name_magic", "num_names", "names", "padding_1", "type_magic", "num_types", "types", "padding_2", "tlen_magic", "lengths", "padding_3", "strc_magic", "num_structs", "structs"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = self._io.ensure_fixed_contents(b"\x53\x44\x4E\x41")
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['name_magic']['start'] = self._io.pos()
+            self.name_magic = self._io.ensure_fixed_contents(b"\x4E\x41\x4D\x45")
+            self._debug['name_magic']['end'] = self._io.pos()
+            self._debug['num_names']['start'] = self._io.pos()
+            self.num_names = self._io.read_u4le()
+            self._debug['num_names']['end'] = self._io.pos()
+            self._debug['names']['start'] = self._io.pos()
+            self.names = [None] * (self.num_names)
+            for i in range(self.num_names):
+                if not 'arr' in self._debug['names']:
+                    self._debug['names']['arr'] = []
+                self._debug['names']['arr'].append({'start': self._io.pos()})
+                self.names[i] = (self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
+                self._debug['names']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['names']['end'] = self._io.pos()
+            self._debug['padding_1']['start'] = self._io.pos()
+            self.padding_1 = self._io.read_bytes(((4 - self._io.pos()) % 4))
+            self._debug['padding_1']['end'] = self._io.pos()
+            self._debug['type_magic']['start'] = self._io.pos()
+            self.type_magic = self._io.ensure_fixed_contents(b"\x54\x59\x50\x45")
+            self._debug['type_magic']['end'] = self._io.pos()
+            self._debug['num_types']['start'] = self._io.pos()
+            self.num_types = self._io.read_u4le()
+            self._debug['num_types']['end'] = self._io.pos()
+            self._debug['types']['start'] = self._io.pos()
+            self.types = [None] * (self.num_types)
+            for i in range(self.num_types):
+                if not 'arr' in self._debug['types']:
+                    self._debug['types']['arr'] = []
+                self._debug['types']['arr'].append({'start': self._io.pos()})
+                self.types[i] = (self._io.read_bytes_term(0, False, True, True)).decode(u"UTF-8")
+                self._debug['types']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['types']['end'] = self._io.pos()
+            self._debug['padding_2']['start'] = self._io.pos()
+            self.padding_2 = self._io.read_bytes(((4 - self._io.pos()) % 4))
+            self._debug['padding_2']['end'] = self._io.pos()
+            self._debug['tlen_magic']['start'] = self._io.pos()
+            self.tlen_magic = self._io.ensure_fixed_contents(b"\x54\x4C\x45\x4E")
+            self._debug['tlen_magic']['end'] = self._io.pos()
+            self._debug['lengths']['start'] = self._io.pos()
+            self.lengths = [None] * (self.num_types)
+            for i in range(self.num_types):
+                if not 'arr' in self._debug['lengths']:
+                    self._debug['lengths']['arr'] = []
+                self._debug['lengths']['arr'].append({'start': self._io.pos()})
+                self.lengths[i] = self._io.read_u2le()
+                self._debug['lengths']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['lengths']['end'] = self._io.pos()
+            self._debug['padding_3']['start'] = self._io.pos()
+            self.padding_3 = self._io.read_bytes(((4 - self._io.pos()) % 4))
+            self._debug['padding_3']['end'] = self._io.pos()
+            self._debug['strc_magic']['start'] = self._io.pos()
+            self.strc_magic = self._io.ensure_fixed_contents(b"\x53\x54\x52\x43")
+            self._debug['strc_magic']['end'] = self._io.pos()
+            self._debug['num_structs']['start'] = self._io.pos()
+            self.num_structs = self._io.read_u4le()
+            self._debug['num_structs']['end'] = self._io.pos()
+            self._debug['structs']['start'] = self._io.pos()
+            self.structs = [None] * (self.num_structs)
+            for i in range(self.num_structs):
+                if not 'arr' in self._debug['structs']:
+                    self._debug['structs']['arr'] = []
+                self._debug['structs']['arr'].append({'start': self._io.pos()})
+                _t_structs = self._root.DnaStruct(self._io, self, self._root)
+                _t_structs._read()
+                self.structs[i] = _t_structs
+                self._debug['structs']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['structs']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "ptr_size_id", "endian", "version"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x42\x4C\x45\x4E\x44\x45\x52")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['ptr_size_id']['start'] = self._io.pos()
+            self.ptr_size_id = KaitaiStream.resolve_enum(self._root.PtrSize, self._io.read_u1())
+            self._debug['ptr_size_id']['end'] = self._io.pos()
+            self._debug['endian']['start'] = self._io.pos()
+            self.endian = KaitaiStream.resolve_enum(self._root.Endian, self._io.read_u1())
+            self._debug['endian']['end'] = self._io.pos()
+            self._debug['version']['start'] = self._io.pos()
+            self.version = (self._io.read_bytes(3)).decode(u"ASCII")
+            self._debug['version']['end'] = self._io.pos()
+
+        @property
+        def psize(self):
+            """Number of bytes that a pointer occupies."""
+            if hasattr(self, '_m_psize'):
+                return self._m_psize if hasattr(self, '_m_psize') else None
+
+            self._m_psize = (8 if self.ptr_size_id == self._root.PtrSize.bits_64 else 4)
+            return self._m_psize if hasattr(self, '_m_psize') else None
+
+
+    class DnaField(KaitaiStruct):
+        SEQ_FIELDS = ["idx_type", "idx_name"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['idx_type']['start'] = self._io.pos()
+            self.idx_type = self._io.read_u2le()
+            self._debug['idx_type']['end'] = self._io.pos()
+            self._debug['idx_name']['start'] = self._io.pos()
+            self.idx_name = self._io.read_u2le()
+            self._debug['idx_name']['end'] = self._io.pos()
+
+        @property
+        def type(self):
+            if hasattr(self, '_m_type'):
+                return self._m_type if hasattr(self, '_m_type') else None
+
+            self._m_type = self._parent._parent.types[self.idx_type]
+            return self._m_type if hasattr(self, '_m_type') else None
+
+        @property
+        def name(self):
+            if hasattr(self, '_m_name'):
+                return self._m_name if hasattr(self, '_m_name') else None
+
+            self._m_name = self._parent._parent.names[self.idx_name]
+            return self._m_name if hasattr(self, '_m_name') else None
+
+
+    @property
+    def sdna_structs(self):
+        if hasattr(self, '_m_sdna_structs'):
+            return self._m_sdna_structs if hasattr(self, '_m_sdna_structs') else None
+
+        self._m_sdna_structs = self.blocks[(len(self.blocks) - 2)].body.structs
+        return self._m_sdna_structs if hasattr(self, '_m_sdna_structs') else None
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/creative_voice_file.py b/python/examples/kaitai/kaitai_struct_formats/media/creative_voice_file.py
new file mode 100644
index 00000000..f49a26ce
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/creative_voice_file.py
@@ -0,0 +1,340 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class CreativeVoiceFile(KaitaiStruct):
+    """Creative Voice File is a container file format for digital audio
+    wave data. Initial revisions were able to support only unsigned
+    8-bit PCM and ADPCM data, later versions were revised to add support
+    for 16-bit PCM and a-law / u-law formats.
+    
+    This format was actively used in 1990s, around the advent of
+    Creative's sound cards (Sound Blaster family). It was a popular
+    choice for a digital sound container in lots of games and multimedia
+    software due to simplicity and availability of Creative's recording
+    / editing tools.
+    
+    .. seealso::
+       Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice
+    """
+
+    class BlockTypes(Enum):
+        terminator = 0
+        sound_data = 1
+        sound_data_cont = 2
+        silence = 3
+        marker = 4
+        text = 5
+        repeat_start = 6
+        repeat_end = 7
+        extra_info = 8
+        sound_data_new = 9
+
+    class Codecs(Enum):
+        pcm_8bit_unsigned = 0
+        adpcm_4bit = 1
+        adpcm_2_6bit = 2
+        adpcm_2_bit = 3
+        pcm_16bit_signed = 4
+        alaw = 6
+        ulaw = 7
+        adpcm_4_to_16bit = 512
+    SEQ_FIELDS = ["magic", "header_size", "version", "checksum", "blocks"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.ensure_fixed_contents(b"\x43\x72\x65\x61\x74\x69\x76\x65\x20\x56\x6F\x69\x63\x65\x20\x46\x69\x6C\x65\x1A")
+        self._debug['magic']['end'] = self._io.pos()
+        self._debug['header_size']['start'] = self._io.pos()
+        self.header_size = self._io.read_u2le()
+        self._debug['header_size']['end'] = self._io.pos()
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u2le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['checksum']['start'] = self._io.pos()
+        self.checksum = self._io.read_u2le()
+        self._debug['checksum']['end'] = self._io.pos()
+        self._debug['blocks']['start'] = self._io.pos()
+        self.blocks = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['blocks']:
+                self._debug['blocks']['arr'] = []
+            self._debug['blocks']['arr'].append({'start': self._io.pos()})
+            _t_blocks = self._root.Block(self._io, self, self._root)
+            _t_blocks._read()
+            self.blocks.append(_t_blocks)
+            self._debug['blocks']['arr'][len(self.blocks) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['blocks']['end'] = self._io.pos()
+
+    class BlockMarker(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x04:_Marker
+        """
+        SEQ_FIELDS = ["marker_id"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['marker_id']['start'] = self._io.pos()
+            self.marker_id = self._io.read_u2le()
+            self._debug['marker_id']['end'] = self._io.pos()
+
+
+    class BlockSilence(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x03:_Silence
+        """
+        SEQ_FIELDS = ["duration_samples", "freq_div"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['duration_samples']['start'] = self._io.pos()
+            self.duration_samples = self._io.read_u2le()
+            self._debug['duration_samples']['end'] = self._io.pos()
+            self._debug['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u1()
+            self._debug['freq_div']['end'] = self._io.pos()
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (1000000.0 / (256 - self.freq_div))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+        @property
+        def duration_sec(self):
+            """Duration of silence, in seconds."""
+            if hasattr(self, '_m_duration_sec'):
+                return self._m_duration_sec if hasattr(self, '_m_duration_sec') else None
+
+            self._m_duration_sec = (self.duration_samples / self.sample_rate)
+            return self._m_duration_sec if hasattr(self, '_m_duration_sec') else None
+
+
+    class BlockSoundDataNew(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x09:_Sound_data_.28New_format.29
+        """
+        SEQ_FIELDS = ["sample_rate", "bits_per_sample", "num_channels", "codec", "reserved", "wave"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['sample_rate']['start'] = self._io.pos()
+            self.sample_rate = self._io.read_u4le()
+            self._debug['sample_rate']['end'] = self._io.pos()
+            self._debug['bits_per_sample']['start'] = self._io.pos()
+            self.bits_per_sample = self._io.read_u1()
+            self._debug['bits_per_sample']['end'] = self._io.pos()
+            self._debug['num_channels']['start'] = self._io.pos()
+            self.num_channels = self._io.read_u1()
+            self._debug['num_channels']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(self._root.Codecs, self._io.read_u2le())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(4)
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['wave']['start'] = self._io.pos()
+            self.wave = self._io.read_bytes_full()
+            self._debug['wave']['end'] = self._io.pos()
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["block_type", "body_size1", "body_size2", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['block_type']['start'] = self._io.pos()
+            self.block_type = KaitaiStream.resolve_enum(self._root.BlockTypes, self._io.read_u1())
+            self._debug['block_type']['end'] = self._io.pos()
+            if self.block_type != self._root.BlockTypes.terminator:
+                self._debug['body_size1']['start'] = self._io.pos()
+                self.body_size1 = self._io.read_u2le()
+                self._debug['body_size1']['end'] = self._io.pos()
+
+            if self.block_type != self._root.BlockTypes.terminator:
+                self._debug['body_size2']['start'] = self._io.pos()
+                self.body_size2 = self._io.read_u1()
+                self._debug['body_size2']['end'] = self._io.pos()
+
+            if self.block_type != self._root.BlockTypes.terminator:
+                self._debug['body']['start'] = self._io.pos()
+                _on = self.block_type
+                if _on == self._root.BlockTypes.sound_data_new:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockSoundDataNew(io, self, self._root)
+                    self.body._read()
+                elif _on == self._root.BlockTypes.repeat_start:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockRepeatStart(io, self, self._root)
+                    self.body._read()
+                elif _on == self._root.BlockTypes.marker:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockMarker(io, self, self._root)
+                    self.body._read()
+                elif _on == self._root.BlockTypes.sound_data:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockSoundData(io, self, self._root)
+                    self.body._read()
+                elif _on == self._root.BlockTypes.extra_info:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockExtraInfo(io, self, self._root)
+                    self.body._read()
+                elif _on == self._root.BlockTypes.silence:
+                    self._raw_body = self._io.read_bytes(self.body_size)
+                    io = KaitaiStream(BytesIO(self._raw_body))
+                    self.body = self._root.BlockSilence(io, self, self._root)
+                    self.body._read()
+                else:
+                    self.body = self._io.read_bytes(self.body_size)
+                self._debug['body']['end'] = self._io.pos()
+
+
+        @property
+        def body_size(self):
+            """body_size is a 24-bit little-endian integer, so we're
+            emulating that by adding two standard-sized integers
+            (body_size1 and body_size2).
+            """
+            if hasattr(self, '_m_body_size'):
+                return self._m_body_size if hasattr(self, '_m_body_size') else None
+
+            if self.block_type != self._root.BlockTypes.terminator:
+                self._m_body_size = (self.body_size1 + (self.body_size2 << 16))
+
+            return self._m_body_size if hasattr(self, '_m_body_size') else None
+
+
+    class BlockRepeatStart(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x06:_Repeat_start
+        """
+        SEQ_FIELDS = ["repeat_count_1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['repeat_count_1']['start'] = self._io.pos()
+            self.repeat_count_1 = self._io.read_u2le()
+            self._debug['repeat_count_1']['end'] = self._io.pos()
+
+
+    class BlockSoundData(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x01:_Sound_data
+        """
+        SEQ_FIELDS = ["freq_div", "codec", "wave"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u1()
+            self._debug['freq_div']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(self._root.Codecs, self._io.read_u1())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['wave']['start'] = self._io.pos()
+            self.wave = self._io.read_bytes_full()
+            self._debug['wave']['end'] = self._io.pos()
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (1000000.0 / (256 - self.freq_div))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+
+    class BlockExtraInfo(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://wiki.multimedia.cx/index.php?title=Creative_Voice#Block_type_0x08:_Extra_info
+        """
+        SEQ_FIELDS = ["freq_div", "codec", "num_channels_1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['freq_div']['start'] = self._io.pos()
+            self.freq_div = self._io.read_u2le()
+            self._debug['freq_div']['end'] = self._io.pos()
+            self._debug['codec']['start'] = self._io.pos()
+            self.codec = KaitaiStream.resolve_enum(self._root.Codecs, self._io.read_u1())
+            self._debug['codec']['end'] = self._io.pos()
+            self._debug['num_channels_1']['start'] = self._io.pos()
+            self.num_channels_1 = self._io.read_u1()
+            self._debug['num_channels_1']['end'] = self._io.pos()
+
+        @property
+        def num_channels(self):
+            """Number of channels (1 = mono, 2 = stereo)."""
+            if hasattr(self, '_m_num_channels'):
+                return self._m_num_channels if hasattr(self, '_m_num_channels') else None
+
+            self._m_num_channels = (self.num_channels_1 + 1)
+            return self._m_num_channels if hasattr(self, '_m_num_channels') else None
+
+        @property
+        def sample_rate(self):
+            if hasattr(self, '_m_sample_rate'):
+                return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+            self._m_sample_rate = (256000000.0 / (self.num_channels * (65536 - self.freq_div)))
+            return self._m_sample_rate if hasattr(self, '_m_sample_rate') else None
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/genmidi_op2.py b/python/examples/kaitai/kaitai_struct_formats/media/genmidi_op2.py
new file mode 100644
index 00000000..b73c2f8c
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/genmidi_op2.py
@@ -0,0 +1,151 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class GenmidiOp2(KaitaiStruct):
+    """GENMIDI.OP2 is a sound bank file used by players based on DMX sound
+    library to play MIDI files with General MIDI instruments using OPL2
+    sound chip (which was commonly installed on popular AdLib and Sound
+    Blaster sound cards).
+    
+    Major users of DMX sound library include:
+    
+    * Original Doom game engine (and games based on it: Heretic, Hexen, Strife, Chex Quest)
+    * Raptor: Call of the Shadows 
+    
+    .. seealso::
+       http://doom.wikia.com/wiki/GENMIDI - http://www.fit.vutbr.cz/~arnost/muslib/op2_form.zip
+    """
+    SEQ_FIELDS = ["magic", "instruments", "instrument_names"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.ensure_fixed_contents(b"\x23\x4F\x50\x4C\x5F\x49\x49\x23")
+        self._debug['magic']['end'] = self._io.pos()
+        self._debug['instruments']['start'] = self._io.pos()
+        self.instruments = [None] * (175)
+        for i in range(175):
+            if not 'arr' in self._debug['instruments']:
+                self._debug['instruments']['arr'] = []
+            self._debug['instruments']['arr'].append({'start': self._io.pos()})
+            _t_instruments = self._root.InstrumentEntry(self._io, self, self._root)
+            _t_instruments._read()
+            self.instruments[i] = _t_instruments
+            self._debug['instruments']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['instruments']['end'] = self._io.pos()
+        self._debug['instrument_names']['start'] = self._io.pos()
+        self.instrument_names = [None] * (175)
+        for i in range(175):
+            if not 'arr' in self._debug['instrument_names']:
+                self._debug['instrument_names']['arr'] = []
+            self._debug['instrument_names']['arr'].append({'start': self._io.pos()})
+            self.instrument_names[i] = (KaitaiStream.bytes_terminate(KaitaiStream.bytes_strip_right(self._io.read_bytes(32), 0), 0, False)).decode(u"ASCII")
+            self._debug['instrument_names']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['instrument_names']['end'] = self._io.pos()
+
+    class InstrumentEntry(KaitaiStruct):
+        SEQ_FIELDS = ["flags", "finetune", "note", "instruments"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_u2le()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['finetune']['start'] = self._io.pos()
+            self.finetune = self._io.read_u1()
+            self._debug['finetune']['end'] = self._io.pos()
+            self._debug['note']['start'] = self._io.pos()
+            self.note = self._io.read_u1()
+            self._debug['note']['end'] = self._io.pos()
+            self._debug['instruments']['start'] = self._io.pos()
+            self.instruments = [None] * (2)
+            for i in range(2):
+                if not 'arr' in self._debug['instruments']:
+                    self._debug['instruments']['arr'] = []
+                self._debug['instruments']['arr'].append({'start': self._io.pos()})
+                _t_instruments = self._root.Instrument(self._io, self, self._root)
+                _t_instruments._read()
+                self.instruments[i] = _t_instruments
+                self._debug['instruments']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['instruments']['end'] = self._io.pos()
+
+
+    class Instrument(KaitaiStruct):
+        SEQ_FIELDS = ["op1", "feedback", "op2", "unused", "base_note"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['op1']['start'] = self._io.pos()
+            self.op1 = self._root.OpSettings(self._io, self, self._root)
+            self.op1._read()
+            self._debug['op1']['end'] = self._io.pos()
+            self._debug['feedback']['start'] = self._io.pos()
+            self.feedback = self._io.read_u1()
+            self._debug['feedback']['end'] = self._io.pos()
+            self._debug['op2']['start'] = self._io.pos()
+            self.op2 = self._root.OpSettings(self._io, self, self._root)
+            self.op2._read()
+            self._debug['op2']['end'] = self._io.pos()
+            self._debug['unused']['start'] = self._io.pos()
+            self.unused = self._io.read_u1()
+            self._debug['unused']['end'] = self._io.pos()
+            self._debug['base_note']['start'] = self._io.pos()
+            self.base_note = self._io.read_s2le()
+            self._debug['base_note']['end'] = self._io.pos()
+
+
+    class OpSettings(KaitaiStruct):
+        """OPL2 settings for one operator (carrier or modulator)
+        """
+        SEQ_FIELDS = ["trem_vibr", "att_dec", "sust_rel", "wave", "scale", "level"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['trem_vibr']['start'] = self._io.pos()
+            self.trem_vibr = self._io.read_u1()
+            self._debug['trem_vibr']['end'] = self._io.pos()
+            self._debug['att_dec']['start'] = self._io.pos()
+            self.att_dec = self._io.read_u1()
+            self._debug['att_dec']['end'] = self._io.pos()
+            self._debug['sust_rel']['start'] = self._io.pos()
+            self.sust_rel = self._io.read_u1()
+            self._debug['sust_rel']['end'] = self._io.pos()
+            self._debug['wave']['start'] = self._io.pos()
+            self.wave = self._io.read_u1()
+            self._debug['wave']['end'] = self._io.pos()
+            self._debug['scale']['start'] = self._io.pos()
+            self.scale = self._io.read_u1()
+            self._debug['scale']['end'] = self._io.pos()
+            self._debug['level']['start'] = self._io.pos()
+            self.level = self._io.read_u1()
+            self._debug['level']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/id3v1_1.py b/python/examples/kaitai/kaitai_struct_formats/media/id3v1_1.py
new file mode 100644
index 00000000..37a71459
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/id3v1_1.py
@@ -0,0 +1,218 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Id3v11(KaitaiStruct):
+    """ID3v1.1 tag is a method to store simple metadata in .mp3 files. The
+    tag is appended to the end of file and spans exactly 128 bytes.
+    
+    This type is supposed to be used on full .mp3 files, seeking to
+    proper position automatically. If you're interesting in parsing only
+    the tag itself, please use `id3v1_1::id3_v1_1_tag` subtype.
+    
+    .. seealso::
+       Source - http://id3.org/ID3v1
+    """
+    SEQ_FIELDS = []
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        pass
+
+    class Id3V11Tag(KaitaiStruct):
+        """ID3v1.1 tag itself, a fixed size 128 byte structure. Contains
+        several metadata fields as fixed-size strings.
+        
+        Note that string encoding is not specified by standard, so real
+        encoding used would vary a lot from one implementation to
+        another. Most Windows-based applications tend to use "ANSI"
+        (i.e. locale-dependent encoding, usually one byte per
+        character). Some embedded applications allow selection of
+        charset.
+        """
+
+        class GenreEnum(Enum):
+            blues = 0
+            classic_rock = 1
+            country = 2
+            dance = 3
+            disco = 4
+            funk = 5
+            grunge = 6
+            hip_hop = 7
+            jazz = 8
+            metal = 9
+            new_age = 10
+            oldies = 11
+            other = 12
+            pop = 13
+            rnb = 14
+            rap = 15
+            reggae = 16
+            rock = 17
+            techno = 18
+            industrial = 19
+            alternative = 20
+            ska = 21
+            death_metal = 22
+            pranks = 23
+            soundtrack = 24
+            euro_techno = 25
+            ambient = 26
+            trip_hop = 27
+            vocal = 28
+            jazz_funk = 29
+            fusion = 30
+            trance = 31
+            classical = 32
+            instrumental = 33
+            acid = 34
+            house = 35
+            game = 36
+            sound_clip = 37
+            gospel = 38
+            noise = 39
+            alternrock = 40
+            bass = 41
+            soul = 42
+            punk = 43
+            space = 44
+            meditative = 45
+            instrumental_pop = 46
+            instrumental_rock = 47
+            ethnic = 48
+            gothic = 49
+            darkwave = 50
+            techno_industrial = 51
+            electronic = 52
+            pop_folk = 53
+            eurodance = 54
+            dream = 55
+            southern_rock = 56
+            comedy = 57
+            cult = 58
+            gangsta = 59
+            top_40 = 60
+            christian_rap = 61
+            pop_funk = 62
+            jungle = 63
+            native_american = 64
+            cabaret = 65
+            new_wave = 66
+            psychadelic = 67
+            rave = 68
+            showtunes = 69
+            trailer = 70
+            lo_fi = 71
+            tribal = 72
+            acid_punk = 73
+            acid_jazz = 74
+            polka = 75
+            retro = 76
+            musical = 77
+            rock_n_roll = 78
+            hard_rock = 79
+            folk = 80
+            folk_rock = 81
+            national_folk = 82
+            swing = 83
+            fast_fusion = 84
+            bebob = 85
+            latin = 86
+            revival = 87
+            celtic = 88
+            bluegrass = 89
+            avantgarde = 90
+            gothic_rock = 91
+            progressive_rock = 92
+            psychedelic_rock = 93
+            symphonic_rock = 94
+            slow_rock = 95
+            big_band = 96
+            chorus = 97
+            easy_listening = 98
+            acoustic = 99
+            humour = 100
+            speech = 101
+            chanson = 102
+            opera = 103
+            chamber_music = 104
+            sonata = 105
+            symphony = 106
+            booty_bass = 107
+            primus = 108
+            porn_groove = 109
+            satire = 110
+            slow_jam = 111
+            club = 112
+            tango = 113
+            samba = 114
+            folklore = 115
+            ballad = 116
+            power_ballad = 117
+            rhythmic_soul = 118
+            freestyle = 119
+            duet = 120
+            punk_rock = 121
+            drum_solo = 122
+            a_capella = 123
+            euro_house = 124
+            dance_hall = 125
+        SEQ_FIELDS = ["magic", "title", "artist", "album", "year", "comment", "genre"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x54\x41\x47")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['title']['start'] = self._io.pos()
+            self.title = self._io.read_bytes(30)
+            self._debug['title']['end'] = self._io.pos()
+            self._debug['artist']['start'] = self._io.pos()
+            self.artist = self._io.read_bytes(30)
+            self._debug['artist']['end'] = self._io.pos()
+            self._debug['album']['start'] = self._io.pos()
+            self.album = self._io.read_bytes(30)
+            self._debug['album']['end'] = self._io.pos()
+            self._debug['year']['start'] = self._io.pos()
+            self.year = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['year']['end'] = self._io.pos()
+            self._debug['comment']['start'] = self._io.pos()
+            self.comment = self._io.read_bytes(30)
+            self._debug['comment']['end'] = self._io.pos()
+            self._debug['genre']['start'] = self._io.pos()
+            self.genre = KaitaiStream.resolve_enum(self._root.Id3V11Tag.GenreEnum, self._io.read_u1())
+            self._debug['genre']['end'] = self._io.pos()
+
+
+    @property
+    def id3v1_tag(self):
+        if hasattr(self, '_m_id3v1_tag'):
+            return self._m_id3v1_tag if hasattr(self, '_m_id3v1_tag') else None
+
+        _pos = self._io.pos()
+        self._io.seek((self._io.size() - 128))
+        self._debug['_m_id3v1_tag']['start'] = self._io.pos()
+        self._m_id3v1_tag = self._root.Id3V11Tag(self._io, self, self._root)
+        self._m_id3v1_tag._read()
+        self._debug['_m_id3v1_tag']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_id3v1_tag if hasattr(self, '_m_id3v1_tag') else None
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/id3v2_3.py b/python/examples/kaitai/kaitai_struct_formats/media/id3v2_3.py
new file mode 100644
index 00000000..cf6e5e1e
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/id3v2_3.py
@@ -0,0 +1,310 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Id3v23(KaitaiStruct):
+    SEQ_FIELDS = ["tag"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['tag']['start'] = self._io.pos()
+        self.tag = self._root.Tag(self._io, self, self._root)
+        self.tag._read()
+        self._debug['tag']['end'] = self._io.pos()
+
+    class U1beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["padding", "value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['padding']['start'] = self._io.pos()
+            self.padding = self._io.read_bits_int(1) != 0
+            self._debug['padding']['end'] = self._io.pos()
+            self._debug['value']['start'] = self._io.pos()
+            self.value = self._io.read_bits_int(7)
+            self._debug['value']['end'] = self._io.pos()
+
+
+    class U2beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["byte0", "byte1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['byte0']['start'] = self._io.pos()
+            self.byte0 = self._root.U1beSynchsafe(self._io, self, self._root)
+            self.byte0._read()
+            self._debug['byte0']['end'] = self._io.pos()
+            self._debug['byte1']['start'] = self._io.pos()
+            self.byte1 = self._root.U1beSynchsafe(self._io, self, self._root)
+            self.byte1._read()
+            self._debug['byte1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.byte0.value << 7) | self.byte1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Tag(KaitaiStruct):
+        SEQ_FIELDS = ["header", "header_ex", "frames", "padding"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['header']['start'] = self._io.pos()
+            self.header = self._root.Header(self._io, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            if self.header.flags.flag_headerex:
+                self._debug['header_ex']['start'] = self._io.pos()
+                self.header_ex = self._root.HeaderEx(self._io, self, self._root)
+                self.header_ex._read()
+                self._debug['header_ex']['end'] = self._io.pos()
+
+            self._debug['frames']['start'] = self._io.pos()
+            self.frames = []
+            i = 0
+            while True:
+                if not 'arr' in self._debug['frames']:
+                    self._debug['frames']['arr'] = []
+                self._debug['frames']['arr'].append({'start': self._io.pos()})
+                _t_frames = self._root.Frame(self._io, self, self._root)
+                _t_frames._read()
+                _ = _t_frames
+                self.frames.append(_)
+                self._debug['frames']['arr'][len(self.frames) - 1]['end'] = self._io.pos()
+                if  (((self._io.pos() + _.size) > self.header.size.value) or (_.is_invalid)) :
+                    break
+                i += 1
+            self._debug['frames']['end'] = self._io.pos()
+            if self.header.flags.flag_headerex:
+                self._debug['padding']['start'] = self._io.pos()
+                self.padding = self._io.read_bytes((self.header_ex.padding_size - self._io.pos()))
+                self._debug['padding']['end'] = self._io.pos()
+
+
+
+    class U4beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["short0", "short1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['short0']['start'] = self._io.pos()
+            self.short0 = self._root.U2beSynchsafe(self._io, self, self._root)
+            self.short0._read()
+            self._debug['short0']['end'] = self._io.pos()
+            self._debug['short1']['start'] = self._io.pos()
+            self.short1 = self._root.U2beSynchsafe(self._io, self, self._root)
+            self.short1._read()
+            self._debug['short1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.short0.value << 14) | self.short1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Frame(KaitaiStruct):
+        SEQ_FIELDS = ["id", "size", "flags", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4be()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._root.Frame.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(self.size)
+            self._debug['data']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_discard_alter_tag", "flag_discard_alter_file", "flag_read_only", "reserved1", "flag_compressed", "flag_encrypted", "flag_grouping", "reserved2"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['flag_discard_alter_tag']['start'] = self._io.pos()
+                self.flag_discard_alter_tag = self._io.read_bits_int(1) != 0
+                self._debug['flag_discard_alter_tag']['end'] = self._io.pos()
+                self._debug['flag_discard_alter_file']['start'] = self._io.pos()
+                self.flag_discard_alter_file = self._io.read_bits_int(1) != 0
+                self._debug['flag_discard_alter_file']['end'] = self._io.pos()
+                self._debug['flag_read_only']['start'] = self._io.pos()
+                self.flag_read_only = self._io.read_bits_int(1) != 0
+                self._debug['flag_read_only']['end'] = self._io.pos()
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_bits_int(5)
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['flag_compressed']['start'] = self._io.pos()
+                self.flag_compressed = self._io.read_bits_int(1) != 0
+                self._debug['flag_compressed']['end'] = self._io.pos()
+                self._debug['flag_encrypted']['start'] = self._io.pos()
+                self.flag_encrypted = self._io.read_bits_int(1) != 0
+                self._debug['flag_encrypted']['end'] = self._io.pos()
+                self._debug['flag_grouping']['start'] = self._io.pos()
+                self.flag_grouping = self._io.read_bits_int(1) != 0
+                self._debug['flag_grouping']['end'] = self._io.pos()
+                self._debug['reserved2']['start'] = self._io.pos()
+                self.reserved2 = self._io.read_bits_int(5)
+                self._debug['reserved2']['end'] = self._io.pos()
+
+
+        @property
+        def is_invalid(self):
+            if hasattr(self, '_m_is_invalid'):
+                return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+            self._m_is_invalid = self.id == u"\000\000\000\000"
+            return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+
+    class HeaderEx(KaitaiStruct):
+        """ID3v2 extended header.
+        
+        .. seealso::
+           Section 3.2. ID3v2 extended header
+        """
+        SEQ_FIELDS = ["size", "flags_ex", "padding_size", "crc"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4be()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags_ex']['start'] = self._io.pos()
+            self.flags_ex = self._root.HeaderEx.FlagsEx(self._io, self, self._root)
+            self.flags_ex._read()
+            self._debug['flags_ex']['end'] = self._io.pos()
+            self._debug['padding_size']['start'] = self._io.pos()
+            self.padding_size = self._io.read_u4be()
+            self._debug['padding_size']['end'] = self._io.pos()
+            if self.flags_ex.flag_crc:
+                self._debug['crc']['start'] = self._io.pos()
+                self.crc = self._io.read_u4be()
+                self._debug['crc']['end'] = self._io.pos()
+
+
+        class FlagsEx(KaitaiStruct):
+            SEQ_FIELDS = ["flag_crc", "reserved"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['flag_crc']['start'] = self._io.pos()
+                self.flag_crc = self._io.read_bits_int(1) != 0
+                self._debug['flag_crc']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int(15)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+    class Header(KaitaiStruct):
+        """ID3v2 fixed header.
+        
+        .. seealso::
+           Section 3.1. ID3v2 header
+        """
+        SEQ_FIELDS = ["magic", "version_major", "version_revision", "flags", "size"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x49\x44\x33")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['version_major']['start'] = self._io.pos()
+            self.version_major = self._io.read_u1()
+            self._debug['version_major']['end'] = self._io.pos()
+            self._debug['version_revision']['start'] = self._io.pos()
+            self.version_revision = self._io.read_u1()
+            self._debug['version_revision']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._root.Header.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._root.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_unsynchronization", "flag_headerex", "flag_experimental", "reserved"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['flag_unsynchronization']['start'] = self._io.pos()
+                self.flag_unsynchronization = self._io.read_bits_int(1) != 0
+                self._debug['flag_unsynchronization']['end'] = self._io.pos()
+                self._debug['flag_headerex']['start'] = self._io.pos()
+                self.flag_headerex = self._io.read_bits_int(1) != 0
+                self._debug['flag_headerex']['end'] = self._io.pos()
+                self._debug['flag_experimental']['start'] = self._io.pos()
+                self.flag_experimental = self._io.read_bits_int(1) != 0
+                self._debug['flag_experimental']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int(5)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/id3v2_4.py b/python/examples/kaitai/kaitai_struct_formats/media/id3v2_4.py
new file mode 100644
index 00000000..0cdde2eb
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/id3v2_4.py
@@ -0,0 +1,411 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Id3v24(KaitaiStruct):
+    SEQ_FIELDS = ["tag"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['tag']['start'] = self._io.pos()
+        self.tag = self._root.Tag(self._io, self, self._root)
+        self.tag._read()
+        self._debug['tag']['end'] = self._io.pos()
+
+    class U1beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["padding", "value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['padding']['start'] = self._io.pos()
+            self.padding = self._io.read_bits_int(1) != 0
+            self._debug['padding']['end'] = self._io.pos()
+            self._debug['value']['start'] = self._io.pos()
+            self.value = self._io.read_bits_int(7)
+            self._debug['value']['end'] = self._io.pos()
+
+
+    class U2beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["byte0", "byte1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['byte0']['start'] = self._io.pos()
+            self.byte0 = self._root.U1beSynchsafe(self._io, self, self._root)
+            self.byte0._read()
+            self._debug['byte0']['end'] = self._io.pos()
+            self._debug['byte1']['start'] = self._io.pos()
+            self.byte1 = self._root.U1beSynchsafe(self._io, self, self._root)
+            self.byte1._read()
+            self._debug['byte1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.byte0.value << 7) | self.byte1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Tag(KaitaiStruct):
+        SEQ_FIELDS = ["header", "header_ex", "frames", "padding", "footer"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['header']['start'] = self._io.pos()
+            self.header = self._root.Header(self._io, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            if self.header.flags.flag_headerex:
+                self._debug['header_ex']['start'] = self._io.pos()
+                self.header_ex = self._root.HeaderEx(self._io, self, self._root)
+                self.header_ex._read()
+                self._debug['header_ex']['end'] = self._io.pos()
+
+            self._debug['frames']['start'] = self._io.pos()
+            self.frames = []
+            i = 0
+            while True:
+                if not 'arr' in self._debug['frames']:
+                    self._debug['frames']['arr'] = []
+                self._debug['frames']['arr'].append({'start': self._io.pos()})
+                _t_frames = self._root.Frame(self._io, self, self._root)
+                _t_frames._read()
+                _ = _t_frames
+                self.frames.append(_)
+                self._debug['frames']['arr'][len(self.frames) - 1]['end'] = self._io.pos()
+                if  (((self._io.pos() + _.size.value) > self.header.size.value) or (_.is_invalid)) :
+                    break
+                i += 1
+            self._debug['frames']['end'] = self._io.pos()
+            if not (self.header.flags.flag_footer):
+                self._debug['padding']['start'] = self._io.pos()
+                self.padding = self._root.Padding(self._io, self, self._root)
+                self.padding._read()
+                self._debug['padding']['end'] = self._io.pos()
+
+            if self.header.flags.flag_footer:
+                self._debug['footer']['start'] = self._io.pos()
+                self.footer = self._root.Footer(self._io, self, self._root)
+                self.footer._read()
+                self._debug['footer']['end'] = self._io.pos()
+
+
+
+    class U4beSynchsafe(KaitaiStruct):
+        SEQ_FIELDS = ["short0", "short1"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['short0']['start'] = self._io.pos()
+            self.short0 = self._root.U2beSynchsafe(self._io, self, self._root)
+            self.short0._read()
+            self._debug['short0']['end'] = self._io.pos()
+            self._debug['short1']['start'] = self._io.pos()
+            self.short1 = self._root.U2beSynchsafe(self._io, self, self._root)
+            self.short1._read()
+            self._debug['short1']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = ((self.short0.value << 14) | self.short1.value)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Frame(KaitaiStruct):
+        SEQ_FIELDS = ["id", "size", "flags_status", "flags_format", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = (self._io.read_bytes(4)).decode(u"ASCII")
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._root.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags_status']['start'] = self._io.pos()
+            self.flags_status = self._root.Frame.FlagsStatus(self._io, self, self._root)
+            self.flags_status._read()
+            self._debug['flags_status']['end'] = self._io.pos()
+            self._debug['flags_format']['start'] = self._io.pos()
+            self.flags_format = self._root.Frame.FlagsFormat(self._io, self, self._root)
+            self.flags_format._read()
+            self._debug['flags_format']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(self.size.value)
+            self._debug['data']['end'] = self._io.pos()
+
+        class FlagsStatus(KaitaiStruct):
+            SEQ_FIELDS = ["reserved1", "flag_discard_alter_tag", "flag_discard_alter_file", "flag_read_only", "reserved2"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_bits_int(1) != 0
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['flag_discard_alter_tag']['start'] = self._io.pos()
+                self.flag_discard_alter_tag = self._io.read_bits_int(1) != 0
+                self._debug['flag_discard_alter_tag']['end'] = self._io.pos()
+                self._debug['flag_discard_alter_file']['start'] = self._io.pos()
+                self.flag_discard_alter_file = self._io.read_bits_int(1) != 0
+                self._debug['flag_discard_alter_file']['end'] = self._io.pos()
+                self._debug['flag_read_only']['start'] = self._io.pos()
+                self.flag_read_only = self._io.read_bits_int(1) != 0
+                self._debug['flag_read_only']['end'] = self._io.pos()
+                self._debug['reserved2']['start'] = self._io.pos()
+                self.reserved2 = self._io.read_bits_int(4)
+                self._debug['reserved2']['end'] = self._io.pos()
+
+
+        class FlagsFormat(KaitaiStruct):
+            SEQ_FIELDS = ["reserved1", "flag_grouping", "reserved2", "flag_compressed", "flag_encrypted", "flag_unsynchronisated", "flag_indicator"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_bits_int(1) != 0
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['flag_grouping']['start'] = self._io.pos()
+                self.flag_grouping = self._io.read_bits_int(1) != 0
+                self._debug['flag_grouping']['end'] = self._io.pos()
+                self._debug['reserved2']['start'] = self._io.pos()
+                self.reserved2 = self._io.read_bits_int(2)
+                self._debug['reserved2']['end'] = self._io.pos()
+                self._debug['flag_compressed']['start'] = self._io.pos()
+                self.flag_compressed = self._io.read_bits_int(1) != 0
+                self._debug['flag_compressed']['end'] = self._io.pos()
+                self._debug['flag_encrypted']['start'] = self._io.pos()
+                self.flag_encrypted = self._io.read_bits_int(1) != 0
+                self._debug['flag_encrypted']['end'] = self._io.pos()
+                self._debug['flag_unsynchronisated']['start'] = self._io.pos()
+                self.flag_unsynchronisated = self._io.read_bits_int(1) != 0
+                self._debug['flag_unsynchronisated']['end'] = self._io.pos()
+                self._debug['flag_indicator']['start'] = self._io.pos()
+                self.flag_indicator = self._io.read_bits_int(1) != 0
+                self._debug['flag_indicator']['end'] = self._io.pos()
+
+
+        @property
+        def is_invalid(self):
+            if hasattr(self, '_m_is_invalid'):
+                return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+            self._m_is_invalid = self.id == u"\000\000\000\000"
+            return self._m_is_invalid if hasattr(self, '_m_is_invalid') else None
+
+
+    class HeaderEx(KaitaiStruct):
+        SEQ_FIELDS = ["size", "flags_ex", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._root.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['flags_ex']['start'] = self._io.pos()
+            self.flags_ex = self._root.HeaderEx.FlagsEx(self._io, self, self._root)
+            self.flags_ex._read()
+            self._debug['flags_ex']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes((self.size.value - 5))
+            self._debug['data']['end'] = self._io.pos()
+
+        class FlagsEx(KaitaiStruct):
+            SEQ_FIELDS = ["reserved1", "flag_update", "flag_crc", "flag_restrictions", "reserved2"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_bits_int(1) != 0
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['flag_update']['start'] = self._io.pos()
+                self.flag_update = self._io.read_bits_int(1) != 0
+                self._debug['flag_update']['end'] = self._io.pos()
+                self._debug['flag_crc']['start'] = self._io.pos()
+                self.flag_crc = self._io.read_bits_int(1) != 0
+                self._debug['flag_crc']['end'] = self._io.pos()
+                self._debug['flag_restrictions']['start'] = self._io.pos()
+                self.flag_restrictions = self._io.read_bits_int(1) != 0
+                self._debug['flag_restrictions']['end'] = self._io.pos()
+                self._debug['reserved2']['start'] = self._io.pos()
+                self.reserved2 = self._io.read_bits_int(4)
+                self._debug['reserved2']['end'] = self._io.pos()
+
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version_major", "version_revision", "flags", "size"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x49\x44\x33")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['version_major']['start'] = self._io.pos()
+            self.version_major = self._io.read_u1()
+            self._debug['version_major']['end'] = self._io.pos()
+            self._debug['version_revision']['start'] = self._io.pos()
+            self.version_revision = self._io.read_u1()
+            self._debug['version_revision']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._root.Header.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._root.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_unsynchronization", "flag_headerex", "flag_experimental", "flag_footer", "reserved"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['flag_unsynchronization']['start'] = self._io.pos()
+                self.flag_unsynchronization = self._io.read_bits_int(1) != 0
+                self._debug['flag_unsynchronization']['end'] = self._io.pos()
+                self._debug['flag_headerex']['start'] = self._io.pos()
+                self.flag_headerex = self._io.read_bits_int(1) != 0
+                self._debug['flag_headerex']['end'] = self._io.pos()
+                self._debug['flag_experimental']['start'] = self._io.pos()
+                self.flag_experimental = self._io.read_bits_int(1) != 0
+                self._debug['flag_experimental']['end'] = self._io.pos()
+                self._debug['flag_footer']['start'] = self._io.pos()
+                self.flag_footer = self._io.read_bits_int(1) != 0
+                self._debug['flag_footer']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int(4)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+    class Padding(KaitaiStruct):
+        SEQ_FIELDS = ["padding"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['padding']['start'] = self._io.pos()
+            self.padding = self._io.read_bytes((self._root.tag.header.size.value - self._io.pos()))
+            self._debug['padding']['end'] = self._io.pos()
+
+
+    class Footer(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "version_major", "version_revision", "flags", "size"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x33\x44\x49")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['version_major']['start'] = self._io.pos()
+            self.version_major = self._io.read_u1()
+            self._debug['version_major']['end'] = self._io.pos()
+            self._debug['version_revision']['start'] = self._io.pos()
+            self.version_revision = self._io.read_u1()
+            self._debug['version_revision']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._root.Footer.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._root.U4beSynchsafe(self._io, self, self._root)
+            self.size._read()
+            self._debug['size']['end'] = self._io.pos()
+
+        class Flags(KaitaiStruct):
+            SEQ_FIELDS = ["flag_unsynchronization", "flag_headerex", "flag_experimental", "flag_footer", "reserved"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['flag_unsynchronization']['start'] = self._io.pos()
+                self.flag_unsynchronization = self._io.read_bits_int(1) != 0
+                self._debug['flag_unsynchronization']['end'] = self._io.pos()
+                self._debug['flag_headerex']['start'] = self._io.pos()
+                self.flag_headerex = self._io.read_bits_int(1) != 0
+                self._debug['flag_headerex']['end'] = self._io.pos()
+                self._debug['flag_experimental']['start'] = self._io.pos()
+                self.flag_experimental = self._io.read_bits_int(1) != 0
+                self._debug['flag_experimental']['end'] = self._io.pos()
+                self._debug['flag_footer']['start'] = self._io.pos()
+                self.flag_footer = self._io.read_bits_int(1) != 0
+                self._debug['flag_footer']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_bits_int(4)
+                self._debug['reserved']['end'] = self._io.pos()
+
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/magicavoxel_vox.py b/python/examples/kaitai/kaitai_struct_formats/media/magicavoxel_vox.py
new file mode 100644
index 00000000..24841007
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/magicavoxel_vox.py
@@ -0,0 +1,385 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class MagicavoxelVox(KaitaiStruct):
+    """
+    .. seealso::
+       Format Description - https://github.com/ephtracy/voxel-model/blob/master/MagicaVoxel-file-format-vox.txt
+    """
+
+    class ChunkType(Enum):
+        main = 1296124238
+        matt = 1296127060
+        pack = 1346454347
+        rgba = 1380401729
+        size = 1397316165
+        xyzi = 1482250825
+
+    class MaterialType(Enum):
+        diffuse = 0
+        metal = 1
+        glass = 2
+        emissive = 3
+
+    class PropertyBitsType(Enum):
+        plastic = 1
+        roughness = 2
+        specular = 4
+        ior = 8
+        attenuation = 16
+        power = 32
+        glow = 64
+        is_total_power = 128
+    SEQ_FIELDS = ["magic", "version", "main"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.ensure_fixed_contents(b"\x56\x4F\x58\x20")
+        self._debug['magic']['end'] = self._io.pos()
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u4le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['main']['start'] = self._io.pos()
+        self.main = self._root.Chunk(self._io, self, self._root)
+        self.main._read()
+        self._debug['main']['end'] = self._io.pos()
+
+    class Chunk(KaitaiStruct):
+        SEQ_FIELDS = ["chunk_id", "num_bytes_of_chunk_content", "num_bytes_of_children_chunks", "chunk_content", "children_chunks"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['chunk_id']['start'] = self._io.pos()
+            self.chunk_id = KaitaiStream.resolve_enum(self._root.ChunkType, self._io.read_u4be())
+            self._debug['chunk_id']['end'] = self._io.pos()
+            self._debug['num_bytes_of_chunk_content']['start'] = self._io.pos()
+            self.num_bytes_of_chunk_content = self._io.read_u4le()
+            self._debug['num_bytes_of_chunk_content']['end'] = self._io.pos()
+            self._debug['num_bytes_of_children_chunks']['start'] = self._io.pos()
+            self.num_bytes_of_children_chunks = self._io.read_u4le()
+            self._debug['num_bytes_of_children_chunks']['end'] = self._io.pos()
+            if self.num_bytes_of_chunk_content != 0:
+                self._debug['chunk_content']['start'] = self._io.pos()
+                _on = self.chunk_id
+                if _on == self._root.ChunkType.size:
+                    self._raw_chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                    io = KaitaiStream(BytesIO(self._raw_chunk_content))
+                    self.chunk_content = self._root.Size(io, self, self._root)
+                    self.chunk_content._read()
+                elif _on == self._root.ChunkType.matt:
+                    self._raw_chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                    io = KaitaiStream(BytesIO(self._raw_chunk_content))
+                    self.chunk_content = self._root.Matt(io, self, self._root)
+                    self.chunk_content._read()
+                elif _on == self._root.ChunkType.rgba:
+                    self._raw_chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                    io = KaitaiStream(BytesIO(self._raw_chunk_content))
+                    self.chunk_content = self._root.Rgba(io, self, self._root)
+                    self.chunk_content._read()
+                elif _on == self._root.ChunkType.xyzi:
+                    self._raw_chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                    io = KaitaiStream(BytesIO(self._raw_chunk_content))
+                    self.chunk_content = self._root.Xyzi(io, self, self._root)
+                    self.chunk_content._read()
+                elif _on == self._root.ChunkType.pack:
+                    self._raw_chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                    io = KaitaiStream(BytesIO(self._raw_chunk_content))
+                    self.chunk_content = self._root.Pack(io, self, self._root)
+                    self.chunk_content._read()
+                else:
+                    self.chunk_content = self._io.read_bytes(self.num_bytes_of_chunk_content)
+                self._debug['chunk_content']['end'] = self._io.pos()
+
+            if self.num_bytes_of_children_chunks != 0:
+                self._debug['children_chunks']['start'] = self._io.pos()
+                self.children_chunks = []
+                i = 0
+                while not self._io.is_eof():
+                    if not 'arr' in self._debug['children_chunks']:
+                        self._debug['children_chunks']['arr'] = []
+                    self._debug['children_chunks']['arr'].append({'start': self._io.pos()})
+                    _t_children_chunks = self._root.Chunk(self._io, self, self._root)
+                    _t_children_chunks._read()
+                    self.children_chunks.append(_t_children_chunks)
+                    self._debug['children_chunks']['arr'][len(self.children_chunks) - 1]['end'] = self._io.pos()
+                    i += 1
+
+                self._debug['children_chunks']['end'] = self._io.pos()
+
+
+
+    class Size(KaitaiStruct):
+        SEQ_FIELDS = ["size_x", "size_y", "size_z"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['size_x']['start'] = self._io.pos()
+            self.size_x = self._io.read_u4le()
+            self._debug['size_x']['end'] = self._io.pos()
+            self._debug['size_y']['start'] = self._io.pos()
+            self.size_y = self._io.read_u4le()
+            self._debug['size_y']['end'] = self._io.pos()
+            self._debug['size_z']['start'] = self._io.pos()
+            self.size_z = self._io.read_u4le()
+            self._debug['size_z']['end'] = self._io.pos()
+
+
+    class Rgba(KaitaiStruct):
+        SEQ_FIELDS = ["colors"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['colors']['start'] = self._io.pos()
+            self.colors = [None] * (256)
+            for i in range(256):
+                if not 'arr' in self._debug['colors']:
+                    self._debug['colors']['arr'] = []
+                self._debug['colors']['arr'].append({'start': self._io.pos()})
+                _t_colors = self._root.Color(self._io, self, self._root)
+                _t_colors._read()
+                self.colors[i] = _t_colors
+                self._debug['colors']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['colors']['end'] = self._io.pos()
+
+
+    class Pack(KaitaiStruct):
+        SEQ_FIELDS = ["num_models"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['num_models']['start'] = self._io.pos()
+            self.num_models = self._io.read_u4le()
+            self._debug['num_models']['end'] = self._io.pos()
+
+
+    class Matt(KaitaiStruct):
+        SEQ_FIELDS = ["id", "material_type", "material_weight", "property_bits", "plastic", "roughness", "specular", "ior", "attenuation", "power", "glow", "is_total_power"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['id']['start'] = self._io.pos()
+            self.id = self._io.read_u4le()
+            self._debug['id']['end'] = self._io.pos()
+            self._debug['material_type']['start'] = self._io.pos()
+            self.material_type = KaitaiStream.resolve_enum(self._root.MaterialType, self._io.read_u4le())
+            self._debug['material_type']['end'] = self._io.pos()
+            self._debug['material_weight']['start'] = self._io.pos()
+            self.material_weight = self._io.read_f4le()
+            self._debug['material_weight']['end'] = self._io.pos()
+            self._debug['property_bits']['start'] = self._io.pos()
+            self.property_bits = self._io.read_u4le()
+            self._debug['property_bits']['end'] = self._io.pos()
+            if self.has_plastic:
+                self._debug['plastic']['start'] = self._io.pos()
+                self.plastic = self._io.read_f4le()
+                self._debug['plastic']['end'] = self._io.pos()
+
+            if self.has_roughness:
+                self._debug['roughness']['start'] = self._io.pos()
+                self.roughness = self._io.read_f4le()
+                self._debug['roughness']['end'] = self._io.pos()
+
+            if self.has_specular:
+                self._debug['specular']['start'] = self._io.pos()
+                self.specular = self._io.read_f4le()
+                self._debug['specular']['end'] = self._io.pos()
+
+            if self.has_ior:
+                self._debug['ior']['start'] = self._io.pos()
+                self.ior = self._io.read_f4le()
+                self._debug['ior']['end'] = self._io.pos()
+
+            if self.has_attenuation:
+                self._debug['attenuation']['start'] = self._io.pos()
+                self.attenuation = self._io.read_f4le()
+                self._debug['attenuation']['end'] = self._io.pos()
+
+            if self.has_power:
+                self._debug['power']['start'] = self._io.pos()
+                self.power = self._io.read_f4le()
+                self._debug['power']['end'] = self._io.pos()
+
+            if self.has_glow:
+                self._debug['glow']['start'] = self._io.pos()
+                self.glow = self._io.read_f4le()
+                self._debug['glow']['end'] = self._io.pos()
+
+            if self.has_is_total_power:
+                self._debug['is_total_power']['start'] = self._io.pos()
+                self.is_total_power = self._io.read_f4le()
+                self._debug['is_total_power']['end'] = self._io.pos()
+
+
+        @property
+        def has_is_total_power(self):
+            if hasattr(self, '_m_has_is_total_power'):
+                return self._m_has_is_total_power if hasattr(self, '_m_has_is_total_power') else None
+
+            self._m_has_is_total_power = (self.property_bits & 128) != 0
+            return self._m_has_is_total_power if hasattr(self, '_m_has_is_total_power') else None
+
+        @property
+        def has_plastic(self):
+            if hasattr(self, '_m_has_plastic'):
+                return self._m_has_plastic if hasattr(self, '_m_has_plastic') else None
+
+            self._m_has_plastic = (self.property_bits & 1) != 0
+            return self._m_has_plastic if hasattr(self, '_m_has_plastic') else None
+
+        @property
+        def has_attenuation(self):
+            if hasattr(self, '_m_has_attenuation'):
+                return self._m_has_attenuation if hasattr(self, '_m_has_attenuation') else None
+
+            self._m_has_attenuation = (self.property_bits & 16) != 0
+            return self._m_has_attenuation if hasattr(self, '_m_has_attenuation') else None
+
+        @property
+        def has_power(self):
+            if hasattr(self, '_m_has_power'):
+                return self._m_has_power if hasattr(self, '_m_has_power') else None
+
+            self._m_has_power = (self.property_bits & 32) != 0
+            return self._m_has_power if hasattr(self, '_m_has_power') else None
+
+        @property
+        def has_roughness(self):
+            if hasattr(self, '_m_has_roughness'):
+                return self._m_has_roughness if hasattr(self, '_m_has_roughness') else None
+
+            self._m_has_roughness = (self.property_bits & 2) != 0
+            return self._m_has_roughness if hasattr(self, '_m_has_roughness') else None
+
+        @property
+        def has_specular(self):
+            if hasattr(self, '_m_has_specular'):
+                return self._m_has_specular if hasattr(self, '_m_has_specular') else None
+
+            self._m_has_specular = (self.property_bits & 4) != 0
+            return self._m_has_specular if hasattr(self, '_m_has_specular') else None
+
+        @property
+        def has_ior(self):
+            if hasattr(self, '_m_has_ior'):
+                return self._m_has_ior if hasattr(self, '_m_has_ior') else None
+
+            self._m_has_ior = (self.property_bits & 8) != 0
+            return self._m_has_ior if hasattr(self, '_m_has_ior') else None
+
+        @property
+        def has_glow(self):
+            if hasattr(self, '_m_has_glow'):
+                return self._m_has_glow if hasattr(self, '_m_has_glow') else None
+
+            self._m_has_glow = (self.property_bits & 64) != 0
+            return self._m_has_glow if hasattr(self, '_m_has_glow') else None
+
+
+    class Xyzi(KaitaiStruct):
+        SEQ_FIELDS = ["num_voxels", "voxels"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['num_voxels']['start'] = self._io.pos()
+            self.num_voxels = self._io.read_u4le()
+            self._debug['num_voxels']['end'] = self._io.pos()
+            self._debug['voxels']['start'] = self._io.pos()
+            self.voxels = [None] * (self.num_voxels)
+            for i in range(self.num_voxels):
+                if not 'arr' in self._debug['voxels']:
+                    self._debug['voxels']['arr'] = []
+                self._debug['voxels']['arr'].append({'start': self._io.pos()})
+                _t_voxels = self._root.Voxel(self._io, self, self._root)
+                _t_voxels._read()
+                self.voxels[i] = _t_voxels
+                self._debug['voxels']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['voxels']['end'] = self._io.pos()
+
+
+    class Color(KaitaiStruct):
+        SEQ_FIELDS = ["r", "g", "b", "a"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['r']['start'] = self._io.pos()
+            self.r = self._io.read_u1()
+            self._debug['r']['end'] = self._io.pos()
+            self._debug['g']['start'] = self._io.pos()
+            self.g = self._io.read_u1()
+            self._debug['g']['end'] = self._io.pos()
+            self._debug['b']['start'] = self._io.pos()
+            self.b = self._io.read_u1()
+            self._debug['b']['end'] = self._io.pos()
+            self._debug['a']['start'] = self._io.pos()
+            self.a = self._io.read_u1()
+            self._debug['a']['end'] = self._io.pos()
+
+
+    class Voxel(KaitaiStruct):
+        SEQ_FIELDS = ["x", "y", "z", "color_index"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['x']['start'] = self._io.pos()
+            self.x = self._io.read_u1()
+            self._debug['x']['end'] = self._io.pos()
+            self._debug['y']['start'] = self._io.pos()
+            self.y = self._io.read_u1()
+            self._debug['y']['end'] = self._io.pos()
+            self._debug['z']['start'] = self._io.pos()
+            self.z = self._io.read_u1()
+            self._debug['z']['end'] = self._io.pos()
+            self._debug['color_index']['start'] = self._io.pos()
+            self.color_index = self._io.read_u1()
+            self._debug['color_index']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/ogg.py b/python/examples/kaitai/kaitai_struct_formats/media/ogg.py
new file mode 100644
index 00000000..415d6bdf
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/ogg.py
@@ -0,0 +1,114 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Ogg(KaitaiStruct):
+    """Ogg is a popular media container format, which provides basic
+    streaming / buffering mechanisms and is content-agnostic. Most
+    popular codecs that are used within Ogg streams are Vorbis (thus
+    making Ogg/Vorbis streams) and Theora (Ogg/Theora).
+    
+    Ogg stream is a sequence Ogg pages. They can be read sequentially,
+    or one can jump into arbitrary stream location and scan for "OggS"
+    sync code to find the beginning of a new Ogg page and continue
+    decoding the stream contents from that one.
+    """
+    SEQ_FIELDS = ["pages"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['pages']['start'] = self._io.pos()
+        self.pages = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['pages']:
+                self._debug['pages']['arr'] = []
+            self._debug['pages']['arr'].append({'start': self._io.pos()})
+            _t_pages = self._root.Page(self._io, self, self._root)
+            _t_pages._read()
+            self.pages.append(_t_pages)
+            self._debug['pages']['arr'][len(self.pages) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['pages']['end'] = self._io.pos()
+
+    class Page(KaitaiStruct):
+        """Ogg page is a basic unit of data in an Ogg bitstream, usually
+        it's around 4-8 KB, with a maximum size of 65307 bytes.
+        """
+        SEQ_FIELDS = ["sync_code", "version", "reserved1", "is_end_of_stream", "is_beginning_of_stream", "is_continuation", "granule_pos", "bitstream_serial", "page_seq_num", "crc32", "num_segments", "len_segments", "segments"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['sync_code']['start'] = self._io.pos()
+            self.sync_code = self._io.ensure_fixed_contents(b"\x4F\x67\x67\x53")
+            self._debug['sync_code']['end'] = self._io.pos()
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.ensure_fixed_contents(b"\x00")
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bits_int(5)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['is_end_of_stream']['start'] = self._io.pos()
+            self.is_end_of_stream = self._io.read_bits_int(1) != 0
+            self._debug['is_end_of_stream']['end'] = self._io.pos()
+            self._debug['is_beginning_of_stream']['start'] = self._io.pos()
+            self.is_beginning_of_stream = self._io.read_bits_int(1) != 0
+            self._debug['is_beginning_of_stream']['end'] = self._io.pos()
+            self._debug['is_continuation']['start'] = self._io.pos()
+            self.is_continuation = self._io.read_bits_int(1) != 0
+            self._debug['is_continuation']['end'] = self._io.pos()
+            self._io.align_to_byte()
+            self._debug['granule_pos']['start'] = self._io.pos()
+            self.granule_pos = self._io.read_u8le()
+            self._debug['granule_pos']['end'] = self._io.pos()
+            self._debug['bitstream_serial']['start'] = self._io.pos()
+            self.bitstream_serial = self._io.read_u4le()
+            self._debug['bitstream_serial']['end'] = self._io.pos()
+            self._debug['page_seq_num']['start'] = self._io.pos()
+            self.page_seq_num = self._io.read_u4le()
+            self._debug['page_seq_num']['end'] = self._io.pos()
+            self._debug['crc32']['start'] = self._io.pos()
+            self.crc32 = self._io.read_u4le()
+            self._debug['crc32']['end'] = self._io.pos()
+            self._debug['num_segments']['start'] = self._io.pos()
+            self.num_segments = self._io.read_u1()
+            self._debug['num_segments']['end'] = self._io.pos()
+            self._debug['len_segments']['start'] = self._io.pos()
+            self.len_segments = [None] * (self.num_segments)
+            for i in range(self.num_segments):
+                if not 'arr' in self._debug['len_segments']:
+                    self._debug['len_segments']['arr'] = []
+                self._debug['len_segments']['arr'].append({'start': self._io.pos()})
+                self.len_segments[i] = self._io.read_u1()
+                self._debug['len_segments']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['len_segments']['end'] = self._io.pos()
+            self._debug['segments']['start'] = self._io.pos()
+            self.segments = [None] * (self.num_segments)
+            for i in range(self.num_segments):
+                if not 'arr' in self._debug['segments']:
+                    self._debug['segments']['arr'] = []
+                self._debug['segments']['arr'].append({'start': self._io.pos()})
+                self.segments[i] = self._io.read_bytes(self.len_segments[i])
+                self._debug['segments']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['segments']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/quicktime_mov.py b/python/examples/kaitai/kaitai_struct_formats/media/quicktime_mov.py
new file mode 100644
index 00000000..eb2f5c9b
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/quicktime_mov.py
@@ -0,0 +1,479 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class QuicktimeMov(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap1/qtff1.html#//apple_ref/doc/uid/TP40000939-CH203-BBCGDDDF
+    """
+
+    class AtomType(Enum):
+        xtra = 1484026465
+        dinf = 1684631142
+        dref = 1685218662
+        edts = 1701082227
+        elst = 1701606260
+        free = 1718773093
+        ftyp = 1718909296
+        hdlr = 1751411826
+        iods = 1768907891
+        mdat = 1835295092
+        mdhd = 1835296868
+        mdia = 1835297121
+        meta = 1835365473
+        minf = 1835626086
+        moof = 1836019558
+        moov = 1836019574
+        mvhd = 1836476516
+        smhd = 1936549988
+        stbl = 1937007212
+        stco = 1937007471
+        stsc = 1937011555
+        stsd = 1937011556
+        stsz = 1937011578
+        stts = 1937011827
+        tkhd = 1953196132
+        traf = 1953653094
+        trak = 1953653099
+        tref = 1953654118
+        udta = 1969517665
+        vmhd = 1986881636
+
+    class Brand(Enum):
+        x_3g2a = 862401121
+        x_3ge6 = 862414134
+        x_3ge9 = 862414137
+        x_3gf9 = 862414393
+        x_3gg6 = 862414646
+        x_3gg9 = 862414649
+        x_3gh9 = 862414905
+        x_3gm9 = 862416185
+        x_3gp4 = 862416948
+        x_3gp5 = 862416949
+        x_3gp6 = 862416950
+        x_3gp7 = 862416951
+        x_3gp8 = 862416952
+        x_3gp9 = 862416953
+        x_3gr6 = 862417462
+        x_3gr9 = 862417465
+        x_3gs6 = 862417718
+        x_3gs9 = 862417721
+        x_3gt9 = 862417977
+        arri = 1095914057
+        caep = 1128351056
+        cdes = 1128555891
+        j2p0 = 1244811312
+        j2p1 = 1244811313
+        lcag = 1279476039
+        m4a = 1295270176
+        m4b = 1295270432
+        m4p = 1295274016
+        m4v = 1295275552
+        mfsm = 1296454477
+        mgsv = 1296520022
+        mppi = 1297109065
+        msnv = 1297305174
+        ross = 1380930387
+        seau = 1397047637
+        sebk = 1397047883
+        xavc = 1480676931
+        avc1 = 1635148593
+        bbxm = 1650620525
+        caqv = 1667330422
+        ccff = 1667458662
+        da0a = 1684090977
+        da0b = 1684090978
+        da1a = 1684091233
+        da1b = 1684091234
+        da2a = 1684091489
+        da2b = 1684091490
+        da3a = 1684091745
+        da3b = 1684091746
+        dash = 1684108136
+        dby1 = 1684175153
+        dmb1 = 1684890161
+        dsms = 1685286259
+        dv1a = 1685467489
+        dv1b = 1685467490
+        dv2a = 1685467745
+        dv2b = 1685467746
+        dv3a = 1685468001
+        dv3b = 1685468002
+        dvr1 = 1685484081
+        dvt1 = 1685484593
+        dxo = 1685614368
+        emsg = 1701671783
+        ifrm = 1768321645
+        isc2 = 1769169714
+        iso2 = 1769172786
+        iso3 = 1769172787
+        iso4 = 1769172788
+        iso5 = 1769172789
+        iso6 = 1769172790
+        isom = 1769172845
+        jp2 = 1785737760
+        jpm = 1785752864
+        jpsi = 1785754473
+        jpx = 1785755680
+        jpxb = 1785755746
+        lmsg = 1819112295
+        mj2s = 1835676275
+        mjp2 = 1835692082
+        mp21 = 1836069425
+        mp41 = 1836069937
+        mp42 = 1836069938
+        mp71 = 1836070705
+        msdh = 1836278888
+        msix = 1836280184
+        niko = 1852402543
+        odcf = 1868850022
+        opf2 = 1869637170
+        opx2 = 1869641778
+        pana = 1885433441
+        piff = 1885955686
+        pnvi = 1886287465
+        qt = 1903435808
+        risx = 1919513464
+        sdv = 1935963680
+        senv = 1936027254
+        sims = 1936289139
+        sisx = 1936290680
+        ssss = 1936946035
+        uvvu = 1970697845
+    SEQ_FIELDS = ["atoms"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['atoms']['start'] = self._io.pos()
+        self.atoms = self._root.AtomList(self._io, self, self._root)
+        self.atoms._read()
+        self._debug['atoms']['end'] = self._io.pos()
+
+    class MvhdBody(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-BBCGFGJG
+        """
+        SEQ_FIELDS = ["version", "flags", "creation_time", "modification_time", "time_scale", "duration", "preferred_rate", "preferred_volume", "reserved1", "matrix", "preview_time", "preview_duration", "poster_time", "selection_time", "selection_duration", "current_time", "next_track_id"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u1()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_bytes(3)
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['creation_time']['start'] = self._io.pos()
+            self.creation_time = self._io.read_u4be()
+            self._debug['creation_time']['end'] = self._io.pos()
+            self._debug['modification_time']['start'] = self._io.pos()
+            self.modification_time = self._io.read_u4be()
+            self._debug['modification_time']['end'] = self._io.pos()
+            self._debug['time_scale']['start'] = self._io.pos()
+            self.time_scale = self._io.read_u4be()
+            self._debug['time_scale']['end'] = self._io.pos()
+            self._debug['duration']['start'] = self._io.pos()
+            self.duration = self._io.read_u4be()
+            self._debug['duration']['end'] = self._io.pos()
+            self._debug['preferred_rate']['start'] = self._io.pos()
+            self.preferred_rate = self._root.Fixed32(self._io, self, self._root)
+            self.preferred_rate._read()
+            self._debug['preferred_rate']['end'] = self._io.pos()
+            self._debug['preferred_volume']['start'] = self._io.pos()
+            self.preferred_volume = self._root.Fixed16(self._io, self, self._root)
+            self.preferred_volume._read()
+            self._debug['preferred_volume']['end'] = self._io.pos()
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(10)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['matrix']['start'] = self._io.pos()
+            self.matrix = self._io.read_bytes(36)
+            self._debug['matrix']['end'] = self._io.pos()
+            self._debug['preview_time']['start'] = self._io.pos()
+            self.preview_time = self._io.read_u4be()
+            self._debug['preview_time']['end'] = self._io.pos()
+            self._debug['preview_duration']['start'] = self._io.pos()
+            self.preview_duration = self._io.read_u4be()
+            self._debug['preview_duration']['end'] = self._io.pos()
+            self._debug['poster_time']['start'] = self._io.pos()
+            self.poster_time = self._io.read_u4be()
+            self._debug['poster_time']['end'] = self._io.pos()
+            self._debug['selection_time']['start'] = self._io.pos()
+            self.selection_time = self._io.read_u4be()
+            self._debug['selection_time']['end'] = self._io.pos()
+            self._debug['selection_duration']['start'] = self._io.pos()
+            self.selection_duration = self._io.read_u4be()
+            self._debug['selection_duration']['end'] = self._io.pos()
+            self._debug['current_time']['start'] = self._io.pos()
+            self.current_time = self._io.read_u4be()
+            self._debug['current_time']['end'] = self._io.pos()
+            self._debug['next_track_id']['start'] = self._io.pos()
+            self.next_track_id = self._io.read_u4be()
+            self._debug['next_track_id']['end'] = self._io.pos()
+
+
+    class FtypBody(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap1/qtff1.html#//apple_ref/doc/uid/TP40000939-CH203-CJBCBIFF
+        """
+        SEQ_FIELDS = ["major_brand", "minor_version", "compatible_brands"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['major_brand']['start'] = self._io.pos()
+            self.major_brand = KaitaiStream.resolve_enum(self._root.Brand, self._io.read_u4be())
+            self._debug['major_brand']['end'] = self._io.pos()
+            self._debug['minor_version']['start'] = self._io.pos()
+            self.minor_version = self._io.read_bytes(4)
+            self._debug['minor_version']['end'] = self._io.pos()
+            self._debug['compatible_brands']['start'] = self._io.pos()
+            self.compatible_brands = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['compatible_brands']:
+                    self._debug['compatible_brands']['arr'] = []
+                self._debug['compatible_brands']['arr'].append({'start': self._io.pos()})
+                self.compatible_brands.append(KaitaiStream.resolve_enum(self._root.Brand, self._io.read_u4be()))
+                self._debug['compatible_brands']['arr'][len(self.compatible_brands) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['compatible_brands']['end'] = self._io.pos()
+
+
+    class Fixed32(KaitaiStruct):
+        """Fixed-point 32-bit number."""
+        SEQ_FIELDS = ["int_part", "frac_part"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['int_part']['start'] = self._io.pos()
+            self.int_part = self._io.read_s2be()
+            self._debug['int_part']['end'] = self._io.pos()
+            self._debug['frac_part']['start'] = self._io.pos()
+            self.frac_part = self._io.read_u2be()
+            self._debug['frac_part']['end'] = self._io.pos()
+
+
+    class Fixed16(KaitaiStruct):
+        """Fixed-point 16-bit number."""
+        SEQ_FIELDS = ["int_part", "frac_part"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['int_part']['start'] = self._io.pos()
+            self.int_part = self._io.read_s1()
+            self._debug['int_part']['end'] = self._io.pos()
+            self._debug['frac_part']['start'] = self._io.pos()
+            self.frac_part = self._io.read_u1()
+            self._debug['frac_part']['end'] = self._io.pos()
+
+
+    class Atom(KaitaiStruct):
+        SEQ_FIELDS = ["len32", "atom_type", "len64", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len32']['start'] = self._io.pos()
+            self.len32 = self._io.read_u4be()
+            self._debug['len32']['end'] = self._io.pos()
+            self._debug['atom_type']['start'] = self._io.pos()
+            self.atom_type = KaitaiStream.resolve_enum(self._root.AtomType, self._io.read_u4be())
+            self._debug['atom_type']['end'] = self._io.pos()
+            if self.len32 == 1:
+                self._debug['len64']['start'] = self._io.pos()
+                self.len64 = self._io.read_u8be()
+                self._debug['len64']['end'] = self._io.pos()
+
+            self._debug['body']['start'] = self._io.pos()
+            _on = self.atom_type
+            if _on == self._root.AtomType.moof:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.tkhd:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.TkhdBody(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.stbl:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.traf:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.minf:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.trak:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.moov:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.mdia:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.dinf:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.AtomList(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.mvhd:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.MvhdBody(io, self, self._root)
+                self.body._read()
+            elif _on == self._root.AtomType.ftyp:
+                self._raw_body = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_body))
+                self.body = self._root.FtypBody(io, self, self._root)
+                self.body._read()
+            else:
+                self.body = self._io.read_bytes(self.len)
+            self._debug['body']['end'] = self._io.pos()
+
+        @property
+        def len(self):
+            if hasattr(self, '_m_len'):
+                return self._m_len if hasattr(self, '_m_len') else None
+
+            self._m_len = ((self._io.size() - 8) if self.len32 == 0 else ((self.len64 - 16) if self.len32 == 1 else (self.len32 - 8)))
+            return self._m_len if hasattr(self, '_m_len') else None
+
+
+    class TkhdBody(KaitaiStruct):
+        """
+        .. seealso::
+           Source - https://developer.apple.com/library/content/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25550
+        """
+        SEQ_FIELDS = ["version", "flags", "creation_time", "modification_time", "track_id", "reserved1", "duration", "reserved2", "layer", "alternative_group", "volume", "reserved3", "matrix", "width", "height"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u1()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._io.read_bytes(3)
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['creation_time']['start'] = self._io.pos()
+            self.creation_time = self._io.read_u4be()
+            self._debug['creation_time']['end'] = self._io.pos()
+            self._debug['modification_time']['start'] = self._io.pos()
+            self.modification_time = self._io.read_u4be()
+            self._debug['modification_time']['end'] = self._io.pos()
+            self._debug['track_id']['start'] = self._io.pos()
+            self.track_id = self._io.read_u4be()
+            self._debug['track_id']['end'] = self._io.pos()
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bytes(4)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['duration']['start'] = self._io.pos()
+            self.duration = self._io.read_u4be()
+            self._debug['duration']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bytes(8)
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['layer']['start'] = self._io.pos()
+            self.layer = self._io.read_u2be()
+            self._debug['layer']['end'] = self._io.pos()
+            self._debug['alternative_group']['start'] = self._io.pos()
+            self.alternative_group = self._io.read_u2be()
+            self._debug['alternative_group']['end'] = self._io.pos()
+            self._debug['volume']['start'] = self._io.pos()
+            self.volume = self._io.read_u2be()
+            self._debug['volume']['end'] = self._io.pos()
+            self._debug['reserved3']['start'] = self._io.pos()
+            self.reserved3 = self._io.read_u2be()
+            self._debug['reserved3']['end'] = self._io.pos()
+            self._debug['matrix']['start'] = self._io.pos()
+            self.matrix = self._io.read_bytes(36)
+            self._debug['matrix']['end'] = self._io.pos()
+            self._debug['width']['start'] = self._io.pos()
+            self.width = self._root.Fixed32(self._io, self, self._root)
+            self.width._read()
+            self._debug['width']['end'] = self._io.pos()
+            self._debug['height']['start'] = self._io.pos()
+            self.height = self._root.Fixed32(self._io, self, self._root)
+            self.height._read()
+            self._debug['height']['end'] = self._io.pos()
+
+
+    class AtomList(KaitaiStruct):
+        SEQ_FIELDS = ["items"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['items']['start'] = self._io.pos()
+            self.items = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['items']:
+                    self._debug['items']['arr'] = []
+                self._debug['items']['arr'].append({'start': self._io.pos()})
+                _t_items = self._root.Atom(self._io, self, self._root)
+                _t_items._read()
+                self.items.append(_t_items)
+                self._debug['items']['arr'][len(self.items) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['items']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/standard_midi_file.py b/python/examples/kaitai/kaitai_struct_formats/media/standard_midi_file.py
new file mode 100644
index 00000000..6cd7c246
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/standard_midi_file.py
@@ -0,0 +1,386 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+from vlq_base128_be import VlqBase128Be
+class StandardMidiFile(KaitaiStruct):
+    """Standard MIDI file, typically knows just as "MID", is a standard way
+    to serialize series of MIDI events, which is a protocol used in many
+    music synthesizers to transfer music data: notes being played,
+    effects being applied, etc.
+    
+    Internally, file consists of a header and series of tracks, every
+    track listing MIDI events with certain header designating time these
+    events are happening.
+    
+    NOTE: Rarely, MIDI files employ certain stateful compression scheme
+    to avoid storing certain elements of further elements, instead
+    reusing them from events which happened earlier in the
+    stream. Kaitai Struct (as of v0.9) is currently unable to parse
+    these, but files employing this mechanism are relatively rare.
+    """
+    SEQ_FIELDS = ["hdr", "tracks"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['hdr']['start'] = self._io.pos()
+        self.hdr = self._root.Header(self._io, self, self._root)
+        self.hdr._read()
+        self._debug['hdr']['end'] = self._io.pos()
+        self._debug['tracks']['start'] = self._io.pos()
+        self.tracks = [None] * (self.hdr.num_tracks)
+        for i in range(self.hdr.num_tracks):
+            if not 'arr' in self._debug['tracks']:
+                self._debug['tracks']['arr'] = []
+            self._debug['tracks']['arr'].append({'start': self._io.pos()})
+            _t_tracks = self._root.Track(self._io, self, self._root)
+            _t_tracks._read()
+            self.tracks[i] = _t_tracks
+            self._debug['tracks']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['tracks']['end'] = self._io.pos()
+
+    class TrackEvents(KaitaiStruct):
+        SEQ_FIELDS = ["event"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['event']['start'] = self._io.pos()
+            self.event = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['event']:
+                    self._debug['event']['arr'] = []
+                self._debug['event']['arr'].append({'start': self._io.pos()})
+                _t_event = self._root.TrackEvent(self._io, self, self._root)
+                _t_event._read()
+                self.event.append(_t_event)
+                self._debug['event']['arr'][len(self.event) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['event']['end'] = self._io.pos()
+
+
+    class TrackEvent(KaitaiStruct):
+        SEQ_FIELDS = ["v_time", "event_header", "meta_event_body", "sysex_body", "event_body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['v_time']['start'] = self._io.pos()
+            self.v_time = VlqBase128Be(self._io)
+            self.v_time._read()
+            self._debug['v_time']['end'] = self._io.pos()
+            self._debug['event_header']['start'] = self._io.pos()
+            self.event_header = self._io.read_u1()
+            self._debug['event_header']['end'] = self._io.pos()
+            if self.event_header == 255:
+                self._debug['meta_event_body']['start'] = self._io.pos()
+                self.meta_event_body = self._root.MetaEventBody(self._io, self, self._root)
+                self.meta_event_body._read()
+                self._debug['meta_event_body']['end'] = self._io.pos()
+
+            if self.event_header == 240:
+                self._debug['sysex_body']['start'] = self._io.pos()
+                self.sysex_body = self._root.SysexEventBody(self._io, self, self._root)
+                self.sysex_body._read()
+                self._debug['sysex_body']['end'] = self._io.pos()
+
+            self._debug['event_body']['start'] = self._io.pos()
+            _on = self.event_type
+            if _on == 224:
+                self.event_body = self._root.PitchBendEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 144:
+                self.event_body = self._root.NoteOnEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 208:
+                self.event_body = self._root.ChannelPressureEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 192:
+                self.event_body = self._root.ProgramChangeEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 160:
+                self.event_body = self._root.PolyphonicPressureEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 176:
+                self.event_body = self._root.ControllerEvent(self._io, self, self._root)
+                self.event_body._read()
+            elif _on == 128:
+                self.event_body = self._root.NoteOffEvent(self._io, self, self._root)
+                self.event_body._read()
+            self._debug['event_body']['end'] = self._io.pos()
+
+        @property
+        def event_type(self):
+            if hasattr(self, '_m_event_type'):
+                return self._m_event_type if hasattr(self, '_m_event_type') else None
+
+            self._m_event_type = (self.event_header & 240)
+            return self._m_event_type if hasattr(self, '_m_event_type') else None
+
+        @property
+        def channel(self):
+            if hasattr(self, '_m_channel'):
+                return self._m_channel if hasattr(self, '_m_channel') else None
+
+            if self.event_type != 240:
+                self._m_channel = (self.event_header & 15)
+
+            return self._m_channel if hasattr(self, '_m_channel') else None
+
+
+    class PitchBendEvent(KaitaiStruct):
+        SEQ_FIELDS = ["b1", "b2"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['b1']['start'] = self._io.pos()
+            self.b1 = self._io.read_u1()
+            self._debug['b1']['end'] = self._io.pos()
+            self._debug['b2']['start'] = self._io.pos()
+            self.b2 = self._io.read_u1()
+            self._debug['b2']['end'] = self._io.pos()
+
+        @property
+        def bend_value(self):
+            if hasattr(self, '_m_bend_value'):
+                return self._m_bend_value if hasattr(self, '_m_bend_value') else None
+
+            self._m_bend_value = (((self.b2 << 7) + self.b1) - 16384)
+            return self._m_bend_value if hasattr(self, '_m_bend_value') else None
+
+        @property
+        def adj_bend_value(self):
+            if hasattr(self, '_m_adj_bend_value'):
+                return self._m_adj_bend_value if hasattr(self, '_m_adj_bend_value') else None
+
+            self._m_adj_bend_value = (self.bend_value - 16384)
+            return self._m_adj_bend_value if hasattr(self, '_m_adj_bend_value') else None
+
+
+    class ProgramChangeEvent(KaitaiStruct):
+        SEQ_FIELDS = ["program"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['program']['start'] = self._io.pos()
+            self.program = self._io.read_u1()
+            self._debug['program']['end'] = self._io.pos()
+
+
+    class NoteOnEvent(KaitaiStruct):
+        SEQ_FIELDS = ["note", "velocity"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['note']['start'] = self._io.pos()
+            self.note = self._io.read_u1()
+            self._debug['note']['end'] = self._io.pos()
+            self._debug['velocity']['start'] = self._io.pos()
+            self.velocity = self._io.read_u1()
+            self._debug['velocity']['end'] = self._io.pos()
+
+
+    class PolyphonicPressureEvent(KaitaiStruct):
+        SEQ_FIELDS = ["note", "pressure"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['note']['start'] = self._io.pos()
+            self.note = self._io.read_u1()
+            self._debug['note']['end'] = self._io.pos()
+            self._debug['pressure']['start'] = self._io.pos()
+            self.pressure = self._io.read_u1()
+            self._debug['pressure']['end'] = self._io.pos()
+
+
+    class Track(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "len_events", "events"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x4D\x54\x72\x6B")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['len_events']['start'] = self._io.pos()
+            self.len_events = self._io.read_u4be()
+            self._debug['len_events']['end'] = self._io.pos()
+            self._debug['events']['start'] = self._io.pos()
+            self._raw_events = self._io.read_bytes(self.len_events)
+            io = KaitaiStream(BytesIO(self._raw_events))
+            self.events = self._root.TrackEvents(io, self, self._root)
+            self.events._read()
+            self._debug['events']['end'] = self._io.pos()
+
+
+    class MetaEventBody(KaitaiStruct):
+
+        class MetaTypeEnum(Enum):
+            sequence_number = 0
+            text_event = 1
+            copyright = 2
+            sequence_track_name = 3
+            instrument_name = 4
+            lyric_text = 5
+            marker_text = 6
+            cue_point = 7
+            midi_channel_prefix_assignment = 32
+            end_of_track = 47
+            tempo = 81
+            smpte_offset = 84
+            time_signature = 88
+            key_signature = 89
+            sequencer_specific_event = 127
+        SEQ_FIELDS = ["meta_type", "len", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['meta_type']['start'] = self._io.pos()
+            self.meta_type = KaitaiStream.resolve_enum(self._root.MetaEventBody.MetaTypeEnum, self._io.read_u1())
+            self._debug['meta_type']['end'] = self._io.pos()
+            self._debug['len']['start'] = self._io.pos()
+            self.len = VlqBase128Be(self._io)
+            self.len._read()
+            self._debug['len']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            self.body = self._io.read_bytes(self.len.value)
+            self._debug['body']['end'] = self._io.pos()
+
+
+    class ControllerEvent(KaitaiStruct):
+        SEQ_FIELDS = ["controller", "value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['controller']['start'] = self._io.pos()
+            self.controller = self._io.read_u1()
+            self._debug['controller']['end'] = self._io.pos()
+            self._debug['value']['start'] = self._io.pos()
+            self.value = self._io.read_u1()
+            self._debug['value']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "len_header", "format", "num_tracks", "division"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x4D\x54\x68\x64")
+            self._debug['magic']['end'] = self._io.pos()
+            self._debug['len_header']['start'] = self._io.pos()
+            self.len_header = self._io.read_u4be()
+            self._debug['len_header']['end'] = self._io.pos()
+            self._debug['format']['start'] = self._io.pos()
+            self.format = self._io.read_u2be()
+            self._debug['format']['end'] = self._io.pos()
+            self._debug['num_tracks']['start'] = self._io.pos()
+            self.num_tracks = self._io.read_u2be()
+            self._debug['num_tracks']['end'] = self._io.pos()
+            self._debug['division']['start'] = self._io.pos()
+            self.division = self._io.read_s2be()
+            self._debug['division']['end'] = self._io.pos()
+
+
+    class SysexEventBody(KaitaiStruct):
+        SEQ_FIELDS = ["len", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len']['start'] = self._io.pos()
+            self.len = VlqBase128Be(self._io)
+            self.len._read()
+            self._debug['len']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(self.len.value)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class NoteOffEvent(KaitaiStruct):
+        SEQ_FIELDS = ["note", "velocity"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['note']['start'] = self._io.pos()
+            self.note = self._io.read_u1()
+            self._debug['note']['end'] = self._io.pos()
+            self._debug['velocity']['start'] = self._io.pos()
+            self.velocity = self._io.read_u1()
+            self._debug['velocity']['end'] = self._io.pos()
+
+
+    class ChannelPressureEvent(KaitaiStruct):
+        SEQ_FIELDS = ["pressure"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['pressure']['start'] = self._io.pos()
+            self.pressure = self._io.read_u1()
+            self._debug['pressure']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/stl.py b/python/examples/kaitai/kaitai_struct_formats/media/stl.py
new file mode 100644
index 00000000..381f3319
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/stl.py
@@ -0,0 +1,108 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Stl(KaitaiStruct):
+    """STL files are used to represent simple 3D models, defined using
+    triangular 3D faces.
+    
+    Initially it was introduced as native format for 3D Systems
+    Stereolithography CAD system, but due to its extreme simplicity, it
+    was adopted by a wide range of 3D modelling, CAD, rapid prototyping
+    and 3D printing applications as the simplest 3D model exchange
+    format.
+    
+    STL is extremely bare-bones format: there are no complex headers, no
+    texture / color support, no units specifications, no distinct vertex
+    arrays. Whole model is specified as a collection of triangular
+    faces.
+    
+    There are two versions of the format (text and binary), this spec
+    describes binary version.
+    """
+    SEQ_FIELDS = ["header", "num_triangles", "triangles"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['header']['start'] = self._io.pos()
+        self.header = self._io.read_bytes(80)
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['num_triangles']['start'] = self._io.pos()
+        self.num_triangles = self._io.read_u4le()
+        self._debug['num_triangles']['end'] = self._io.pos()
+        self._debug['triangles']['start'] = self._io.pos()
+        self.triangles = [None] * (self.num_triangles)
+        for i in range(self.num_triangles):
+            if not 'arr' in self._debug['triangles']:
+                self._debug['triangles']['arr'] = []
+            self._debug['triangles']['arr'].append({'start': self._io.pos()})
+            _t_triangles = self._root.Triangle(self._io, self, self._root)
+            _t_triangles._read()
+            self.triangles[i] = _t_triangles
+            self._debug['triangles']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['triangles']['end'] = self._io.pos()
+
+    class Triangle(KaitaiStruct):
+        """Each STL triangle is defined by its 3 points in 3D space and a
+        normal vector, which is generally used to determine where is
+        "inside" and "outside" of the model.
+        """
+        SEQ_FIELDS = ["normal", "vertices"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['normal']['start'] = self._io.pos()
+            self.normal = self._root.Vec3d(self._io, self, self._root)
+            self.normal._read()
+            self._debug['normal']['end'] = self._io.pos()
+            self._debug['vertices']['start'] = self._io.pos()
+            self.vertices = [None] * (3)
+            for i in range(3):
+                if not 'arr' in self._debug['vertices']:
+                    self._debug['vertices']['arr'] = []
+                self._debug['vertices']['arr'].append({'start': self._io.pos()})
+                _t_vertices = self._root.Vec3d(self._io, self, self._root)
+                _t_vertices._read()
+                self.vertices[i] = _t_vertices
+                self._debug['vertices']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['vertices']['end'] = self._io.pos()
+
+
+    class Vec3d(KaitaiStruct):
+        SEQ_FIELDS = ["x", "y", "z"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['x']['start'] = self._io.pos()
+            self.x = self._io.read_f4le()
+            self._debug['x']['end'] = self._io.pos()
+            self._debug['y']['start'] = self._io.pos()
+            self.y = self._io.read_f4le()
+            self._debug['y']['end'] = self._io.pos()
+            self._debug['z']['start'] = self._io.pos()
+            self.z = self._io.read_f4le()
+            self._debug['z']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/__init__.py b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/__init__.py
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/fasttracker_xm_module.py b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/fasttracker_xm_module.py
new file mode 100644
index 00000000..fad6c2cc
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/fasttracker_xm_module.py
@@ -0,0 +1,554 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ....kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class FasttrackerXmModule(KaitaiStruct):
+    """XM (standing for eXtended Module) is a popular module music file
+    format, that was introduced in 1994 in FastTracker2 by Triton demo
+    group. Akin to MOD files, it bundles both digital samples
+    (instruments) and instructions on which note to play at what time
+    (patterns), which provides good audio quality with relatively small
+    file size. Audio is reproducible without relying on the sound of
+    particular hardware samplers or synths.
+    
+    .. seealso::
+       Source - http://sid.ethz.ch/debian/milkytracker/milkytracker-0.90.85%2Bdfsg/resources/reference/xm-form.txt
+       ftp://ftp.modland.com/pub/documents/format_documentation/FastTracker%202%20v2.04%20(.xm).html
+    """
+    SEQ_FIELDS = ["preheader", "header", "patterns", "instruments"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['preheader']['start'] = self._io.pos()
+        self.preheader = self._root.Preheader(self._io, self, self._root)
+        self.preheader._read()
+        self._debug['preheader']['end'] = self._io.pos()
+        self._debug['header']['start'] = self._io.pos()
+        self._raw_header = self._io.read_bytes((self.preheader.header_size - 4))
+        io = KaitaiStream(BytesIO(self._raw_header))
+        self.header = self._root.Header(io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+        self._debug['patterns']['start'] = self._io.pos()
+        self.patterns = [None] * (self.header.num_patterns)
+        for i in range(self.header.num_patterns):
+            if not 'arr' in self._debug['patterns']:
+                self._debug['patterns']['arr'] = []
+            self._debug['patterns']['arr'].append({'start': self._io.pos()})
+            _t_patterns = self._root.Pattern(self._io, self, self._root)
+            _t_patterns._read()
+            self.patterns[i] = _t_patterns
+            self._debug['patterns']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['patterns']['end'] = self._io.pos()
+        self._debug['instruments']['start'] = self._io.pos()
+        self.instruments = [None] * (self.header.num_instruments)
+        for i in range(self.header.num_instruments):
+            if not 'arr' in self._debug['instruments']:
+                self._debug['instruments']['arr'] = []
+            self._debug['instruments']['arr'].append({'start': self._io.pos()})
+            _t_instruments = self._root.Instrument(self._io, self, self._root)
+            _t_instruments._read()
+            self.instruments[i] = _t_instruments
+            self._debug['instruments']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['instruments']['end'] = self._io.pos()
+
+    class Preheader(KaitaiStruct):
+        SEQ_FIELDS = ["signature0", "module_name", "signature1", "tracker_name", "version_number", "header_size"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['signature0']['start'] = self._io.pos()
+            self.signature0 = self._io.ensure_fixed_contents(b"\x45\x78\x74\x65\x6E\x64\x65\x64\x20\x4D\x6F\x64\x75\x6C\x65\x3A\x20")
+            self._debug['signature0']['end'] = self._io.pos()
+            self._debug['module_name']['start'] = self._io.pos()
+            self.module_name = (KaitaiStream.bytes_terminate(self._io.read_bytes(20), 0, False)).decode(u"utf-8")
+            self._debug['module_name']['end'] = self._io.pos()
+            self._debug['signature1']['start'] = self._io.pos()
+            self.signature1 = self._io.ensure_fixed_contents(b"\x1A")
+            self._debug['signature1']['end'] = self._io.pos()
+            self._debug['tracker_name']['start'] = self._io.pos()
+            self.tracker_name = (KaitaiStream.bytes_terminate(self._io.read_bytes(20), 0, False)).decode(u"utf-8")
+            self._debug['tracker_name']['end'] = self._io.pos()
+            self._debug['version_number']['start'] = self._io.pos()
+            self.version_number = self._root.Preheader.Version(self._io, self, self._root)
+            self.version_number._read()
+            self._debug['version_number']['end'] = self._io.pos()
+            self._debug['header_size']['start'] = self._io.pos()
+            self.header_size = self._io.read_u4le()
+            self._debug['header_size']['end'] = self._io.pos()
+
+        class Version(KaitaiStruct):
+            SEQ_FIELDS = ["minor", "major"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['minor']['start'] = self._io.pos()
+                self.minor = self._io.read_u1()
+                self._debug['minor']['end'] = self._io.pos()
+                self._debug['major']['start'] = self._io.pos()
+                self.major = self._io.read_u1()
+                self._debug['major']['end'] = self._io.pos()
+
+            @property
+            def value(self):
+                if hasattr(self, '_m_value'):
+                    return self._m_value if hasattr(self, '_m_value') else None
+
+                self._m_value = ((self.major << 8) | self.minor)
+                return self._m_value if hasattr(self, '_m_value') else None
+
+
+
+    class Pattern(KaitaiStruct):
+        SEQ_FIELDS = ["header", "packed_data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['header']['start'] = self._io.pos()
+            self.header = self._root.Pattern.Header(self._io, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            self._debug['packed_data']['start'] = self._io.pos()
+            self.packed_data = self._io.read_bytes(self.header.main.len_packed_pattern)
+            self._debug['packed_data']['end'] = self._io.pos()
+
+        class Header(KaitaiStruct):
+            SEQ_FIELDS = ["header_length", "main"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['header_length']['start'] = self._io.pos()
+                self.header_length = self._io.read_u4le()
+                self._debug['header_length']['end'] = self._io.pos()
+                self._debug['main']['start'] = self._io.pos()
+                self._raw_main = self._io.read_bytes((self.header_length - 4))
+                io = KaitaiStream(BytesIO(self._raw_main))
+                self.main = self._root.Pattern.Header.HeaderMain(io, self, self._root)
+                self.main._read()
+                self._debug['main']['end'] = self._io.pos()
+
+            class HeaderMain(KaitaiStruct):
+                SEQ_FIELDS = ["packing_type", "num_rows_raw", "len_packed_pattern"]
+                def __init__(self, _io, _parent=None, _root=None):
+                    self._io = _io
+                    self._parent = _parent
+                    self._root = _root if _root else self
+                    self._debug = collections.defaultdict(dict)
+
+                def _read(self):
+                    self._debug['packing_type']['start'] = self._io.pos()
+                    self.packing_type = self._io.read_u1()
+                    self._debug['packing_type']['end'] = self._io.pos()
+                    self._debug['num_rows_raw']['start'] = self._io.pos()
+                    _on = self._root.preheader.version_number.value
+                    if _on == 258:
+                        self.num_rows_raw = self._io.read_u1()
+                    else:
+                        self.num_rows_raw = self._io.read_u2le()
+                    self._debug['num_rows_raw']['end'] = self._io.pos()
+                    self._debug['len_packed_pattern']['start'] = self._io.pos()
+                    self.len_packed_pattern = self._io.read_u2le()
+                    self._debug['len_packed_pattern']['end'] = self._io.pos()
+
+                @property
+                def num_rows(self):
+                    if hasattr(self, '_m_num_rows'):
+                        return self._m_num_rows if hasattr(self, '_m_num_rows') else None
+
+                    self._m_num_rows = (self.num_rows_raw + (1 if self._root.preheader.version_number.value == 258 else 0))
+                    return self._m_num_rows if hasattr(self, '_m_num_rows') else None
+
+
+
+
+    class Flags(KaitaiStruct):
+        SEQ_FIELDS = ["reserved", "freq_table_type"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bits_int(15)
+            self._debug['reserved']['end'] = self._io.pos()
+            self._debug['freq_table_type']['start'] = self._io.pos()
+            self.freq_table_type = self._io.read_bits_int(1) != 0
+            self._debug['freq_table_type']['end'] = self._io.pos()
+
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["song_length", "restart_position", "num_channels", "num_patterns", "num_instruments", "flags", "default_tempo", "default_bpm", "pattern_order_table"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['song_length']['start'] = self._io.pos()
+            self.song_length = self._io.read_u2le()
+            self._debug['song_length']['end'] = self._io.pos()
+            self._debug['restart_position']['start'] = self._io.pos()
+            self.restart_position = self._io.read_u2le()
+            self._debug['restart_position']['end'] = self._io.pos()
+            self._debug['num_channels']['start'] = self._io.pos()
+            self.num_channels = self._io.read_u2le()
+            self._debug['num_channels']['end'] = self._io.pos()
+            self._debug['num_patterns']['start'] = self._io.pos()
+            self.num_patterns = self._io.read_u2le()
+            self._debug['num_patterns']['end'] = self._io.pos()
+            self._debug['num_instruments']['start'] = self._io.pos()
+            self.num_instruments = self._io.read_u2le()
+            self._debug['num_instruments']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = self._root.Flags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['default_tempo']['start'] = self._io.pos()
+            self.default_tempo = self._io.read_u2le()
+            self._debug['default_tempo']['end'] = self._io.pos()
+            self._debug['default_bpm']['start'] = self._io.pos()
+            self.default_bpm = self._io.read_u2le()
+            self._debug['default_bpm']['end'] = self._io.pos()
+            self._debug['pattern_order_table']['start'] = self._io.pos()
+            self.pattern_order_table = [None] * (256)
+            for i in range(256):
+                if not 'arr' in self._debug['pattern_order_table']:
+                    self._debug['pattern_order_table']['arr'] = []
+                self._debug['pattern_order_table']['arr'].append({'start': self._io.pos()})
+                self.pattern_order_table[i] = self._io.read_u1()
+                self._debug['pattern_order_table']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['pattern_order_table']['end'] = self._io.pos()
+
+
+    class Instrument(KaitaiStruct):
+        """XM's notion of "instrument" typically constitutes of a
+        instrument metadata and one or several samples. Metadata
+        includes:
+        
+        * instrument's name
+        * instruction of which sample to use for which note
+        * volume and panning envelopes and looping instructions
+        * vibrato settings
+        """
+        SEQ_FIELDS = ["header_size", "header", "samples_headers", "samples"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['header_size']['start'] = self._io.pos()
+            self.header_size = self._io.read_u4le()
+            self._debug['header_size']['end'] = self._io.pos()
+            self._debug['header']['start'] = self._io.pos()
+            self._raw_header = self._io.read_bytes((self.header_size - 4))
+            io = KaitaiStream(BytesIO(self._raw_header))
+            self.header = self._root.Instrument.Header(io, self, self._root)
+            self.header._read()
+            self._debug['header']['end'] = self._io.pos()
+            self._debug['samples_headers']['start'] = self._io.pos()
+            self.samples_headers = [None] * (self.header.num_samples)
+            for i in range(self.header.num_samples):
+                if not 'arr' in self._debug['samples_headers']:
+                    self._debug['samples_headers']['arr'] = []
+                self._debug['samples_headers']['arr'].append({'start': self._io.pos()})
+                _t_samples_headers = self._root.Instrument.SampleHeader(self._io, self, self._root)
+                _t_samples_headers._read()
+                self.samples_headers[i] = _t_samples_headers
+                self._debug['samples_headers']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['samples_headers']['end'] = self._io.pos()
+            self._debug['samples']['start'] = self._io.pos()
+            self.samples = [None] * (self.header.num_samples)
+            for i in range(self.header.num_samples):
+                if not 'arr' in self._debug['samples']:
+                    self._debug['samples']['arr'] = []
+                self._debug['samples']['arr'].append({'start': self._io.pos()})
+                _t_samples = self._root.Instrument.SamplesData(self.samples_headers[i], self._io, self, self._root)
+                _t_samples._read()
+                self.samples[i] = _t_samples
+                self._debug['samples']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['samples']['end'] = self._io.pos()
+
+        class Header(KaitaiStruct):
+            SEQ_FIELDS = ["name", "type", "num_samples", "extra_header"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['name']['start'] = self._io.pos()
+                self.name = (KaitaiStream.bytes_terminate(self._io.read_bytes(22), 0, False)).decode(u"utf-8")
+                self._debug['name']['end'] = self._io.pos()
+                self._debug['type']['start'] = self._io.pos()
+                self.type = self._io.read_u1()
+                self._debug['type']['end'] = self._io.pos()
+                self._debug['num_samples']['start'] = self._io.pos()
+                self.num_samples = self._io.read_u2le()
+                self._debug['num_samples']['end'] = self._io.pos()
+                if self.num_samples > 0:
+                    self._debug['extra_header']['start'] = self._io.pos()
+                    self.extra_header = self._root.Instrument.ExtraHeader(self._io, self, self._root)
+                    self.extra_header._read()
+                    self._debug['extra_header']['end'] = self._io.pos()
+
+
+
+        class ExtraHeader(KaitaiStruct):
+
+            class Type(Enum):
+                true = 0
+                sustain = 1
+                loop = 2
+            SEQ_FIELDS = ["len_sample_header", "idx_sample_per_note", "volume_points", "panning_points", "num_volume_points", "num_panning_points", "volume_sustain_point", "volume_loop_start_point", "volume_loop_end_point", "panning_sustain_point", "panning_loop_start_point", "panning_loop_end_point", "volume_type", "panning_type", "vibrato_type", "vibrato_sweep", "vibrato_depth", "vibrato_rate", "volume_fadeout", "reserved"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['len_sample_header']['start'] = self._io.pos()
+                self.len_sample_header = self._io.read_u4le()
+                self._debug['len_sample_header']['end'] = self._io.pos()
+                self._debug['idx_sample_per_note']['start'] = self._io.pos()
+                self.idx_sample_per_note = [None] * (96)
+                for i in range(96):
+                    if not 'arr' in self._debug['idx_sample_per_note']:
+                        self._debug['idx_sample_per_note']['arr'] = []
+                    self._debug['idx_sample_per_note']['arr'].append({'start': self._io.pos()})
+                    self.idx_sample_per_note[i] = self._io.read_u1()
+                    self._debug['idx_sample_per_note']['arr'][i]['end'] = self._io.pos()
+
+                self._debug['idx_sample_per_note']['end'] = self._io.pos()
+                self._debug['volume_points']['start'] = self._io.pos()
+                self.volume_points = [None] * (12)
+                for i in range(12):
+                    if not 'arr' in self._debug['volume_points']:
+                        self._debug['volume_points']['arr'] = []
+                    self._debug['volume_points']['arr'].append({'start': self._io.pos()})
+                    _t_volume_points = self._root.Instrument.ExtraHeader.EnvelopePoint(self._io, self, self._root)
+                    _t_volume_points._read()
+                    self.volume_points[i] = _t_volume_points
+                    self._debug['volume_points']['arr'][i]['end'] = self._io.pos()
+
+                self._debug['volume_points']['end'] = self._io.pos()
+                self._debug['panning_points']['start'] = self._io.pos()
+                self.panning_points = [None] * (12)
+                for i in range(12):
+                    if not 'arr' in self._debug['panning_points']:
+                        self._debug['panning_points']['arr'] = []
+                    self._debug['panning_points']['arr'].append({'start': self._io.pos()})
+                    _t_panning_points = self._root.Instrument.ExtraHeader.EnvelopePoint(self._io, self, self._root)
+                    _t_panning_points._read()
+                    self.panning_points[i] = _t_panning_points
+                    self._debug['panning_points']['arr'][i]['end'] = self._io.pos()
+
+                self._debug['panning_points']['end'] = self._io.pos()
+                self._debug['num_volume_points']['start'] = self._io.pos()
+                self.num_volume_points = self._io.read_u1()
+                self._debug['num_volume_points']['end'] = self._io.pos()
+                self._debug['num_panning_points']['start'] = self._io.pos()
+                self.num_panning_points = self._io.read_u1()
+                self._debug['num_panning_points']['end'] = self._io.pos()
+                self._debug['volume_sustain_point']['start'] = self._io.pos()
+                self.volume_sustain_point = self._io.read_u1()
+                self._debug['volume_sustain_point']['end'] = self._io.pos()
+                self._debug['volume_loop_start_point']['start'] = self._io.pos()
+                self.volume_loop_start_point = self._io.read_u1()
+                self._debug['volume_loop_start_point']['end'] = self._io.pos()
+                self._debug['volume_loop_end_point']['start'] = self._io.pos()
+                self.volume_loop_end_point = self._io.read_u1()
+                self._debug['volume_loop_end_point']['end'] = self._io.pos()
+                self._debug['panning_sustain_point']['start'] = self._io.pos()
+                self.panning_sustain_point = self._io.read_u1()
+                self._debug['panning_sustain_point']['end'] = self._io.pos()
+                self._debug['panning_loop_start_point']['start'] = self._io.pos()
+                self.panning_loop_start_point = self._io.read_u1()
+                self._debug['panning_loop_start_point']['end'] = self._io.pos()
+                self._debug['panning_loop_end_point']['start'] = self._io.pos()
+                self.panning_loop_end_point = self._io.read_u1()
+                self._debug['panning_loop_end_point']['end'] = self._io.pos()
+                self._debug['volume_type']['start'] = self._io.pos()
+                self.volume_type = KaitaiStream.resolve_enum(self._root.Instrument.ExtraHeader.Type, self._io.read_u1())
+                self._debug['volume_type']['end'] = self._io.pos()
+                self._debug['panning_type']['start'] = self._io.pos()
+                self.panning_type = KaitaiStream.resolve_enum(self._root.Instrument.ExtraHeader.Type, self._io.read_u1())
+                self._debug['panning_type']['end'] = self._io.pos()
+                self._debug['vibrato_type']['start'] = self._io.pos()
+                self.vibrato_type = self._io.read_u1()
+                self._debug['vibrato_type']['end'] = self._io.pos()
+                self._debug['vibrato_sweep']['start'] = self._io.pos()
+                self.vibrato_sweep = self._io.read_u1()
+                self._debug['vibrato_sweep']['end'] = self._io.pos()
+                self._debug['vibrato_depth']['start'] = self._io.pos()
+                self.vibrato_depth = self._io.read_u1()
+                self._debug['vibrato_depth']['end'] = self._io.pos()
+                self._debug['vibrato_rate']['start'] = self._io.pos()
+                self.vibrato_rate = self._io.read_u1()
+                self._debug['vibrato_rate']['end'] = self._io.pos()
+                self._debug['volume_fadeout']['start'] = self._io.pos()
+                self.volume_fadeout = self._io.read_u2le()
+                self._debug['volume_fadeout']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_u2le()
+                self._debug['reserved']['end'] = self._io.pos()
+
+            class EnvelopePoint(KaitaiStruct):
+                """Envelope frame-counters work in range 0..FFFFh (0..65535 dec).
+                BUT! FT2 only itself supports only range 0..FFh (0..255 dec).
+                Some other trackers (like SoundTracker for Unix), however, can use the full range 0..FFFF, so it should be supported.
+                !!TIP: This is also a good way to detect if the module has been made with FT2 or not. (In case the tracker name is brain- deadly left unchanged!)
+                Of course it does not help if all instruments have the values inside FT2 supported range.
+                The value-field of the envelope point is ranged between 00..3Fh (0..64 dec).
+                """
+                SEQ_FIELDS = ["x", "y"]
+                def __init__(self, _io, _parent=None, _root=None):
+                    self._io = _io
+                    self._parent = _parent
+                    self._root = _root if _root else self
+                    self._debug = collections.defaultdict(dict)
+
+                def _read(self):
+                    self._debug['x']['start'] = self._io.pos()
+                    self.x = self._io.read_u2le()
+                    self._debug['x']['end'] = self._io.pos()
+                    self._debug['y']['start'] = self._io.pos()
+                    self.y = self._io.read_u2le()
+                    self._debug['y']['end'] = self._io.pos()
+
+
+
+        class SamplesData(KaitaiStruct):
+            """The saved data uses simple delta-encoding to achieve better compression ratios (when compressed with pkzip, etc.)
+            Pseudocode for converting the delta-coded data to normal data,
+            old = 0;
+            for i in range(data_len):
+              new = sample[i] + old;
+              sample[i] = new;
+              old = new;
+            """
+            SEQ_FIELDS = ["data"]
+            def __init__(self, header, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self.header = header
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['data']['start'] = self._io.pos()
+                self.data = self._io.read_bytes((self.header.sample_length * (2 if self.header.type.is_sample_data_16_bit else 1)))
+                self._debug['data']['end'] = self._io.pos()
+
+
+        class SampleHeader(KaitaiStruct):
+            SEQ_FIELDS = ["sample_length", "sample_loop_start", "sample_loop_length", "volume", "fine_tune", "type", "panning", "relative_note_number", "reserved", "name"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['sample_length']['start'] = self._io.pos()
+                self.sample_length = self._io.read_u4le()
+                self._debug['sample_length']['end'] = self._io.pos()
+                self._debug['sample_loop_start']['start'] = self._io.pos()
+                self.sample_loop_start = self._io.read_u4le()
+                self._debug['sample_loop_start']['end'] = self._io.pos()
+                self._debug['sample_loop_length']['start'] = self._io.pos()
+                self.sample_loop_length = self._io.read_u4le()
+                self._debug['sample_loop_length']['end'] = self._io.pos()
+                self._debug['volume']['start'] = self._io.pos()
+                self.volume = self._io.read_u1()
+                self._debug['volume']['end'] = self._io.pos()
+                self._debug['fine_tune']['start'] = self._io.pos()
+                self.fine_tune = self._io.read_s1()
+                self._debug['fine_tune']['end'] = self._io.pos()
+                self._debug['type']['start'] = self._io.pos()
+                self.type = self._root.Instrument.SampleHeader.LoopType(self._io, self, self._root)
+                self.type._read()
+                self._debug['type']['end'] = self._io.pos()
+                self._debug['panning']['start'] = self._io.pos()
+                self.panning = self._io.read_u1()
+                self._debug['panning']['end'] = self._io.pos()
+                self._debug['relative_note_number']['start'] = self._io.pos()
+                self.relative_note_number = self._io.read_s1()
+                self._debug['relative_note_number']['end'] = self._io.pos()
+                self._debug['reserved']['start'] = self._io.pos()
+                self.reserved = self._io.read_u1()
+                self._debug['reserved']['end'] = self._io.pos()
+                self._debug['name']['start'] = self._io.pos()
+                self.name = (KaitaiStream.bytes_terminate(self._io.read_bytes(22), 0, False)).decode(u"utf-8")
+                self._debug['name']['end'] = self._io.pos()
+
+            class LoopType(KaitaiStruct):
+
+                class LoopType(Enum):
+                    none = 0
+                    forward = 1
+                    ping_pong = 2
+                SEQ_FIELDS = ["reserved0", "is_sample_data_16_bit", "reserved1", "loop_type"]
+                def __init__(self, _io, _parent=None, _root=None):
+                    self._io = _io
+                    self._parent = _parent
+                    self._root = _root if _root else self
+                    self._debug = collections.defaultdict(dict)
+
+                def _read(self):
+                    self._debug['reserved0']['start'] = self._io.pos()
+                    self.reserved0 = self._io.read_bits_int(3)
+                    self._debug['reserved0']['end'] = self._io.pos()
+                    self._debug['is_sample_data_16_bit']['start'] = self._io.pos()
+                    self.is_sample_data_16_bit = self._io.read_bits_int(1) != 0
+                    self._debug['is_sample_data_16_bit']['end'] = self._io.pos()
+                    self._debug['reserved1']['start'] = self._io.pos()
+                    self.reserved1 = self._io.read_bits_int(2)
+                    self._debug['reserved1']['end'] = self._io.pos()
+                    self._debug['loop_type']['start'] = self._io.pos()
+                    self.loop_type = KaitaiStream.resolve_enum(self._root.Instrument.SampleHeader.LoopType.LoopType, self._io.read_bits_int(2))
+                    self._debug['loop_type']['end'] = self._io.pos()
+
+
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/s3m.py b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/s3m.py
new file mode 100644
index 00000000..472291fc
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/tracker_modules/s3m.py
@@ -0,0 +1,485 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ....kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+from enum import Enum
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class S3m(KaitaiStruct):
+    """Scream Tracker 3 module is a tracker music file format that, as all
+    tracker music, bundles both sound samples and instructions on which
+    notes to play. It originates from a Scream Tracker 3 music editor
+    (1994) by Future Crew, derived from original Scream Tracker 2 (.stm)
+    module format.
+    
+    Instrument descriptions in S3M format allow to use either digital
+    samples or setup and control AdLib (OPL2) synth.
+    
+    Music is organized in so called `patterns`. "Pattern" is a generally
+    a 64-row long table, which instructs which notes to play on which
+    time measure. "Patterns" are played one-by-one in a sequence
+    determined by `orders`, which is essentially an array of pattern IDs
+    - this way it's possible to reuse certain patterns more than once
+    for repetitive musical phrases.
+    
+    .. seealso::
+       Source - http://hackipedia.org/File%20formats/Music/Sample%20based/text/Scream%20Tracker%203.20%20file%20format.cp437.txt.utf-8.txt
+    """
+    SEQ_FIELDS = ["song_name", "magic1", "file_type", "reserved1", "num_orders", "num_instruments", "num_patterns", "flags", "version", "samples_format", "magic2", "global_volume", "initial_speed", "initial_tempo", "is_stereo", "master_volume", "ultra_click_removal", "has_custom_pan", "reserved2", "ofs_special", "channels", "orders", "instruments", "patterns", "channel_pans"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['song_name']['start'] = self._io.pos()
+        self.song_name = KaitaiStream.bytes_terminate(self._io.read_bytes(28), 0, False)
+        self._debug['song_name']['end'] = self._io.pos()
+        self._debug['magic1']['start'] = self._io.pos()
+        self.magic1 = self._io.ensure_fixed_contents(b"\x1A")
+        self._debug['magic1']['end'] = self._io.pos()
+        self._debug['file_type']['start'] = self._io.pos()
+        self.file_type = self._io.read_u1()
+        self._debug['file_type']['end'] = self._io.pos()
+        self._debug['reserved1']['start'] = self._io.pos()
+        self.reserved1 = self._io.read_bytes(2)
+        self._debug['reserved1']['end'] = self._io.pos()
+        self._debug['num_orders']['start'] = self._io.pos()
+        self.num_orders = self._io.read_u2le()
+        self._debug['num_orders']['end'] = self._io.pos()
+        self._debug['num_instruments']['start'] = self._io.pos()
+        self.num_instruments = self._io.read_u2le()
+        self._debug['num_instruments']['end'] = self._io.pos()
+        self._debug['num_patterns']['start'] = self._io.pos()
+        self.num_patterns = self._io.read_u2le()
+        self._debug['num_patterns']['end'] = self._io.pos()
+        self._debug['flags']['start'] = self._io.pos()
+        self.flags = self._io.read_u2le()
+        self._debug['flags']['end'] = self._io.pos()
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u2le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['samples_format']['start'] = self._io.pos()
+        self.samples_format = self._io.read_u2le()
+        self._debug['samples_format']['end'] = self._io.pos()
+        self._debug['magic2']['start'] = self._io.pos()
+        self.magic2 = self._io.ensure_fixed_contents(b"\x53\x43\x52\x4D")
+        self._debug['magic2']['end'] = self._io.pos()
+        self._debug['global_volume']['start'] = self._io.pos()
+        self.global_volume = self._io.read_u1()
+        self._debug['global_volume']['end'] = self._io.pos()
+        self._debug['initial_speed']['start'] = self._io.pos()
+        self.initial_speed = self._io.read_u1()
+        self._debug['initial_speed']['end'] = self._io.pos()
+        self._debug['initial_tempo']['start'] = self._io.pos()
+        self.initial_tempo = self._io.read_u1()
+        self._debug['initial_tempo']['end'] = self._io.pos()
+        self._debug['is_stereo']['start'] = self._io.pos()
+        self.is_stereo = self._io.read_bits_int(1) != 0
+        self._debug['is_stereo']['end'] = self._io.pos()
+        self._debug['master_volume']['start'] = self._io.pos()
+        self.master_volume = self._io.read_bits_int(7)
+        self._debug['master_volume']['end'] = self._io.pos()
+        self._io.align_to_byte()
+        self._debug['ultra_click_removal']['start'] = self._io.pos()
+        self.ultra_click_removal = self._io.read_u1()
+        self._debug['ultra_click_removal']['end'] = self._io.pos()
+        self._debug['has_custom_pan']['start'] = self._io.pos()
+        self.has_custom_pan = self._io.read_u1()
+        self._debug['has_custom_pan']['end'] = self._io.pos()
+        self._debug['reserved2']['start'] = self._io.pos()
+        self.reserved2 = self._io.read_bytes(8)
+        self._debug['reserved2']['end'] = self._io.pos()
+        self._debug['ofs_special']['start'] = self._io.pos()
+        self.ofs_special = self._io.read_u2le()
+        self._debug['ofs_special']['end'] = self._io.pos()
+        self._debug['channels']['start'] = self._io.pos()
+        self.channels = [None] * (32)
+        for i in range(32):
+            if not 'arr' in self._debug['channels']:
+                self._debug['channels']['arr'] = []
+            self._debug['channels']['arr'].append({'start': self._io.pos()})
+            _t_channels = self._root.Channel(self._io, self, self._root)
+            _t_channels._read()
+            self.channels[i] = _t_channels
+            self._debug['channels']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['channels']['end'] = self._io.pos()
+        self._debug['orders']['start'] = self._io.pos()
+        self.orders = self._io.read_bytes(self.num_orders)
+        self._debug['orders']['end'] = self._io.pos()
+        self._debug['instruments']['start'] = self._io.pos()
+        self.instruments = [None] * (self.num_instruments)
+        for i in range(self.num_instruments):
+            if not 'arr' in self._debug['instruments']:
+                self._debug['instruments']['arr'] = []
+            self._debug['instruments']['arr'].append({'start': self._io.pos()})
+            _t_instruments = self._root.InstrumentPtr(self._io, self, self._root)
+            _t_instruments._read()
+            self.instruments[i] = _t_instruments
+            self._debug['instruments']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['instruments']['end'] = self._io.pos()
+        self._debug['patterns']['start'] = self._io.pos()
+        self.patterns = [None] * (self.num_patterns)
+        for i in range(self.num_patterns):
+            if not 'arr' in self._debug['patterns']:
+                self._debug['patterns']['arr'] = []
+            self._debug['patterns']['arr'].append({'start': self._io.pos()})
+            _t_patterns = self._root.PatternPtr(self._io, self, self._root)
+            _t_patterns._read()
+            self.patterns[i] = _t_patterns
+            self._debug['patterns']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['patterns']['end'] = self._io.pos()
+        if self.has_custom_pan == 252:
+            self._debug['channel_pans']['start'] = self._io.pos()
+            self.channel_pans = [None] * (32)
+            for i in range(32):
+                if not 'arr' in self._debug['channel_pans']:
+                    self._debug['channel_pans']['arr'] = []
+                self._debug['channel_pans']['arr'].append({'start': self._io.pos()})
+                _t_channel_pans = self._root.ChannelPan(self._io, self, self._root)
+                _t_channel_pans._read()
+                self.channel_pans[i] = _t_channel_pans
+                self._debug['channel_pans']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['channel_pans']['end'] = self._io.pos()
+
+
+    class ChannelPan(KaitaiStruct):
+        SEQ_FIELDS = ["reserved1", "has_custom_pan", "reserved2", "pan"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['reserved1']['start'] = self._io.pos()
+            self.reserved1 = self._io.read_bits_int(2)
+            self._debug['reserved1']['end'] = self._io.pos()
+            self._debug['has_custom_pan']['start'] = self._io.pos()
+            self.has_custom_pan = self._io.read_bits_int(1) != 0
+            self._debug['has_custom_pan']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bits_int(1) != 0
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['pan']['start'] = self._io.pos()
+            self.pan = self._io.read_bits_int(4)
+            self._debug['pan']['end'] = self._io.pos()
+
+
+    class PatternCell(KaitaiStruct):
+        SEQ_FIELDS = ["has_fx", "has_volume", "has_note_and_instrument", "channel_num", "note", "instrument", "volume", "fx_type", "fx_value"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['has_fx']['start'] = self._io.pos()
+            self.has_fx = self._io.read_bits_int(1) != 0
+            self._debug['has_fx']['end'] = self._io.pos()
+            self._debug['has_volume']['start'] = self._io.pos()
+            self.has_volume = self._io.read_bits_int(1) != 0
+            self._debug['has_volume']['end'] = self._io.pos()
+            self._debug['has_note_and_instrument']['start'] = self._io.pos()
+            self.has_note_and_instrument = self._io.read_bits_int(1) != 0
+            self._debug['has_note_and_instrument']['end'] = self._io.pos()
+            self._debug['channel_num']['start'] = self._io.pos()
+            self.channel_num = self._io.read_bits_int(5)
+            self._debug['channel_num']['end'] = self._io.pos()
+            self._io.align_to_byte()
+            if self.has_note_and_instrument:
+                self._debug['note']['start'] = self._io.pos()
+                self.note = self._io.read_u1()
+                self._debug['note']['end'] = self._io.pos()
+
+            if self.has_note_and_instrument:
+                self._debug['instrument']['start'] = self._io.pos()
+                self.instrument = self._io.read_u1()
+                self._debug['instrument']['end'] = self._io.pos()
+
+            if self.has_volume:
+                self._debug['volume']['start'] = self._io.pos()
+                self.volume = self._io.read_u1()
+                self._debug['volume']['end'] = self._io.pos()
+
+            if self.has_fx:
+                self._debug['fx_type']['start'] = self._io.pos()
+                self.fx_type = self._io.read_u1()
+                self._debug['fx_type']['end'] = self._io.pos()
+
+            if self.has_fx:
+                self._debug['fx_value']['start'] = self._io.pos()
+                self.fx_value = self._io.read_u1()
+                self._debug['fx_value']['end'] = self._io.pos()
+
+
+
+    class PatternCells(KaitaiStruct):
+        SEQ_FIELDS = ["cells"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['cells']['start'] = self._io.pos()
+            self.cells = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['cells']:
+                    self._debug['cells']['arr'] = []
+                self._debug['cells']['arr'].append({'start': self._io.pos()})
+                _t_cells = self._root.PatternCell(self._io, self, self._root)
+                _t_cells._read()
+                self.cells.append(_t_cells)
+                self._debug['cells']['arr'][len(self.cells) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['cells']['end'] = self._io.pos()
+
+
+    class Channel(KaitaiStruct):
+        SEQ_FIELDS = ["is_disabled", "ch_type"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['is_disabled']['start'] = self._io.pos()
+            self.is_disabled = self._io.read_bits_int(1) != 0
+            self._debug['is_disabled']['end'] = self._io.pos()
+            self._debug['ch_type']['start'] = self._io.pos()
+            self.ch_type = self._io.read_bits_int(7)
+            self._debug['ch_type']['end'] = self._io.pos()
+
+
+    class SwappedU3(KaitaiStruct):
+        """Custom 3-byte integer, stored in mixed endian manner."""
+        SEQ_FIELDS = ["hi", "lo"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['hi']['start'] = self._io.pos()
+            self.hi = self._io.read_u1()
+            self._debug['hi']['end'] = self._io.pos()
+            self._debug['lo']['start'] = self._io.pos()
+            self.lo = self._io.read_u2le()
+            self._debug['lo']['end'] = self._io.pos()
+
+        @property
+        def value(self):
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = (self.lo | (self.hi << 16))
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    class Pattern(KaitaiStruct):
+        SEQ_FIELDS = ["size", "body"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u2le()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            self._raw_body = self._io.read_bytes((self.size - 2))
+            io = KaitaiStream(BytesIO(self._raw_body))
+            self.body = self._root.PatternCells(io, self, self._root)
+            self.body._read()
+            self._debug['body']['end'] = self._io.pos()
+
+
+    class PatternPtr(KaitaiStruct):
+        SEQ_FIELDS = ["paraptr"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['paraptr']['start'] = self._io.pos()
+            self.paraptr = self._io.read_u2le()
+            self._debug['paraptr']['end'] = self._io.pos()
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            _pos = self._io.pos()
+            self._io.seek((self.paraptr * 16))
+            self._debug['_m_body']['start'] = self._io.pos()
+            self._m_body = self._root.Pattern(self._io, self, self._root)
+            self._m_body._read()
+            self._debug['_m_body']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_body if hasattr(self, '_m_body') else None
+
+
+    class InstrumentPtr(KaitaiStruct):
+        SEQ_FIELDS = ["paraptr"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['paraptr']['start'] = self._io.pos()
+            self.paraptr = self._io.read_u2le()
+            self._debug['paraptr']['end'] = self._io.pos()
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            _pos = self._io.pos()
+            self._io.seek((self.paraptr * 16))
+            self._debug['_m_body']['start'] = self._io.pos()
+            self._m_body = self._root.Instrument(self._io, self, self._root)
+            self._m_body._read()
+            self._debug['_m_body']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_body if hasattr(self, '_m_body') else None
+
+
+    class Instrument(KaitaiStruct):
+
+        class InstTypes(Enum):
+            sample = 1
+            melodic = 2
+            bass_drum = 3
+            snare_drum = 4
+            tom = 5
+            cymbal = 6
+            hihat = 7
+        SEQ_FIELDS = ["type", "filename", "body", "tuning_hz", "reserved2", "sample_name", "magic"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['type']['start'] = self._io.pos()
+            self.type = KaitaiStream.resolve_enum(self._root.Instrument.InstTypes, self._io.read_u1())
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['filename']['start'] = self._io.pos()
+            self.filename = KaitaiStream.bytes_terminate(self._io.read_bytes(12), 0, False)
+            self._debug['filename']['end'] = self._io.pos()
+            self._debug['body']['start'] = self._io.pos()
+            _on = self.type
+            if _on == self._root.Instrument.InstTypes.sample:
+                self.body = self._root.Instrument.Sampled(self._io, self, self._root)
+                self.body._read()
+            else:
+                self.body = self._root.Instrument.Adlib(self._io, self, self._root)
+                self.body._read()
+            self._debug['body']['end'] = self._io.pos()
+            self._debug['tuning_hz']['start'] = self._io.pos()
+            self.tuning_hz = self._io.read_u4le()
+            self._debug['tuning_hz']['end'] = self._io.pos()
+            self._debug['reserved2']['start'] = self._io.pos()
+            self.reserved2 = self._io.read_bytes(12)
+            self._debug['reserved2']['end'] = self._io.pos()
+            self._debug['sample_name']['start'] = self._io.pos()
+            self.sample_name = KaitaiStream.bytes_terminate(self._io.read_bytes(28), 0, False)
+            self._debug['sample_name']['end'] = self._io.pos()
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.ensure_fixed_contents(b"\x53\x43\x52\x53")
+            self._debug['magic']['end'] = self._io.pos()
+
+        class Sampled(KaitaiStruct):
+            SEQ_FIELDS = ["paraptr_sample", "len_sample", "loop_begin", "loop_end", "default_volume", "reserved1", "is_packed", "flags"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['paraptr_sample']['start'] = self._io.pos()
+                self.paraptr_sample = self._root.SwappedU3(self._io, self, self._root)
+                self.paraptr_sample._read()
+                self._debug['paraptr_sample']['end'] = self._io.pos()
+                self._debug['len_sample']['start'] = self._io.pos()
+                self.len_sample = self._io.read_u4le()
+                self._debug['len_sample']['end'] = self._io.pos()
+                self._debug['loop_begin']['start'] = self._io.pos()
+                self.loop_begin = self._io.read_u4le()
+                self._debug['loop_begin']['end'] = self._io.pos()
+                self._debug['loop_end']['start'] = self._io.pos()
+                self.loop_end = self._io.read_u4le()
+                self._debug['loop_end']['end'] = self._io.pos()
+                self._debug['default_volume']['start'] = self._io.pos()
+                self.default_volume = self._io.read_u1()
+                self._debug['default_volume']['end'] = self._io.pos()
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.read_u1()
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['is_packed']['start'] = self._io.pos()
+                self.is_packed = self._io.read_u1()
+                self._debug['is_packed']['end'] = self._io.pos()
+                self._debug['flags']['start'] = self._io.pos()
+                self.flags = self._io.read_u1()
+                self._debug['flags']['end'] = self._io.pos()
+
+            @property
+            def sample(self):
+                if hasattr(self, '_m_sample'):
+                    return self._m_sample if hasattr(self, '_m_sample') else None
+
+                _pos = self._io.pos()
+                self._io.seek((self.paraptr_sample.value * 16))
+                self._debug['_m_sample']['start'] = self._io.pos()
+                self._m_sample = self._io.read_bytes(self.len_sample)
+                self._debug['_m_sample']['end'] = self._io.pos()
+                self._io.seek(_pos)
+                return self._m_sample if hasattr(self, '_m_sample') else None
+
+
+        class Adlib(KaitaiStruct):
+            SEQ_FIELDS = ["reserved1", "_unnamed1"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['reserved1']['start'] = self._io.pos()
+                self.reserved1 = self._io.ensure_fixed_contents(b"\x00\x00\x00")
+                self._debug['reserved1']['end'] = self._io.pos()
+                self._debug['_unnamed1']['start'] = self._io.pos()
+                self._unnamed1 = self._io.read_bytes(16)
+                self._debug['_unnamed1']['end'] = self._io.pos()
+
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/vlq_base128_be.py b/python/examples/kaitai/kaitai_struct_formats/media/vlq_base128_be.py
new file mode 100644
index 00000000..826cdd95
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/vlq_base128_be.py
@@ -0,0 +1,102 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class VlqBase128Be(KaitaiStruct):
+    """A variable-length unsigned integer using base128 encoding. 1-byte groups
+    consist of 1-bit flag of continuation and 7-bit value chunk, and are ordered
+    "most significant group first", i.e. in "big-endian" manner.
+    
+    This particular encoding is specified and used in:
+    
+    * Standard MIDI file format
+    * ASN.1 BER encoding
+    
+    More information on this encoding is available at
+    https://en.wikipedia.org/wiki/Variable-length_quantity
+    
+    This particular implementation supports serialized values to up 8 bytes long.
+    """
+    SEQ_FIELDS = ["groups"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['groups']['start'] = self._io.pos()
+        self.groups = []
+        i = 0
+        while True:
+            if not 'arr' in self._debug['groups']:
+                self._debug['groups']['arr'] = []
+            self._debug['groups']['arr'].append({'start': self._io.pos()})
+            _t_groups = self._root.Group(self._io, self, self._root)
+            _t_groups._read()
+            _ = _t_groups
+            self.groups.append(_)
+            self._debug['groups']['arr'][len(self.groups) - 1]['end'] = self._io.pos()
+            if not (_.has_next):
+                break
+            i += 1
+        self._debug['groups']['end'] = self._io.pos()
+
+    class Group(KaitaiStruct):
+        """One byte group, clearly divided into 7-bit "value" chunk and 1-bit "continuation" flag.
+        """
+        SEQ_FIELDS = ["b"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['b']['start'] = self._io.pos()
+            self.b = self._io.read_u1()
+            self._debug['b']['end'] = self._io.pos()
+
+        @property
+        def has_next(self):
+            """If true, then we have more bytes to read."""
+            if hasattr(self, '_m_has_next'):
+                return self._m_has_next if hasattr(self, '_m_has_next') else None
+
+            self._m_has_next = (self.b & 128) != 0
+            return self._m_has_next if hasattr(self, '_m_has_next') else None
+
+        @property
+        def value(self):
+            """The 7-bit (base128) numeric value chunk of this group."""
+            if hasattr(self, '_m_value'):
+                return self._m_value if hasattr(self, '_m_value') else None
+
+            self._m_value = (self.b & 127)
+            return self._m_value if hasattr(self, '_m_value') else None
+
+
+    @property
+    def last(self):
+        if hasattr(self, '_m_last'):
+            return self._m_last if hasattr(self, '_m_last') else None
+
+        self._m_last = (len(self.groups) - 1)
+        return self._m_last if hasattr(self, '_m_last') else None
+
+    @property
+    def value(self):
+        """Resulting value as normal integer."""
+        if hasattr(self, '_m_value'):
+            return self._m_value if hasattr(self, '_m_value') else None
+
+        self._m_value = (((((((self.groups[self.last].value + ((self.groups[(self.last - 1)].value << 7) if self.last >= 1 else 0)) + ((self.groups[(self.last - 2)].value << 14) if self.last >= 2 else 0)) + ((self.groups[(self.last - 3)].value << 21) if self.last >= 3 else 0)) + ((self.groups[(self.last - 4)].value << 28) if self.last >= 4 else 0)) + ((self.groups[(self.last - 5)].value << 35) if self.last >= 5 else 0)) + ((self.groups[(self.last - 6)].value << 42) if self.last >= 6 else 0)) + ((self.groups[(self.last - 7)].value << 49) if self.last >= 7 else 0))
+        return self._m_value if hasattr(self, '_m_value') else None
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/vp8_ivf.py b/python/examples/kaitai/kaitai_struct_formats/media/vp8_ivf.py
new file mode 100644
index 00000000..38ef9ece
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/vp8_ivf.py
@@ -0,0 +1,108 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Vp8Ivf(KaitaiStruct):
+    """IVF is a simple container format for raw VP8 data, which is an open
+    and royalty-free video compression format, currently developed by
+    Google.
+    
+    Test .ivf files are available at https://chromium.googlesource.com/webm/vp8-test-vectors
+    
+    .. seealso::
+       Source - https://wiki.multimedia.cx/index.php/IVF
+    """
+    SEQ_FIELDS = ["magic1", "version", "len_header", "codec", "width", "height", "framerate", "timescale", "num_frames", "unused", "image_data"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic1']['start'] = self._io.pos()
+        self.magic1 = self._io.ensure_fixed_contents(b"\x44\x4B\x49\x46")
+        self._debug['magic1']['end'] = self._io.pos()
+        self._debug['version']['start'] = self._io.pos()
+        self.version = self._io.read_u2le()
+        self._debug['version']['end'] = self._io.pos()
+        self._debug['len_header']['start'] = self._io.pos()
+        self.len_header = self._io.read_u2le()
+        self._debug['len_header']['end'] = self._io.pos()
+        self._debug['codec']['start'] = self._io.pos()
+        self.codec = self._io.ensure_fixed_contents(b"\x56\x50\x38\x30")
+        self._debug['codec']['end'] = self._io.pos()
+        self._debug['width']['start'] = self._io.pos()
+        self.width = self._io.read_u2le()
+        self._debug['width']['end'] = self._io.pos()
+        self._debug['height']['start'] = self._io.pos()
+        self.height = self._io.read_u2le()
+        self._debug['height']['end'] = self._io.pos()
+        self._debug['framerate']['start'] = self._io.pos()
+        self.framerate = self._io.read_u4le()
+        self._debug['framerate']['end'] = self._io.pos()
+        self._debug['timescale']['start'] = self._io.pos()
+        self.timescale = self._io.read_u4le()
+        self._debug['timescale']['end'] = self._io.pos()
+        self._debug['num_frames']['start'] = self._io.pos()
+        self.num_frames = self._io.read_u4le()
+        self._debug['num_frames']['end'] = self._io.pos()
+        self._debug['unused']['start'] = self._io.pos()
+        self.unused = self._io.read_u4le()
+        self._debug['unused']['end'] = self._io.pos()
+        self._debug['image_data']['start'] = self._io.pos()
+        self.image_data = [None] * (self.num_frames)
+        for i in range(self.num_frames):
+            if not 'arr' in self._debug['image_data']:
+                self._debug['image_data']['arr'] = []
+            self._debug['image_data']['arr'].append({'start': self._io.pos()})
+            _t_image_data = self._root.Blocks(self._io, self, self._root)
+            _t_image_data._read()
+            self.image_data[i] = _t_image_data
+            self._debug['image_data']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['image_data']['end'] = self._io.pos()
+
+    class Blocks(KaitaiStruct):
+        SEQ_FIELDS = ["entries"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['entries']['start'] = self._io.pos()
+            self.entries = self._root.Block(self._io, self, self._root)
+            self.entries._read()
+            self._debug['entries']['end'] = self._io.pos()
+
+
+    class Block(KaitaiStruct):
+        SEQ_FIELDS = ["len_frame", "timestamp", "framedata"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['len_frame']['start'] = self._io.pos()
+            self.len_frame = self._io.read_u4le()
+            self._debug['len_frame']['end'] = self._io.pos()
+            self._debug['timestamp']['start'] = self._io.pos()
+            self.timestamp = self._io.read_u8le()
+            self._debug['timestamp']['end'] = self._io.pos()
+            self._debug['framedata']['start'] = self._io.pos()
+            self.framedata = self._io.read_bytes(self.len_frame)
+            self._debug['framedata']['end'] = self._io.pos()
+
+
+
diff --git a/python/examples/kaitai/kaitai_struct_formats/media/wav.py b/python/examples/kaitai/kaitai_struct_formats/media/wav.py
new file mode 100644
index 00000000..0a151964
--- /dev/null
+++ b/python/examples/kaitai/kaitai_struct_formats/media/wav.py
@@ -0,0 +1,492 @@
+from __future__ import absolute_import
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+from ...kaitaistruct import __version__ as ks_version, KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(ks_version) < parse_version('0.7'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.7 or later is required, but you have %s" % (ks_version))
+
+class Wav(KaitaiStruct):
+    """The WAVE file format is a subset of Microsoft's RIFF specification for the
+    storage of multimedia files. A RIFF file starts out with a file header
+    followed by a sequence of data chunks. A WAVE file is often just a RIFF
+    file with a single "WAVE" chunk which consists of two sub-chunks --
+    a "fmt " chunk specifying the data format and a "data" chunk containing
+    the actual sample data.
+    
+    This Kaitai implementation was written by John Byrd of Gigantic Software
+    (jbyrd@giganticsoftware.com), and it is likely to contain bugs.
+    
+    .. seealso::
+       Source - https://www.loc.gov/preservation/digital/formats/fdd/fdd000001.shtml
+    """
+
+    class WFormatTagType(Enum):
+        unknown = 0
+        pcm = 1
+        adpcm = 2
+        ieee_float = 3
+        alaw = 6
+        mulaw = 7
+        dvi_adpcm = 17
+        dolby_ac3_spdif = 146
+        extensible = 65534
+        development = 65535
+
+    class ChunkType(Enum):
+        fmt = 544501094
+        bext = 1650817140
+        cue = 1668637984
+        data = 1684108385
+        minf = 1835626086
+        regn = 1919248238
+        umid = 1970104676
+    SEQ_FIELDS = ["riff_id", "file_size", "wave_id", "chunks"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['riff_id']['start'] = self._io.pos()
+        self.riff_id = self._io.ensure_fixed_contents(b"\x52\x49\x46\x46")
+        self._debug['riff_id']['end'] = self._io.pos()
+        self._debug['file_size']['start'] = self._io.pos()
+        self.file_size = self._io.read_u4le()
+        self._debug['file_size']['end'] = self._io.pos()
+        self._debug['wave_id']['start'] = self._io.pos()
+        self.wave_id = self._io.ensure_fixed_contents(b"\x57\x41\x56\x45")
+        self._debug['wave_id']['end'] = self._io.pos()
+        self._debug['chunks']['start'] = self._io.pos()
+        self._raw_chunks = self._io.read_bytes((self.file_size - 5))
+        io = KaitaiStream(BytesIO(self._raw_chunks))
+        self.chunks = self._root.ChunksType(io, self, self._root)
+        self.chunks._read()
+        self._debug['chunks']['end'] = self._io.pos()
+
+    class SampleType(KaitaiStruct):
+        SEQ_FIELDS = ["sample"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['sample']['start'] = self._io.pos()
+            self.sample = self._io.read_u2le()
+            self._debug['sample']['end'] = self._io.pos()
+
+
+    class FormatChunkType(KaitaiStruct):
+        SEQ_FIELDS = ["w_format_tag", "n_channels", "n_samples_per_sec", "n_avg_bytes_per_sec", "n_block_align", "w_bits_per_sample", "cb_size", "w_valid_bits_per_sample", "channel_mask_and_subformat"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['w_format_tag']['start'] = self._io.pos()
+            self.w_format_tag = KaitaiStream.resolve_enum(self._root.WFormatTagType, self._io.read_u2le())
+            self._debug['w_format_tag']['end'] = self._io.pos()
+            self._debug['n_channels']['start'] = self._io.pos()
+            self.n_channels = self._io.read_u2le()
+            self._debug['n_channels']['end'] = self._io.pos()
+            self._debug['n_samples_per_sec']['start'] = self._io.pos()
+            self.n_samples_per_sec = self._io.read_u4le()
+            self._debug['n_samples_per_sec']['end'] = self._io.pos()
+            self._debug['n_avg_bytes_per_sec']['start'] = self._io.pos()
+            self.n_avg_bytes_per_sec = self._io.read_u4le()
+            self._debug['n_avg_bytes_per_sec']['end'] = self._io.pos()
+            self._debug['n_block_align']['start'] = self._io.pos()
+            self.n_block_align = self._io.read_u2le()
+            self._debug['n_block_align']['end'] = self._io.pos()
+            self._debug['w_bits_per_sample']['start'] = self._io.pos()
+            self.w_bits_per_sample = self._io.read_u2le()
+            self._debug['w_bits_per_sample']['end'] = self._io.pos()
+            if not (self.is_basic_pcm):
+                self._debug['cb_size']['start'] = self._io.pos()
+                self.cb_size = self._io.read_u2le()
+                self._debug['cb_size']['end'] = self._io.pos()
+
+            if self.is_cb_size_meaningful:
+                self._debug['w_valid_bits_per_sample']['start'] = self._io.pos()
+                self.w_valid_bits_per_sample = self._io.read_u2le()
+                self._debug['w_valid_bits_per_sample']['end'] = self._io.pos()
+
+            if self.is_extensible:
+                self._debug['channel_mask_and_subformat']['start'] = self._io.pos()
+                self.channel_mask_and_subformat = self._root.ChannelMaskAndSubformatType(self._io, self, self._root)
+                self.channel_mask_and_subformat._read()
+                self._debug['channel_mask_and_subformat']['end'] = self._io.pos()
+
+
+        @property
+        def is_extensible(self):
+            if hasattr(self, '_m_is_extensible'):
+                return self._m_is_extensible if hasattr(self, '_m_is_extensible') else None
+
+            self._m_is_extensible = self.w_format_tag == self._root.WFormatTagType.extensible
+            return self._m_is_extensible if hasattr(self, '_m_is_extensible') else None
+
+        @property
+        def is_basic_pcm(self):
+            if hasattr(self, '_m_is_basic_pcm'):
+                return self._m_is_basic_pcm if hasattr(self, '_m_is_basic_pcm') else None
+
+            self._m_is_basic_pcm = self.w_format_tag == self._root.WFormatTagType.pcm
+            return self._m_is_basic_pcm if hasattr(self, '_m_is_basic_pcm') else None
+
+        @property
+        def is_basic_float(self):
+            if hasattr(self, '_m_is_basic_float'):
+                return self._m_is_basic_float if hasattr(self, '_m_is_basic_float') else None
+
+            self._m_is_basic_float = self.w_format_tag == self._root.WFormatTagType.ieee_float
+            return self._m_is_basic_float if hasattr(self, '_m_is_basic_float') else None
+
+        @property
+        def is_cb_size_meaningful(self):
+            if hasattr(self, '_m_is_cb_size_meaningful'):
+                return self._m_is_cb_size_meaningful if hasattr(self, '_m_is_cb_size_meaningful') else None
+
+            self._m_is_cb_size_meaningful =  ((not (self.is_basic_pcm)) and (self.cb_size != 0)) 
+            return self._m_is_cb_size_meaningful if hasattr(self, '_m_is_cb_size_meaningful') else None
+
+
+    class GuidType(KaitaiStruct):
+        SEQ_FIELDS = ["data1", "data2", "data3", "data4", "data4a"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['data1']['start'] = self._io.pos()
+            self.data1 = self._io.read_u4le()
+            self._debug['data1']['end'] = self._io.pos()
+            self._debug['data2']['start'] = self._io.pos()
+            self.data2 = self._io.read_u2le()
+            self._debug['data2']['end'] = self._io.pos()
+            self._debug['data3']['start'] = self._io.pos()
+            self.data3 = self._io.read_u2le()
+            self._debug['data3']['end'] = self._io.pos()
+            self._debug['data4']['start'] = self._io.pos()
+            self.data4 = self._io.read_u4be()
+            self._debug['data4']['end'] = self._io.pos()
+            self._debug['data4a']['start'] = self._io.pos()
+            self.data4a = self._io.read_u4be()
+            self._debug['data4a']['end'] = self._io.pos()
+
+
+    class CuePointType(KaitaiStruct):
+        SEQ_FIELDS = ["dw_name", "dw_position", "fcc_chunk", "dw_chunk_start", "dw_block_start", "dw_sample_offset"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['dw_name']['start'] = self._io.pos()
+            self.dw_name = self._io.read_u4le()
+            self._debug['dw_name']['end'] = self._io.pos()
+            self._debug['dw_position']['start'] = self._io.pos()
+            self.dw_position = self._io.read_u4le()
+            self._debug['dw_position']['end'] = self._io.pos()
+            self._debug['fcc_chunk']['start'] = self._io.pos()
+            self.fcc_chunk = self._io.read_u4le()
+            self._debug['fcc_chunk']['end'] = self._io.pos()
+            self._debug['dw_chunk_start']['start'] = self._io.pos()
+            self.dw_chunk_start = self._io.read_u4le()
+            self._debug['dw_chunk_start']['end'] = self._io.pos()
+            self._debug['dw_block_start']['start'] = self._io.pos()
+            self.dw_block_start = self._io.read_u4le()
+            self._debug['dw_block_start']['end'] = self._io.pos()
+            self._debug['dw_sample_offset']['start'] = self._io.pos()
+            self.dw_sample_offset = self._io.read_u4le()
+            self._debug['dw_sample_offset']['end'] = self._io.pos()
+
+
+    class DataChunkType(KaitaiStruct):
+        SEQ_FIELDS = ["data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes_full()
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class SamplesType(KaitaiStruct):
+        SEQ_FIELDS = ["samples"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['samples']['start'] = self._io.pos()
+            self.samples = self._io.read_u4le()
+            self._debug['samples']['end'] = self._io.pos()
+
+
+    class ChannelMaskAndSubformatType(KaitaiStruct):
+        SEQ_FIELDS = ["dw_channel_mask", "subformat"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['dw_channel_mask']['start'] = self._io.pos()
+            self.dw_channel_mask = self._root.ChannelMaskType(self._io, self, self._root)
+            self.dw_channel_mask._read()
+            self._debug['dw_channel_mask']['end'] = self._io.pos()
+            self._debug['subformat']['start'] = self._io.pos()
+            self.subformat = self._root.GuidType(self._io, self, self._root)
+            self.subformat._read()
+            self._debug['subformat']['end'] = self._io.pos()
+
+
+    class ChunksType(KaitaiStruct):
+        SEQ_FIELDS = ["chunk"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['chunk']['start'] = self._io.pos()
+            self.chunk = []
+            i = 0
+            while not self._io.is_eof():
+                if not 'arr' in self._debug['chunk']:
+                    self._debug['chunk']['arr'] = []
+                self._debug['chunk']['arr'].append({'start': self._io.pos()})
+                _t_chunk = self._root.ChunkType(self._io, self, self._root)
+                _t_chunk._read()
+                self.chunk.append(_t_chunk)
+                self._debug['chunk']['arr'][len(self.chunk) - 1]['end'] = self._io.pos()
+                i += 1
+
+            self._debug['chunk']['end'] = self._io.pos()
+
+
+    class CueChunkType(KaitaiStruct):
+        SEQ_FIELDS = ["dw_cue_points", "cue_points"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['dw_cue_points']['start'] = self._io.pos()
+            self.dw_cue_points = self._io.read_u4le()
+            self._debug['dw_cue_points']['end'] = self._io.pos()
+            if self.dw_cue_points != 0:
+                self._debug['cue_points']['start'] = self._io.pos()
+                self.cue_points = [None] * (self.dw_cue_points)
+                for i in range(self.dw_cue_points):
+                    if not 'arr' in self._debug['cue_points']:
+                        self._debug['cue_points']['arr'] = []
+                    self._debug['cue_points']['arr'].append({'start': self._io.pos()})
+                    _t_cue_points = self._root.CuePointType(self._io, self, self._root)
+                    _t_cue_points._read()
+                    self.cue_points[i] = _t_cue_points
+                    self._debug['cue_points']['arr'][i]['end'] = self._io.pos()
+
+                self._debug['cue_points']['end'] = self._io.pos()
+
+
+
+    class ChannelMaskType(KaitaiStruct):
+        SEQ_FIELDS = ["front_right_of_center", "front_left_of_center", "back_right", "back_left", "low_frequency", "front_center", "front_right", "front_left", "top_center", "side_right", "side_left", "back_center", "top_back_left", "top_front_right", "top_front_center", "top_front_left", "unused1", "top_back_right", "top_back_center", "unused2"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['front_right_of_center']['start'] = self._io.pos()
+            self.front_right_of_center = self._io.read_bits_int(1) != 0
+            self._debug['front_right_of_center']['end'] = self._io.pos()
+            self._debug['front_left_of_center']['start'] = self._io.pos()
+            self.front_left_of_center = self._io.read_bits_int(1) != 0
+            self._debug['front_left_of_center']['end'] = self._io.pos()
+            self._debug['back_right']['start'] = self._io.pos()
+            self.back_right = self._io.read_bits_int(1) != 0
+            self._debug['back_right']['end'] = self._io.pos()
+            self._debug['back_left']['start'] = self._io.pos()
+            self.back_left = self._io.read_bits_int(1) != 0
+            self._debug['back_left']['end'] = self._io.pos()
+            self._debug['low_frequency']['start'] = self._io.pos()
+            self.low_frequency = self._io.read_bits_int(1) != 0
+            self._debug['low_frequency']['end'] = self._io.pos()
+            self._debug['front_center']['start'] = self._io.pos()
+            self.front_center = self._io.read_bits_int(1) != 0
+            self._debug['front_center']['end'] = self._io.pos()
+            self._debug['front_right']['start'] = self._io.pos()
+            self.front_right = self._io.read_bits_int(1) != 0
+            self._debug['front_right']['end'] = self._io.pos()
+            self._debug['front_left']['start'] = self._io.pos()
+            self.front_left = self._io.read_bits_int(1) != 0
+            self._debug['front_left']['end'] = self._io.pos()
+            self._debug['top_center']['start'] = self._io.pos()
+            self.top_center = self._io.read_bits_int(1) != 0
+            self._debug['top_center']['end'] = self._io.pos()
+            self._debug['side_right']['start'] = self._io.pos()
+            self.side_right = self._io.read_bits_int(1) != 0
+            self._debug['side_right']['end'] = self._io.pos()
+            self._debug['side_left']['start'] = self._io.pos()
+            self.side_left = self._io.read_bits_int(1) != 0
+            self._debug['side_left']['end'] = self._io.pos()
+            self._debug['back_center']['start'] = self._io.pos()
+            self.back_center = self._io.read_bits_int(1) != 0
+            self._debug['back_center']['end'] = self._io.pos()
+            self._debug['top_back_left']['start'] = self._io.pos()
+            self.top_back_left = self._io.read_bits_int(1) != 0
+            self._debug['top_back_left']['end'] = self._io.pos()
+            self._debug['top_front_right']['start'] = self._io.pos()
+            self.top_front_right = self._io.read_bits_int(1) != 0
+            self._debug['top_front_right']['end'] = self._io.pos()
+            self._debug['top_front_center']['start'] = self._io.pos()
+            self.top_front_center = self._io.read_bits_int(1) != 0
+            self._debug['top_front_center']['end'] = self._io.pos()
+            self._debug['top_front_left']['start'] = self._io.pos()
+            self.top_front_left = self._io.read_bits_int(1) != 0
+            self._debug['top_front_left']['end'] = self._io.pos()
+            self._debug['unused1']['start'] = self._io.pos()
+            self.unused1 = self._io.read_bits_int(6)
+            self._debug['unused1']['end'] = self._io.pos()
+            self._debug['top_back_right']['start'] = self._io.pos()
+            self.top_back_right = self._io.read_bits_int(1) != 0
+            self._debug['top_back_right']['end'] = self._io.pos()
+            self._debug['top_back_center']['start'] = self._io.pos()
+            self.top_back_center = self._io.read_bits_int(1) != 0
+            self._debug['top_back_center']['end'] = self._io.pos()
+            self._debug['unused2']['start'] = self._io.pos()
+            self.unused2 = self._io.read_bits_int(8)
+            self._debug['unused2']['end'] = self._io.pos()
+
+
+    class ChunkType(KaitaiStruct):
+        SEQ_FIELDS = ["chunk_id", "len", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['chunk_id']['start'] = self._io.pos()
+            self.chunk_id = self._io.read_u4be()
+            self._debug['chunk_id']['end'] = self._io.pos()
+            self._debug['len']['start'] = self._io.pos()
+            self.len = self._io.read_u4le()
+            self._debug['len']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            _on = self.chunk_id
+            if _on == 1684108385:
+                self._raw_data = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.DataChunkType(io, self, self._root)
+                self.data._read()
+            elif _on == 1668637984:
+                self._raw_data = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.CueChunkType(io, self, self._root)
+                self.data._read()
+            elif _on == 1650817140:
+                self._raw_data = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.BextChunkType(io, self, self._root)
+                self.data._read()
+            elif _on == 1718449184:
+                self._raw_data = self._io.read_bytes(self.len)
+                io = KaitaiStream(BytesIO(self._raw_data))
+                self.data = self._root.FormatChunkType(io, self, self._root)
+                self.data._read()
+            else:
+                self.data = self._io.read_bytes(self.len)
+            self._debug['data']['end'] = self._io.pos()
+
+
+    class BextChunkType(KaitaiStruct):
+        SEQ_FIELDS = ["description", "originator", "originator_reference", "origination_date", "origination_time", "time_reference_low", "time_reference_high", "version", "umid", "loudness_value", "loudness_range", "max_true_peak_level", "max_momentary_loudness", "max_short_term_loudness"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['description']['start'] = self._io.pos()
+            self.description = (self._io.read_bytes(256)).decode(u"ASCII")
+            self._debug['description']['end'] = self._io.pos()
+            self._debug['originator']['start'] = self._io.pos()
+            self.originator = (self._io.read_bytes(32)).decode(u"ASCII")
+            self._debug['originator']['end'] = self._io.pos()
+            self._debug['originator_reference']['start'] = self._io.pos()
+            self.originator_reference = (self._io.read_bytes(32)).decode(u"ASCII")
+            self._debug['originator_reference']['end'] = self._io.pos()
+            self._debug['origination_date']['start'] = self._io.pos()
+            self.origination_date = (self._io.read_bytes(10)).decode(u"ASCII")
+            self._debug['origination_date']['end'] = self._io.pos()
+            self._debug['origination_time']['start'] = self._io.pos()
+            self.origination_time = (self._io.read_bytes(8)).decode(u"ASCII")
+            self._debug['origination_time']['end'] = self._io.pos()
+            self._debug['time_reference_low']['start'] = self._io.pos()
+            self.time_reference_low = self._io.read_u4le()
+            self._debug['time_reference_low']['end'] = self._io.pos()
+            self._debug['time_reference_high']['start'] = self._io.pos()
+            self.time_reference_high = self._io.read_u4le()
+            self._debug['time_reference_high']['end'] = self._io.pos()
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u2le()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['umid']['start'] = self._io.pos()
+            self.umid = self._io.read_bytes(64)
+            self._debug['umid']['end'] = self._io.pos()
+            self._debug['loudness_value']['start'] = self._io.pos()
+            self.loudness_value = self._io.read_u2le()
+            self._debug['loudness_value']['end'] = self._io.pos()
+            self._debug['loudness_range']['start'] = self._io.pos()
+            self.loudness_range = self._io.read_u2le()
+            self._debug['loudness_range']['end'] = self._io.pos()
+            self._debug['max_true_peak_level']['start'] = self._io.pos()
+            self.max_true_peak_level = self._io.read_u2le()
+            self._debug['max_true_peak_level']['end'] = self._io.pos()
+            self._debug['max_momentary_loudness']['start'] = self._io.pos()
+            self.max_momentary_loudness = self._io.read_u2le()
+            self._debug['max_momentary_loudness']['end'] = self._io.pos()
+            self._debug['max_short_term_loudness']['start'] = self._io.pos()
+            self.max_short_term_loudness = self._io.read_u2le()
+            self._debug['max_short_term_loudness']['end'] = self._io.pos()
+
+
+    @property
+    def format_chunk(self):
+        if hasattr(self, '_m_format_chunk'):
+            return self._m_format_chunk if hasattr(self, '_m_format_chunk') else None
+
+        self._m_format_chunk = self.chunks.chunk[0].data
+        return self._m_format_chunk if hasattr(self, '_m_format_chunk') else None
+
+