mirror of
https://github.com/xiph/opus.git
synced 2025-05-24 12:19:15 +00:00
70 lines
2.7 KiB
Python
70 lines
2.7 KiB
Python
"""
|
|
Tensorflow/Keras helper functions to do the following:
|
|
1. \mu law <-> Linear domain conversion
|
|
2. Differentiable prediction from the input signal and LP coefficients
|
|
3. Differentiable transformations Reflection Coefficients (RCs) <-> LP Coefficients
|
|
"""
|
|
from tensorflow.keras.layers import Lambda, Multiply, Layer, Concatenate
|
|
from tensorflow.keras import backend as K
|
|
import tensorflow as tf
|
|
|
|
# \mu law <-> Linear conversion functions
|
|
scale = 255.0/32768.0
|
|
scale_1 = 32768.0/255.0
|
|
def tf_l2u(x):
|
|
s = K.sign(x)
|
|
x = K.abs(x)
|
|
u = (s*(128*K.log(1+scale*x)/K.log(256.0)))
|
|
u = K.clip(128 + u, 0, 255)
|
|
return u
|
|
|
|
def tf_u2l(u):
|
|
u = tf.cast(u,"float32")
|
|
u = u - 128.0
|
|
s = K.sign(u)
|
|
u = K.abs(u)
|
|
return s*scale_1*(K.exp(u/128.*K.log(256.0))-1)
|
|
|
|
# Differentiable Prediction Layer
|
|
# Computes the LP prediction from the input lag signal and the LP coefficients
|
|
# The inputs xt and lpc conform with the shapes in lpcnet.py (the '2400' is coded keeping this in mind)
|
|
class diff_pred(Layer):
|
|
def call(self, inputs, lpcoeffs_N = 16, frame_size = 160):
|
|
xt = inputs[0]
|
|
lpc = inputs[1]
|
|
|
|
rept = Lambda(lambda x: K.repeat_elements(x , frame_size, 1))
|
|
zpX = Lambda(lambda x: K.concatenate([0*x[:,0:lpcoeffs_N,:], x],axis = 1))
|
|
cX = Lambda(lambda x: K.concatenate([x[:,(lpcoeffs_N - i):(lpcoeffs_N - i + 2400),:] for i in range(lpcoeffs_N)],axis = 2))
|
|
|
|
pred = -Multiply()([rept(lpc),cX(zpX(xt))])
|
|
|
|
return K.sum(pred,axis = 2,keepdims = True)
|
|
|
|
# Differentiable Transformations (RC <-> LPC) computed using the Levinson Durbin Recursion
|
|
class diff_rc2lpc(Layer):
|
|
def call(self, inputs, lpcoeffs_N = 16):
|
|
def pred_lpc_recursive(input):
|
|
temp = (input[0] + K.repeat_elements(input[1],input[0].shape[2],2)*K.reverse(input[0],axes = 2))
|
|
temp = Concatenate(axis = 2)([temp,input[1]])
|
|
return temp
|
|
Llpc = Lambda(pred_lpc_recursive)
|
|
inputs = inputs[:,:,:lpcoeffs_N]
|
|
lpc_init = inputs
|
|
for i in range(1,lpcoeffs_N):
|
|
lpc_init = Llpc([lpc_init[:,:,:i],K.expand_dims(inputs[:,:,i],axis = -1)])
|
|
return lpc_init
|
|
|
|
class diff_lpc2rc(Layer):
|
|
def call(self, inputs, lpcoeffs_N = 16):
|
|
def pred_rc_recursive(input):
|
|
ki = K.repeat_elements(K.expand_dims(input[1][:,:,0],axis = -1),input[0].shape[2],2)
|
|
temp = (input[0] - ki*K.reverse(input[0],axes = 2))/(1 - ki*ki)
|
|
temp = Concatenate(axis = 2)([temp,input[1]])
|
|
return temp
|
|
Lrc = Lambda(pred_rc_recursive)
|
|
rc_init = inputs
|
|
for i in range(1,lpcoeffs_N):
|
|
j = (lpcoeffs_N - i + 1)
|
|
rc_init = Lrc([rc_init[:,:,:(j - 1)],rc_init[:,:,(j - 1):]])
|
|
return rc_init
|