#
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import numpy as np
import lc3
import tables as T, appendix_c as C
### ------------------------------------------------------------------------ ###
class Tns:
SUB_LIM_2M5_NB = [ [ 3, 10, 20 ] ]
SUB_LIM_2M5_WB = [ [ 3, 20, 40 ] ]
SUB_LIM_2M5_SSWB = [ [ 3, 30, 60 ] ]
SUB_LIM_2M5_SWB = [ [ 3, 40, 80 ] ]
SUB_LIM_2M5_FB = [ [ 3, 51, 100 ] ]
SUB_LIM_2M5 = [
SUB_LIM_2M5_NB , SUB_LIM_2M5_WB, SUB_LIM_2M5_SSWB,
SUB_LIM_2M5_SWB, SUB_LIM_2M5_FB, SUB_LIM_2M5_FB, SUB_LIM_2M5_FB ]
SUB_LIM_5M_NB = [ [ 6, 23, 40 ] ]
SUB_LIM_5M_WB = [ [ 6, 43, 80 ] ]
SUB_LIM_5M_SSWB = [ [ 6, 63, 120 ] ]
SUB_LIM_5M_SWB = [ [ 6, 43, 80 ], [ 80, 120, 160 ] ]
SUB_LIM_5M_FB = [ [ 6, 53, 100 ], [ 100, 150, 200 ] ]
SUB_LIM_5M = [
SUB_LIM_5M_NB , SUB_LIM_5M_WB, SUB_LIM_5M_SSWB,
SUB_LIM_5M_SWB, SUB_LIM_5M_FB, SUB_LIM_5M_FB, SUB_LIM_5M_FB ]
SUB_LIM_7M5_NB = [ [ 9, 26, 43, 60 ] ]
SUB_LIM_7M5_WB = [ [ 9, 46, 83, 120 ] ]
SUB_LIM_7M5_SSWB = [ [ 9, 66, 123, 180 ] ]
SUB_LIM_7M5_SWB = [ [ 9, 46, 82, 120 ], [ 120, 159, 200, 240 ] ]
SUB_LIM_7M5_FB = [ [ 9, 56, 103, 150 ], [ 150, 200, 250, 300 ] ]
SUB_LIM_7M5 = [
SUB_LIM_7M5_NB , SUB_LIM_7M5_WB, SUB_LIM_7M5_SSWB,
SUB_LIM_7M5_SWB, SUB_LIM_7M5_FB, None, None ]
SUB_LIM_10M_NB = [ [ 12, 34, 57, 80 ] ]
SUB_LIM_10M_WB = [ [ 12, 61, 110, 160 ] ]
SUB_LIM_10M_SSWB = [ [ 12, 88, 164, 240 ] ]
SUB_LIM_10M_SWB = [ [ 12, 61, 110, 160 ], [ 160, 213, 266, 320 ] ]
SUB_LIM_10M_FB = [ [ 12, 74, 137, 200 ], [ 200, 266, 333, 400 ] ]
SUB_LIM_10M = [
SUB_LIM_10M_NB , SUB_LIM_10M_WB, SUB_LIM_10M_SSWB,
SUB_LIM_10M_SWB, SUB_LIM_10M_FB, SUB_LIM_10M_FB, SUB_LIM_10M_FB ]
SUB_LIM = [ SUB_LIM_2M5, SUB_LIM_5M, SUB_LIM_7M5, SUB_LIM_10M ]
FREQ_LIM_2M5_NB = [ 3, 20 ]
FREQ_LIM_2M5_WB = [ 3, 40 ]
FREQ_LIM_2M5_SSWB = [ 3, 60 ]
FREQ_LIM_2M5_SWB = [ 3, 80 ]
FREQ_LIM_2M5_FB = [ 3, 100 ]
FREQ_LIM_2M5 = [
FREQ_LIM_2M5_NB , FREQ_LIM_2M5_WB, FREQ_LIM_2M5_SSWB,
FREQ_LIM_2M5_SWB, FREQ_LIM_2M5_FB, FREQ_LIM_2M5_FB, FREQ_LIM_2M5_FB ]
FREQ_LIM_5M_NB = [ 6, 40 ]
FREQ_LIM_5M_WB = [ 6, 80 ]
FREQ_LIM_5M_SSWB = [ 6, 120 ]
FREQ_LIM_5M_SWB = [ 6, 80, 160 ]
FREQ_LIM_5M_FB = [ 6, 100, 200 ]
FREQ_LIM_5M = [
FREQ_LIM_5M_NB , FREQ_LIM_5M_WB, FREQ_LIM_5M_SSWB,
FREQ_LIM_5M_SWB, FREQ_LIM_5M_FB, FREQ_LIM_5M_FB, FREQ_LIM_5M_FB ]
FREQ_LIM_7M5_NB = [ 9, 60 ]
FREQ_LIM_7M5_WB = [ 9, 120 ]
FREQ_LIM_7M5_SSWB = [ 9, 180 ]
FREQ_LIM_7M5_SWB = [ 9, 120, 240 ]
FREQ_LIM_7M5_FB = [ 9, 150, 300 ]
FREQ_LIM_7M5 = [
FREQ_LIM_7M5_NB , FREQ_LIM_7M5_WB, FREQ_LIM_7M5_SSWB,
FREQ_LIM_7M5_SWB, FREQ_LIM_7M5_FB, None, None ]
FREQ_LIM_10M_NB = [ 12, 80 ]
FREQ_LIM_10M_WB = [ 12, 160 ]
FREQ_LIM_10M_SSWB = [ 12, 240 ]
FREQ_LIM_10M_SWB = [ 12, 160, 320 ]
FREQ_LIM_10M_FB = [ 12, 200, 400 ]
FREQ_LIM_10M = [
FREQ_LIM_10M_NB , FREQ_LIM_10M_WB, FREQ_LIM_10M_SSWB,
FREQ_LIM_10M_SWB, FREQ_LIM_10M_FB, FREQ_LIM_10M_FB, FREQ_LIM_10M_FB ]
FREQ_LIM = [ FREQ_LIM_2M5, FREQ_LIM_5M, FREQ_LIM_7M5, FREQ_LIM_10M ]
def __init__(self, dt):
self.dt = dt
(self.nfilters, self.lpc_weighting, self.rc_order, self.rc) = \
(0, False, np.array([ 0, 0 ]), np.array([ 0, 0 ]))
def get_data(self):
rc = np.append(self.rc - 8, np.zeros((2, 8 - len(self.rc[0]))), axis=1)
return { 'nfilters' : self.nfilters,
'lpc_weighting' : self.lpc_weighting,
'rc_order' : self.rc_order, 'rc' : rc }
def get_nbits(self):
lpc_weighting = self.lpc_weighting
nbits = 0
for f in range(self.nfilters):
rc_order = self.rc_order[f]
rc = self.rc[f]
nbits_order = T.TNS_ORDER_BITS[int(lpc_weighting)][rc_order]
nbits_coef = sum([ T.TNS_COEF_BITS[k][rc[k]]
for k in range(rc_order) ])
nbits += ((2048 + nbits_order + nbits_coef) + 2047) >> 11
return nbits
class TnsAnalysis(Tns):
def __init__(self, dt):
super().__init__(dt)
def compute_lpc_coeffs(self, bw, f, x):
### Normalized autocorrelation function
S = Tns.SUB_LIM[self.dt][bw][f]
maxorder = [ 4, 8 ][self.dt > T.DT_5M]
r = np.append([ 3 ], np.zeros(maxorder))
e = [ sum(x[S[s]:S[s+1]] ** 2) for s in range(len(S)-1) ]
for k in range(len(r) if sum(e) > 0 else 0):
c = [ np.dot(x[S[s]:S[s+1]-k], x[S[s]+k:S[s+1]])
for s in range(len(S)-1) ]
r[k] = np.sum( np.array(c) / np.array(e) )
r *= np.exp(-0.5 * (0.02 * np.pi * np.arange(1+maxorder)) ** 2)
### Levinson-Durbin recursion
err = r[0]
a = np.ones(len(r))
for k in range(1, len(a)):
rc = -sum(a[:k] * r[k:0:-1]) / err
a[1:k] += rc * a[k-1:0:-1]
a[k] = rc
err *= 1 - rc ** 2
return (r[0] / err, a)
def lpc_weight(self, pred_gain, a):
gamma = 1 - (1 - 0.85) * (2 - pred_gain) / (2 - 1.5)
return a * np.power(gamma, np.arange(len(a)))
def coeffs_reflexion(self, a):
rc = np.zeros(len(a)-1)
b = a.copy()
for k in range(len(rc), 0, -1):
rc[k-1] = b[k]
e = 1 - rc[k-1] ** 2
b[1:k] = (b[1:k] - rc[k-1] * b[k-1:0:-1]) / e
return rc
def quantization(self, rc, lpc_weighting):
delta = np.pi / 17
rc_i = np.rint(np.arcsin(rc) / delta).astype(int) + 8
rc_q = np.sin(delta * (rc_i - 8))
rc_q = np.rint(rc_q * 2**15) / 2**15
rc_order = len(rc_i) - np.argmin(rc_i[::-1] == 8)
return (rc_order, rc_q, rc_i)
def filtering(self, st, x, rc_order, rc):
y = np.empty(len(x))
for i in range(len(x)):
xi = x[i]
s1 = xi
for k in range(rc_order):
s0 = st[k]
st[k] = s1
s1 = rc[k] * xi + s0
xi += rc[k] * s0
y[i] = xi
return y
def run(self, x, bw, nn_flag, nbytes):
fstate = np.zeros(8)
y = x.copy()
self.nfilters = len(Tns.SUB_LIM[self.dt][bw])
maxorder = [ 4, 8 ][self.dt > T.DT_5M]
self.lpc_weighting = nbytes < 120 * (1 + self.dt) / 8
self.rc_order = np.zeros(2, dtype=np.intc)
self.rc = np.zeros((2, maxorder), dtype=np.intc)
for f in range(self.nfilters):
(pred_gain, a) = self.compute_lpc_coeffs(bw, f, x)
tns_off = pred_gain <= 1.5 or nn_flag
if tns_off:
continue
if self.lpc_weighting and pred_gain < 2:
a = self.lpc_weight(pred_gain, a)
rc = self.coeffs_reflexion(a)
(rc_order, rc_q, rc_i) = \
self.quantization(rc, self.lpc_weighting)
self.rc_order[f] = rc_order
self.rc[f] = rc_i
if rc_order > 0:
i0 = Tns.FREQ_LIM[self.dt][bw][f]
i1 = Tns.FREQ_LIM[self.dt][bw][f+1]
y[i0:i1] = self.filtering(
fstate, x[i0:i1], rc_order, rc_q)
return y
def store(self, b):
for f in range(self.nfilters):
lpc_weighting = self.lpc_weighting
rc_order = self.rc_order[f]
rc = self.rc[f]
b.write_bit(min(rc_order, 1))
if rc_order > 0:
b.ac_encode(
T.TNS_ORDER_CUMFREQ[int(lpc_weighting)][rc_order-1],
T.TNS_ORDER_FREQ[int(lpc_weighting)][rc_order-1] )
for k in range(rc_order):
b.ac_encode(T.TNS_COEF_CUMFREQ[k][rc[k]],
T.TNS_COEF_FREQ[k][rc[k]] )
class TnsSynthesis(Tns):
def filtering(self, st, x, rc_order, rc):
y = x.copy()
for i in range(len(x)):
xi = x[i] - rc[rc_order-1] * st[rc_order-1]
for k in range(rc_order-2, -1, -1):
xi -= rc[k] * st[k]
st[k+1] = xi * rc[k] + st[k]
st[0] = xi
y[i] = xi
return y
def load(self, b, bw, nbytes):
self.nfilters = len(Tns.SUB_LIM[self.dt][bw])
self.lpc_weighting = nbytes < 120 * (1 + self.dt) / 8
self.rc_order = np.zeros(2, dtype=np.intc)
self.rc = 8 * np.ones((2, 8), dtype=np.intc)
for f in range(self.nfilters):
if not b.read_bit():
continue
rc_order = 1 + b.ac_decode(
T.TNS_ORDER_CUMFREQ[int(self.lpc_weighting)],
T.TNS_ORDER_FREQ[int(self.lpc_weighting)])
self.rc_order[f] = rc_order
for k in range(rc_order):
rc = b.ac_decode(T.TNS_COEF_CUMFREQ[k], T.TNS_COEF_FREQ[k])
self.rc[f][k] = rc
def run(self, x, bw):
fstate = np.zeros(8)
y = x.copy()
for f in range(self.nfilters):
rc_order = self.rc_order[f]
rc = np.sin((np.pi / 17) * (self.rc[f] - 8))
rc = np.rint(rc * 2**15) / 2**15
if rc_order > 0:
i0 = Tns.FREQ_LIM[self.dt][bw][f]
i1 = Tns.FREQ_LIM[self.dt][bw][f+1]
y[i0:i1] = self.filtering(
fstate, x[i0:i1], rc_order, rc)
return y
### ------------------------------------------------------------------------ ###
def check_analysis(rng, dt, bw):
ok = True
analysis = TnsAnalysis(dt)
nbytes_lim = int((48 * T.DT_MS[dt]) // 8)
for i in range(10):
ne = T.I[dt][bw][-1]
x = rng.random(ne) * 1e2
x = pow(x, .5 + i/5)
for nn_flag in (True, False):
for nbytes in (nbytes_lim, nbytes_lim + 1):
y = analysis.run(x, bw, nn_flag, nbytes)
(y_c, data_c) = lc3.tns_analyze(dt, bw, nn_flag, nbytes, x)
ok = ok and data_c['lpc_weighting'] == analysis.lpc_weighting
ok = ok and data_c['nfilters'] == analysis.nfilters
for f in range(analysis.nfilters):
rc_order = analysis.rc_order[f]
rc_order_c = data_c['rc_order'][f]
rc_c = 8 + data_c['rc'][f]
ok = ok and rc_order_c == rc_order
ok = ok and not np.any(rc_c[:rc_order] - analysis.rc[f][:rc_order])
ok = ok and lc3.tns_get_nbits(data_c) == analysis.get_nbits()
ok = ok and np.amax(np.abs(y_c - y)) < 1e-2
return ok
def check_synthesis(rng, dt, bw):
ok = True
synthesis = TnsSynthesis(dt)
for i in range(100):
ne = T.I[dt][bw][-1]
x = rng.random(ne) * 1e2
maxorder = [ 4, 8 ][dt > T.DT_5M]
synthesis.nfilters = 1 + int(dt >= T.DT_5M and bw >= T.SRATE_32K)
synthesis.rc_order = rng.integers(0, 1+maxorder, 2)
synthesis.rc = rng.integers(0, 17, 16).reshape(2, 8)
y = synthesis.run(x, bw)
y_c = lc3.tns_synthesize(dt, bw, synthesis.get_data(), x)
ok = ok and np.amax(np.abs(y_c - y) < 1e-4)
return ok
def check_analysis_appendix_c(dt):
i0 = dt - T.DT_7M5
sr = T.SRATE_16K
ok = True
fs = Tns.FREQ_LIM[i0][sr][0]
fe = Tns.FREQ_LIM[i0][sr][1]
st = np.zeros(8)
for i in range(len(C.X_S[i0])):
(_, a) = lc3.tns_compute_lpc_coeffs(dt, sr, C.X_S[i0][i])
ok = ok and np.amax(np.abs(a[0] - C.TNS_LEV_A[i0][i])) < 1e-5
rc = lc3.tns_lpc_reflection(dt, a[0])
ok = ok and np.amax(np.abs(rc - C.TNS_LEV_RC[i0][i])) < 1e-5
(rc_order, rc_i) = lc3.tns_quantize_rc(dt, C.TNS_LEV_RC[i0][i])
ok = ok and rc_order == C.RC_ORDER[i0][i][0]
ok = ok and np.any((rc_i + 8) - C.RC_I_1[i0][i] == 0)
rc_q = lc3.tns_unquantize_rc(rc_i, rc_order)
ok = ok and np.amax(np.abs(rc_q - C.RC_Q_1[i0][i])) < 1e-6
(x, side) = lc3.tns_analyze(dt, sr, False, C.NBYTES[i0], C.X_S[i0][i])
ok = ok and side['nfilters'] == 1
ok = ok and side['rc_order'][0] == C.RC_ORDER[i0][i][0]
ok = ok and not np.any((side['rc'][0] + 8) - C.RC_I_1[i0][i])
ok = ok and lc3.tns_get_nbits(side) == C.NBITS_TNS[i0][i]
ok = ok and np.amax(np.abs(x - C.X_F[i0][i])) < 1e-3
return ok
def check_synthesis_appendix_c(dt):
i0 = dt - T.DT_7M5
sr = T.SRATE_16K
ok = True
for i in range(len(C.X_HAT_Q[i0])):
side = {
'nfilters' : 1,
'lpc_weighting' : C.NBYTES[i0] < 120 * (1 + dt) / 8,
'rc_order': C.RC_ORDER[i0][i],
'rc': [ C.RC_I_1[i0][i] - 8, C.RC_I_2[i0][i] - 8 ]
}
g_int = C.GG_IND_ADJ[i0][i] + C.GG_OFF[i0][i]
x = C.X_HAT_Q[i0][i] * (10 ** (g_int / 28))
x = lc3.tns_synthesize(dt, sr, side, x)
ok = ok and np.amax(np.abs(x - C.X_HAT_TNS[i0][i])) < 1e-3
sr = T.SRATE_48K
if dt != T.DT_10M:
return ok
side = {
'nfilters' : 2,
'lpc_weighting' : False,
'rc_order': C.RC_ORDER_48K_10M,
'rc': [ C.RC_I_1_48K_10M - 8, C.RC_I_2_48K_10M - 8 ]
}
x = C.X_HAT_F_48K_10M
x = lc3.tns_synthesize(dt, sr, side, x)
ok = ok and np.amax(np.abs(x - C.X_HAT_TNS_48K_10M)) < 1e-3
return ok
def check():
rng = np.random.default_rng(1234)
ok = True
for dt in range(T.NUM_DT):
for sr in range(T.SRATE_8K, T.SRATE_48K + 1):
ok = ok and check_analysis(rng, dt, sr)
ok = ok and check_synthesis(rng, dt, sr)
for dt in ( T.DT_2M5, T.DT_5M, T.DT_10M ):
for sr in ( T.SRATE_48K_HR, T.SRATE_96K_HR ):
ok = ok and check_analysis(rng, dt, sr)
for dt in ( T.DT_7M5, T.DT_10M ):
check_analysis_appendix_c(dt)
check_synthesis_appendix_c(dt)
return ok
### ------------------------------------------------------------------------ ###