path: root/python/examples/kaitai/wav.py

# 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