def test_get_block(self):
with open("./test_data/blocks/blocks_9_8", "rb") as f:
data = f.read()
c = Chunk(data)
for x in range(32):
for y in range(32):
c.get_block(x, y)
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._file = Chunk(file, bigendian = 0)
if self._file.getname() != b'RIFF':
raise Error('file does not start with RIFF id')
if self._file.read(4) != b'WAVE':
raise Error('not a WAVE file')
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian = 0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == b'data':
if not self._fmt_chunk_read:
raise Error('data chunk before fmt chunk')
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
break
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error('fmt chunk and/or data chunk missing')
def exitTl69asmLine(self, ctx: tl69asmParser.Tl69asmLineContext):
if ctx.label():
label_name = ctx.label().label_name
self.label_dict[label_name] = self.get_line_number()
if ctx.instruction():
self.lines[-1].instructions.append(ctx.instruction().instruction)
elif ctx.directive():
directive = ctx.directive().directive
value = None
if directive.expr[0] == OperandType.LABEL:
label_name = directive.expr[1]
if label_name in self.label_dict:
value = self.label_dict[label_name]
else:
print("TODO: proper label resolution")
return
elif directive.expr[0] == OperandType.INTEGER:
value = directive.expr[1]
if not value:
return
if directive.directive_type == DirectiveType.ORG:
if self.lines[-1].empty():
self.lines[-1] = Chunk(value)
else:
self.lines.append(Chunk(value))
elif directive.directive_type == DirectiveType.DW:
dw_instruction = UnformedInstruction(
"DW", [Operand(OperandType.INTEGER, value)])
self.lines[-1].instructions.append(dw_instruction)
elif directive.directive_type == DirectiveType.EQU:
self.label_dict[directive.label] = value
def v3_score_par(profile, candidate, real_chunk_sizes, vehicle_used, roads):
chunks = []
cons = 0
for i in range(0, len(profile) - 1):
lcl_slope = ((profile[i+1] - profile[i])/(real_chunk_sizes[i+1] - real_chunk_sizes[i])) * 100
#print("{:0.1f}-".format(lcl_slope), end='', flush=True)
if i==0:
chunks.append(Chunk(0, candidate[0][0], lcl_slope, (real_chunk_sizes[i+1] - real_chunk_sizes[i])))
else:
chunks.append(Chunk(chunks[-1].v1, candidate[0][i], lcl_slope, (real_chunk_sizes[i+1] - real_chunk_sizes[i])))
d = (chunks[-1].v0**2) - (2*chunks[-1].accel*chunks[-1].space)
time1 = ((-1 * chunks[-1].v0) - cmath.sqrt(d)) / chunks[-1].accel
time2 = ((-1 * chunks[-1].v0) + cmath.sqrt(d)) / chunks[-1].accel
#print("{},{},{} ".format(chunks[-1].v0, chunks[-1].accel, chunks[-1].space), end='')
chunks[-1].v1 = math.sqrt(max(0,(chunks[-1].v0**2) + (2*chunks[-1].accel*chunks[-1].space)))
chunks[-1].est_time_s = abs((chunks[-1].v1 - chunks[-1].v0) / chunks[-1].accel)
chunks[-1].calculate_CPEM_kwh(vehicle_used)
if chunks[-1].est_cons > 0:
cons += chunks[-1].est_cons
#print(" --> {}".format(chunks[-1].est_cons))
#print("Cons (kWh): {}".format(cons/1000))
if (not v2_check_valid_par(chunks, roads)):
return -1
return cons
def generate(self, x, z):
chunk = Chunk()
for y in range(64):
for x in range(16):
for z in range(16):
chunk.block(x, y, z)[0] = '\xff'
return chunk
def __read_until(self, name):
if self.__chunk is not None:
self.__chunk.skip()
self.__chunk = None
while 1:
try:
chunk = Chunk(self.__file)
except EOFError:
raise audio.Error, 'chunk %s not found' % name
else:
self.__chunk = chunk
chunkname = chunk.getname()
if chunkname == 'COMM':
self.__read_comm_chunk(chunk)
elif chunkname == 'SSND':
self.__read_ssnd_chunk(chunk)
elif chunkname == 'FVER':
self.__read_vfer_chunk(chunk)
elif chunkname == 'MARK':
self.__read_mark_chunk(chunk)
elif chunkname in ('COMT', 'INST', 'MIDI', 'AESD', 'APPL', 'NAME',
'AUTH', '(c) ', 'ANNO'):
self.__skip_chunk(chunk)
else:
raise audio.Error, 'unrecognized chunk type ' + chunkname
if name == chunkname:
return
chunk.skip()
self.__chunk = None
def create_chunks(self):
_pos = self.pos
_len = len
_length = self.length
chunks = []
words = self.find_match_word(_pos)
for w0 in words:
index0 = _pos + _len(w0)
if index0 < _length:
words1 = self.find_match_word(index0)
for w1 in words1:
index1 = index0 + _len(w1)
if index1 < _length:
words2 = self.find_match_word(index1)
for w2 in words2:
if w2.wtype == UNRECOGNIZED:
chunks.append(Chunk([w0, w1]))
else:
chunks.append(Chunk([w0, w1, w2]))
else:
chunks.append(Chunk([w0, w1]))
else:
chunks.append(Chunk([w0]))
return chunks
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._file = Chunk(file, bigendian=0)
if self._file.getname() != "RIFF":
raise Error, "file does not start with RIFF id"
if self._file.read(4) != "WAVE":
raise Error, "not a WAVE file"
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == "fmt ":
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == "data":
if not self._fmt_chunk_read:
raise Error, "data chunk before fmt chunk"
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
break
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error, "fmt chunk and/or data chunk missing"
def parse():
cabocha = CaboCha.Parser()
result = []
with open('neko.txt') as input_data:
for line in input_data:
line = line.strip()
parsed = cabocha.parse(line).toString(CaboCha.FORMAT_LATTICE)
chunks = {}
for sentence_str in parsed.split('* '):
sentence_analysis = sentence_str.split('\n')
affliation_str = sentence_analysis.pop(0)
if affliation_str in ['', 'EOS']:
continue
morph_analysis = affliation_str.split(' ')
chunk = Chunk()
chunk.id = int(morph_analysis[0])
chunk.srcs = int(morph_analysis[1][:-1])
morphs = []
for morph_str in sentence_analysis:
if morph_str in ['', 'EOS']:
continue
surface, right = morph_str.split('\t')
morph_items = right.split(',')
morphs.append(Morph(surface, morph_items[6],
morph_items[0], morph_items[1]))
chunk.morphs = morphs
chunks[chunk.id] = chunk
for i, chunk in chunks.items():
if chunk.srcs > 0:
chunks[chunk.srcs].dst.append(i)
result.append(chunks)
return result
def get_chunk_in_pos(self,
pos: (),
addx=0,
addy=0,
addz=0): # retourne le chunk à la position donnée
tpos = (to_chunk(pos[0]) + addx, to_chunk(pos[1]) + addy,
to_chunk(pos[2]) + addz)
ret = self.chunks.get(tpos)
if ret is None:
world_file = open(DEFAULT_WORLD_FILE, "br")
size = int.from_bytes(world_file.read(4), "big")
chunks = world_file.read()[size * 16:]
pos_ = (to_chunk(pos[0]) + addx, to_chunk(pos[1]) + addy,
to_chunk(pos[2]) + addz)
if pos_ in list(self.chunks_indexes.keys()):
chunk = chunks[self.chunks_indexes[pos_] *
BLOCKS_FOR_CHUNK:self.chunks_indexes[pos_] *
BLOCKS_FOR_CHUNK + BLOCKS_FOR_CHUNK]
chunk_ = Chunk(pos_, self.noise, self)
for block_ in range(len(chunk)):
chunk_.blocks[block_].type = BLOCKS_ID[chunk[block_]]
ret = chunk_
if ret is None:
self.chunks[tpos] = Chunk(tpos, self.noise, self)
self.chunks_indexes[tpos] = len(self.chunks_indexes) + 1
chunk = self.chunks[tpos]
chunk.gen_chunk()
ret = chunk
return ret
class TestChunk(unittest.TestCase):
"""Tests for the chunk data structure"""
def setUp(self):
load_block_types("code/pynecraft/blocks.xml")
self.chunk = Chunk(CatchAll(), None, 32, 0, 0, 0)
def test_is_empty_block(self):
for x in xrange(32):
for y in xrange(32):
for z in xrange(32):
self.assertTrue(self.chunk.is_empty_block(x, y, z))
self.chunk.add_block_without_rebuild(BLOCK_TYPES.Wood, 5, 5, 5)
self.assertFalse(self.chunk.is_empty_block(5, 5, 5))
def test_valid_coordinates(self):
size = self.chunk.size
self.assertTrue(self.chunk.valid_coordinates(0, 0, 0))
self.assertFalse(self.chunk.valid_coordinates(size, size, size))
self.assertTrue(self.chunk.valid_coordinates(size - 1, size - 1, size - 1))
def test_grid_coords_inside(self):
size = self.chunk.size
self.assertTrue(self.chunk.grid_coords_inside(0, 0, 0))
self.assertFalse(self.chunk.grid_coords_inside(size, size, size))
self.assertTrue(self.chunk.grid_coords_inside(size - 1, size - 1, size - 1))
def generate(self, x, z): chunk = Chunk() for y in range(64): for x in range(16): for z in range(16): chunk.block(x, y, z)[0] = '\xff' return chunk
def _create_chunk(self):
"""
Instantiate chunk object for crawler to use to create headers and documents. Create chunk file to be writen to.
:return: Chunk object
"""
self.chunk = Chunk(self.chunk_id)
self.chunk.create_chunk()
return self.chunk
def test_init_chunk(self):
chunk = Chunk()
chunk.set_block(0, 0, 0, Block(config.BlockType.Grass))
res = self.world_client.init_chunk(0, 0, chunk)
self.assertFalse(res)
res = self.world_client.init_chunk(0, 0, chunk)
self.assertTrue(res)
def parse_chunk_header(self, line):
chunk = Chunk()
# FIXME: If you delete these lines, chunks.morphs references the old list of Morph
chunk.morphs = []
chunk.srcs = []
chunk.dst = int(line.split()[2][:-1])
return chunk
def initfp(self, file):
self._version = 0
self._decomp = None
self._convert = None
self._markers = []
self._soundpos = 0
self._file = file
chunk = Chunk(file)
if chunk.getname() != 'FORM':
raise Error, 'file does not start with FORM id'
formdata = chunk.read(4)
if formdata == 'AIFF':
self._aifc = 0
elif formdata == 'AIFC':
self._aifc = 1
else:
raise Error, 'not an AIFF or AIFF-C file'
self._comm_chunk_read = 0
while 1:
self._ssnd_seek_needed = 1
try:
chunk = Chunk(self._file)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == 'COMM':
self._read_comm_chunk(chunk)
self._comm_chunk_read = 1
elif chunkname == 'SSND':
self._ssnd_chunk = chunk
dummy = chunk.read(8)
self._ssnd_seek_needed = 0
elif chunkname == 'FVER':
self._version = _read_ulong(chunk)
elif chunkname == 'MARK':
self._readmark(chunk)
chunk.skip()
if not self._comm_chunk_read or not self._ssnd_chunk:
raise Error, 'COMM chunk and/or SSND chunk missing'
if self._aifc and self._decomp:
import cl
params = [cl.ORIGINAL_FORMAT,
0,
cl.BITS_PER_COMPONENT,
self._sampwidth * 8,
cl.FRAME_RATE,
self._framerate]
if self._nchannels == 1:
params[1] = cl.MONO
elif self._nchannels == 2:
params[1] = cl.STEREO_INTERLEAVED
else:
raise Error, 'cannot compress more than 2 channels'
self._decomp.SetParams(params)
return
def generate(cls, cx, cy, world_client):
chunk = Chunk()
column_heights = cls.column_heights(cx, cy)
for bx, bz in chunk.all_columns():
lowest = max(0, column_heights[bx, bz]-PerlinHeight.DEPTH)
for by in range(lowest, column_heights[bx, bz]):
chunk.set_block(bx, by, bz, Block(config.BlockType.Grass))
return chunk
def chunks(f):
"""Yield (name, data) chunks read from file f."""
while True:
try:
c = Chunk(f, align=False, bigendian=False)
yield (c.getname(), c.read())
c.skip()
except EOFError:
break
class waveread(wave.Wave_read):
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._cue = []
self._loops = []
self._ieee = False
self._file = Chunk(file, bigendian=0)
if self._file.getname() != b'RIFF':
raise exceptions_samplerbox.WaveReadError(
'file does not start with RIFF id')
if self._file.read(4) != b'WAVE':
raise exceptions_samplerbox.WaveReadError('not a WAVE file')
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == b'data':
if not self._fmt_chunk_read:
raise exceptions_samplerbox.WaveReadError(
'data chunk before fmt chunk')
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
elif chunkname == b'cue ':
numcue = struct.unpack('<i', chunk.read(4))[0]
for i in range(numcue):
id, position, datachunkid, chunkstart, blockstart, sampleoffset = struct.unpack(
'<iiiiii', chunk.read(24))
self._cue.append(sampleoffset)
elif chunkname == b'smpl':
manuf, prod, sampleperiod, midiunitynote, midipitchfraction, smptefmt, smpteoffs, numsampleloops, samplerdata = struct.unpack(
'<iiiiiiiii', chunk.read(36))
for i in range(numsampleloops):
cuepointid, type, start, end, fraction, playcount = struct.unpack(
'<iiiiii', chunk.read(24))
self._loops.append([start, end])
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise exceptions_samplerbox.WaveReadError(
'fmt chunk and/or data chunk missing')
def getmarkers(self):
return self._cue
def getloops(self):
if gv.sample_mode == gv.PLAYLIVE or gv.sample_mode == gv.PLAYLOOP or gv.sample_mode == gv.PLAYLO2X:
return self._loops
def test_read_and_export(self):
with open("./test_data/blocks/blocks_9_8", "rb") as f:
data = f.read()
c = Chunk(data)
r1 = repr(c)
exported = c.export()
f = io.BytesIO(exported)
c2 = Chunk.from_compressed_file(f)
r2 = repr(c2)
assert r1 == r2
def generate_chunk (self, cx, cy, cz): res = Chunk () if cy < 0: for z in range(16): for y in range (16): for x in range (16): res.put (x, y, z, 1) return res
def _read_wav_header(self):
""" Read RIFF WAV header. """
ch = Chunk(self.wav, bigendian=0)
if ch.getname() != 'RIFF' or ch.read(4) != 'WAVE':
logging.debug('Not a WAV file.')
return False
# this would normally be 0
self.riff_pos = self.wav.tell() - 12
riff_size = ch.getsize()
self.sampwidth, self.nchannels, self.framerate = 0, 0, 0
while True:
try:
chunk = Chunk(ch, bigendian=0)
except EOFError:
logging.debug('No data chunk found in WAV file.')
return False
chunkname = chunk.getname()
if chunkname == 'fmt ':
format_tag, self.nchannels, self.framerate, _, _ = struct.unpack('<HHLLH', chunk.read(14))
if format_tag == 1:
sampwidth = struct.unpack('<H', chunk.read(2))[0]
self.sampwidth = (sampwidth + 7) // 8
else:
logging.debug('WAV file not in uncompressed PCM format.')
return False
elif chunkname == 'data':
if not self.sampwidth:
logging.debug('Format chunk not found.')
return False
self.data_pos = self.wav.tell() - 4
#self.wav.read(4)
self.start = self.wav.tell()
return True
chunk.skip()
class waveread(wave.Wave_read):
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._cue = []
self._loops = []
self._ieee = False
self._file = Chunk(file, bigendian=0)
if self._file.getname() != "RIFF":
raise Error, "file does not start with RIFF id"
if self._file.read(4) != "WAVE":
raise Error, "not a WAVE file"
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == "fmt ":
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == "data":
if not self._fmt_chunk_read:
raise Error, "data chunk before fmt chunk"
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
elif chunkname == "cue ":
numcue = struct.unpack("<i", chunk.read(4))[0]
for i in range(numcue):
id, position, datachunkid, chunkstart, blockstart, sampleoffset = struct.unpack(
"<iiiiii", chunk.read(24)
)
self._cue.append(sampleoffset)
elif chunkname == "smpl":
manuf, prod, sampleperiod, midiunitynote, midipitchfraction, smptefmt, smpteoffs, numsampleloops, samplerdata = struct.unpack(
"<iiiiiiiii", chunk.read(36)
)
for i in range(numsampleloops):
cuepointid, type, start, end, fraction, playcount = struct.unpack("<iiiiii", chunk.read(24))
self._loops.append([start, end])
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error, "fmt chunk and/or data chunk missing"
def getmarkers(self):
return self._cue
def getloops(self):
return self._loops
def parse_quetzal(fp) -> HeaderData:
"""Reads a Quetzal save file, and returns information about the associated game."""
if type(fp) != str and not hasattr(fp, 'read'):
raise TypeError("file is not a string or a bytes-like object.")
if type(fp) == str:
if not os.path.isfile(fp):
raise Exception("File provided isn't a file, or doesn't exist.")
# Open file as bytes
qzl = open(fp, 'rb')
else:
qzl = fp
header = qzl.read(4)
# Header checking yay.
if header != b"FORM":
raise Exception("Invalid file format.")
qzl.read(4) # Skip some bytes we don't care about.
ftype = qzl.read(4)
# More header checking yay.
if ftype != b"IFZS":
raise Exception("Invalid file format.")
chunk = Chunk(qzl)
name = chunk.getname()
size = chunk.getsize()
data = chunk.read(size).decode("latin_1")
# Make sure first chunk is IFhd.
if name != b"IFhd":
raise Exception("File does not start with an IFhd chunk.")
elif size != 13:
raise Exception("Invalid size for IFhd chunk: " + str(size))
try:
# Bitwise magic to get data.
release = (ord(data[0]) << 8) + ord(data[1])
serial = int(data[2:8])
checksum = (ord(data[8]) << 8) + ord(data[9])
# pc = (ord(data[10]) << 16) + (ord(data[11]) << 8) + ord(data[12]) # This isn't needed rn, but it's commented just in case.
except ValueError as e:
print(data)
print(release)
print(data[2:8])
print((ord(data[8]) << 8) + ord(data[9]))
raise e
return HeaderData(release, serial, checksum)
def test_is_generated(self):
res = self.world_client.is_generated(0, 0)
self.assertFalse(
res,
"World Client says an ungenerated chunk is already generated.")
chunk = Chunk()
chunk.set_block(0, 0, 0, Block(config.BlockType.Grass))
res = self.world_client.init_chunk(0, 0, chunk)
self.assertFalse(res, "Couldn't init the chunk.")
res = self.world_client.is_generated(0, 0)
self.assertTrue(res)
def test_setget_chunk(self):
# Create a chunk with a non-default blocks
chunk = Chunk()
chunk.set_block(0, 0, 0, Block(config.BlockType.Grass))
# Ensure that the block the server sets the chunk without error.
res = self.world_client.set_chunk(0, 0, chunk)
self.assertFalse(res)
# Ensure the chunk it gives back to us is the same one we but in.
res = self.world_client.get_chunk(0,
0)[config.WorldRequestData.ChunkData]
self.assertIsNotNone(res, "get_chunk failed")
self.assertEqual(chunk, res)
def _read_header(self, f: BinaryIO) -> None:
""" Read Bank Header (BKHD) chunk. """
chunk = Chunk(f, bigendian=False, align=False)
if chunk.getname() != b"BKHD":
raise exception.AudioKineticFormatError(
"Not an AudioKinetic WWise SoundBank file.")
self._soundbank.version = self._read_uint32(chunk)
self._soundbank.id = self._read_uint32(chunk)
# There are additional 6 unknown uint32 values.
chunk.skip()
# Get name from SoundBankInfo
info = self.soundbankinfo.get(self._soundbank.id)
self._soundbank.name = info.name if isinstance(
info, soundbanksinfo.SoundBankInfo) else ""
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._file = Chunk(file, bigendian=0)
if self._file.getname() != b'RIFF':
raise Error('file does not start with RIFF id')
if self._file.read(4) != b'WAVE':
raise Error('not a WAVE file')
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == b'data':
if not self._fmt_chunk_read:
raise Error('data chunk before fmt chunk')
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
break
else:
self.other_chunks.append(chunk.read())
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error('fmt chunk and/or data chunk missing')
def read_iff(fh,keys=["FORM"]):
while True:
try:
ch = Chunk(fh, align=False)
except EOFError:
return
name = ch.getname()
if name == "FORM":
typ = ch.read(4) # TODO return somehow
for x in read_iff(ch):
yield x
else:
data = ch.read(ch.getsize())
yield name, data
def _read_data_index(self, chunk: Chunk) -> None:
""" Read Data Index (DIDX) chunk."""
num_objects = chunk.getsize() // 12
for i in range(num_objects):
try:
file_id, offset, length = struct.unpack("<LLL", chunk.read(12))
except struct.error as e:
raise exception.AudioKineticIOError(
"Failed to read Data Index (DIDX) chunk.") from e
assert file_id
assert length
assert file_id not in self._soundbank.objs
self._soundbank.objs[file_id] = File(self._soundbank.id, file_id,
offset, length)
class Request:
'''Detect HTTP request header fields'''
def __init__(self, parser: Parser):
self.parser = parser
self.buf = Chunk()
self.start_parsed = False
self.headers_parsed = False
self.body_unparsed = 0
def push(self, data: bytes):
'''Push received data at the end of buffer'''
self.buf.push(data)
self.parse()
def parse(self):
'''Parse so far received buffer'''
if not self.start_parsed:
self.parse_start()
elif not self.headers_parsed:
self.parse_headers()
elif self.body_unparsed:
data = self.buf.pop_all()
self.body_unparsed -= len(data)
self.parser.on_body(data)
self.parse()
else:
self.parser.on_finished()
def parse_start(self):
'''Parse the starting line of the HTTP request'''
line = self.buf.pop(separator=b"\r\n")
if line is not None:
method, url, version = line.strip().split()
self.start_parsed = True
self.parser.on_method(method, url, version)
self.parse()
def parse_headers(self):
'''Parse the subsequent header name-value pairs of the HTTP request'''
line = self.buf.pop(separator=b"\r\n")
if line is not None:
if line:
name, value = line.strip().split(b": ", maxsplit=1)
if name.lower() == b"content-length":
self.body_unparsed = int(value.decode("utf-8"))
self.parser.on_header(name, value)
else:
self.headers_parsed = True
self.parse()
def __init__(self, size, chunks_no, name, IP, port, peer):
self.size = size
self.chunk_total = chunks_no
self.file_name = name
self.owners.append(peer)
for i in range(chunks_no):
self.chunks.append(Chunk(i, IP, port))
def threaded_update():
while executing:
player_pos_chunk = utils.player_to_chunk(player.position)
for j in range(
int(player_pos_chunk.z) - render_distance,
int(player_pos_chunk.z) + render_distance):
for i in range(
int(player_pos_chunk.x) - render_distance,
int(player_pos_chunk.x) + render_distance):
if not (Vec3(i, 0, j) in world):
world.update(
{Vec3(i, 0, j): Chunk(position=Vec3(i, 0, j))})
#print("Generating new chunk in {}, {}, {}".format(i,0,j))
for vec in world:
if utils.vec2dist(
utils.player_to_chunk(player.position).xz,
vec.xz) > render_distance + 1:
world[vec].destroy()
todelete.append(vec)
else:
world[vec].compute_mesh()
#update_queue.put(world[vec])
for vec in todelete:
del world[vec]
todelete.clear()
time.sleep(0.5)
class Compiler():
chunk = Chunk()
scope_depth = 0
global_variables = []
local_variables = []
def payload(self):
c = Chunk(self.mem,self.argv,self.envp)
print "Type\tOffset VirtAddr PsychAddr FileSz MemSz Flg Align"
for ph in self.elf.enum_phdr():
print ph
if ph.p_type in [ph.PT_LOAD,ph.PT_GNU_STACK] :
c.append(ph)
c.append(self.elf)
for a in c.chunks:
print hex(len(a))
# needle = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz'
return self.loader() + ''.join(c.chunks)
def get_block(self, x, y):
assert 0 <= x < (self._data["world_db"]["main"] \
["worldv2"]["worldWidthMacro"] << 5) and 0 <= y < 1024
name = "%d_%d" % (x >> 5, y >> 5)
if not isinstance(self.chunks[name], Chunk):
self.chunks[name] = Chunk(self.chunks[name]._data[0])
return self.chunks[name].get_block(x & 31, y & 31)
def get_chunk(self, x, y):
assert 0 <= x < self._data["world_db"]["main"] \
["worldv2"]["worldWidthMacro"] and 0 <= y < 32
name = "%d_%d" % (x, y)
if not isinstance(self.chunks[name], Chunk):
self.chunks[name] = Chunk(self.chunks[name]._data[0])
return self.chunks[name]
def dump(node):
debugcnt = 0
sentence_id = -1
for c in node:
if c.tag == "sentence":
sentence = []
sentence_id += 1
chunk_dict = {} # chunkは1sentenceに複数
token_dict = {} #tokenは1chunkに複数
chunk_iter = c.getiterator('chunk')
for chunk in chunk_iter:
morphs = []
tok_iter = chunk.getiterator('tok')
chunk_dict['id'] = chunk.get("id")
chunk_dict['link'] = chunk.get("link")
chunk_dict['rel'] = chunk.get("rel")
chunk_dict['score'] = chunk.get("score")
chunk_dict['head'] = chunk.get("head")
chunk_dict['func'] = chunk.get("func")
for tok in tok_iter:
tok_id = tok.get('id')
tok_feature = tok.get('feature')
morph = Morph(sentence_id, chunk_dict['id'], tok_id, tok_feature, tok.text)
morphs.append(morph)
tok_content = tok.text
a_chunk = Chunk(sentence_id,chunk_dict['id'], chunk_dict['link'], chunk_dict['rel'], \
chunk_dict['score'], chunk_dict['head'], chunk_dict['func'], morphs)
# chuncks.append(a_chunk)
sentence.append(a_chunk)
sents_list.append(sentence)
dump(c)
def __init__(self, parent_log):
"""parent_log: The logging.getLogger() object that will be the parent for this log."""
super(WorldDataServer, self).__init__()
self.__running__ = mp.Value('b', True)
self.__main_pipe_pub__, self.__main_pipe__ = mp.Pipe(True)
self.__chunks__ = defaultdict(lambda: Chunk())
self.__connections__ = {
self.__main_pipe__: config.WorldDataServer.MainConnectionName,
}
self.parent_log = parent_log
#self.log = logging.getLogger('WorldDataServer')
self.log = parent_log.getChild('WorldDataServer')
self.log.setLevel(config.WorldDataServer.LogLevel)
#self.__handler__ = logging.StreamHandler()
# DON'T DELETE ME. This is the format I want for the main log.
#self.__formatter__ = logging.Formatter('%(asctime)s %(processName)-6s %(filename)s:%(funcName)s[%(lineno)s] %(levelname)-8s %(message)s')
#self.__handler__.setFormatter(self.__formatter__)
#self.log.addHandler(self.__handler__)
#self.log.setLevel(log_level)
self.log.info("WorldDataServer is ready.")
def __init__(self, save_file, machine):
f = open(save_file, 'rb')
form = Chunk(f)
self.machine = machine
if form.read(4) != 'IFZS':
raise QuetzalError, "File is not a quetzal save file!"
# Read the thing
while True:
try:
chunk = Chunk(form)
except EOFError:
break
function = "chunk_%s" % chunk.getname().strip()
if hasattr(self, function):
self.__getattribute__(function)(chunk)
def __init__(self, file):
if type(file) == type(''):
self.__filename = file # only needed for __repr__
self.__file = file = open(file, 'rb')
else:
self.__filename = '<unknown filename>'
self.__file = file
# initialization
self.__chunk = None # the chunk currently being read
self.__format = None
self.__ssnd_chunk = None
self.__version = None
self.__markers = None
self.__soundpos = 0
self.__framesread = 0
# start parsing
self.__file = file = Chunk(file)
if file.getname() != 'FORM':
raise audio.Error, 'file does not start with FORM id'
formdata = file.read(4)
if formdata == 'AIFF':
self.__aifc = 0
elif formdata == 'AIFC':
self.__aifc = 1
else:
raise audio.Error, 'not an AIFF or AIFF-C file'
def initfp(self, file):
self._version = 0
self._decomp = None
self._convert = None
self._markers = []
self._soundpos = 0
self._file = file
chunk = Chunk(file)
if chunk.getname() != 'FORM':
raise Error, 'file does not start with FORM id'
formdata = chunk.read(4)
if formdata == 'AIFF':
self._aifc = 0
elif formdata == 'AIFC':
self._aifc = 1
else:
raise Error, 'not an AIFF or AIFF-C file'
self._comm_chunk_read = 0
while 1:
self._ssnd_seek_needed = 1
try:
chunk = Chunk(self._file)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == 'COMM':
self._read_comm_chunk(chunk)
self._comm_chunk_read = 1
elif chunkname == 'SSND':
self._ssnd_chunk = chunk
dummy = chunk.read(8)
self._ssnd_seek_needed = 0
elif chunkname == 'FVER':
self._version = _read_ulong(chunk)
elif chunkname == 'MARK':
self._readmark(chunk)
chunk.skip()
if not self._comm_chunk_read or not self._ssnd_chunk:
raise Error, 'COMM chunk and/or SSND chunk missing'
if self._aifc and self._decomp:
import cl
params = [cl.ORIGINAL_FORMAT,
0,
cl.BITS_PER_COMPONENT,
self._sampwidth * 8,
cl.FRAME_RATE,
self._framerate]
if self._nchannels == 1:
params[1] = cl.MONO
elif self._nchannels == 2:
params[1] = cl.STEREO_INTERLEAVED
else:
raise Error, 'cannot compress more than 2 channels'
self._decomp.SetParams(params)
return
def loadFile(self, filename):
with open(filename) as iff:
chunk = Chunk(iff)
logging.info('Reading file "%s"' % filename)
if chunk.getname() == "FORM" and chunk.read(4) == self._kind:
iff.seek(12)
while True:
try:
chunk = Chunk(iff)
except EOFError:
break
name = chunk.getname()
size = chunk.getsize()
data = chunk.read()
logging.debug("Encountered %s chunk of size %d" % (name, size))
self._chunks.append(self._parseChunk(name, data))
else:
logging.error("File %s is not of IFF/%s type." % (filename, self._kind))
return False
return True
def load(self, filename):
self.chunks = []
with open(filename) as iff:
chunk = Chunk(iff)
logging.info('Reading file "%s" as IFF/%s type.' % (filename, self.form))
if chunk.getname() == 'FORM' and chunk.read(4) == self.form:
iff.seek(12)
while True:
try:
chunk = Chunk(iff)
except EOFError:
break
name = chunk.getname()
size = chunk.getsize()
data = chunk.read()
if name in self.ChunkBlackList:
logging.info('Ignoring %s chunk of size %d' % (name, size))
else:
logging.debug('Encountered %s chunk of size %d' % (name, size))
self.chunks.append(self.readChunk(name, data))
else:
logging.warn(
'File %s is not of IFF/%s type.' % (filename, self.form))
return False
return True
def readChunks(self, file):
file.seek(self.offset)
self.chunks = {}
done = False
# Marathon maps are made of many types of 'chunks'
# Lines, points, sides, mission info, etc
while not done:
chunk = Chunk()
chunk.read(file)
file.seek(chunk.next + self.offset)
if chunk.next == 0:
done = True
self.chunks[chunk.tag] = chunk
def parse(self, filename):
book = []
sentence = []
chunk = Chunk()
srcs = {}
cnt_eos = 0
for line in codecs.open(filename, "r"):
# 文節の始まり
if line[0] == '*':
# print line
column = line.split(" ")
chunk_id = str(column[1])
if chunk_id != '0':
sentence.append(chunk)
# 係り先
dst = column[2].replace("D", "")
if dst != '-1':
if srcs.has_key(dst):
srcs[dst].append(chunk_id)
else:
srcs[dst] = [chunk_id]
# Chunkオブジェクト生成
chunk = Chunk()
chunk.chunk_id = chunk_id
chunk.dst = dst
chunk.srcs = srcs.get(chunk_id)
continue
# 一文の終わりの場合
if line.strip() == 'EOS':
cnt_eos += 1
if len(sentence) > 0:
sentence.append(chunk)
book.append(sentence)
# print chunk
sentence = []
srcs = {}
continue
# 文の開始または途中の場合
column = re.split("[\t|,]", line)
morpheme = Morph(column[0], column[7], column[1], column[2])
chunk.addMorph(morpheme)
self.parsed = book
def build_chunk(Schema,chunk_id,cellcount,chunksize):
chosen = []
coords = [] # coordinates of nonempty cells
attrvals = [] # attribute values of nonempty cells
chunk = Chunk(Schema,chunk_id,cellcount,[],[]) # empty chunk for now
if chunksize == 1:
return [0]
candidates = range(chunksize)
if cellcount == chunksize:
return candidates
chosen = choose_randk(candidates,cellcount)
#generate dimension coordinates
for i in chosen:
coords.append(Schema.compute_dimid(chunk_id,i))
chunk.coordinates = coords
#generate attribute values
attrvals = generate_attributes(Schema.attributes,cellcount)
chunk.attributes = attrvals
#print "chosen:",chosen
#print "dimensions for cell",chosen[0],"of chunk",chunk_id,":",Schema.compute_dimid(chunk_id,chosen[0])
#print "coords for chunk",chunk_id,":",coords
#print "attributes for chunk",chunk_id,":",attrvals
return chunk
def _read_wav_header(self):
""" Read RIFF WAV header. """
try:
ch = Chunk(self.wav, bigendian=0)
except (EOFError):
logging.debug("WAV file is corrupted.")
return False
if ch.getname() != "RIFF" or ch.read(4) != "WAVE":
logging.debug("Not a WAV file.")
return False
# this would normally be 0
self.riff_pos = self.wav.tell() - 12
riff_size = ch.getsize()
self.sampwidth, self.nchannels, self.framerate = 0, 0, 0
while True:
try:
chunk = Chunk(ch, bigendian=0)
except EOFError:
logging.debug("No data chunk found in WAV file.")
return False
chunkname = chunk.getname()
if chunkname == "fmt ":
format_tag, self.nchannels, self.framerate, _, _ = struct.unpack("<HHLLH", chunk.read(14))
if format_tag == 1:
sampwidth = struct.unpack("<H", chunk.read(2))[0]
self.sampwidth = (sampwidth + 7) // 8
else:
logging.debug("WAV file not in uncompressed PCM format.")
return False
elif chunkname == "data":
if not self.sampwidth:
logging.debug("Format chunk not found.")
return False
self.data_pos = self.wav.tell() - 4
# self.wav.read(4)
self.start = self.wav.tell()
return True
chunk.skip()
def __init__(self, path):
super(DownmixedWavFile, self).__init__()
self._file = None
self._file = open(path, 'rb')
try:
riff = Chunk(self._file, bigendian=False)
if riff.getname() != 'RIFF':
raise SushiError('File does not start with RIFF id')
if riff.read(4) != 'WAVE':
raise SushiError('Not a WAVE file')
fmt_chunk_read = False
data_chink_read = False
file_size = os.path.getsize(path)
while True:
try:
chunk = Chunk(self._file, bigendian=False)
except EOFError:
break
if chunk.getname() == 'fmt ':
self._read_fmt_chunk(chunk)
fmt_chunk_read = True
elif chunk.getname() == 'data':
if file_size > 0xFFFFFFFF:
# large broken wav
self.frames_count = (file_size - self._file.tell()) // self.frame_size
else:
self.frames_count = chunk.chunksize // self.frame_size
data_chink_read = True
break
chunk.skip()
if not fmt_chunk_read or not data_chink_read:
raise SushiError('Invalid WAV file')
except:
if self._file:
self._file.close()
raise
def initfp(self, file):
self._version = 0
self._convert = None
self._markers = []
self._soundpos = 0
self._file = file
chunk = Chunk(file)
if chunk.getname() != b'FORM':
raise Error('file does not start with FORM id')
formdata = chunk.read(4)
if formdata == b'AIFF':
self._aifc = 0
elif formdata == b'AIFC':
self._aifc = 1
else:
raise Error('not an AIFF or AIFF-C file')
self._comm_chunk_read = 0
self._ssnd_chunk = None
while 1:
self._ssnd_seek_needed = 1
try:
chunk = Chunk(self._file)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b'COMM':
self._read_comm_chunk(chunk)
self._comm_chunk_read = 1
elif chunkname == b'SSND':
self._ssnd_chunk = chunk
dummy = chunk.read(8)
self._ssnd_seek_needed = 0
elif chunkname == b'FVER':
self._version = _read_ulong(chunk)
elif chunkname == b'MARK':
self._readmark(chunk)
chunk.skip()
if not self._comm_chunk_read or not self._ssnd_chunk:
raise Error('COMM chunk and/or SSND chunk missing')
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._cue = []
self._loops = []
self._ieee = False
self._file = Chunk(file, bigendian=0)
if self._file.getname() != 'RIFF':
raise Error, 'file does not start with RIFF id'
if self._file.read(4) != 'WAVE':
raise Error, 'not a WAVE file'
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == 'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == 'data':
if not self._fmt_chunk_read:
raise Error, 'data chunk before fmt chunk'
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
elif chunkname == 'cue ':
numcue = struct.unpack('<i', chunk.read(4))[0]
for i in range(numcue):
id, position, datachunkid, chunkstart, blockstart, sampleoffset = struct.unpack('<iiiiii', chunk.read(24))
self._cue.append(sampleoffset)
elif chunkname == 'smpl':
manuf, prod, sampleperiod, midiunitynote, midipitchfraction, smptefmt, smpteoffs, numsampleloops, samplerdata = struct.unpack(
'<iiiiiiiii', chunk.read(36))
for i in range(numsampleloops):
cuepointid, type, start, end, fraction, playcount = struct.unpack('<iiiiii', chunk.read(24))
self._loops.append([start, end])
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error, 'fmt chunk and/or data chunk missing'
def initfp(self, file):
self._version = 0
self._convert = None
self._markers = []
self._soundpos = 0
self._file = file
chunk = Chunk(file)
if chunk.getname() != b"FORM":
raise Error("file does not start with FORM id")
formdata = chunk.read(4)
if formdata == b"AIFF":
self._aifc = 0
elif formdata == b"AIFC":
self._aifc = 1
else:
raise Error("not an AIFF or AIFF-C file")
self._comm_chunk_read = 0
while 1:
self._ssnd_seek_needed = 1
try:
chunk = Chunk(self._file)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b"COMM":
self._read_comm_chunk(chunk)
self._comm_chunk_read = 1
elif chunkname == b"SSND":
self._ssnd_chunk = chunk
dummy = chunk.read(8)
self._ssnd_seek_needed = 0
elif chunkname == b"FVER":
self._version = _read_ulong(chunk)
elif chunkname == b"MARK":
self._readmark(chunk)
chunk.skip()
if not self._comm_chunk_read or not self._ssnd_chunk:
raise Error("COMM chunk and/or SSND chunk missing")
def parseFromFile(cls, iFile, nodeName = None):
# parse a file generating an SF2 tree structure
# read stuff from file at the current position
aChunk = Chunk(iFile, align=True, bigendian=False)
ckID = aChunk.getname()
ckSize = aChunk.getsize()
ckData = aChunk.read()
aChunk.close()
# let's create a node from this data
node = SF2Parser.createNode(nodeName, ckID, ckSize, ckData)
# depending on the type of node, children could be inside of it
SF2Parser.parseNode(node)
# return the root node
return node
def setUp(self):
load_block_types("code/pynecraft/blocks.xml")
self.chunk = Chunk(CatchAll(), None, 32, 0, 0, 0)
"""Stuff to parse WAVE files.
class Aifc_read:
# Variables used in this class:
#
# These variables are available to the user though appropriate
# methods of this class:
# _file -- the open file with methods read(), close(), and seek()
# set through the __init__() method
# _nchannels -- the number of audio channels
# available through the getnchannels() method
# _nframes -- the number of audio frames
# available through the getnframes() method
# _sampwidth -- the number of bytes per audio sample
# available through the getsampwidth() method
# _framerate -- the sampling frequency
# available through the getframerate() method
# _comptype -- the AIFF-C compression type ('NONE' if AIFF)
# available through the getcomptype() method
# _compname -- the human-readable AIFF-C compression type
# available through the getcomptype() method
# _markers -- the marks in the audio file
# available through the getmarkers() and getmark()
# methods
# _soundpos -- the position in the audio stream
# available through the tell() method, set through the
# setpos() method
#
# These variables are used internally only:
# _version -- the AIFF-C version number
# _decomp -- the decompressor from builtin module cl
# _comm_chunk_read -- 1 iff the COMM chunk has been read
# _aifc -- 1 iff reading an AIFF-C file
# _ssnd_seek_needed -- 1 iff positioned correctly in audio
# file for readframes()
# _ssnd_chunk -- instantiation of a chunk class for the SSND chunk
# _framesize -- size of one frame in the file
def initfp(self, file):
self._version = 0
self._decomp = None
self._convert = None
self._markers = []
self._soundpos = 0
self._file = Chunk(file)
if self._file.getname() != 'FORM':
raise Error, 'file does not start with FORM id'
formdata = self._file.read(4)
if formdata == 'AIFF':
self._aifc = 0
elif formdata == 'AIFC':
self._aifc = 1
else:
raise Error, 'not an AIFF or AIFF-C file'
self._comm_chunk_read = 0
while 1:
self._ssnd_seek_needed = 1
try:
chunk = Chunk(self._file)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == 'COMM':
self._read_comm_chunk(chunk)
self._comm_chunk_read = 1
elif chunkname == 'SSND':
self._ssnd_chunk = chunk
dummy = chunk.read(8)
self._ssnd_seek_needed = 0
elif chunkname == 'FVER':
self._version = _read_ulong(chunk)
elif chunkname == 'MARK':
self._readmark(chunk)
elif chunkname in _skiplist:
pass
else:
raise Error, 'unrecognized chunk type '+chunk.chunkname
chunk.skip()
if not self._comm_chunk_read or not self._ssnd_chunk:
raise Error, 'COMM chunk and/or SSND chunk missing'
if self._aifc and self._decomp:
import cl
params = [cl.ORIGINAL_FORMAT, 0,
cl.BITS_PER_COMPONENT, self._sampwidth * 8,
cl.FRAME_RATE, self._framerate]
if self._nchannels == 1:
params[1] = cl.MONO
elif self._nchannels == 2:
params[1] = cl.STEREO_INTERLEAVED
else:
raise Error, 'cannot compress more than 2 channels'
self._decomp.SetParams(params)
def __init__(self, f):
if type(f) == type(''):
f = __builtin__.open(f, 'rb')
# else, assume it is an open file object already
self.initfp(f)
#
# User visible methods.
#
def getfp(self):
return self._file
def rewind(self):
self._ssnd_seek_needed = 1
self._soundpos = 0
def close(self):
if self._decomp:
self._decomp.CloseDecompressor()
self._decomp = None
self._file = None
def tell(self):
return self._soundpos
def getnchannels(self):
return self._nchannels
def getnframes(self):
return self._nframes
def getsampwidth(self):
return self._sampwidth
def getframerate(self):
return self._framerate
def getcomptype(self):
return self._comptype
def getcompname(self):
return self._compname
## def getversion(self):
## return self._version
def getparams(self):
return self.getnchannels(), self.getsampwidth(), \
self.getframerate(), self.getnframes(), \
self.getcomptype(), self.getcompname()
def getmarkers(self):
if len(self._markers) == 0:
return None
return self._markers
def getmark(self, id):
for marker in self._markers:
if id == marker[0]:
return marker
raise Error, 'marker %r does not exist' % (id,)
def setpos(self, pos):
if pos < 0 or pos > self._nframes:
raise Error, 'position not in range'
self._soundpos = pos
self._ssnd_seek_needed = 1
def readframes(self, nframes):
if self._ssnd_seek_needed:
self._ssnd_chunk.seek(0)
dummy = self._ssnd_chunk.read(8)
pos = self._soundpos * self._framesize
if pos:
self._ssnd_chunk.seek(pos + 8)
self._ssnd_seek_needed = 0
if nframes == 0:
return ''
data = self._ssnd_chunk.read(nframes * self._framesize)
if self._convert and data:
data = self._convert(data)
self._soundpos = self._soundpos + len(data) / (self._nchannels * self._sampwidth)
return data
#
# Internal methods.
#
def _decomp_data(self, data):
import cl
dummy = self._decomp.SetParam(cl.FRAME_BUFFER_SIZE,
len(data) * 2)
return self._decomp.Decompress(len(data) / self._nchannels,
data)
def _ulaw2lin(self, data):
import audioop
return audioop.ulaw2lin(data, 2)
def _adpcm2lin(self, data):
import audioop
if not hasattr(self, '_adpcmstate'):
# first time
self._adpcmstate = None
data, self._adpcmstate = audioop.adpcm2lin(data, 2,
self._adpcmstate)
return data
def _read_comm_chunk(self, chunk):
self._nchannels = _read_short(chunk)
self._nframes = _read_long(chunk)
self._sampwidth = (_read_short(chunk) + 7) / 8
self._framerate = int(_read_float(chunk))
self._framesize = self._nchannels * self._sampwidth
if self._aifc:
#DEBUG: SGI's soundeditor produces a bad size :-(
kludge = 0
if chunk.chunksize == 18:
kludge = 1
print 'Warning: bad COMM chunk size'
chunk.chunksize = 23
#DEBUG end
self._comptype = chunk.read(4)
#DEBUG start
if kludge:
length = ord(chunk.file.read(1))
if length & 1 == 0:
length = length + 1
chunk.chunksize = chunk.chunksize + length
chunk.file.seek(-1, 1)
#DEBUG end
self._compname = _read_string(chunk)
if self._comptype != 'NONE':
if self._comptype == 'G722':
try:
import audioop
except ImportError:
pass
else:
self._convert = self._adpcm2lin
self._framesize = self._framesize / 4
return
# for ULAW and ALAW try Compression Library
try:
import cl
except ImportError:
if self._comptype == 'ULAW':
try:
import audioop
self._convert = self._ulaw2lin
self._framesize = self._framesize / 2
return
except ImportError:
pass
raise Error, 'cannot read compressed AIFF-C files'
if self._comptype == 'ULAW':
scheme = cl.G711_ULAW
self._framesize = self._framesize / 2
elif self._comptype == 'ALAW':
scheme = cl.G711_ALAW
self._framesize = self._framesize / 2
#else:
# raise Error, 'unsupported compression type'
self._decomp = cl.OpenDecompressor(scheme)
self._convert = self._decomp_data
else:
self._comptype = 'NONE'
self._compname = 'not compressed'
def _readmark(self, chunk):
nmarkers = _read_short(chunk)
# Some files appear to contain invalid counts.
# Cope with this by testing for EOF.
try:
for i in range(nmarkers):
id = _read_short(chunk)
pos = _read_long(chunk)
name = _read_string(chunk)
if pos or name:
# some files appear to have
# dummy markers consisting of
# a position 0 and name ''
self._markers.append((id, pos, name))
except EOFError:
print 'Warning: MARK chunk contains only',
print len(self._markers),
if len(self._markers) == 1: print 'marker',
else: print 'markers',
print 'instead of', nmarkers
from chunk import Chunk
c = Chunk()
c.load("test.dat")
print(c)
c[0, 0] = 1
print(c)
c.save("test.dat")
class Wave_read:
"""Variables used in this class:
These variables are available to the user though appropriate
methods of this class:
_file -- the open file with methods read(), close(), and seek()
set through the __init__() method
_nchannels -- the number of audio channels
available through the getnchannels() method
_nframes -- the number of audio frames
available through the getnframes() method
_sampwidth -- the number of bytes per audio sample
available through the getsampwidth() method
_framerate -- the sampling frequency
available through the getframerate() method
_comptype -- the AIFF-C compression type ('NONE' if AIFF)
available through the getcomptype() method
_compname -- the human-readable AIFF-C compression type
available through the getcomptype() method
_soundpos -- the position in the audio stream
available through the tell() method, set through the
setpos() method
These variables are used internally only:
_fmt_chunk_read -- 1 iff the FMT chunk has been read
_data_seek_needed -- 1 iff positioned correctly in audio
file for readframes()
_data_chunk -- instantiation of a chunk class for the DATA chunk
_framesize -- size of one frame in the file
"""
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._file = Chunk(file, bigendian=0)
if self._file.getname() != 'RIFF':
raise Error, 'file does not start with RIFF id'
if self._file.read(4) != 'WAVE':
raise Error, 'not a WAVE file'
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian=0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == 'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == 'data':
if not self._fmt_chunk_read:
raise Error, 'data chunk before fmt chunk'
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
break
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error, 'fmt chunk and/or data chunk missing'
return
def __init__(self, f):
self._i_opened_the_file = None
if isinstance(f, basestring):
f = __builtin__.open(f, 'rb')
self._i_opened_the_file = f
try:
self.initfp(f)
except:
if self._i_opened_the_file:
f.close()
raise
return
def __del__(self):
self.close()
def getfp(self):
return self._file
def rewind(self):
self._data_seek_needed = 1
self._soundpos = 0
def close(self):
if self._i_opened_the_file:
self._i_opened_the_file.close()
self._i_opened_the_file = None
self._file = None
return
def tell(self):
return self._soundpos
def getnchannels(self):
return self._nchannels
def getnframes(self):
return self._nframes
def getsampwidth(self):
return self._sampwidth
def getframerate(self):
return self._framerate
def getcomptype(self):
return self._comptype
def getcompname(self):
return self._compname
def getparams(self):
return (self.getnchannels(),
self.getsampwidth(),
self.getframerate(),
self.getnframes(),
self.getcomptype(),
self.getcompname())
def getmarkers(self):
return None
def getmark(self, id):
raise Error, 'no marks'
def setpos(self, pos):
if pos < 0 or pos > self._nframes:
raise Error, 'position not in range'
self._soundpos = pos
self._data_seek_needed = 1
def readframes(self, nframes):
if self._data_seek_needed:
self._data_chunk.seek(0, 0)
pos = self._soundpos * self._framesize
if pos:
self._data_chunk.seek(pos, 0)
self._data_seek_needed = 0
if nframes == 0:
return ''
if self._sampwidth in (2, 4) and sys.byteorder == 'big':
import array
chunk = self._data_chunk
data = array.array(_array_fmts[self._sampwidth])
if not data.itemsize == self._sampwidth:
raise AssertionError
nitems = nframes * self._nchannels
if nitems * self._sampwidth > chunk.chunksize - chunk.size_read:
nitems = (chunk.chunksize - chunk.size_read) / self._sampwidth
data.fromfile(chunk.file.file, nitems)
chunk.size_read = chunk.size_read + nitems * self._sampwidth
chunk = chunk.file
chunk.size_read = chunk.size_read + nitems * self._sampwidth
data.byteswap()
data = data.tostring()
else:
data = self._data_chunk.read(nframes * self._framesize)
if self._sampwidth == 3 and sys.byteorder == 'big':
data = _byteswap3(data)
data = self._convert and data and self._convert(data)
self._soundpos = self._soundpos + len(data) // (self._nchannels * self._sampwidth)
return data
def _read_fmt_chunk(self, chunk):
wFormatTag, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack('<HHLLH', chunk.read(14))
if wFormatTag == WAVE_FORMAT_PCM:
sampwidth = struct.unpack('<H', chunk.read(2))[0]
self._sampwidth = (sampwidth + 7) // 8
else:
raise Error, 'unknown format: %r' % (wFormatTag,)
self._framesize = self._nchannels * self._sampwidth
self._comptype = 'NONE'
self._compname = 'not compressed'
class Wave_read:
"""Variables used in this class:
These variables are available to the user though appropriate
methods of this class:
_file -- the open file with methods read(), close(), and seek()
set through the __init__() method
_nchannels -- the number of audio channels
available through the getnchannels() method
_nframes -- the number of audio frames
available through the getnframes() method
_sampwidth -- the number of bytes per audio sample
available through the getsampwidth() method
_framerate -- the sampling frequency
available through the getframerate() method
_comptype -- the AIFF-C compression type ('NONE' if AIFF)
available through the getcomptype() method
_compname -- the human-readable AIFF-C compression type
available through the getcomptype() method
_soundpos -- the position in the audio stream
available through the tell() method, set through the
setpos() method
These variables are used internally only:
_fmt_chunk_read -- 1 iff the FMT chunk has been read
_data_seek_needed -- 1 iff positioned correctly in audio
file for readframes()
_data_chunk -- instantiation of a chunk class for the DATA chunk
_framesize -- size of one frame in the file
"""
def initfp(self, file):
self._convert = None
self._soundpos = 0
self._file = Chunk(file, bigendian = 0)
if self._file.getname() != b'RIFF':
raise Error('file does not start with RIFF id')
if self._file.read(4) != b'WAVE':
raise Error('not a WAVE file')
self._fmt_chunk_read = 0
self._data_chunk = None
while 1:
self._data_seek_needed = 1
try:
chunk = Chunk(self._file, bigendian = 0)
except EOFError:
break
chunkname = chunk.getname()
if chunkname == b'fmt ':
self._read_fmt_chunk(chunk)
self._fmt_chunk_read = 1
elif chunkname == b'data':
if not self._fmt_chunk_read:
raise Error('data chunk before fmt chunk')
self._data_chunk = chunk
self._nframes = chunk.chunksize // self._framesize
self._data_seek_needed = 0
break
chunk.skip()
if not self._fmt_chunk_read or not self._data_chunk:
raise Error('fmt chunk and/or data chunk missing')
def __init__(self, f):
self._i_opened_the_file = None
if isinstance(f, str):
f = builtins.open(f, 'rb')
self._i_opened_the_file = f
# else, assume it is an open file object already
try:
self.initfp(f)
except:
if self._i_opened_the_file:
f.close()
raise
def __del__(self):
self.close()
#
# User visible methods.
#
def getfp(self):
return self._file
def rewind(self):
self._data_seek_needed = 1
self._soundpos = 0
def close(self):
if self._i_opened_the_file:
self._i_opened_the_file.close()
self._i_opened_the_file = None
self._file = None
def tell(self):
return self._soundpos
def getnchannels(self):
return self._nchannels
def getnframes(self):
return self._nframes
def getsampwidth(self):
return self._sampwidth
def getframerate(self):
return self._framerate
def getcomptype(self):
return self._comptype
def getcompname(self):
return self._compname
def getparams(self):
return self.getnchannels(), self.getsampwidth(), \
self.getframerate(), self.getnframes(), \
self.getcomptype(), self.getcompname()
def getmarkers(self):
return None
def getmark(self, id):
raise Error('no marks')
def setpos(self, pos):
if pos < 0 or pos > self._nframes:
raise Error('position not in range')
self._soundpos = pos
self._data_seek_needed = 1
def readframes(self, nframes):
if self._data_seek_needed:
self._data_chunk.seek(0, 0)
pos = self._soundpos * self._framesize
if pos:
self._data_chunk.seek(pos, 0)
self._data_seek_needed = 0
if nframes == 0:
return b''
if self._sampwidth > 1 and big_endian:
# unfortunately the fromfile() method does not take
# something that only looks like a file object, so
# we have to reach into the innards of the chunk object
import array
chunk = self._data_chunk
data = array.array(_array_fmts[self._sampwidth])
nitems = nframes * self._nchannels
if nitems * self._sampwidth > chunk.chunksize - chunk.size_read:
nitems = (chunk.chunksize - chunk.size_read) // self._sampwidth
data.fromfile(chunk.file.file, nitems)
# "tell" data chunk how much was read
chunk.size_read = chunk.size_read + nitems * self._sampwidth
# do the same for the outermost chunk
chunk = chunk.file
chunk.size_read = chunk.size_read + nitems * self._sampwidth
data.byteswap()
data = data.tobytes()
else:
data = self._data_chunk.read(nframes * self._framesize)
if self._convert and data:
data = self._convert(data)
self._soundpos = self._soundpos + len(data) // (self._nchannels * self._sampwidth)
return data
#
# Internal methods.
#
def _read_fmt_chunk(self, chunk):
wFormatTag, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack_from('<hhllh', chunk.read(14))
if wFormatTag == WAVE_FORMAT_PCM:
sampwidth = struct.unpack_from('<h', chunk.read(2))[0]
self._sampwidth = (sampwidth + 7) // 8
else:
raise Error('unknown format: %r' % (wFormatTag,))
self._framesize = self._nchannels * self._sampwidth
self._comptype = 'NONE'
self._compname = 'not compressed'
def __init__(self, filename, outfilename=None):
self.chunks = []
self.chunkmap = {}
self.chunkatpos = {}
self.usages = []
self.usagemap = {}
self.filename = filename
self.outfilename = outfilename
if (not self.outfilename):
self.outfilename = self.filename
if (not self.filename):
# No loading; create an empty file.
self.file = None
self.formchunk = None
self.changed = True
chunk = BlorbChunk(self, b'RIdx', -1, 4)
chunk.literaldata = struct.pack('>I', 0)
self.add_chunk(chunk, None, None, 0)
return
self.changed = False
self.file = open(filename, 'rb')
formchunk = Chunk(self.file)
self.formchunk = formchunk
if (formchunk.getname() != b'FORM'):
raise Exception('This does not appear to be a Blorb file.')
formtype = formchunk.read(4)
if (formtype != b'IFRS'):
raise Exception('This does not appear to be a Blorb file.')
formlen = formchunk.getsize()
while formchunk.tell() < formlen:
chunk = Chunk(formchunk)
start = formchunk.tell()
size = chunk.getsize()
formtype = None
if chunk.getname() == b'FORM':
formtype = chunk.read(4)
subchunk = BlorbChunk(self, chunk.getname(), start, size, formtype)
self.chunks.append(subchunk)
chunk.skip()
chunk.close()
for chunk in self.chunks:
self.chunkatpos[chunk.start] = chunk
dict_append(self.chunkmap, chunk.type, chunk)
# Sanity checks. Also get the usage list.
ls = self.chunkmap.get(b'RIdx')
if (not ls):
raise Exception('No resource index chunk!')
elif (len(ls) != 1):
print('Warning: too many resource index chunks!')
else:
chunk = ls[0]
if (self.chunks[0] is not chunk):
print('Warning: resource index chunk is not first!')
dat = chunk.data()
numres = struct.unpack('>I', dat[0:4])[0]
if (numres*12+4 != chunk.len):
print('Warning: resource index chunk has wrong size!')
for ix in range(numres):
subdat = dat[4+ix*12 : 16+ix*12]
typ = struct.unpack('>4c', subdat[0:4])
typ = b''.join(typ)
num = struct.unpack('>I', subdat[4:8])[0]
start = struct.unpack('>I', subdat[8:12])[0]
subchunk = self.chunkatpos.get(start)
if (not subchunk):
print('Warning: resource (%s, %d) refers to a nonexistent chunk!' % (typestring(typ), num))
self.usages.append( (typ, num, subchunk) )
self.usagemap[(typ, num)] = subchunk
