qwad/WiiPy/bns.py

619 lines
22 KiB
Python
Raw Normal View History

2012-08-21 19:28:14 +02:00
#!/usr/bin/python
from common import *
class SoundFile:
def __init__(self, signal, filename, samplerate=32000):
self.actual_file = StringIO()
self.file = wave.open(filename, 'wb')
self.signal = signal
self.sr = samplerate
def write(self):
self.file.setparams((2, 2, self.sr, self.sr*4, 'NONE', 'noncompressed'))
self.file.writeframes(self.signal)
self.actual_file.seek(0)
self.file.close()
class BNS_data(object):
def __init__(self):
self.magic = "DATA"
self.size = 0x0004d000
def eat(self, buffer, offset):
self.magic, self.size = struct.unpack('>4sI', buffer[offset:offset+8])
return offset + 8
def show(self):
print "Magic: %s" % self.magic
print "Length: %08x" % self.size
return
def write(self, file):
file.write(self.magic)
file.write(struct.pack('>I', self.size))
file.write(self.data)
return
class BNS_info(object):
def __init__(self):
self.magic = "INFO"
self.size = 0x000000a0
self.codec = 0x00
self.has_loop = 0x00
self.chan_cnt = 0x02
self.zero = 0x00
self.samplerate = 0xac44
self.pad0 = 0x0000
self.loop_start = 0x00000000
self.loop_end = 0x00000000
self.offset_to_chan_starts = 0x00000018
self.pad2 = 0x00000000
self.channel1_start_offset = 0x00000020
self.channel2_start_offset = 0x0000002C
self.chan1_start = 0x00000000
self.coefficients1_offset = 0x0000038
self.pad1 = 0x00000000
self.chan2_start = 0x00000000
self.coefficients2_offset = 0x00000068
self.pad3 = 0x00000000
self.coefficients1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.chan1_gain = 0x0000
self.chan1_predictive_scale = 0x0000
self.chan1_previous_value = 0x0000
self.chan1_next_previous_value = 0x0000
self.chan1_loop_predictive_scale = 0x0000
self.chan1_loop_previous_value = 0x0000
self.chan1_loop_next_previous_value = 0x0000
self.chan1_loop_padding = 0x0000
self.coefficients2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.chan2_gain = 0x0000
self.chan2_predictive_scale = 0x0000
self.chan2_previous_value = 0x0000
self.chan2_next_previous_value = 0x0000
self.chan2_loop_predictive_scale = 0x0000
self.chan2_loop_previous_value = 0x0000
self.chan2_loop_next_previous_value = 0x0000
self.chan2_loop_padding = 0x0000
def eat(self, buffer, offset):
self.magic, self.size = struct.unpack('>4sI', buffer[offset+0:offset+8])
self.codec, self.has_loop = struct.unpack('>BB', buffer[offset+8:offset+10])
self.chan_cnt, self.zero = struct.unpack('>BB', buffer[offset+10:offset+12])
self.samplerate, self.pad0 = struct.unpack('>HH', buffer[offset+12:offset+16])
assert self.samplerate <= 48000
assert self.samplerate > 32000
self.loop_start, self.loop_end = struct.unpack('>II', buffer[offset+16:offset+24])
co = offset + 24
self.offset_to_chan_starts = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.pad2 = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.channel1_start_offset = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.channel2_start_offset = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.chan1_start = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.coefficients1_offset = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
if self.chan_cnt == 2:
self.pad1 = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.chan2_start = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.coefficients2_offset = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
self.pad3 = Struct.uint32(buffer[co:co+4], endian='>')
co += 4
for x in xrange(16):
self.coefficients1[x] = Struct.int16(buffer[co:co+2], endian='>')
co += 2
self.chan1_gain = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_padding = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
for x in xrange(16):
self.coefficients2[x] = Struct.int16(buffer[co:co+2], endian='>')
co += 2
self.chan2_gain = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_loop_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_loop_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_loop_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan2_loop_padding = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
elif self.chan_cnt == 1:
for x in xrange(16):
self.coefficients1[x] = Struct.int16(buffer[co:co+2], endian='>')
co += 2
self.chan1_gain = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_predictive_scale = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_next_previous_value = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
self.chan1_loop_padding = Struct.uint16(buffer[co:co+2], endian='>')
co += 2
return co
def show(self):
print "Magic: %s" % self.magic
print "Length: %08x" % self.size
print "Codec: %02x " % self.codec,
if self.codec == 0: print "ADPCM"
else: print "Unknown (Maybe >_>, please contact megazig)"
print "Loop Flag: %02x " % self.has_loop,
if self.has_loop == 0: print "One shot"
else: print "Looping"
print "Channel Count: %02x" % self.chan_cnt
print "Zero: %02x" % self.zero
print "Samplerate: %04x %d" % ( self.samplerate , self.samplerate )
print "Padding: %04x" % self.pad0
print "Loop Start: %08x" % self.loop_start
print "Loop End: %08x" % self.loop_end
print "Channels Starts Offsets: %08x" % self.offset_to_chan_starts
print "Padding: %08x" % self.pad2
print "Channel 1 Start Offset: %08x" % self.channel1_start_offset
print "Channel 2 Start Offset: %08x" % self.channel2_start_offset
print "Channel 1 Start: %08x" % self.chan1_start
print "Coefficients 1 Offset: %08x" % self.coefficients1_offset
if self.chan_cnt == 2:
print "Padding: %08x" % self.pad1
print "Channel 2 Start: %08x" % self.chan2_start
print "Coefficients 2 Offset: %08x" % self.coefficients2_offset
print "Padding: %08x" % self.pad3
for x in xrange(16):
print "\t\tCoefficients 1: %2d - %04x - %d" % ( x , self.coefficients1[x], self.coefficients1[x] )
print "\tGain: %04x" % self.chan1_gain
print "\tPredictive Scale: %04x" % self.chan1_predictive_scale
print "\tPrevious Value: %04x" % self.chan1_previous_value
print "\tNext Previous Value: %04x" % self.chan1_next_previous_value
print "\tLoop Predictive Scale: %04x" % self.chan1_loop_predictive_scale
print "\tLoop Previous Value: %04x" % self.chan1_loop_previous_value
print "\tLoop Next Previous Value: %04x" % self.chan1_loop_next_previous_value
print "\tPadding: %04x" % self.chan1_loop_padding
for x in xrange(16):
print "\t\tCoefficients 2: %2d - %04x - %d" % ( x , self.coefficients2[x], self.coefficients2[x] )
print "\tGain: %04x" % self.chan2_gain
print "\tPredictive Scale: %04x" % self.chan2_predictive_scale
print "\tPrevious Value: %04x" % self.chan2_previous_value
print "\tNext Previous Value: %04x" % self.chan2_next_previous_value
print "\tLoop Predictive Scale: %04x" % self.chan2_loop_predictive_scale
print "\tLoop Previous Value: %04x" % self.chan2_loop_previous_value
print "\tLoop Next Previous Value: %04x" % self.chan2_loop_next_previous_value
print "\tPadding: %04x" % self.chan2_loop_padding
elif self.chan_cnt == 1:
for x in xrange(16):
print "\t\tCoefficients 1: %2d - %04x - %d" % ( x , self.coefficients1[x], self.coefficients1[x] )
print "\tGain: %04x" % self.chan1_gain
print "\tPredictive Scale: %04x" % self.chan1_predictive_scale
print "\tPrevious Value: %04x" % self.chan1_previous_value
print "\tNext Previous Value: %04x" % self.chan1_next_previous_value
print "\tLoop Predictive Scale: %04x" % self.chan1_loop_predictive_scale
print "\tLoop Previous Value: %04x" % self.chan1_loop_previous_value
print "\tLoop Next Previous Value: %04x" % self.chan1_loop_next_previous_value
print "\tPadding: %04x" % self.chan1_loop_padding
return
def write(self, file):
file.write(self.magic)
file.write(struct.pack('>I', self.size))
file.write(struct.pack('>B', self.codec))
file.write(struct.pack('>B', self.has_loop))
file.write(struct.pack('>B', self.chan_cnt))
file.write(struct.pack('>B', self.zero))
file.write(struct.pack('>H', self.samplerate))
file.write(struct.pack('>H', self.pad0))
file.write(struct.pack('>I', self.loop_start))
file.write(struct.pack('>I', self.loop_end))
file.write(struct.pack('>I', self.offset_to_chan_starts))
file.write(struct.pack('>I', self.pad2))
file.write(struct.pack('>I', self.channel1_start_offset))
file.write(struct.pack('>I', self.channel2_start_offset))
file.write(struct.pack('>I', self.chan1_start))
file.write(struct.pack('>I', self.coefficients1_offset))
if self.chan_cnt == 2:
file.write(struct.pack('>I', self.pad1))
file.write(struct.pack('>I', self.chan2_start))
file.write(struct.pack('>I', self.coefficients2_offset))
file.write(struct.pack('>I', self.pad3))
for x in xrange(16):
file.write(struct.pack('>h', self.coefficients1[x]))
file.write(struct.pack('>H', self.chan1_gain))
file.write(struct.pack('>H', self.chan1_predictive_scale))
file.write(struct.pack('>H', self.chan1_previous_value))
file.write(struct.pack('>H', self.chan1_next_previous_value))
file.write(struct.pack('>H', self.chan1_loop_predictive_scale))
file.write(struct.pack('>H', self.chan1_loop_previous_value))
file.write(struct.pack('>H', self.chan1_loop_next_previous_value))
file.write(struct.pack('>H', self.chan1_loop_padding))
for x in xrange(16):
file.write(struct.pack('>h', self.coefficients2[x]))
file.write(struct.pack('>H', self.chan2_gain))
file.write(struct.pack('>H', self.chan2_predictive_scale))
file.write(struct.pack('>H', self.chan2_previous_value))
file.write(struct.pack('>H', self.chan2_next_previous_value))
file.write(struct.pack('>H', self.chan2_loop_predictive_scale))
file.write(struct.pack('>H', self.chan2_loop_previous_value))
file.write(struct.pack('>H', self.chan2_loop_next_previous_value))
file.write(struct.pack('>H', self.chan2_loop_padding))
elif self.chan_cnt == 1:
for x in xrange(16):
file.write(struct.pack('>h', self.coefficients1[x]))
file.write(struct.pack('>H', self.chan1_gain))
file.write(struct.pack('>H', self.chan1_predictive_scale))
file.write(struct.pack('>H', self.chan1_previous_value))
file.write(struct.pack('>H', self.chan1_next_previous_value))
file.write(struct.pack('>H', self.chan1_loop_predictive_scale))
file.write(struct.pack('>H', self.chan1_loop_previous_value))
file.write(struct.pack('>H', self.chan1_loop_next_previous_value))
file.write(struct.pack('>H', self.chan1_loop_padding))
return
class BNS_header(object):
def __init__(self):
self.magic = "BNS "
self.flags = 0xfeff0100
self.filesize = 0x0004d0c0
self.size = 0x0020
self.chunk_cnt = 0x0002
self.info_off = 0x00000020
self.info_len = 0x000000a0
self.data_off = 0x000000c0
self.data_len = 0x0004d000
def eat(self, buffer, offset):
if struct.unpack('>4s', buffer[offset:offset+4])[0] != "BNS ":
offset += 0x20
self.magic, self.flags = struct.unpack('>4sI', buffer[offset+0:offset+8])
self.filesize, self.size, self.chunk_cnt = struct.unpack('>IHH', buffer[offset+8:offset+16])
self.info_off, self.info_len = struct.unpack('>II', buffer[offset+16:offset+24])
self.data_off, self.data_len = struct.unpack('>II', buffer[offset+24:offset+32])
assert self.magic == "BNS "
assert self.info_off < self.filesize
assert self.data_off < self.filesize
return offset + 32
def show(self):
print "Magic: %s" % self.magic
print "Flags: %08x" % self.flags
print "Length: %08x" % self.filesize
print "Header Size: %04x" % self.size
print "Chunk Count: %04x" % self.chunk_cnt
print "Info Offset: %08x" % self.info_off
print "Info Length: %08x" % self.info_len
print "Data Offset: %08x" % self.data_off
print "Data Length: %08x" % self.data_len
return
def write(self, file):
file.write(self.magic)
file.write(struct.pack('>I', self.flags))
file.write(struct.pack('>I', self.filesize))
file.write(struct.pack('>H', self.size))
file.write(struct.pack('>H', self.chunk_cnt))
file.write(struct.pack('>I', self.info_off))
file.write(struct.pack('>I', self.info_len))
file.write(struct.pack('>I', self.data_off))
file.write(struct.pack('>I', self.data_len))
return
class BNS(object):
def __init__(self):
self.header = BNS_header()
self.info = BNS_info()
self.data = BNS_data()
self.buffered_data = ""
self.lsamps = [ [ 0 , 0 ] , [ 0 , 0 ] ]
self.rlsamps = [ [ 0 , 0 ] , [ 0 , 0 ] ]
self.tlsamps = [ 0 , 0 ]
self.hbc_deftbl = [ 674 , 1040,
3598, -1738,
2270, -583,
3967, -1969,
1516, 381,
3453, -1468,
2606, -617,
3795, -1759 ]
self.deftbl = [ 1820 , -856 ,
3238 , -1514 ,
2333 , -550 ,
3336 , -1376 ,
2444 , -949 ,
3666 , -1764 ,
2654 , -701 ,
3420 , -1398 ]
self.phist1 = [ 0 , 0 ]
self.phist2 = [ 0 , 0 ]
self.errors = 0
def find_exp(self, residual):
exp = 0
while residual>7.5 or residual<-8.5:
exp += 1
residual /= 2.0
return exp
def determine_std_exponent(self, idx, table, index, inbuf):
elsamps = [ 0 , 0 ]
max_res = 0
factor1 = table[2*index+0]
factor2 = table[2*index+1]
for x in xrange(2):
elsamps[x] = self.rlsamps[idx][x]
for i in xrange(14):
predictor = (elsamps[1]*factor1 + elsamps[0]*factor2) >> 11
residual = inbuf[i] - predictor
if residual>max_res:
max_res = residual
elsamps[0] = elsamps[1]
elsamps[1] = inbuf[i]
return self.find_exp(max_res)
def compress_adpcm(self, idx, table, tblidx, inbuf):
data = [0 for i in range(8)]
error = 0
factor1 = table[2*tblidx+0]
factor2 = table[2*tblidx+1]
exp = self.determine_std_exponent(idx, table, tblidx, inbuf)
while exp<=15:
error = 0
data[0] = exp | (tblidx << 4)
for x in xrange(2):
self.tlsamps[x] = self.rlsamps[idx][x]
j = 0
for i in xrange(14):
predictor = (self.tlsamps[1]*factor1 + self.tlsamps[0]*factor2) >> 11
residual = inbuf[i] - predictor
residual = residual >> exp
if residual>7 or residual<-8:
exp += 1
break
nibble = clamp(residual, -8, 7)
if i&1:
data[i/2+1] = data[i/2+1] | (nibble & 0xf)
else:
data[i/2+1] = nibble << 4
predictor = predictor + (nibble << exp)
self.tlsamps[0] = self.tlsamps[1]
self.tlsamps[1] = clamp(predictor, -32768, 32767)
error = error + ((self.tlsamps[1] - inbuf[i]) ** 2)
else:
j = 14
if j == 14:
break
return error, data
def repack_adpcm(self, idx, table, inbuf):
data = [0 for i in range(8)]
blsamps = [ 0 , 0 ]
bestidx = -1
besterror = 999999999.0
for tblidx in xrange(8):
error, testdata = self.compress_adpcm(idx, table, tblidx, inbuf)
if error < besterror:
besterror = error
for x in xrange(8):
data[x] = testdata[x]
for x in xrange(2):
blsamps[x] = self.tlsamps[x]
bestidx = tblidx
for x in xrange(2):
self.rlsamps[idx][x] = blsamps[x]
return data
def encode(self, buffer, offset=0):
sampsbuf = [0 for i in range(14)]
templen = len(buffer)
templen = templen / 4
modlen = templen % 14
for x in xrange(14-modlen):
buffer = buffer + '\x00'
buffer = buffer + '\x00'
buffer = buffer + '\x00'
buffer = buffer + '\x00'
num_samps = len(buffer) / 4
blocks = (num_samps + 13) / 14
snddatal = []
snddatar = []
co = offset
temp = 0
for x in xrange(num_samps):
snddatal.append(Struct.int16(buffer[co:co+2]))
co += 2
snddatar.append(Struct.int16(buffer[co:co+2]))
co += 2
data = [0 for i in range(blocks*16)]
data1_off = 0
data2_off = blocks * 8
self.info.chan2_start = data2_off
for i in xrange(blocks):
for j in xrange(14):
sampsbuf[j] = snddatal[i*14+j]
out_buf = self.repack_adpcm(0, self.deftbl, sampsbuf)
for k in xrange(8):
data[data1_off+k] = out_buf[k]
for j in xrange(14):
sampsbuf[j] = snddatar[i*14+j]
out_buf = self.repack_adpcm(1, self.deftbl, sampsbuf)
for k in xrange(8):
data[data2_off+k] = out_buf[k]
data1_off += 8
data2_off += 8
self.info.loop_end = blocks * 7
return data
def create_bns(self, inbuf, samplerate=44100, channels=2):
self.info.chan_cnt = channels
self.info.samplerate = samplerate
assert samplerate >=32000
self.data.data = ''.join(Struct.int8(p) for p in self.encode(inbuf))
self.data.size = len(self.data.data)
self.header.data_len = self.data.size
self.header.filesize = self.info.size + self.data.size + 8 + self.header.size
self.info.loop_end = self.data.size - (self.data.size / 7)
for x in xrange(16):
self.info.coefficients1[x] = self.deftbl[x]
if self.info.chan_cnt == 2:
for x in xrange(16): self.info.coefficients2[x] = self.deftbl[x]
return
def decode_adpcm(self, index, coefs, buffer):
outbuf = [0 for i in range(14)]
header = Struct.uint8(buffer[0:1], endian='>')
coef_index = (header >> 4) & 0x7
scale = 1 << (header & 0xf)
hist1 = self.phist1[index]
hist2 = self.phist2[index]
coef1 = coefs[coef_index * 2 + 0]
coef2 = coefs[coef_index * 2 + 1]
for x in xrange(14):
sample_byte = Struct.uint8(buffer[x/2+1:x/2+2], endian='>')
if x&1:
nibble = (sample_byte & 0xf0) >> 4
else:
nibble = (sample_byte & 0x0f) >> 0
if nibble >= 8:
nibble -= 16
sample_delta_11 = (scale * nibble) << 11
predicted_sample_11 = coef1*hist1 + coef2*hist2
sample_11 = predicted_sample_11 + sample_delta_11
sample_raw = (sample_11 + 1024) >> 11
sample_raw = clamp(sample_raw, -32768, 32767)
outbuf[x] = sample_raw
hist2 = hist1
hist1 = outbuf[x]
self.phist1[index] = hist1
self.phist2[index] = hist2
return outbuf
def decode(self, buffer, offset):
decoded_buffer = []
if self.info.chan_cnt == 2:
multi = 16
coeff0 = self.info.coefficients1
coeff1 = self.info.coefficients2
elif self.info.chan_cnt == 1:
multi = 8
coeff0 = self.info.coefficients1
coeff1 = self.info.coefficients1
blocks = self.data.size / multi
data1_offset = offset
data2_offset = offset + blocks * 8
decoded_buffer_l = [0 for i in range(blocks * 14)]
decoded_buffer_r = [0 for i in range(blocks * 14)]
for x in xrange(blocks):
out_buffer = self.decode_adpcm(0, coeff0, buffer[data1_offset:data1_offset+8])
for y in xrange(14):
decoded_buffer_l[x*14+y] = out_buffer[y]
out_buffer = self.decode_adpcm(1, coeff1, buffer[data2_offset:data2_offset+8])
for y in xrange(14):
decoded_buffer_r[x*14+y] = out_buffer[y]
data1_offset += 8
data2_offset += 8
for x in xrange(blocks * 14):
decoded_buffer.append(decoded_buffer_l[x])
decoded_buffer.append(decoded_buffer_r[x])
return decoded_buffer
def eat(self, buffer, offset, decode=False):
co = self.header.eat(buffer, offset)
co = self.info.eat(buffer, co)
co = self.data.eat(buffer, co)
self.data.data = buffer[co:]
if decode == True:
buffer_out = self.decode(buffer, co)
return buffer_out
return
def show(self):
self.header.show()
self.info.show()
self.data.show()
return
def write(self, filename):
file = open(filename, 'wb')
if file:
self.header.write(file)
self.info.write(file)
self.data.write(file)
file.close()
else:
print "Could not open file for writing"
return
def main():
if sys.argv[1] == "-d":
file = open(sys.argv[2], 'rb')
if file:
buffer = file.read()
file.close()
else:
print "Could not open file"
sys.exit(2)
bns = BNS()
wavbuffer = bns.eat(buffer, 0x00, True)
wavstring = ''.join(Struct.int16(p) for p in wavbuffer)
f = SoundFile(wavstring, sys.argv[3], bns.info.samplerate)
f.write()
elif sys.argv[1] == "-e":
f = wave.open(sys.argv[2], 'rb')
num_chans = f.getnchannels()
samplerate = f.getframerate()
assert samplerate >= 32000
assert samplerate <= 48000
buffer = f.readframes(f.getnframes())
f.close()
bns = BNS()
bns.create_bns(buffer, samplerate, num_chans)
bns.write(sys.argv[3])
elif sys.argv[1] == "-s":
file = open(sys.argv[2], 'rb')
if file:
buffer = file.read()
file.close()
else:
print "Could not open file"
sys.exit(2)
bns = BNS()
bns.eat(buffer, 0x00, False)
bns.show()
else:
print "Unknown second argument. possiblities are -d and -e"
print "Usage: python bns.py -d <sound.bin> <output.wav>"
print " == OR == "
print " python bns.py -e <input.wav> <sound.bin> "
print " == OR == "
print " python bns.py -s <sound.bin> "
sys.exit(1)
if __name__ == "__main__":
# Import Psyco if available
try:
import psyco
psyco.full()
except ImportError:
print "no psycho import"
if len(sys.argv) == 1:
print "Usage: python bns.py -d <sound.bin> <output.wav>"
print " == OR == "
print " python bns.py -e <input.wav> <sound.bin> "
print " == OR == "
print " python bns.py -s <sound.bin> "
sys.exit(1)
main()