119 lines
2.9 KiB
Python
119 lines
2.9 KiB
Python
from math import modf #fuck me rounding is hard
|
|
|
|
# header map
|
|
# https://wiki.multimedia.cx/index.php/CRI_ADX_file
|
|
|
|
MAGIC_OFF = 0x00
|
|
MAGIC_LEN = 2
|
|
MAGIC = 0x8000
|
|
|
|
DATA_OFF_OFF = 0x02
|
|
DATA_OFF_LEN = 2
|
|
DATA_OFF_MIN = 0x38
|
|
|
|
FORMAT_OFF = 0x04
|
|
FORMAT_LEN = 1
|
|
FORMAT = 3 # always 3 for adx apparently
|
|
|
|
LOOP_TYPE_OFF = 0x12
|
|
LOOP_TYPE_LEN = 1
|
|
LOOP_TYPE_SUP = [4] # supported loop styles
|
|
|
|
SRATE_OFF = 0x08
|
|
SRATE_LEN = 4
|
|
|
|
SCOUNT_OFF = 0x0c
|
|
SCOUNT_LEN = 4
|
|
|
|
CRYPT_OFF = 0x13
|
|
CRYPT_LEN = 1
|
|
|
|
LOOP4_FLAG_OFF = 0x24
|
|
LOOP4_FLAG_LEN = 4
|
|
|
|
LOOP4_START_OFF = 0x28
|
|
LOOP4_START_LEN = 4
|
|
|
|
LOOP4_END_OFF = 0x30
|
|
LOOP4_END_LEN = 4
|
|
|
|
|
|
#class independent functions
|
|
|
|
def dumb_round(number):
|
|
dec = modf(number)[0]
|
|
if (dec <= 0.5):
|
|
return int(number)
|
|
else:
|
|
return int(number+1)
|
|
|
|
class adx_file(object):
|
|
magic = 0
|
|
form = 0
|
|
l_style = 0
|
|
encrypted = 0
|
|
sam_rate = 0
|
|
sam_count = 0
|
|
l_flag = 0
|
|
l_start = 0
|
|
l_end = 0
|
|
l_exists = 0
|
|
d_offset = 0
|
|
is_valid = 0
|
|
|
|
data = None
|
|
|
|
def __init__(self, data):
|
|
# first, validate
|
|
self.data = data
|
|
self.magic = self.get_val(MAGIC_OFF, MAGIC_LEN)
|
|
self.form = self.get_val(FORMAT_OFF, FORMAT_LEN)
|
|
self.l_style = self.get_val(LOOP_TYPE_OFF, LOOP_TYPE_LEN)
|
|
self.encrypted = self.get_val(CRYPT_OFF, CRYPT_LEN)
|
|
self.d_offset = self.get_val(DATA_OFF_OFF, DATA_OFF_LEN)
|
|
if self.d_offset < DATA_OFF_MIN:
|
|
return None
|
|
self.l_exists = 1
|
|
# now load things for math
|
|
self.sam_rate = self.get_val(SRATE_OFF, SRATE_LEN)
|
|
self.sam_count = self.get_val(SCOUNT_OFF, SCOUNT_LEN)
|
|
self.validate()
|
|
|
|
def get_val(self, offset, length):
|
|
return int.from_bytes(self.data[offset:offset+length], byteorder='big', signed=False)
|
|
|
|
def validate(self):
|
|
if self.magic != MAGIC:
|
|
raise ValueError("Invalid ADX File")
|
|
if self.form != FORMAT:
|
|
raise ValueError("Invalid ADX File")
|
|
if self.encrypted:
|
|
raise NotImplementedError("Encryption Not Supported")
|
|
self.is_valid = 1
|
|
|
|
def parse_loop_data(self):
|
|
if self.l_style == 4:
|
|
self.l_flag = self.get_val(LOOP4_FLAG_OFF, LOOP4_FLAG_LEN)
|
|
self.l_start = self.get_val(LOOP4_START_OFF, LOOP4_START_LEN)
|
|
self.l_end = self.get_val(LOOP4_END_OFF, LOOP4_END_LEN)
|
|
if not self.l_flag:
|
|
return None
|
|
if self.l_start == 0 and self.l_end == self.sam_count:
|
|
return None
|
|
if self.l_start > self.sam_count or self.l_end > self.sam_count:
|
|
raise ValueError("Invalid Loop Data")
|
|
return None
|
|
if not self.l_style in LOOP_TYPE_SUP:
|
|
raise NotImplementedError("Loop Style {} Not Implemented".format(str(self.l_style)))
|
|
return None
|
|
ret = {}
|
|
ret['duration'] = self.sam_count / self.sam_rate
|
|
ret['loop_start'] = {}
|
|
ret['loop_start']['seconds'] = self.l_start / self.sam_rate
|
|
ret['loop_start']['samples_native'] = self.l_start
|
|
ret['loop_start']['samples_48k'] = dumb_round(self.l_start / self.sam_rate * 48000)
|
|
ret['loop_end'] = {}
|
|
ret['loop_end']['seconds'] = self.l_end / self.sam_rate
|
|
ret['loop_end']['samples_native'] = self.l_end
|
|
ret['loop_end']['samples_48k'] = dumb_round(self.l_end / self.sam_rate * 48000)
|
|
return ret
|