-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathSKP_Silk_control_codec_FIX.go
210 lines (208 loc) · 8.57 KB
/
SKP_Silk_control_codec_FIX.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
package silk
import "unsafe"
func SKP_Silk_control_encoder_FIX(psEnc *SKP_Silk_encoder_state_FIX, PacketSize_ms int32, TargetRate_bps int32, PacketLoss_perc int32, DTX_enabled int32, Complexity int32) int32 {
var (
fs_kHz int32
ret int32 = 0
)
if psEnc.SCmn.Controlled_since_last_payload != 0 {
if psEnc.SCmn.API_fs_Hz != psEnc.SCmn.Prev_API_fs_Hz && psEnc.SCmn.Fs_kHz > 0 {
ret += SKP_Silk_setup_resamplers_FIX(psEnc, psEnc.SCmn.Fs_kHz)
}
return ret
}
fs_kHz = SKP_Silk_control_audio_bandwidth(&psEnc.SCmn, TargetRate_bps)
ret += SKP_Silk_setup_resamplers_FIX(psEnc, fs_kHz)
ret += SKP_Silk_setup_packetsize_FIX(psEnc, PacketSize_ms)
ret += SKP_Silk_setup_fs_FIX(psEnc, fs_kHz)
ret += SKP_Silk_setup_complexity(&psEnc.SCmn, Complexity)
ret += SKP_Silk_setup_rate_FIX(psEnc, TargetRate_bps)
if PacketLoss_perc < 0 || PacketLoss_perc > 100 {
ret = -5
}
psEnc.SCmn.PacketLoss_perc = PacketLoss_perc
ret += SKP_Silk_setup_LBRR_FIX(psEnc)
if DTX_enabled < 0 || DTX_enabled > 1 {
ret = -8
}
psEnc.SCmn.UseDTX = DTX_enabled
psEnc.SCmn.Controlled_since_last_payload = 1
return ret
}
func SKP_Silk_LBRR_ctrl_FIX(psEnc *SKP_Silk_encoder_state_FIX, psEncCtrlC *SKP_Silk_encoder_control) {
var LBRR_usage int32
if psEnc.SCmn.LBRR_enabled != 0 {
LBRR_usage = SKP_SILK_NO_LBRR
if psEnc.Speech_activity_Q8 > SKP_FIX_CONST(0.5, 8) && psEnc.SCmn.PacketLoss_perc > LBRR_LOSS_THRES {
LBRR_usage = SKP_SILK_ADD_LBRR_TO_PLUS1
}
psEncCtrlC.LBRR_usage = LBRR_usage
} else {
psEncCtrlC.LBRR_usage = SKP_SILK_NO_LBRR
}
}
func SKP_Silk_setup_resamplers_FIX(psEnc *SKP_Silk_encoder_state_FIX, fs_kHz int32) int32 {
var ret int32 = SKP_SILK_NO_ERROR
if psEnc.SCmn.Fs_kHz != fs_kHz || psEnc.SCmn.Prev_API_fs_Hz != psEnc.SCmn.API_fs_Hz {
if psEnc.SCmn.Fs_kHz == 0 {
ret += SKP_Silk_resampler_init(&psEnc.SCmn.Resampler_state, psEnc.SCmn.API_fs_Hz, fs_kHz*1000)
} else {
var (
x_buf_API_fs_Hz [6480]int16
nSamples_temp int32 = (psEnc.SCmn.Frame_length << 1) + LA_SHAPE_MS*psEnc.SCmn.Fs_kHz
)
if SKP_SMULBB(fs_kHz, 1000) < psEnc.SCmn.API_fs_Hz && psEnc.SCmn.Fs_kHz != 0 {
var temp_resampler_state SKP_Silk_resampler_state_struct
ret += SKP_Silk_resampler_init(&temp_resampler_state, SKP_SMULBB(psEnc.SCmn.Fs_kHz, 1000), psEnc.SCmn.API_fs_Hz)
ret += SKP_Silk_resampler(&temp_resampler_state, x_buf_API_fs_Hz[:], psEnc.X_buf[:], nSamples_temp)
nSamples_temp = (nSamples_temp * psEnc.SCmn.API_fs_Hz) / SKP_SMULBB(psEnc.SCmn.Fs_kHz, 1000)
ret += SKP_Silk_resampler_init(&psEnc.SCmn.Resampler_state, psEnc.SCmn.API_fs_Hz, SKP_SMULBB(fs_kHz, 1000))
} else {
memcpy(unsafe.Pointer(&x_buf_API_fs_Hz[0]), unsafe.Pointer(&psEnc.X_buf[0]), size_t(uintptr(nSamples_temp)*unsafe.Sizeof(int16(0))))
}
if fs_kHz*1000 != psEnc.SCmn.API_fs_Hz {
ret += SKP_Silk_resampler(&psEnc.SCmn.Resampler_state, psEnc.X_buf[:], x_buf_API_fs_Hz[:], nSamples_temp)
}
}
}
psEnc.SCmn.Prev_API_fs_Hz = psEnc.SCmn.API_fs_Hz
return ret
}
func SKP_Silk_setup_packetsize_FIX(psEnc *SKP_Silk_encoder_state_FIX, PacketSize_ms int32) int32 {
var ret int32 = SKP_SILK_NO_ERROR
if PacketSize_ms != 20 && PacketSize_ms != 40 && PacketSize_ms != 60 && PacketSize_ms != 80 && PacketSize_ms != 100 {
ret = -3
} else {
if PacketSize_ms != psEnc.SCmn.PacketSize_ms {
psEnc.SCmn.PacketSize_ms = PacketSize_ms
SKP_Silk_LBRR_reset(&psEnc.SCmn)
}
}
return ret
}
func SKP_Silk_setup_fs_FIX(psEnc *SKP_Silk_encoder_state_FIX, fs_kHz int32) int32 {
var ret int32 = SKP_SILK_NO_ERROR
if psEnc.SCmn.Fs_kHz != fs_kHz {
memset(unsafe.Pointer(&psEnc.SShape), 0, size_t(unsafe.Sizeof(SKP_Silk_shape_state_FIX{})))
memset(unsafe.Pointer(&psEnc.SPrefilt), 0, size_t(unsafe.Sizeof(SKP_Silk_prefilter_state_FIX{})))
memset(unsafe.Pointer(&psEnc.SPred), 0, size_t(unsafe.Sizeof(SKP_Silk_predict_state_FIX{})))
memset(unsafe.Pointer(&psEnc.SCmn.SNSQ), 0, size_t(unsafe.Sizeof(SKP_Silk_nsq_state{})))
memset(unsafe.Pointer(&psEnc.SCmn.SNSQ_LBRR.Xq[0]), 0, size_t(((FRAME_LENGTH_MS*MAX_FS_KHZ)*2)*unsafe.Sizeof(int16(0))))
memset(unsafe.Pointer(&psEnc.SCmn.LBRR_buffer[0]), 0, size_t(MAX_LBRR_DELAY*unsafe.Sizeof(SKP_SILK_LBRR_struct{})))
memset(unsafe.Pointer(&psEnc.SCmn.SLP.In_LP_State[0]), 0, size_t(unsafe.Sizeof(int32(0))*2))
if psEnc.SCmn.SLP.Mode == 1 {
psEnc.SCmn.SLP.Transition_frame_no = 1
} else {
psEnc.SCmn.SLP.Transition_frame_no = 0
}
psEnc.SCmn.InputBufIx = 0
psEnc.SCmn.NFramesInPayloadBuf = 0
psEnc.SCmn.NBytesInPayloadBuf = 0
psEnc.SCmn.Oldest_LBRR_idx = 0
psEnc.SCmn.TargetRate_bps = 0
memset(unsafe.Pointer(&psEnc.SPred.Prev_NLSFq_Q15[0]), 0, size_t(MAX_LPC_ORDER*unsafe.Sizeof(int32(0))))
psEnc.SCmn.PrevLag = 100
psEnc.SCmn.Prev_sigtype = SIG_TYPE_UNVOICED
psEnc.SCmn.First_frame_after_reset = 1
psEnc.SPrefilt.LagPrev = 100
psEnc.SShape.LastGainIndex = 1
psEnc.SCmn.SNSQ.LagPrev = 100
psEnc.SCmn.SNSQ.Prev_inv_gain_Q16 = 0x10000
psEnc.SCmn.SNSQ_LBRR.Prev_inv_gain_Q16 = 0x10000
psEnc.SCmn.Fs_kHz = fs_kHz
if psEnc.SCmn.Fs_kHz == 8 {
psEnc.SCmn.PredictLPCOrder = MIN_LPC_ORDER
psEnc.SCmn.PsNLSF_CB[0] = &SKP_Silk_NLSF_CB0_10
psEnc.SCmn.PsNLSF_CB[1] = &SKP_Silk_NLSF_CB1_10
} else {
psEnc.SCmn.PredictLPCOrder = MAX_LPC_ORDER
psEnc.SCmn.PsNLSF_CB[0] = &SKP_Silk_NLSF_CB0_16
psEnc.SCmn.PsNLSF_CB[1] = &SKP_Silk_NLSF_CB1_16
}
psEnc.SCmn.Frame_length = SKP_SMULBB(FRAME_LENGTH_MS, fs_kHz)
psEnc.SCmn.Subfr_length = psEnc.SCmn.Frame_length / NB_SUBFR
psEnc.SCmn.La_pitch = SKP_SMULBB(LA_PITCH_MS, fs_kHz)
psEnc.SPred.Min_pitch_lag = SKP_SMULBB(3, fs_kHz)
psEnc.SPred.Max_pitch_lag = SKP_SMULBB(18, fs_kHz)
psEnc.SPred.Pitch_LPC_win_length = SKP_SMULBB((LA_PITCH_MS<<1)+20, fs_kHz)
if psEnc.SCmn.Fs_kHz == 24 {
psEnc.Mu_LTP_Q8 = SKP_FIX_CONST(0.016, 8)
psEnc.SCmn.Bitrate_threshold_up = SKP_int32_MAX
psEnc.SCmn.Bitrate_threshold_down = SWB2WB_BITRATE_BPS
} else if psEnc.SCmn.Fs_kHz == 16 {
psEnc.Mu_LTP_Q8 = SKP_FIX_CONST(0.02, 8)
psEnc.SCmn.Bitrate_threshold_up = WB2SWB_BITRATE_BPS
psEnc.SCmn.Bitrate_threshold_down = WB2MB_BITRATE_BPS
} else if psEnc.SCmn.Fs_kHz == 12 {
psEnc.Mu_LTP_Q8 = SKP_FIX_CONST(0.025, 8)
psEnc.SCmn.Bitrate_threshold_up = MB2WB_BITRATE_BPS
psEnc.SCmn.Bitrate_threshold_down = MB2NB_BITRATE_BPS
} else {
psEnc.Mu_LTP_Q8 = SKP_FIX_CONST(0.03, 8)
psEnc.SCmn.Bitrate_threshold_up = NB2MB_BITRATE_BPS
psEnc.SCmn.Bitrate_threshold_down = 0
}
psEnc.SCmn.Fs_kHz_changed = 1
}
return ret
}
func SKP_Silk_setup_rate_FIX(psEnc *SKP_Silk_encoder_state_FIX, TargetRate_bps int32) int32 {
var (
k int32
ret int32 = SKP_SILK_NO_ERROR
frac_Q6 int32
rateTable *int32
)
if TargetRate_bps != psEnc.SCmn.TargetRate_bps {
psEnc.SCmn.TargetRate_bps = TargetRate_bps
if psEnc.SCmn.Fs_kHz == 8 {
rateTable = &TargetRate_table_NB[0]
} else if psEnc.SCmn.Fs_kHz == 12 {
rateTable = &TargetRate_table_MB[0]
} else if psEnc.SCmn.Fs_kHz == 16 {
rateTable = &TargetRate_table_WB[0]
} else {
rateTable = &TargetRate_table_SWB[0]
}
for k = 1; k < TARGET_RATE_TAB_SZ; k++ {
if TargetRate_bps <= *(*int32)(unsafe.Add(unsafe.Pointer(rateTable), unsafe.Sizeof(int32(0))*uintptr(k))) {
frac_Q6 = ((TargetRate_bps - *(*int32)(unsafe.Add(unsafe.Pointer(rateTable), unsafe.Sizeof(int32(0))*uintptr(k-1)))) << 6) / (*(*int32)(unsafe.Add(unsafe.Pointer(rateTable), unsafe.Sizeof(int32(0))*uintptr(k))) - *(*int32)(unsafe.Add(unsafe.Pointer(rateTable), unsafe.Sizeof(int32(0))*uintptr(k-1))))
psEnc.SNR_dB_Q7 = ((SNR_table_Q1[k-1]) << 6) + frac_Q6*(SNR_table_Q1[k]-SNR_table_Q1[k-1])
break
}
}
}
return ret
}
func SKP_Silk_setup_LBRR_FIX(psEnc *SKP_Silk_encoder_state_FIX) int32 {
var (
ret int32 = SKP_SILK_NO_ERROR
LBRRRate_thres_bps int32
)
if psEnc.SCmn.UseInBandFEC < 0 || psEnc.SCmn.UseInBandFEC > 1 {
ret = -7
}
psEnc.SCmn.LBRR_enabled = psEnc.SCmn.UseInBandFEC
if psEnc.SCmn.Fs_kHz == 8 {
LBRRRate_thres_bps = INBAND_FEC_MIN_RATE_BPS - 9000
} else if psEnc.SCmn.Fs_kHz == 12 {
LBRRRate_thres_bps = INBAND_FEC_MIN_RATE_BPS - 6000
} else if psEnc.SCmn.Fs_kHz == 16 {
LBRRRate_thres_bps = INBAND_FEC_MIN_RATE_BPS - 3000
} else {
LBRRRate_thres_bps = INBAND_FEC_MIN_RATE_BPS
}
if psEnc.SCmn.TargetRate_bps >= LBRRRate_thres_bps {
psEnc.SCmn.LBRR_GainIncreases = SKP_max_int(8-(psEnc.SCmn.PacketLoss_perc>>1), 0)
if psEnc.SCmn.LBRR_enabled != 0 && psEnc.SCmn.PacketLoss_perc > LBRR_LOSS_THRES {
psEnc.InBandFEC_SNR_comp_Q8 = SKP_FIX_CONST(6.0, 8) - (psEnc.SCmn.LBRR_GainIncreases << 7)
} else {
psEnc.InBandFEC_SNR_comp_Q8 = 0
psEnc.SCmn.LBRR_enabled = 0
}
} else {
psEnc.InBandFEC_SNR_comp_Q8 = 0
psEnc.SCmn.LBRR_enabled = 0
}
return ret
}