def Log2(L_x: int, exponent: int, fraction: int) -> Tuple[int, int]:
"""
# (i) Q0 : input value
# (o) Q0 : Integer part of Log2. (range: 0<=val<=30)
# (o) Q15: Fractional part of Log2. (range: 0<=val<1)
"""
if L_x <= 0:
return (0, 0)
exp = basic_op.norm_l(L_x)
L_x = basic_op.L_shl(L_x, exp) # L_x is normalized
exponent = basic_op.sub(30, exp)
L_x = basic_op.L_shr(L_x, 9)
i = basic_op.extract_h(L_x) # Extract b25-b31
L_x = basic_op.L_shr(L_x, 1)
a = basic_op.extract_l(L_x) # Extract b10-b24 of fraction
a = a & 0x7fff
i = basic_op.sub(i, 32)
L_y = basic_op.L_deposit_h(tab_ld8a.tablog[i]) # tablog[i] << 16
tmp = basic_op.sub(tab_ld8a.tablog[i],
tab_ld8a.tablog[i + 1]) # tablog[i] - tablog[i+1]
L_y = basic_op.L_msu(L_y, tmp, a) # L_y -= tmp*a*2
fraction = basic_op.extract_h(L_y)
return (exponent, fraction)
def Inv_sqrt(L_x) -> int:
"""
# (o) Q30 : output value (range: 0<=val<1)
# (i) Q0 : input value (range: 0<=val<=7fffffff)
"""
if L_x <= 0:
return basic_op.MAX_INT_30
exp = basic_op.norm_l(L_x)
L_x = basic_op.L_shl(L_x, exp) # L_x is normalize
exp = basic_op.sub(30, exp)
if (exp & 1) == 0: # If exponent even -> shift right
L_x = basic_op.L_shr(L_x, 1)
exp = basic_op.shr(exp, 1)
exp = basic_op.add(exp, 1)
L_x = basic_op.L_shr(L_x, 9)
i = basic_op.extract_h(L_x) # Extract b25-b31
L_x = basic_op.L_shr(L_x, 1)
a = basic_op.extract_l(L_x) # Extract b10-b24
a = a & 0x7fff
i = basic_op.sub(i, 16)
L_y = basic_op.L_deposit_h(tab_ld8a.tabsqr[i]) # tabsqr[i] << 16
tmp = basic_op.sub(tab_ld8a.tabsqr[i],
tab_ld8a.tabsqr[i + 1]) # tabsqr[i] - tabsqr[i+1])
L_y = basic_op.L_msu(L_y, tmp, a) # L_y -= tmp*a*2
L_y = basic_op.L_shr(L_y, exp) # denormalization
return L_y
def Chebps_10(x: int, f: List[int], n: int) -> int:
# Note: All computation are done in Q23.
b2_h = 128 # b2 = 1.0 in Q23 DPF
b2_l = 0
t0 = basic_op.L_mult(x, 256) # 2*x in Q23
t0 = basic_op.L_mac(t0, f[1], 4096) # + f[1] in Q23
b1_h, b1_l = oper_32b.L_Extract(t0) # b1 = 2*x + f[1]
for i in range(2, n):
t0 = oper_32b.Mpy_32_16(b1_h, b1_l, x) # t0 = 2.0*x*b1
t0 = basic_op.L_shl(t0, 1)
t0 = basic_op.L_mac(t0, b2_h, -32768) # t0 = 2.0*x*b1 - b2
t0 = basic_op.L_msu(t0, b2_l, 1)
t0 = basic_op.L_mac(t0, f[i], 4096) # t0 = 2.0*x*b1 - b2 + f[i]
b0_h, b0_l = oper_32b.L_Extract(t0) # b0 = 2.0*x*b1 - b2 + f[i]
b2_l = b1_l # b2 = b1
b2_h = b1_h
b1_l = b0_l # b1 = b0
b1_h = b0_h
t0 = oper_32b.Mpy_32_16(b1_h, b1_l, x) # t0 = x*b1
t0 = basic_op.L_mac(t0, b2_h, -32768) # t0 = x*b1 - b2
t0 = basic_op.L_msu(t0, b2_l, 1)
t0 = basic_op.L_mac(t0, f[i], 2048) # t0 = x*b1 - b2 + f[i]/2
t0 = basic_op.L_shl(t0, 7) # Q23 to Q30 with saturation
cheb = basic_op.extract_h(t0)
return cheb
def Lsp_prev_extract(lsp: List[int], lsp_ele: List[int], fg: List[List[int]],
freq_prev: List[List[int]],
fg_sum_inv: List[int]) -> None:
"""
# (i) Q13 : unquantized LSP parameters
# (o) Q13 : target vector
# (i) Q15 : MA prediction coef.
# (i) Q13 : previous LSP vector
# (i) Q12 : inverse previous LSP vector
"""
for j in range(0, M):
L_temp = L_deposit_h(lsp[j])
for k in range(0, MA_NP):
L_temp = L_msu(L_temp, freq_prev[k][j], fg[k][j])
temp = extract_h(L_temp)
L_temp = L_mult(temp, fg_sum_inv[j])
lsp_ele[j] = extract_h(L_shl(L_temp, 3))
def Convolve(x: List[int], h: List[int], y: List[int], L: int) -> None:
"""
# (i) : input vector
# (i) Q12 : impulse response
# (o) : output vector
# (i) : vector size
"""
for n in range(0, L):
s = 0
for i in range(0, n + 1):
s = basic_op.L_mac(s, x[i], h[n-i])
s = basic_op.L_shl(s, 3) # h is in Q12 and saturation
y[n] = basic_op.extract_h(s)
def Lsp_prev_compose(lsp_ele: List[int], lsp: List[int], fg: List[List[int]],
freq_prev: List[List[int]], fg_sum: List[int]) -> None:
"""
# (i) Q13 : LSP vectors
# (o) Q13 : quantized LSP parameters
# (i) Q15 : MA prediction coef.
# (i) Q13 : previous LSP vector
# (i) Q15 : present MA prediction coef.
"""
for j in range(0, M):
L_acc = L_mult(lsp_ele[j], fg_sum[j])
for k in range(0, MA_NP):
L_acc = L_mac(L_acc, freq_prev[k][j], fg[k][j])
lsp[j] = extract_h(L_acc)
def Gain_update(past_qua_en: List[int], L_gbk12: int) -> None:
"""
# (io) Q10 :Past quantized energies
# (i) Q13 : gbk1[indice1][1]+gbk2[indice2][1]
"""
for i in range(3, 0, -1):
past_qua_en[i] = past_qua_en[i - 1] # Q10
##########
# -- past_qua_en[0] = 20*log10(gbk1[index1][1]+gbk2[index2][1]) --
# 2 * 10 log10( gbk1[index1][1]+gbk2[index2][1] )
# = 2 * 3.0103 log2( gbk1[index1][1]+gbk2[index2][1] )
# = 2 * 3.0103 log2( gbk1[index1][1]+gbk2[index2][1] )
# 24660:Q12(6.0205)
##########
exp, frac = dsp_func.Log2(L_gbk12, exp, frac) # L_gbk12:Q13
L_acc = oper_32b.L_Comp(basic_op.sub(exp, 13), frac) # L_acc:Q16
tmp = basic_op.extract_h(basic_op.L_shl(L_acc, 13)) # tmp:Q13
past_qua_en[0] = basic_op.mult(tmp, 24660) # past_qua_en[]:Q10
def Pow2(exponent: int, fraction: int) -> int:
"""
# (o) Q0 : result (range: 0<=val<=0x7fffffff)
# (i) Q0 : Integer part. (range: 0<=val<=30)
# (i) Q15 : Fractional part. (range: 0.0<=val<1.0)
"""
L_x = basic_op.L_mult(fraction, 32) # L_x = fraction<<6
i = basic_op.extract_h(L_x) # Extract b10-b15 of fraction
L_x = basic_op.L_shr(L_x, 1)
a = basic_op.extract_l(L_x) # Extract b0-b9 of fraction
a = a & 0x7fff
L_x = basic_op.L_deposit_h(tab_ld8a.tabpow[i]) # tabpow[i] << 16
tmp = basic_op.sub(tab_ld8a.tabpow[i],
tab_ld8a.tabpow[i + 1]) # tabpow[i] - tabpow[i+1]
L_x = basic_op.L_msu(L_x, tmp, a) # L_x -= tmp*a*2
exp = basic_op.sub(30, exponent)
L_x = basic_op.L_shr_r(L_x, exp)
return L_x
def Az_lsp(a: List[int], lsp: List[int], old_lsp: List[int]) -> None:
"""
# (i) Q12 : predictor coefficients
# (o) Q15 : line spectral pairs
# (i) : old lsp[] (in case not found 10 roots)
"""
#Word16 i, j, nf, ip
#Word16 xlow, ylow, xhigh, yhigh, xmid, ymid, xint
#Word16 x, y, sign, exp
#Word16 *coef
#Word16 f1[M / 2 + 1], f2[M / 2 + 1]
#Word32 t0, L_temp
#Flag ovf_coef
#Word16 (*pChebps)(Word16 x, Word16 f[], Word16 n)
f1 = [0] * ((ld8a.M / 2) + 1)
f2 = [0] * ((ld8a.M / 2) + 1)
#########
# find the sum and diff. pol. F1(z) and F2(z)
# F1(z) <--- F1(z)/(1+z**-1) & F2(z) <--- F2(z)/(1-z**-1)
#
# f1[0] = 1.0
# f2[0] = 1.0
#
# for (i = 0 i< NC i++)
# {
# f1[i+1] = a[i+1] + a[M-i] - f1[i]
# f2[i+1] = a[i+1] - a[M-i] + f2[i]
# }
########
ovf_coef = 0
pChebps = 'Chebps_11'
f1[0] = 2048 # f1[0] = 1.0 is in Q11
f2[0] = 2048 # f2[0] = 1.0 is in Q11
for i in range(0, ld8a.NC):
basic_op.setOverflow(0)
t0 = basic_op.L_mult(a[i + 1], 16384) # x = (a[i+1] + a[M-i]) >> 1
t0 = basic_op.L_mac(t0, a[M - i], 16384) # -> From Q12 to Q11
x = basic_op.extract_h(t0)
if basic_op.getOverflow() != 0:
ovf_coef = 1
basic_op.setOverflow(0)
f1[i + 1] = basic_op.sub(x, f1[i]) # f1[i+1] = a[i+1] + a[M-i] - f1[i]
if basic_op.getOverflow() != 0:
ovf_coef = 1
basic_op.setOverflow(0)
t0 = basic_op.L_mult(a[i + 1], 16384) # x = (a[i+1] - a[M-i]) >> 1
t0 = basic_op.L_msu(t0, a[M - i], 16384) # -> From Q12 to Q11
x = basic_op.extract_h(t0)
if basic_op.getOverflow() != 0:
ovf_coef = 1
basic_op.setOverflow(0)
f2[i + 1] = basic_op.add(x, f2[i]) # f2[i+1] = a[i+1] - a[M-i] + f2[i]
if basic_op.getOverflow() != 0:
ovf_coef = 1
if ovf_coef == 1:
#printf("===== OVF ovf_coef =====\n")
pChebps = 'Chebps_10'
f1[0] = 1024 # f1[0] = 1.0 is in Q10
f2[0] = 1024 # f2[0] = 1.0 is in Q10
for i in range(0, ld8a.NC):
t0 = basic_op.L_mult(a[i + 1], 8192) # x = (a[i+1] + a[M-i]) >> 1
t0 = basic_op.L_mac(t0, a[M - i], 8192) # -> From Q11 to Q10
x = basic_op.extract_h(t0)
f1[i + 1] = basic_op.sub(x, f1[i]) # f1[i+1] = a[i+1] + a[M-i] - f1[i]
t0 = basic_op.L_mult(a[i + 1], 8192) # x = (a[i+1] - a[M-i]) >> 1
t0 = basic_op.L_msu(t0, a[M - i], 8192) # -> From Q11 to Q10
x = basic_op.extract_h(t0)
f2[i + 1] = basic_op.add(x, f2[i]) # f2[i+1] = a[i+1] - a[M-i] + f2[i]
########
# find the LSPs using the Chebichev pol. evaluation
########
nf = 0 # number of found frequencies
ip = 0 # indicator for f1 or f2
coef = f1 # Alias for f1 or f2
xlow = grid[0]
if pChebps == 'Chebps_11':
ylow = Chebps_11(xlow, coef, NC)
else:
ylow = Chebps_10(xlow, coef, NC)
j = 0
while nf < ld81.M and j < ld8a.GRID_POINTS:
j = basic_op.add(j, 1)
xhigh = xlow
yhigh = ylow
xlow = grid[j]
if pChebps == 'Chebps_11':
ylow = Chebps_11(xlow, coef, ld8a.NC)
else:
ylow = Chebps_10(xlow, coef, ld8a.NC)
L_temp = basic_op.L_mult(ylow, yhigh)
if L_temp <= 0:
# divide 2 times the interval
for i in range(0, 2):
xmid = basic_op.add(basic_op.shr(xlow, 1), basic_op.shr(xhigh, 1)) # xmid = (xlow + xhigh)/2
if pChebps == 'Chebps_11':
ymid = Chebps_11(xmid, coef, ld8a.NC)
else:
ymid = Chebps_10(xmid, coef, ld8a.NC)
L_temp = basic_op.L_mult(ylow, ymid)
if L_temp <= 0:
yhigh = ymid
xhigh = xmid
else:
ylow = ymid
xlow = xmid
########
# Linear interpolation
# xint = xlow - ylow*(xhigh-xlow)/(yhigh-ylow)
########
x = basic_op.sub(xhigh, xlow)
y = basic_op.sub(yhigh, ylow)
if y == 0:
xint = xlow
else:
sign = y
y = basic_op.abs_s(y)
exp = basic_op.norm_s(y)
y = basic_op.shl(y, exp)
y = basic_op.div_s(16383, y)
t0 = basic_op.L_mult(x, y)
t0 = basic_op.L_shr(t0, basic_op.sub(20, exp))
y = basic_op.extract_l(t0) # y= (xhigh-xlow)/(yhigh-ylow) in Q11
if sign < 0:
y = basic_op.negate(y)
t0 = basic_op.L_mult(ylow, y) # result in Q26
t0 = basic_op.L_shr(t0, 11) # result in Q15
xint = basic_op.sub(xlow, basic_op.extract_l(t0)) # xint = xlow - ylow*y
lsp[nf] = xint
xlow = xint
nf = basic_op.add(nf, 1)
if ip == 0:
ip = 1
coef = f2
else:
ip = 0
coef = f1
if pChebps == 'Chebps_11':
ylow = Chebps_11(xlow, coef, ld8a.NC)
else:
ylow = Chebps_10(xlow, coef, ld8a.NC)
# Check if M roots found
if basic_op.sub(nf, ld8a.M) < 0:
for i in range (0, ld8a.M):
lsp[i] = old_lsp[i]
def Gain_predict(past_qua_en: List[int], code: List[int],
L_subfr: int) -> Tuple[int, int]:
"""
# (i) Q10 :Past quantized energies
# (i) Q13 :Innovative vector.
# (i) :Subframe length.
# (o) Qxx :Predicted codebook gain - omitted param
# (o) :Q-Format(gcode0) - omitted param
"""
#Word16 i, exp, frac
#Word32 L_tmp
##########
# Energy coming from code
##########
L_tmp = 0
for i in range(0, L_subfr):
L_tmp = basic_op.L_mac(L_tmp, code[i], code[i])
##########
# Compute: means_ener - 10log10(ener_code/ L_sufr)
# Note: mean_ener change from 36 dB to 30 dB because input/2
#
# = 30.0 - 10 log10( ener_code / lcode) + 10log10(2^27)
# !!ener_code in Q27!!
# = 30.0 - 3.0103 log2(ener_code) + 10log10(40) + 10log10(2^27)
# = 30.0 - 3.0103 log2(ener_code) + 16.02 + 81.278
# = 127.298 - 3.0103 log2(ener_code)
##########
exp, frac = dsp_func.Log2(L_tmp, exp, frac) # Q27->Q0 ^Q0 ^Q15
L_tmp = oper_32b.Mpy_32_16(exp, frac, -24660) # Q0 Q15 Q13 -> ^Q14
# hi:Q0+Q13+1
# lo:Q15+Q13-15+1
# -24660[Q13]=-3.0103
L_tmp = basic_op.L_mac(basic_op.L_tmp, 32588, 32) # 32588*32[Q14]=127.298
##########
# Compute gcode0. *
# = Sum(i=0,3) pred[i]*past_qua_en[i] - ener_code + mean_ener *
##########
L_tmp = basic_op.L_shl(L_tmp, 10) # From Q14 to Q24
for i in range(0, 4):
L_tmp = basic_op.L_mac(L_tmp, pred[i], past_qua_en[i]) # Q13*Q10 ->Q24
gcode0 = basic_op.extract_h(L_tmp) # From Q24 to Q8
##########
# gcode0 = pow(10.0, gcode0/20) *
# = pow(2, 3.3219*gcode0/20) *
# = pow(2, 0.166*gcode0) *
##########
L_tmp = basic_op.L_mult(gcode0, 5439) # *0.166 in Q15, result in Q24
L_tmp = basic_op.L_shr(L_tmp, 8) # From Q24 to Q16
exp, frac = oper_32b.L_Extract(L_tmp, exp,
frac) # Extract exponent of gcode0
gcode0 = basic_op.extract_l(dsp_func.Pow2(
14, frac)) # Put 14 as exponent so that
# output of Pow2() will be:
# 16768 < Pow2() <= 32767
exp_gcode0 = basic_op.sub(14, exp)
return (gcode0, exp_gcode0)
