Skip to content

GitLab

Commit 06924f5d authored by mayong's avatar mayong
Browse files

Add the src of libs.

parent 83ff3a7f
Hide whitespace changes
Inline Side-by-side
Showing with 2271 additions and 0 deletions
cpp_onnx/src/lib/Audio.cpp 0 → 100644
View file @ 06924f5d
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <webrtc_vad.h>
#include "Audio.h"
using namespace std;
class AudioWindow {
private:
int *window;
int in_idx;
int out_idx;
int sum;
int window_size = 0;
public:
AudioWindow(int window_size) : window_size(window_size)
{
window = (int *)calloc(sizeof(int), window_size + 1);
in_idx = 0;
out_idx = 1;
sum = 0;
};
~AudioWindow()
{
free(window);
};
int put(int val)
{
sum = sum + val - window[out_idx];
window[in_idx] = val;
in_idx = in_idx == window_size ? 0 : in_idx + 1;
out_idx = out_idx == window_size ? 0 : out_idx + 1;
return sum;
};
};
AudioFrame::AudioFrame(){};
AudioFrame::AudioFrame(int len) : len(len)
{
start = 0;
};
AudioFrame::~AudioFrame(){};
int AudioFrame::set_start(int val)
{
start = val < 0 ? 0 : val;
return start;
};
int AudioFrame::set_end(int val, int max_len)
{
float num_samples = val - start;
float frame_length = 400;
float frame_shift = 160;
float num_new_samples =
ceil((num_samples - 400) / frame_shift) * frame_shift + frame_length;
end = start + num_new_samples;
len = (int)num_new_samples;
if (end > max_len)
printf("frame end > max_len!!!!!!!\n");
return end;
};
int AudioFrame::get_start()
{
return start;
};
int AudioFrame::get_len()
{
return len;
};
int AudioFrame::disp()
{
printf("not imp!!!!\n");
return 0;
};
Audio::Audio(int data_type) : data_type(data_type)
{
speech_buff = NULL;
speech_data = NULL;
align_size = 1360;
}
Audio::Audio(int data_type, int size) : data_type(data_type)
{
speech_buff = NULL;
speech_data = NULL;
align_size = (float)size;
}
Audio::~Audio()
{
if (speech_buff != NULL) {
free(speech_buff);
free(speech_data);
}
}
void Audio::disp()
{
printf("Audio time is %f s. len is %d\n", (float)speech_len / 16000,
speech_len);
}
void Audio::loadwav(const char *filename)
{
if (speech_buff != NULL) {
free(speech_buff);
free(speech_data);
}
offset = 0;
FILE *fp;
fp = fopen(filename, "rb");
fseek(fp, 0, SEEK_END);
uint32_t nFileLen = ftell(fp);
fseek(fp, 44, SEEK_SET);
speech_len = (nFileLen - 44) / 2;
speech_align_len = (int)(ceil((float)speech_len / align_size) * align_size);
speech_buff = (int16_t *)malloc(sizeof(int16_t) * speech_align_len);
memset(speech_buff, 0, sizeof(int16_t) * speech_align_len);
int ret = fread(speech_buff, sizeof(int16_t), speech_len, fp);
fclose(fp);
speech_data = (float *)malloc(sizeof(float) * speech_align_len);
memset(speech_data, 0, sizeof(float) * speech_align_len);
int i;
float scale = 1;
if (data_type == 1) {
scale = 32768;
}
for (i = 0; i < speech_len; i++) {
speech_data[i] = (float)speech_buff[i] / scale;
}
AudioFrame *frame = new AudioFrame(speech_len);
frame_queue.push(frame);
}
int Audio::fetch_chunck(float *&dout, int len)
{
if (offset >= speech_align_len) {
dout = NULL;
return S_ERR;
} else if (offset == speech_align_len - len) {
dout = speech_data + offset;
offset = speech_align_len;
// 临时解决
AudioFrame *frame = frame_queue.front();
frame_queue.pop();
delete frame;
return S_END;
} else {
dout = speech_data + offset;
offset += len;
return S_MIDDLE;
}
}
int Audio::fetch(float *&dout, int &len, int &flag)
{
if (frame_queue.size() > 0) {
AudioFrame *frame = frame_queue.front();
frame_queue.pop();
dout = speech_data + frame->get_start();
len = frame->get_len();
delete frame;
flag = S_END;
return 1;
} else {
return 0;
}
}
void Audio::padding()
{
float num_samples = speech_len;
float frame_length = 400;
float frame_shift = 160;
float num_frames = floor((num_samples + (frame_shift / 2)) / frame_shift);
float num_new_samples = (num_frames - 1) * frame_shift + frame_length;
float num_padding = num_new_samples - num_samples;
float num_left_padding = (frame_length - frame_shift) / 2;
float num_right_padding = num_padding - num_left_padding;
float *new_data = (float *)malloc(num_new_samples * sizeof(float));
int i;
int tmp_off = 0;
for (i = 0; i < num_left_padding; i++) {
int ii = num_left_padding - i - 1;
new_data[i] = speech_data[ii];
}
tmp_off = num_left_padding;
memcpy(new_data + tmp_off, speech_data, speech_len * sizeof(float));
tmp_off += speech_len;
for (i = 0; i < num_right_padding; i++) {
int ii = speech_len - i - 1;
new_data[tmp_off + i] = speech_data[ii];
}
free(speech_data);
speech_data = new_data;
speech_len = num_new_samples;
AudioFrame *frame = new AudioFrame(num_new_samples);
frame_queue.push(frame);
frame = frame_queue.front();
frame_queue.pop();
delete frame;
}
#define UNTRIGGERED 0
#define TRIGGERED 1
#define SPEECH_LEN_5S (16000 * 5)
#define SPEECH_LEN_10S (16000 * 10)
#define SPEECH_LEN_20S (16000 * 20)
#define SPEECH_LEN_30S (16000 * 30)
void Audio::split()
{
VadInst *handle = WebRtcVad_Create();
WebRtcVad_Init(handle);
WebRtcVad_set_mode(handle, 2);
int window_size = 10;
AudioWindow audiowindow(window_size);
int status = UNTRIGGERED;
int offset = 0;
int fs = 16000;
int step = 480;
AudioFrame *frame;
frame = frame_queue.front();
frame_queue.pop();
delete frame;
frame = NULL;
while (offset < speech_len - step) {
int n = WebRtcVad_Process(handle, fs, speech_buff + offset, step);
if (status == UNTRIGGERED && audiowindow.put(n) >= window_size - 1) {
frame = new AudioFrame();
int start = offset - step * (window_size - 1);
frame->set_start(start);
status = TRIGGERED;
} else if (status == TRIGGERED) {
int win_weight = audiowindow.put(n);
int voice_len = (offset - frame->get_start());
int gap = 0;
if (voice_len < SPEECH_LEN_5S) {
offset += step;
continue;
} else if (voice_len < SPEECH_LEN_10S) {
gap = 1;
} else if (voice_len < SPEECH_LEN_20S) {
gap = window_size / 5;
} else {
gap = window_size / 2;
}
if (win_weight < gap) {
status = UNTRIGGERED;
offset = frame->set_end(offset, speech_align_len);
frame_queue.push(frame);
frame = NULL;
}
}
offset += step;
}
if (frame != NULL) {
frame->set_end(speech_len, speech_align_len);
frame_queue.push(frame);
frame = NULL;
}
WebRtcVad_Free(handle);
}
cpp_onnx/src/lib/CMakeLists.txt 0 → 100644
View file @ 06924f5d
file(GLOB files1 "*.cpp")
file(GLOB files4 "paraformer/*.cpp")
set(files ${files1} ${files2} ${files3} ${files4})
# message("${files}")
add_library(rapidasr ${files})
if(WIN32)
set(EXTRA_LIBS libfftw3f-3 libopenblas webrtcvad)
if(CMAKE_CL_64)
target_link_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x64)
else()
target_link_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x86)
endif()
target_include_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/include ${CMAKE_SOURCE_DIR}/win/include/openblas)
else()
set(EXTRA_LIBS fftw3f openblas webrtcvad pthread)
target_include_directories(rapidasr PUBLIC "/usr/local/opt/fftw/include")
target_link_directories(rapidasr PUBLIC "/usr/local/opt/fftw/lib")
target_include_directories(rapidasr PUBLIC "/usr/local/opt/openblas/include")
target_link_directories(rapidasr PUBLIC "/usr/local/opt/openblas/lib")
target_include_directories(rapidasr PUBLIC "/usr/include")
target_link_directories(rapidasr PUBLIC "/usr/lib64")
target_include_directories(rapidasr PUBLIC ${OPENBLAS_INCLUDE_DIR} ${FFTW3F_INCLUDE_DIR})
target_link_directories(rapidasr PUBLIC ${OPENBLAS_LIBRARY_DIR} ${FFTW3F_LIBRARY_DIR})
endif()
include_directories(${ONNXRUNTIME_DIR}\\include)
message(${ONNXRUNTIME_DIR}\\lib)
include_directories(${CMAKE_SOURCE_DIR}/include)
target_link_libraries(rapidasr PUBLIC onnxruntime ${EXTRA_LIBS})
cpp_onnx/src/lib/CommonStruct.h 0 → 100644
View file @ 06924f5d
#ifndef COMMONSTRUCT_H
#define COMMONSTRUCT_H
#endif
cpp_onnx/src/lib/FeatureExtract.cpp 0 → 100644
View file @ 06924f5d
#include "precomp.h"
using namespace std;
FeatureExtract::FeatureExtract(int mode) : mode(mode)
{
fftw_init();
}
FeatureExtract::~FeatureExtract()
{
fftwf_free(fft_input);
fftwf_free(fft_out);
fftwf_destroy_plan(p);
}
void FeatureExtract::reset()
{
speech.reset();
fqueue.reset();
}
int FeatureExtract::size()
{
return fqueue.size();
}
void FeatureExtract::fftw_init()
{
int fft_size = 512;
fft_input = (float *)fftwf_malloc(sizeof(float) * fft_size);
fft_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * fft_size);
memset(fft_input, 0, sizeof(float) * fft_size);
p = fftwf_plan_dft_r2c_1d(fft_size, fft_input, fft_out, FFTW_ESTIMATE);
}
void FeatureExtract::insert(float *din, int len, int flag)
{
const float *window = (const float *)&window_hex;
if (mode == 3)
window = (const float *)&window_hamm_hex;
int window_size = 400;
int fft_size = 512;
int window_shift = 160;
speech.load(din, len);
int i, j;
float tmp_feature[80];
if (mode == 0 || mode == 2 || mode == 3) {
int ll = (speech.size() - 400) / 160 + 1;
fqueue.reinit(ll);
}
for (i = 0; i <= speech.size() - 400; i = i + window_shift) {
float tmp_mean = 0;
for (j = 0; j < window_size; j++) {
tmp_mean += speech[i + j];
}
tmp_mean = tmp_mean / window_size;
float pre_val = (float)speech[i] - tmp_mean;
for (j = 0; j < window_size; j++) {
float win = window[j];
float cur_val = (float)speech[i + j] - tmp_mean;
fft_input[j] = win * (cur_val - 0.97 * pre_val);
pre_val = cur_val;
}
fftwf_execute(p);
melspect((float *)fft_out, tmp_feature);
int tmp_flag = S_MIDDLE;
if (flag == S_END && i > speech.size() - 560)
tmp_flag = S_END;
fqueue.push(tmp_feature, tmp_flag);
}
speech.update(i);
}
bool FeatureExtract::fetch(Tensor<float> *&dout)
{
if (fqueue.size() < 1) {
return false;
} else {
dout = fqueue.pop();
return true;
}
}
void FeatureExtract::global_cmvn(float *din)
{
const float *std;
const float *mean;
if (mode < 2) {
if (mode == 0) {
std = (const float *)global_cmvn_std_hex;
mean = (const float *)global_cmvn_mean_hex;
} else {
std = (const float *)global_cmvn_std_online_hex;
mean = (const float *)global_cmvn_mean_online_hex;
}
int i;
for (i = 0; i < 80; i++) {
float tmp = din[i] < 1e-7 ? 1e-7 : din[i];
tmp = log(tmp);
din[i] = (tmp - mean[i]) / std[i];
}
} else {
int i;
int val = 0x34000000;
float min_resol = *((float *)&val);
for (i = 0; i < 80; i++) {
float tmp = din[i] < min_resol ? min_resol : din[i];
din[i] = log(tmp);
}
}
}
void FeatureExtract::melspect(float *din, float *dout)
{
float fftmag[256];
// float tmp;
const float *melcoe = (const float *)melcoe_hex;
int i;
for (i = 0; i < 256; i++) {
float real = din[2 * i];
float imag = din[2 * i + 1];
fftmag[i] = real * real + imag * imag;
}
dout[0] = melcoe[0] * fftmag[1] + melcoe[1] * fftmag[2];
dout[1] = melcoe[2] * fftmag[2];
dout[2] = melcoe[3] * fftmag[3];
dout[3] = melcoe[4] * fftmag[3] + melcoe[5] * fftmag[4];
dout[4] = melcoe[6] * fftmag[4] + melcoe[7] * fftmag[5];
dout[5] = melcoe[8] * fftmag[5] + melcoe[9] * fftmag[6];
dout[6] = melcoe[10] * fftmag[6] + melcoe[11] * fftmag[7];
dout[7] = melcoe[12] * fftmag[7];
dout[8] = melcoe[13] * fftmag[8];
dout[9] = melcoe[14] * fftmag[8] + melcoe[15] * fftmag[9];
dout[10] = melcoe[16] * fftmag[9] + melcoe[17] * fftmag[10];
dout[11] = melcoe[18] * fftmag[10] + melcoe[19] * fftmag[11];
dout[12] = melcoe[20] * fftmag[11] + melcoe[21] * fftmag[12] +
melcoe[22] * fftmag[13];
dout[13] = melcoe[23] * fftmag[12] + melcoe[24] * fftmag[13] +
melcoe[25] * fftmag[14];
dout[14] = melcoe[26] * fftmag[14] + melcoe[27] * fftmag[15];
dout[15] = melcoe[28] * fftmag[15] + melcoe[29] * fftmag[16];
dout[16] = melcoe[30] * fftmag[16] + melcoe[31] * fftmag[17];
dout[17] = melcoe[32] * fftmag[17] + melcoe[33] * fftmag[18];
dout[18] = melcoe[34] * fftmag[18] + melcoe[35] * fftmag[19] +
melcoe[36] * fftmag[20];
dout[19] = melcoe[37] * fftmag[19] + melcoe[38] * fftmag[20] +
melcoe[39] * fftmag[21];
dout[20] = melcoe[40] * fftmag[21] + melcoe[41] * fftmag[22];
dout[21] = melcoe[42] * fftmag[22] + melcoe[43] * fftmag[23] +
melcoe[44] * fftmag[24];
dout[22] = melcoe[45] * fftmag[23] + melcoe[46] * fftmag[24] +
melcoe[47] * fftmag[25];
dout[23] = melcoe[48] * fftmag[25] + melcoe[49] * fftmag[26] +
melcoe[50] * fftmag[27];
dout[24] = melcoe[51] * fftmag[26] + melcoe[52] * fftmag[27] +
melcoe[53] * fftmag[28];
dout[25] = melcoe[54] * fftmag[28] + melcoe[55] * fftmag[29] +
melcoe[56] * fftmag[30];
dout[26] = melcoe[57] * fftmag[29] + melcoe[58] * fftmag[30] +
melcoe[59] * fftmag[31] + melcoe[60] * fftmag[32];
dout[27] = melcoe[61] * fftmag[31] + melcoe[62] * fftmag[32] +
melcoe[63] * fftmag[33];
dout[28] = melcoe[64] * fftmag[33] + melcoe[65] * fftmag[34] +
melcoe[66] * fftmag[35];
dout[29] = melcoe[67] * fftmag[34] + melcoe[68] * fftmag[35] +
melcoe[69] * fftmag[36] + melcoe[70] * fftmag[37];
dout[30] = melcoe[71] * fftmag[36] + melcoe[72] * fftmag[37] +
melcoe[73] * fftmag[38] + melcoe[74] * fftmag[39];
dout[31] = melcoe[75] * fftmag[38] + melcoe[76] * fftmag[39] +
melcoe[77] * fftmag[40] + melcoe[78] * fftmag[41];
dout[32] = melcoe[79] * fftmag[40] + melcoe[80] * fftmag[41] +
melcoe[81] * fftmag[42] + melcoe[82] * fftmag[43];
dout[33] = melcoe[83] * fftmag[42] + melcoe[84] * fftmag[43] +
melcoe[85] * fftmag[44] + melcoe[86] * fftmag[45];
dout[34] = melcoe[87] * fftmag[44] + melcoe[88] * fftmag[45] +
melcoe[89] * fftmag[46] + melcoe[90] * fftmag[47];
dout[35] = melcoe[91] * fftmag[46] + melcoe[92] * fftmag[47] +
melcoe[93] * fftmag[48] + melcoe[94] * fftmag[49];
dout[36] = melcoe[95] * fftmag[48] + melcoe[96] * fftmag[49] +
melcoe[97] * fftmag[50] + melcoe[98] * fftmag[51];
dout[37] = melcoe[99] * fftmag[50] + melcoe[100] * fftmag[51] +
melcoe[101] * fftmag[52] + melcoe[102] * fftmag[53] +
melcoe[103] * fftmag[54];
dout[38] = melcoe[104] * fftmag[52] + melcoe[105] * fftmag[53] +
melcoe[106] * fftmag[54] + melcoe[107] * fftmag[55] +
melcoe[108] * fftmag[56];
dout[39] = melcoe[109] * fftmag[55] + melcoe[110] * fftmag[56] +
melcoe[111] * fftmag[57] + melcoe[112] * fftmag[58];
dout[40] = melcoe[113] * fftmag[57] + melcoe[114] * fftmag[58] +
melcoe[115] * fftmag[59] + melcoe[116] * fftmag[60] +
melcoe[117] * fftmag[61];
dout[41] = melcoe[118] * fftmag[59] + melcoe[119] * fftmag[60] +
melcoe[120] * fftmag[61] + melcoe[121] * fftmag[62] +
melcoe[122] * fftmag[63] + melcoe[123] * fftmag[64];
dout[42] = melcoe[124] * fftmag[62] + melcoe[125] * fftmag[63] +
melcoe[126] * fftmag[64] + melcoe[127] * fftmag[65] +
melcoe[128] * fftmag[66];
dout[43] = melcoe[129] * fftmag[65] + melcoe[130] * fftmag[66] +
melcoe[131] * fftmag[67] + melcoe[132] * fftmag[68] +
melcoe[133] * fftmag[69];
dout[44] = melcoe[134] * fftmag[67] + melcoe[135] * fftmag[68] +
melcoe[136] * fftmag[69] + melcoe[137] * fftmag[70] +
melcoe[138] * fftmag[71] + melcoe[139] * fftmag[72];
dout[45] = melcoe[140] * fftmag[70] + melcoe[141] * fftmag[71] +
melcoe[142] * fftmag[72] + melcoe[143] * fftmag[73] +
melcoe[144] * fftmag[74] + melcoe[145] * fftmag[75];
dout[46] = melcoe[146] * fftmag[73] + melcoe[147] * fftmag[74] +
melcoe[148] * fftmag[75] + melcoe[149] * fftmag[76] +
melcoe[150] * fftmag[77] + melcoe[151] * fftmag[78];
dout[47] = melcoe[152] * fftmag[76] + melcoe[153] * fftmag[77] +
melcoe[154] * fftmag[78] + melcoe[155] * fftmag[79] +
melcoe[156] * fftmag[80] + melcoe[157] * fftmag[81];
dout[48] = melcoe[158] * fftmag[79] + melcoe[159] * fftmag[80] +
melcoe[160] * fftmag[81] + melcoe[161] * fftmag[82] +
melcoe[162] * fftmag[83] + melcoe[163] * fftmag[84];
dout[49] = melcoe[164] * fftmag[82] + melcoe[165] * fftmag[83] +
melcoe[166] * fftmag[84] + melcoe[167] * fftmag[85] +
melcoe[168] * fftmag[86] + melcoe[169] * fftmag[87] +
melcoe[170] * fftmag[88];
dout[50] = melcoe[171] * fftmag[85] + melcoe[172] * fftmag[86] +
melcoe[173] * fftmag[87] + melcoe[174] * fftmag[88] +
melcoe[175] * fftmag[89] + melcoe[176] * fftmag[90] +
melcoe[177] * fftmag[91];
dout[51] = melcoe[178] * fftmag[89] + melcoe[179] * fftmag[90] +
melcoe[180] * fftmag[91] + melcoe[181] * fftmag[92] +
melcoe[182] * fftmag[93] + melcoe[183] * fftmag[94] +
melcoe[184] * fftmag[95];
dout[52] = melcoe[185] * fftmag[92] + melcoe[186] * fftmag[93] +
melcoe[187] * fftmag[94] + melcoe[188] * fftmag[95] +
melcoe[189] * fftmag[96] + melcoe[190] * fftmag[97] +
melcoe[191] * fftmag[98];
dout[53] = melcoe[192] * fftmag[96] + melcoe[193] * fftmag[97] +
melcoe[194] * fftmag[98] + melcoe[195] * fftmag[99] +
melcoe[196] * fftmag[100] + melcoe[197] * fftmag[101] +
melcoe[198] * fftmag[102];
dout[54] = melcoe[199] * fftmag[99] + melcoe[200] * fftmag[100] +
melcoe[201] * fftmag[101] + melcoe[202] * fftmag[102] +
melcoe[203] * fftmag[103] + melcoe[204] * fftmag[104] +
melcoe[205] * fftmag[105] + melcoe[206] * fftmag[106];
dout[55] = melcoe[207] * fftmag[103] + melcoe[208] * fftmag[104] +
melcoe[209] * fftmag[105] + melcoe[210] * fftmag[106] +
melcoe[211] * fftmag[107] + melcoe[212] * fftmag[108] +
melcoe[213] * fftmag[109] + melcoe[214] * fftmag[110];
dout[56] = melcoe[215] * fftmag[107] + melcoe[216] * fftmag[108] +
melcoe[217] * fftmag[109] + melcoe[218] * fftmag[110] +
melcoe[219] * fftmag[111] + melcoe[220] * fftmag[112] +
melcoe[221] * fftmag[113] + melcoe[222] * fftmag[114];
dout[57] = melcoe[223] * fftmag[111] + melcoe[224] * fftmag[112] +
melcoe[225] * fftmag[113] + melcoe[226] * fftmag[114] +
melcoe[227] * fftmag[115] + melcoe[228] * fftmag[116] +
melcoe[229] * fftmag[117] + melcoe[230] * fftmag[118] +
melcoe[231] * fftmag[119];
dout[58] = melcoe[232] * fftmag[115] + melcoe[233] * fftmag[116] +
melcoe[234] * fftmag[117] + melcoe[235] * fftmag[118] +
melcoe[236] * fftmag[119] + melcoe[237] * fftmag[120] +
melcoe[238] * fftmag[121] + melcoe[239] * fftmag[122] +
melcoe[240] * fftmag[123];
dout[59] = melcoe[241] * fftmag[120] + melcoe[242] * fftmag[121] +
melcoe[243] * fftmag[122] + melcoe[244] * fftmag[123] +
melcoe[245] * fftmag[124] + melcoe[246] * fftmag[125] +
melcoe[247] * fftmag[126] + melcoe[248] * fftmag[127] +
melcoe[249] * fftmag[128];
dout[60] = melcoe[250] * fftmag[124] + melcoe[251] * fftmag[125] +
melcoe[252] * fftmag[126] + melcoe[253] * fftmag[127] +
melcoe[254] * fftmag[128] + melcoe[255] * fftmag[129] +
melcoe[256] * fftmag[130] + melcoe[257] * fftmag[131] +
melcoe[258] * fftmag[132];
dout[61] = melcoe[259] * fftmag[129] + melcoe[260] * fftmag[130] +
melcoe[261] * fftmag[131] + melcoe[262] * fftmag[132] +
melcoe[263] * fftmag[133] + melcoe[264] * fftmag[134] +
melcoe[265] * fftmag[135] + melcoe[266] * fftmag[136] +
melcoe[267] * fftmag[137];
dout[62] = melcoe[268] * fftmag[133] + melcoe[269] * fftmag[134] +
melcoe[270] * fftmag[135] + melcoe[271] * fftmag[136] +
melcoe[272] * fftmag[137] + melcoe[273] * fftmag[138] +
melcoe[274] * fftmag[139] + melcoe[275] * fftmag[140] +
melcoe[276] * fftmag[141] + melcoe[277] * fftmag[142];
dout[63] = melcoe[278] * fftmag[138] + melcoe[279] * fftmag[139] +
melcoe[280] * fftmag[140] + melcoe[281] * fftmag[141] +
melcoe[282] * fftmag[142] + melcoe[283] * fftmag[143] +
melcoe[284] * fftmag[144] + melcoe[285] * fftmag[145] +
melcoe[286] * fftmag[146] + melcoe[287] * fftmag[147];
dout[64] = melcoe[288] * fftmag[143] + melcoe[289] * fftmag[144] +
melcoe[290] * fftmag[145] + melcoe[291] * fftmag[146] +
melcoe[292] * fftmag[147] + melcoe[293] * fftmag[148] +
melcoe[294] * fftmag[149] + melcoe[295] * fftmag[150] +
melcoe[296] * fftmag[151] + melcoe[297] * fftmag[152] +
melcoe[298] * fftmag[153];
dout[65] = melcoe[299] * fftmag[148] + melcoe[300] * fftmag[149] +
melcoe[301] * fftmag[150] + melcoe[302] * fftmag[151] +
melcoe[303] * fftmag[152] + melcoe[304] * fftmag[153] +
melcoe[305] * fftmag[154] + melcoe[306] * fftmag[155] +
melcoe[307] * fftmag[156] + melcoe[308] * fftmag[157] +
melcoe[309] * fftmag[158];
dout[66] = melcoe[310] * fftmag[154] + melcoe[311] * fftmag[155] +
melcoe[312] * fftmag[156] + melcoe[313] * fftmag[157] +
melcoe[314] * fftmag[158] + melcoe[315] * fftmag[159] +
melcoe[316] * fftmag[160] + melcoe[317] * fftmag[161] +
melcoe[318] * fftmag[162] + melcoe[319] * fftmag[163] +
melcoe[320] * fftmag[164];
dout[67] = melcoe[321] * fftmag[159] + melcoe[322] * fftmag[160] +
melcoe[323] * fftmag[161] + melcoe[324] * fftmag[162] +
melcoe[325] * fftmag[163] + melcoe[326] * fftmag[164] +
melcoe[327] * fftmag[165] + melcoe[328] * fftmag[166] +
melcoe[329] * fftmag[167] + melcoe[330] * fftmag[168] +
melcoe[331] * fftmag[169] + melcoe[332] * fftmag[170];
dout[68] = melcoe[333] * fftmag[165] + melcoe[334] * fftmag[166] +
melcoe[335] * fftmag[167] + melcoe[336] * fftmag[168] +
melcoe[337] * fftmag[169] + melcoe[338] * fftmag[170] +
melcoe[339] * fftmag[171] + melcoe[340] * fftmag[172] +
melcoe[341] * fftmag[173] + melcoe[342] * fftmag[174] +
melcoe[343] * fftmag[175] + melcoe[344] * fftmag[176];
dout[69] = melcoe[345] * fftmag[171] + melcoe[346] * fftmag[172] +
melcoe[347] * fftmag[173] + melcoe[348] * fftmag[174] +
melcoe[349] * fftmag[175] + melcoe[350] * fftmag[176] +
melcoe[351] * fftmag[177] + melcoe[352] * fftmag[178] +
melcoe[353] * fftmag[179] + melcoe[354] * fftmag[180] +
melcoe[355] * fftmag[181] + melcoe[356] * fftmag[182];
dout[70] = melcoe[357] * fftmag[177] + melcoe[358] * fftmag[178] +
melcoe[359] * fftmag[179] + melcoe[360] * fftmag[180] +
melcoe[361] * fftmag[181] + melcoe[362] * fftmag[182] +
melcoe[363] * fftmag[183] + melcoe[364] * fftmag[184] +
melcoe[365] * fftmag[185] + melcoe[366] * fftmag[186] +
melcoe[367] * fftmag[187] + melcoe[368] * fftmag[188];
dout[71] = melcoe[369] * fftmag[183] + melcoe[370] * fftmag[184] +
melcoe[371] * fftmag[185] + melcoe[372] * fftmag[186] +
melcoe[373] * fftmag[187] + melcoe[374] * fftmag[188] +
melcoe[375] * fftmag[189] + melcoe[376] * fftmag[190] +
melcoe[377] * fftmag[191] + melcoe[378] * fftmag[192] +
melcoe[379] * fftmag[193] + melcoe[380] * fftmag[194] +
melcoe[381] * fftmag[195];
dout[72] = melcoe[382] * fftmag[189] + melcoe[383] * fftmag[190] +
melcoe[384] * fftmag[191] + melcoe[385] * fftmag[192] +
melcoe[386] * fftmag[193] + melcoe[387] * fftmag[194] +
melcoe[388] * fftmag[195] + melcoe[389] * fftmag[196] +
melcoe[390] * fftmag[197] + melcoe[391] * fftmag[198] +
melcoe[392] * fftmag[199] + melcoe[393] * fftmag[200] +
melcoe[394] * fftmag[201] + melcoe[395] * fftmag[202];
dout[73] = melcoe[396] * fftmag[196] + melcoe[397] * fftmag[197] +
melcoe[398] * fftmag[198] + melcoe[399] * fftmag[199] +
melcoe[400] * fftmag[200] + melcoe[401] * fftmag[201] +
melcoe[402] * fftmag[202] + melcoe[403] * fftmag[203] +
melcoe[404] * fftmag[204] + melcoe[405] * fftmag[205] +
melcoe[406] * fftmag[206] + melcoe[407] * fftmag[207] +
melcoe[408] * fftmag[208] + melcoe[409] * fftmag[209];
dout[74] = melcoe[410] * fftmag[203] + melcoe[411] * fftmag[204] +
melcoe[412] * fftmag[205] + melcoe[413] * fftmag[206] +
melcoe[414] * fftmag[207] + melcoe[415] * fftmag[208] +
melcoe[416] * fftmag[209] + melcoe[417] * fftmag[210] +
melcoe[418] * fftmag[211] + melcoe[419] * fftmag[212] +
melcoe[420] * fftmag[213] + melcoe[421] * fftmag[214] +
melcoe[422] * fftmag[215] + melcoe[423] * fftmag[216];
dout[75] = melcoe[424] * fftmag[210] + melcoe[425] * fftmag[211] +
melcoe[426] * fftmag[212] + melcoe[427] * fftmag[213] +
melcoe[428] * fftmag[214] + melcoe[429] * fftmag[215] +
melcoe[430] * fftmag[216] + melcoe[431] * fftmag[217] +
melcoe[432] * fftmag[218] + melcoe[433] * fftmag[219] +
melcoe[434] * fftmag[220] + melcoe[435] * fftmag[221] +
melcoe[436] * fftmag[222] + melcoe[437] * fftmag[223];
dout[76] = melcoe[438] * fftmag[217] + melcoe[439] * fftmag[218] +
melcoe[440] * fftmag[219] + melcoe[441] * fftmag[220] +
melcoe[442] * fftmag[221] + melcoe[443] * fftmag[222] +
melcoe[444] * fftmag[223] + melcoe[445] * fftmag[224] +
melcoe[446] * fftmag[225] + melcoe[447] * fftmag[226] +
melcoe[448] * fftmag[227] + melcoe[449] * fftmag[228] +
melcoe[450] * fftmag[229] + melcoe[451] * fftmag[230] +
melcoe[452] * fftmag[231];
dout[77] = melcoe[453] * fftmag[224] + melcoe[454] * fftmag[225] +
melcoe[455] * fftmag[226] + melcoe[456] * fftmag[227] +
melcoe[457] * fftmag[228] + melcoe[458] * fftmag[229] +
melcoe[459] * fftmag[230] + melcoe[460] * fftmag[231] +
melcoe[461] * fftmag[232] + melcoe[462] * fftmag[233] +
melcoe[463] * fftmag[234] + melcoe[464] * fftmag[235] +
melcoe[465] * fftmag[236] + melcoe[466] * fftmag[237] +
melcoe[467] * fftmag[238] + melcoe[468] * fftmag[239];
dout[78] = melcoe[469] * fftmag[232] + melcoe[470] * fftmag[233] +
melcoe[471] * fftmag[234] + melcoe[472] * fftmag[235] +
melcoe[473] * fftmag[236] + melcoe[474] * fftmag[237] +
melcoe[475] * fftmag[238] + melcoe[476] * fftmag[239] +
melcoe[477] * fftmag[240] + melcoe[478] * fftmag[241] +
melcoe[479] * fftmag[242] + melcoe[480] * fftmag[243] +
melcoe[481] * fftmag[244] + melcoe[482] * fftmag[245] +
melcoe[483] * fftmag[246] + melcoe[484] * fftmag[247];
dout[79] = melcoe[485] * fftmag[240] + melcoe[486] * fftmag[241] +
melcoe[487] * fftmag[242] + melcoe[488] * fftmag[243] +
melcoe[489] * fftmag[244] + melcoe[490] * fftmag[245] +
melcoe[491] * fftmag[246] + melcoe[492] * fftmag[247] +
melcoe[493] * fftmag[248] + melcoe[494] * fftmag[249] +
melcoe[495] * fftmag[250] + melcoe[496] * fftmag[251] +
melcoe[497] * fftmag[252] + melcoe[498] * fftmag[253] +
melcoe[499] * fftmag[254] + melcoe[500] * fftmag[255];
global_cmvn(dout);
}
cpp_onnx/src/lib/FeatureExtract.h 0 → 100644
View file @ 06924f5d
#ifndef FEATUREEXTRACT_H
#define FEATUREEXTRACT_H
#include <fftw3.h>
#include <stdint.h>
#include "FeatureQueue.h"
#include "SpeechWrap.h"
#include "Tensor.h"
class FeatureExtract {
private:
SpeechWrap speech;
FeatureQueue fqueue;
int mode;
float *fft_input;
fftwf_complex *fft_out;
fftwf_plan p;
void fftw_init();
void melspect(float *din, float *dout);
void global_cmvn(float *din);
public:
FeatureExtract(int mode);
~FeatureExtract();
int size();
int status();
void reset();
void insert(float *din, int len, int flag);
bool fetch(Tensor<float> *&dout);
};
#endif
cpp_onnx/src/lib/FeatureQueue.cpp 0 → 100644
View file @ 06924f5d
#include "FeatureQueue.h"
#include "CommonStruct.h"
#include <string>
#include <ComDefine.h>
FeatureQueue::FeatureQueue()
{
buff = new Tensor<float>(67, 80);
window_size = 67;
buff_idx = 0;
}
FeatureQueue::~FeatureQueue()
{
delete buff;
}
void FeatureQueue::reinit(int size)
{
delete buff;
buff = new Tensor<float>(size, 80);
buff_idx = 0;
window_size = size;
}
void FeatureQueue::reset()
{
buff_idx = 0;
}
void FeatureQueue::push(float *din, int flag)
{
int offset = buff_idx * 80;
memcpy(buff->buff + offset, din, 80 * sizeof(float));
buff_idx++;
if (flag == S_END) {
Tensor<float> *tmp = new Tensor<float>(buff_idx, 80);
memcpy(tmp->buff, buff->buff, buff_idx * 80 * sizeof(float));
feature_queue.push(tmp);
buff_idx = 0;
} else if (buff_idx == window_size) {
feature_queue.push(buff);
Tensor<float> *tmp = new Tensor<float>(window_size, 80);
memcpy(tmp->buff, buff->buff + (window_size - 3) * 80,
3 * 80 * sizeof(float));
buff_idx = 3;
buff = tmp;
}
}
Tensor<float> *FeatureQueue::pop()
{
Tensor<float> *tmp = feature_queue.front();
feature_queue.pop();
return tmp;
}
int FeatureQueue::size()
{
return feature_queue.size();
}
cpp_onnx/src/lib/FeatureQueue.h 0 → 100644
View file @ 06924f5d
#ifndef FEATUREQUEUE_H
#define FEATUREQUEUE_H
#include "Tensor.h"
#include <queue>
#include <stdint.h>
using namespace std;
class FeatureQueue {
private:
queue<Tensor<float> *> feature_queue;
Tensor<float> *buff;
int buff_idx;
int window_size;
public:
FeatureQueue();
~FeatureQueue();
void reinit(int size);
void reset();
void push(float *din, int flag);
Tensor<float> *pop();
int size();
};
#endif
cpp_onnx/src/lib/Model.cpp 0 → 100644
View file @ 06924f5d
#include "precomp.h"
Model *create_model(const char *path, int mode)
{
Model *mm;
mm = new paraformer::ModelImp(path, mode);
return mm;
}
cpp_onnx/src/lib/SpeechWrap.cpp 0 → 100644
View file @ 06924f5d
#include "precomp.h"
SpeechWrap::SpeechWrap()
{
cache_size = 0;
}
SpeechWrap::~SpeechWrap()
{
}
void SpeechWrap::reset()
{
cache_size = 0;
}
void SpeechWrap::load(float *din, int len)
{
in = din;
in_size = len;
total_size = cache_size + in_size;
}
int SpeechWrap::size()
{
return total_size;
}
void SpeechWrap::update(int offset)
{
int in_offset = offset - cache_size;
cache_size = (total_size - offset);
memcpy(cache, in + in_offset, cache_size * sizeof(float));
}
float &SpeechWrap::operator[](int i)
{
return i < cache_size ? cache[i] : in[i - cache_size];
}
cpp_onnx/src/lib/SpeechWrap.h 0 → 100644
View file @ 06924f5d
#ifndef SPEECHWRAP_H
#define SPEECHWRAP_H
#include <stdint.h>
class SpeechWrap {
private:
float cache[400];
int cache_size;
float *in;
int in_size;
int total_size;
int next_cache_size;
public:
SpeechWrap();
~SpeechWrap();
void load(float *din, int len);
void update(int offset);
void reset();
int size();
float &operator[](int i);
};
#endif
cpp_onnx/src/lib/Tensor.h 0 → 100644
View file @ 06924f5d
#ifndef TENSOR_H
#define TENSOR_H
#include "alignedmem.h"
using namespace std;
template <typename T> class Tensor {
private:
void alloc_buff();
void free_buff();
int mem_size;
public:
T *buff;
int size[4];
int buff_size;
Tensor(Tensor<T> *in);
Tensor(int a);
Tensor(int a, int b);
Tensor(int a, int b, int c);
Tensor(int a, int b, int c, int d);
~Tensor();
void zeros();
void shape();
void disp();
void dump(const char *mode);
void concat(Tensor<T> *din, int dim);
void resize(int a, int b, int c, int d);
void add(float coe, Tensor<T> *in);
void add(Tensor<T> *in);
void add(Tensor<T> *in1, Tensor<T> *in2);
void reload(Tensor<T> *in);
};
template <typename T> Tensor<T>::Tensor(int a) : size{1, 1, 1, a}
{
alloc_buff();
}
template <typename T> Tensor<T>::Tensor(int a, int b) : size{1, 1, a, b}
{
alloc_buff();
}
template <typename T> Tensor<T>::Tensor(int a, int b, int c) : size{1, a, b, c}
{
alloc_buff();
}
template <typename T>
Tensor<T>::Tensor(int a, int b, int c, int d) : size{a, b, c, d}
{
alloc_buff();
}
template <typename T> Tensor<T>::Tensor(Tensor<T> *in)
{
memcpy(size, in->size, 4 * sizeof(int));
alloc_buff();
memcpy(buff, in->buff, in->buff_size * sizeof(T));
}
template <typename T> Tensor<T>::~Tensor()
{
free_buff();
}
template <typename T> void Tensor<T>::alloc_buff()
{
buff_size = size[0] * size[1] * size[2] * size[3];
mem_size = buff_size;
buff = (T *)aligned_malloc(32, buff_size * sizeof(T));
}
template <typename T> void Tensor<T>::free_buff()
{
aligned_free(buff);
}
template <typename T> void Tensor<T>::zeros()
{
memset(buff, 0, buff_size * sizeof(T));
}
template <typename T> void Tensor<T>::shape()
{
printf("(%d,%d,%d,%d)\n", size[0], size[1], size[2], size[3]);
}
// TODO:: fix it!!!!
template <typename T> void Tensor<T>::concat(Tensor<T> *din, int dim)
{
memcpy(buff + buff_size, din->buff, din->buff_size * sizeof(T));
buff_size += din->buff_size;
size[dim] += din->size[dim];
}
// TODO:: fix it!!!!
template <typename T> void Tensor<T>::resize(int a, int b, int c, int d)
{
size[0] = a;
size[1] = b;
size[2] = c;
size[3] = d;
buff_size = size[0] * size[1] * size[2] * size[3];
}
template <typename T> void Tensor<T>::add(float coe, Tensor<T> *in)
{
int i;
for (i = 0; i < buff_size; i++) {
buff[i] = buff[i] + coe * in->buff[i];
}
}
template <typename T> void Tensor<T>::add(Tensor<T> *in)
{
int i;
for (i = 0; i < buff_size; i++) {
buff[i] = buff[i] + in->buff[i];
}
}
template <typename T> void Tensor<T>::add(Tensor<T> *in1, Tensor<T> *in2)
{
int i;
for (i = 0; i < buff_size; i++) {
buff[i] = buff[i] + in1->buff[i] + in2->buff[i];
}
}
template <typename T> void Tensor<T>::reload(Tensor<T> *in)
{
memcpy(buff, in->buff, in->buff_size * sizeof(T));
}
template <typename T> void Tensor<T>::disp()
{
int i;
for (i = 0; i < buff_size; i++) {
cout << buff[i] << " ";
}
cout << endl;
}
template <typename T> void Tensor<T>::dump(const char *mode)
{
FILE *fp;
fp = fopen("tmp.bin", mode);
fwrite(buff, 1, buff_size * sizeof(T), fp);
fclose(fp);
}
#endif
cpp_onnx/src/lib/Vocab.cpp 0 → 100644
View file @ 06924f5d
#include "Vocab.h"
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <string>
using namespace std;
Vocab::Vocab(const char *filename)
{
ifstream in(filename);
string line;
if (in) // 有该文件
{
while (getline(in, line)) // line中不包括每行的换行符
{
vocab.push_back(line);
}
// cout << vocab[1719] << endl;
}
// else // 没有该文件
//{
// cout << "no such file" << endl;
// }
}
Vocab::~Vocab()
{
}
string Vocab::vector2string(vector<int> in)
{
int i;
stringstream ss;
for (auto it = in.begin(); it != in.end(); it++) {
ss << vocab[*it];
}
return ss.str();
}
int str2int(string str)
{
const char *ch_array = str.c_str();
if (((ch_array[0] & 0xf0) != 0xe0) || ((ch_array[1] & 0xc0) != 0x80) ||
((ch_array[2] & 0xc0) != 0x80))
return 0;
int val = ((ch_array[0] & 0x0f) << 12) | ((ch_array[1] & 0x3f) << 6) |
(ch_array[2] & 0x3f);
return val;
}
bool Vocab::isChinese(string ch)
{
if (ch.size() != 3) {
return false;
}
int unicode = str2int(ch);
if (unicode >= 19968 && unicode <= 40959) {
return true;
}
return false;
}
string Vocab::vector2stringV2(vector<int> in)
{
int i;
list<string> words;
int is_pre_english = false;
int pre_english_len = 0;
int is_combining = false;
string combine = "";
for (auto it = in.begin(); it != in.end(); it++) {
string word = vocab[*it];
// step1 space character skips
if (word == "<s>" || word == "</s>" || word == "<unk>")
continue;
// step2 combie phoneme to full word
{
int sub_word = !(word.find("@@") == string::npos);
// process word start and middle part
if (sub_word) {
combine += word.erase(word.length() - 2);
is_combining = true;
continue;
}
// process word end part
else if (is_combining) {
combine += word;
is_combining = false;
word = combine;
combine = "";
}
}
// step3 process english word deal with space , turn abbreviation to upper case
{
// input word is chinese, not need process
if (isChinese(word)) {
words.push_back(word);
is_pre_english = false;
}
// input word is english word
else {
// pre word is chinese
if (!is_pre_english) {
word[0] = word[0] - 32;
words.push_back(word);
pre_english_len = word.size();
}
// pre word is english word
else {
// single letter turn to upper case
if (word.size() == 1) {
word[0] = word[0] - 32;
}
if (pre_english_len > 1) {
words.push_back(" ");
words.push_back(word);
pre_english_len = word.size();
}
else {
if (word.size() > 1) {
words.push_back(" ");
}
words.push_back(word);
pre_english_len = word.size();
}
}
is_pre_english = true;
}
}
}
// for (auto it = words.begin(); it != words.end(); it++) {
// cout << *it << endl;
// }
stringstream ss;
for (auto it = words.begin(); it != words.end(); it++) {
ss << *it;
}
return ss.str();
}
int Vocab::size()
{
return vocab.size();
}
cpp_onnx/src/lib/Vocab.h 0 → 100644
View file @ 06924f5d
#ifndef VOCAB_H
#define VOCAB_H
#include <stdint.h>
#include <string>
#include <vector>
using namespace std;
class Vocab {
private:
vector<string> vocab;
bool isChinese(string ch);
bool isEnglish(string ch);
public:
Vocab(const char *filename);
~Vocab();
int size();
string vector2string(vector<int> in);
string vector2stringV2(vector<int> in);
};
#endif
cpp_onnx/src/lib/alignedmem.cpp 0 → 100644
View file @ 06924f5d
#include "precomp.h"
void *aligned_malloc(size_t alignment, size_t required_bytes)
{
void *p1; // original block
void **p2; // aligned block
int offset = alignment - 1 + sizeof(void *);
if ((p1 = (void *)malloc(required_bytes + offset)) == NULL) {
return NULL;
}
p2 = (void **)(((size_t)(p1) + offset) & ~(alignment - 1));
p2[-1] = p1;
return p2;
}
void aligned_free(void *p)
{
free(((void **)p)[-1]);
}
cpp_onnx/src/lib/alignedmem.h 0 → 100644
View file @ 06924f5d
#ifndef ALIGNEDMEM_H
#define ALIGNEDMEM_H
extern void *aligned_malloc(size_t alignment, size_t required_bytes);
extern void aligned_free(void *p);
#endif
cpp_onnx/src/lib/commonfunc.h 0 → 100644
View file @ 06924f5d
#pragma once
#ifdef _WIN32
#include <codecvt>
inline std::wstring string2wstring(const std::string& str, const std::string& locale)
{
typedef std::codecvt_byname<wchar_t, char, std::mbstate_t> F;
std::wstring_convert<F> strCnv(new F(locale));
return strCnv.from_bytes(str);
}
inline std::wstring strToWstr(std::string str) {
if (str.length() == 0)
return L"";
return string2wstring(str, "zh-CN");
}
#endif
inline void getInputName(Ort::Session* session, string& inputName,int nIndex=0) {
size_t numInputNodes = session->GetInputCount();
if (numInputNodes > 0) {
Ort::AllocatorWithDefaultOptions allocator;
{
auto t = session->GetInputNameAllocated(nIndex, allocator);
inputName = t.get();
}
}
}
inline void getOutputName(Ort::Session* session, string& outputName, int nIndex = 0) {
size_t numOutputNodes = session->GetOutputCount();
if (numOutputNodes > 0) {
Ort::AllocatorWithDefaultOptions allocator;
{
auto t = session->GetOutputNameAllocated(nIndex, allocator);
outputName = t.get();
}
}
}
\ No newline at end of file
cpp_onnx/src/lib/paraformer_onnx.cpp 0 → 100644
View file @ 06924f5d
#include "precomp.h"
using namespace std;
using namespace paraformer;
ModelImp::ModelImp(const char* path, int mode,int nNumThread)
{
string model_path = pathAppend(path, "model.onnx");
string vocab_path = pathAppend(path, "vocab.txt");
fe = new FeatureExtract(mode);
//p_helper = new ModelParamsHelper(wenet_path.c_str(), 500);
//encoder = new Encoder(&p_helper->params.encoder);
//predictor = new Predictor(&p_helper->params.predictor);
//decoder = new Decoder(&p_helper->params.decoder);
sessionOptions.SetInterOpNumThreads(nNumThread);
sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
#ifdef _WIN32
wstring wstrPath = strToWstr(model_path);
m_session = new Ort::Session(env, wstrPath.c_str(), sessionOptions);
#else
m_session = new Ort::Session(env, model_path.c_str(), sessionOptions);
#endif
string strName;
getInputName(m_session, strName);
m_strInputNames.push_back(strName.c_str());
getInputName(m_session, strName,1);
m_strInputNames.push_back(strName);
getOutputName(m_session, strName);
m_strOutputNames.push_back(strName);
getOutputName(m_session, strName,1);
m_strOutputNames.push_back(strName);
for (auto& item : m_strInputNames)
m_szInputNames.push_back(item.c_str());
for (auto& item : m_strOutputNames)
m_szOutputNames.push_back(item.c_str());
vocab = new Vocab(vocab_path.c_str());
}
ModelImp::~ModelImp()
{
delete fe;
//delete p_helper;
//delete encoder;
//delete predictor;
//
//delete decoder;
if (m_session)
{
delete m_session;
m_session = nullptr;
}
delete vocab;
}
void ModelImp::reset()
{
fe->reset();
}
void ModelImp::apply_lfr(Tensor<float>*& din)
{
int mm = din->size[2];
int ll = ceil(mm / 6.0);
Tensor<float>* tmp = new Tensor<float>(ll, 560);
int i, j;
int out_offset = 0;
for (i = 0; i < ll; i++) {
for (j = 0; j < 7; j++) {
int idx = i * 6 + j - 3;
if (idx < 0) {
idx = 0;
}
if (idx >= mm) {
idx = mm - 1;
}
memcpy(tmp->buff + out_offset, din->buff + idx * 80,
sizeof(float) * 80);
out_offset += 80;
}
}
delete din;
din = tmp;
}
void ModelImp::apply_cmvn(Tensor<float>* din)
{
const float* var;
const float* mean;
float scale = 22.6274169979695;
int m = din->size[2];
int n = din->size[3];
var = (const float*)paraformer_cmvn_var_hex;
mean = (const float*)paraformer_cmvn_mean_hex;
int i, j;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
int idx = i * n + j;
din->buff[idx] = (din->buff[idx] + mean[j]) * var[j];
}
}
}
string ModelImp::greedy_search(float * in, int nLen )
{
vector<int> hyps;
int Tmax = nLen;
int i;
for (i = 0; i < Tmax; i++) {
int max_idx;
float max_val;
findmax(in + i * 8404, 8404, max_val, max_idx);
hyps.push_back(max_idx);
}
return vocab->vector2stringV2(hyps);
}
string ModelImp::forward(float* din, int len, int flag)
{
Tensor<float>* in;
fe->insert(din, len, flag);
fe->fetch(in);
apply_lfr(in);
apply_cmvn(in);
//encoder->forward(in);
//Tensor<float> enc_out(in);
//predictor->forward(in);
//decoder->forward(in, &enc_out);
//int64_t speech_len = in->size[2];
//Ort::Value inputTensor = Ort::Value::CreateTensor<float>(m_memoryInfo, in->buff, in->buff_size, input_shape_.data(), input_shape_.size());
Ort::RunOptions run_option;
std::array<int64_t, 3> input_shape_{ in->size[0],in->size[2],in->size[3] };
Ort::Value onnx_feats = Ort::Value::CreateTensor<float>(m_memoryInfo,
in->buff,
in->buff_size,
input_shape_.data(),
input_shape_.size());
std::vector<int32_t> feats_len{ in->size[2] };
std::vector<int64_t> feats_len_dim{ 1 };
Ort::Value onnx_feats_len = Ort::Value::CreateTensor(
m_memoryInfo,
feats_len.data(),
feats_len.size() * sizeof(int32_t),
feats_len_dim.data(),
feats_len_dim.size(), ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32);
std::vector<Ort::Value> input_onnx;
input_onnx.emplace_back(std::move(onnx_feats));
input_onnx.emplace_back(std::move(onnx_feats_len));
//auto output = m_session_encoder->Run(run_option,
// m_strEncInputName.data(),
// input_onnx.data(),
// m_strEncInputName.size(),
// m_strEncOutputName.data(),
// m_strEncOutputName.size()
//);
auto outputTensor = m_session->Run(run_option, m_szInputNames.data(), input_onnx.data(), m_szInputNames.size(), m_szOutputNames.data(), m_szOutputNames.size());
//assert(outputTensor.size() == 1 && outputTensor[0].IsTensor());
std::vector<int64_t> outputShape = outputTensor[0].GetTensorTypeAndShapeInfo().GetShape();
int64_t outputCount = std::accumulate(outputShape.begin(), outputShape.end(), 1, std::multiplies<int64_t>());
float* floatData = outputTensor[0].GetTensorMutableData<float>();
auto encoder_out_lens = outputTensor[1].GetTensorMutableData<int64_t>();
//float* floatSize = outputTensor[1].GetTensorMutableData<float>();
//std::vector<float> out_data(floatArray, floatArray + outputCount);
string result = greedy_search(floatData, *encoder_out_lens);
if(in)
delete in;
return result;
}
string ModelImp::forward_chunk(float* din, int len, int flag)
{
printf("Not Imp!!!!!!\n");
return "Hello";
}
string ModelImp::rescoring()
{
printf("Not Imp!!!!!!\n");
return "Hello";
}
cpp_onnx/src/lib/paraformer_onnx.h 0 → 100644
View file @ 06924f5d
#pragma once
#ifndef PARAFORMER_MODELIMP_H
#define PARAFORMER_MODELIMP_H
namespace paraformer {
class ModelImp : public Model {
private:
FeatureExtract* fe;
Vocab* vocab;
void apply_lfr(Tensor<float>*& din);
void apply_cmvn(Tensor<float>* din);
string greedy_search( float* in, int nLen);
#ifdef _WIN_X86
Ort::MemoryInfo m_memoryInfo = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);
#else
Ort::MemoryInfo m_memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
#endif
Ort::Session* m_session = nullptr;
Ort::Env env = Ort::Env(ORT_LOGGING_LEVEL_ERROR, "paraformer");
Ort::SessionOptions sessionOptions = Ort::SessionOptions();
vector<string> m_strInputNames, m_strOutputNames;
vector<const char*> m_szInputNames;
vector<const char*> m_szOutputNames;
//string m_strInputName, m_strInputNameLen;
//string m_strOutputName, m_strOutputNameLen;
public:
ModelImp(const char* path, int mode, int nNumThread=4);
~ModelImp();
void reset();
string forward_chunk(float* din, int len, int flag);
string forward(float* din, int len, int flag);
string rescoring();
};
} // namespace paraformer
#endif
cpp_onnx/src/lib/precomp.h 0 → 100644
View file @ 06924f5d
#pragma once
// system
#include "alignedmem.h"
#include <iostream>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <deque>
#include <iostream>
#include <list>
#include <locale.h>
#include <vector>
#include <string>
#include <math.h>
#include <numeric>
using namespace std;
// third part
#include <fftw3.h>
#include "onnxruntime_run_options_config_keys.h"
#include "onnxruntime_cxx_api.h"
// mine
#include "commonfunc.h"
#include <ComDefine.h>
#include "predefine_coe.h"
#include "Vocab.h"
#include "util.h"
#include "CommonStruct.h"
#include "FeatureExtract.h"
#include "SpeechWrap.h"
#include "Model.h"
#include "paraformer_onnx.h"
using namespace paraformer;
\ No newline at end of file
cpp_onnx/src/lib/predefine_coe.h 0 → 100644
View file @ 06924f5d
#ifndef PREDEFINE_COE_H
#define PREDEFINE_COE_H
#include <stdint.h>
const int32_t melcoe_hex[] = {
0x3f01050c, 0x3e0afb11, 0x3f5d413c, 0x3f547fd0, 0x3e2e00c1, 0x3f132970,
0x3ed9ad21, 0x3ebb8bb9, 0x3f223a24, 0x3e4de6f8, 0x3f4c8642, 0x3d9c0424,
0x3f6c7f7c, 0x3f7d295a, 0x3c35a961, 0x3f6fd497, 0x3d815b45, 0x3f6af197,
0x3da87344, 0x3f6dfce9, 0x3d9018b9, 0x3f787ebc, 0x3d2098fe, 0x3cf02873,
0x3f75f670, 0x3e08e423, 0x3f5dc6f7, 0x3e8161eb, 0x3f3f4f0b, 0x3eca38e2,
0x3f1ae38f, 0x3f0f2d23, 0x3ee1a5ba, 0x3f3e9a98, 0x3e82cad1, 0x3f7321ac,
0x3e321028, 0x3d4de548, 0x3f537bf6, 0x3ed50f76, 0x3f157845, 0x3f2cf6bc,
0x3ea61288, 0x3f739ea7, 0x3e794186, 0x3d461590, 0x3f41af9f, 0x3f0cdfd4,
0x3ee64058, 0x3f5f23aa, 0x3e53d467, 0x3e037156, 0x3f4b0ae6, 0x3f0e2fac,
0x3ee3a0a8, 0x3f6ab111, 0x3e94b1ed, 0x3daa7774, 0x3f35a70a, 0x3f2d08dc,
0x3d951fb4, 0x3ea5ee48, 0x3f6d5c09, 0x3ef61e1a, 0x3f04f0f3, 0x3f66305c,
0x3ea7def9, 0x3dce7d20, 0x3f2c1083, 0x3f44354b, 0x3e5baf49, 0x3e6f2ad2,
0x3f49142e, 0x3f2bfe35, 0x3e0d627b, 0x3ea80396, 0x3f5ca761, 0x3f1ce830,
0x3dc4d786, 0x3ec62fa0, 0x3f67650f, 0x3f165fc0, 0x3db1323f, 0x3ed34080,
0x3f69d9b8, 0x3f17def1, 0x3ddbd6b6, 0x3ed0421e, 0x3f648529, 0x3f20ebbd,
0x3e20901a, 0x3ebe2886, 0x3f57dbf9, 0x3f3116ac, 0x3e6edcc6, 0x3e9dd2a9,
0x3f4448ce, 0x3f47f9a3, 0x3eaba511, 0x3e601974, 0x3f2a2d77, 0x3f6536e2,
0x3eec3842, 0x3d0781f6, 0x3dd648ed, 0x3f09e3df, 0x3f7787e1, 0x3f1c411f,
0x3e45b702, 0x3ec77dc2, 0x3f4e9240, 0x3f47f500, 0x3ebf9c61, 0x3e602c00,
0x3f2031d0, 0x3f78f0f7, 0x3f135547, 0x3e3bcd78, 0x3ce1e12a, 0x3ed95573,
0x3f510ca2, 0x3f4bc3c2, 0x3ed37e77, 0x3d0ded37, 0x3e50f0f8, 0x3f1640c5,
0x3f77212d, 0x3f291bd1, 0x3e94df6c, 0x3eadc85e, 0x3f35904a, 0x3f6cd43b,
0x3f104351, 0x3e52dc63, 0x3d995e26, 0x3edf795f, 0x3f4b48e7, 0x3f5a29e7,
0x3f00963d, 0x3e1fdb2f, 0x3e175865, 0x3efed385, 0x3f580934, 0x3f50466d,
0x3ef30046, 0x3e0e7c6b, 0x3e3ee64e, 0x3f067fdd, 0x3f5c60e5, 0x3f4e9ea4,
0x3ef4f46a, 0x3e1cb596, 0x3e45856f, 0x3f0585cb, 0x3f58d29b, 0x3f54b3ef,
0x3f0309ad, 0x3e48aa5b, 0x3e2d3042, 0x3ef9eca6, 0x3f4dd569, 0x3f6212c4,
0x3f12be68, 0x3e8853a3, 0x3def69e0, 0x3eda8330, 0x3f3bd62e, 0x3f76516a,
0x3f2931b5, 0x3eb98e9b, 0x3d88773c, 0x3d1ae95c, 0x3ead9c96, 0x3f2338b2,
0x3f6ef119, 0x3f46054d, 0x3ef74eba, 0x3e47c83a, 0x3e67eace, 0x3f0458a3,
0x3f4e0df1, 0x3f68e26b, 0x3f207590, 0x3eb1515d, 0x3d8bc852, 0x3db8eca9,
0x3ebf14e0, 0x3f275751, 0x3f6e86f6, 0x3f4ae3f8, 0x3f04e6de, 0x3e7dfcce,
0x3e547020, 0x3ef63244, 0x3f4080cd, 0x3f7aaa80, 0x3f366659, 0x3ee560cb,
0x3e3e1967, 0x3caab00e, 0x3e93334e, 0x3f0d4f9a, 0x3f5079a6, 0x3f6ce5f8,
0x3f2acd10, 0x3ed272ff, 0x3e20a4c5, 0x3d98d042, 0x3eaa65e0, 0x3f16c680,
0x3f57d6cf, 0x3f679a1b, 0x3f278a40, 0x3ecfef5c, 0x3e2381fd, 0x3dc32f28,
0x3eb0eb80, 0x3f180852, 0x3f571f81, 0x3f6a42d8, 0x3f2c1ce8, 0x3edcd9d1,
0x3e44c475, 0x3dade93f, 0x3ea7c630, 0x3f119318, 0x3f4ecee3, 0x3f7467d4,
0x3f380f62, 0x3ef84c54, 0x3e815525, 0x3cb361d7, 0x3d3982c8, 0x3e8fe13b,
0x3f03d9d6, 0x3f3f556d, 0x3f7a64f1, 0x3f4af618, 0x3f10ba30, 0x3eadcbc5,
0x3debbe02, 0x3e5427a0, 0x3ede8b9f, 0x3f291a1d, 0x3f628840, 0x3f646e63,
0x3f2bc86b, 0x3ee70902, 0x3e6e854e, 0x3c83b300, 0x3ddc8cea, 0x3ea86f2a,
0x3f0c7b7f, 0x3f445eac, 0x3f7be268, 0x3f4cf80b, 0x3f162f6e, 0x3ebf8516,
0x3e26c0c2, 0x3e4c1fd5, 0x3ed3a124, 0x3f203d75, 0x3f564fd0, 0x3f73f733,
0x3f3e966d, 0x3f098cbf, 0x3ea9b21c, 0x3e01e917, 0x3d408cd1, 0x3e82d326,
0x3eece682, 0x3f2b26f2, 0x3f5f85ba, 0x3f6c6f56, 0x3f38b733, 0x3f0550d9,
0x3ea47689, 0x3dfbabd7, 0x3d9c8552, 0x3e8e919a, 0x3ef55e4f, 0x3f2dc4bb,
0x3f608a85, 0x3f6cfe84, 0x3f3ad56c, 0x3f08f945, 0x3eaed247, 0x3e189086,
0x3d980be2, 0x3e8a5528, 0x3eee0d76, 0x3f2896dc, 0x3f59dbde, 0x3f75295d,
0x3f4477f6, 0x3f140f14, 0x3ec7dbbd, 0x3e504e0f, 0x3c8fe67e, 0x3d2d6a38,
0x3e6e2028, 0x3ed7e1d9, 0x3f1c1221, 0x3f4bec7c, 0x3f7b80cc, 0x3f553023,
0x3f262589, 0x3eeebd40, 0x3e91b54d, 0x3dd4c6f8, 0x3e2b3f74, 0x3eb3b4ef,
0x3f08a160, 0x3f372559, 0x3f656721, 0x3f6c988d, 0x3f3ed8f9, 0x3f11596d,
0x3ec83270, 0x3e5c5ea4, 0x3d254149, 0x3d9b3b97, 0x3e824e0e, 0x3edd4d25,
0x3f1be6c8, 0x3f48e857, 0x3f75abeb, 0x3f5dcdd1, 0x3f318436, 0x3f0576a0,
0x3eb348db, 0x3e3833fb, 0x3c2bedc9, 0x3e08c8be, 0x3e9cf794, 0x3ef512c0,
0x3f265b92, 0x3f51f301, 0x3f7d5049, 0x3f578bfc, 0x3f2ca136, 0x3f01eecf,
0x3eaee867, 0x3e34c34c, 0x3c490794, 0x3e21d00f, 0x3ea6bd94, 0x3efc2262,
0x3f288bcc, 0x3f52cf2d, 0x3f7cdbe2, 0x3f594d89, 0x3f2fac87, 0x3f064092,
0x3eba1245, 0x3e5016cd, 0x3d335c27, 0x3e1ac9dd, 0x3ea0a6f1, 0x3ef37edc,
0x3f22f6de, 0x3f4bfa4d, 0x3f74ca3e, 0x3f6298cf, 0x3f3a2e5b, 0x3f11f5e8,
0x3ed3ddf9, 0x3e84323c, 0x3dd39eaa, 0x3deb3986, 0x3e8ba34a, 0x3edc142f,
0x3f161103, 0x3f3de6e2, 0x3f658c2b, 0x3f72feac, 0x3f4bb92e, 0x3f24a2e9,
0x3efb76d9, 0x3eae048f, 0x3e41dc34, 0x3d219509, 0x3d50153e, 0x3e511b46,
0x3eb6ba2d, 0x3f024494, 0x3f28fdb9, 0x3f4f88f3, 0x3f75e6af, 0x3f63e8a7,
0x3f3de4a8, 0x3f180cea, 0x3ee4c20e, 0x3e99c134, 0x3e1e2cfc, 0x3c1824f4,
0x3de0bac6, 0x3e8436b1, 0x3ecfe62d, 0x3f0d9ef9, 0x3f331f66, 0x3f5874c1,
0x3f7d9f6c, 0x3f5d6037, 0x3f3889c9, 0x3f13dcea, 0x3edeb27d, 0x3e95fcd3,
0x3e1b303e, 0x3c3075cb, 0x3e0a7f24, 0x3e8eec6e, 0x3ed8462b, 0x3f10a6c1,
0x3f350197, 0x3f5933f1, 0x3f7d3e29, 0x3f5edf68, 0x3f3b246a, 0x3f179088,
0x3ee846d8, 0x3ea1b983, 0x3e36f0d8, 0x3d2c1773, 0x3e048260, 0x3e89b72b,
0x3ed0def0, 0x3f0bdc94, 0x3f2f233e, 0x3f5243ca, 0x3f753e89, 0x3f67ec34,
0x3f453c1d, 0x3f22b0e2, 0x3f004a36, 0x3ebc0f98, 0x3e6fa55d, 0x3dcf7467,
0x3dc09e5f, 0x3e6b0f8d, 0x3eba9e3c, 0x3eff6b94, 0x3f21f834, 0x3f4416a9,
0x3f661173, 0x3f781723, 0x3f5662cf, 0x3f34d14a, 0x3f13624c, 0x3ee42b1a,
0x3ea1d591, 0x3e3f86e3, 0x3d6fa1a1, 0x3cfd1ba9, 0x3e2674c3, 0x3e965d6c,
0x3ed93b69, 0x3f0dea73, 0x3f2f1538, 0x3f501e47, 0x3f7105e6, 0x3f6e33a9,
0x3f4d8e22, 0x3f2d0944, 0x3f0ca4cd, 0x3ed8c0fd, 0x3e98782f, 0x3e30dd66,
0x3d452061, 0x3d8e62bc, 0x3e49c779, 0x3ea5ed78, 0x3ee6b665, 0x3f139f81,
0x3f33c3e8, 0x3f53c8a7, 0x3f73adfa, 0x3f6c8be0, 0x3f4ce4ab, 0x3f2d5c2a,
0x3f0df223, 0x3edd4cb5, 0x3e9ef12d, 0x3e41a276, 0x3d8bb1ba, 0x3d9ba0ff,
0x3e4c6d54, 0x3ea547ab, 0x3ee41bba, 0x3f1159a6, 0x3f30876a, 0x3f4f9762,
0x3f6e89c9, 0x3f72a12b, 0x3f53e942, 0x3f354e46, 0x3f16cffe, 0x3ef0dc6f,
0x3eb45177, 0x3e6ffd59, 0x3def8e9c
};
const int32_t window_hex[] = {
0x00000000, 0x398b03f6, 0x3a61d1c5, 0x3ae0ee32, 0x3b37623a, 0x3b85f871,
0x3bb69d19, 0x3bed453b, 0x3c14d40b, 0x3c35c45b, 0x3c59595d, 0x3c7f7c1d,
0x3c940c13, 0x3ca98d81, 0x3cc039eb, 0x3cd8098d, 0x3cf0f52e, 0x3d057b06,
0x3d1302e6, 0x3d210f33, 0x3d2f9d0e, 0x3d3ea9ba, 0x3d4e3293, 0x3d5e3510,
0x3d6eaebd, 0x3d7f9d38, 0x3d887f19, 0x3d9167b5, 0x3d9a8756, 0x3da3dce9,
0x3dad675d, 0x3db725ab, 0x3dc116cc, 0x3dcb39bf, 0x3dd58d86, 0x3de01126,
0x3deac3a7, 0x3df5a413, 0x3e0058bb, 0x3e05f571, 0x3e0ba7b2, 0x3e116f08,
0x3e174afe, 0x3e1d3b1c, 0x3e233ef0, 0x3e295605, 0x3e2f7fe7, 0x3e35bc23,
0x3e3c0a46, 0x3e4269de, 0x3e48da79, 0x3e4f5ba5, 0x3e55ecf2, 0x3e5c8ded,
0x3e633e26, 0x3e69fd2c, 0x3e70ca8f, 0x3e77a5de, 0x3e7e8eaa, 0x3e82c241,
0x3e86437c, 0x3e89cacd, 0x3e8d57fc, 0x3e90ead3, 0x3e948319, 0x3e982097,
0x3e9bc316, 0x3e9f6a5d, 0x3ea31636, 0x3ea6c66a, 0x3eaa7ac0, 0x3eae3303,
0x3eb1eefa, 0x3eb5ae6f, 0x3eb9712a, 0x3ebd36f6, 0x3ec0ff9b, 0x3ec4cae2,
0x3ec89895, 0x3ecc687d, 0x3ed03a64, 0x3ed40e13, 0x3ed7e354, 0x3edbb9f2,
0x3edf91b5, 0x3ee36a69, 0x3ee743d7, 0x3eeb1dca, 0x3eeef80c, 0x3ef2d267,
0x3ef6aca8, 0x3efa8698, 0x3efe6002, 0x3f011c59, 0x3f03083a, 0x3f04f389,
0x3f06de2d, 0x3f08c80b, 0x3f0ab10a, 0x3f0c990f, 0x3f0e8001, 0x3f1065c6,
0x3f124a45, 0x3f142d65, 0x3f160f0c, 0x3f17ef21, 0x3f19cd8b, 0x3f1baa32,
0x3f1d84fb, 0x3f1f5dd0, 0x3f213498, 0x3f230939, 0x3f24db9d, 0x3f26abaa,
0x3f28794a, 0x3f2a4464, 0x3f2c0ce1, 0x3f2dd2a9, 0x3f2f95a6, 0x3f3155bf,
0x3f3312e0, 0x3f34ccef, 0x3f3683d8, 0x3f383784, 0x3f39e7dd, 0x3f3b94cc,
0x3f3d3e3c, 0x3f3ee418, 0x3f40864a, 0x3f4224bd, 0x3f43bf5c, 0x3f455613,
0x3f46e8cc, 0x3f487774, 0x3f4a01f6, 0x3f4b883f, 0x3f4d0a3b, 0x3f4e87d6,
0x3f5000fe, 0x3f5175a0, 0x3f52e5a9, 0x3f545106, 0x3f55b7a5, 0x3f571975,
0x3f587664, 0x3f59ce60, 0x3f5b2158, 0x3f5c6f3b, 0x3f5db7f9, 0x3f5efb80,
0x3f6039c2, 0x3f6172af, 0x3f62a636, 0x3f63d448, 0x3f64fcd6, 0x3f661fd3,
0x3f673d2e, 0x3f6854db, 0x3f6966ca, 0x3f6a72ef, 0x3f6b793d, 0x3f6c79a5,
0x3f6d741d, 0x3f6e6896, 0x3f6f5706, 0x3f703f5f, 0x3f712198, 0x3f71fda4,
0x3f72d379, 0x3f73a30c, 0x3f746c52, 0x3f752f43, 0x3f75ebd4, 0x3f76a1fc,
0x3f7751b2, 0x3f77faee, 0x3f789da6, 0x3f7939d4, 0x3f79cf6e, 0x3f7a5e6f,
0x3f7ae6cf, 0x3f7b6886, 0x3f7be38f, 0x3f7c57e4, 0x3f7cc57f, 0x3f7d2c5b,
0x3f7d8c72, 0x3f7de5bf, 0x3f7e3840, 0x3f7e83ee, 0x3f7ec8c7, 0x3f7f06c7,
0x3f7f3deb, 0x3f7f6e31, 0x3f7f9795, 0x3f7fba17, 0x3f7fd5b4, 0x3f7fea6b,
0x3f7ff83b, 0x3f7fff23, 0x3f7fff23, 0x3f7ff83b, 0x3f7fea6b, 0x3f7fd5b4,
0x3f7fba17, 0x3f7f9795, 0x3f7f6e31, 0x3f7f3deb, 0x3f7f06c7, 0x3f7ec8c7,
0x3f7e83ee, 0x3f7e3840, 0x3f7de5bf, 0x3f7d8c72, 0x3f7d2c5b, 0x3f7cc57f,
0x3f7c57e4, 0x3f7be38f, 0x3f7b6886, 0x3f7ae6cf, 0x3f7a5e6f, 0x3f79cf6e,
0x3f7939d4, 0x3f789da6, 0x3f77faee, 0x3f7751b2, 0x3f76a1fc, 0x3f75ebd4,
0x3f752f43, 0x3f746c52, 0x3f73a30c, 0x3f72d379, 0x3f71fda4, 0x3f712198,
0x3f703f5f, 0x3f6f5706, 0x3f6e6896, 0x3f6d741d, 0x3f6c79a5, 0x3f6b793d,
0x3f6a72ef, 0x3f6966ca, 0x3f6854db, 0x3f673d2e, 0x3f661fd3, 0x3f64fcd6,
0x3f63d448, 0x3f62a636, 0x3f6172af, 0x3f6039c2, 0x3f5efb80, 0x3f5db7f9,
0x3f5c6f3b, 0x3f5b2158, 0x3f59ce60, 0x3f587664, 0x3f571975, 0x3f55b7a5,
0x3f545106, 0x3f52e5a9, 0x3f5175a0, 0x3f5000fe, 0x3f4e87d6, 0x3f4d0a3b,
0x3f4b883f, 0x3f4a01f6, 0x3f487774, 0x3f46e8cc, 0x3f455613, 0x3f43bf5c,
0x3f4224bd, 0x3f40864a, 0x3f3ee418, 0x3f3d3e3c, 0x3f3b94cc, 0x3f39e7dd,
0x3f383784, 0x3f3683d8, 0x3f34ccef, 0x3f3312e0, 0x3f3155bf, 0x3f2f95a6,
0x3f2dd2a9, 0x3f2c0ce1, 0x3f2a4464, 0x3f28794a, 0x3f26abaa, 0x3f24db9d,
0x3f230939, 0x3f213498, 0x3f1f5dd0, 0x3f1d84fb, 0x3f1baa32, 0x3f19cd8b,
0x3f17ef21, 0x3f160f0c, 0x3f142d65, 0x3f124a45, 0x3f1065c6, 0x3f0e8001,
0x3f0c990f, 0x3f0ab10a, 0x3f08c80b, 0x3f06de2d, 0x3f04f389, 0x3f03083a,
0x3f011c59, 0x3efe6002, 0x3efa8698, 0x3ef6aca8, 0x3ef2d267, 0x3eeef80c,
0x3eeb1dca, 0x3ee743d7, 0x3ee36a69, 0x3edf91b5, 0x3edbb9f2, 0x3ed7e354,
0x3ed40e13, 0x3ed03a64, 0x3ecc687d, 0x3ec89895, 0x3ec4cae2, 0x3ec0ff9b,
0x3ebd36f6, 0x3eb9712a, 0x3eb5ae6f, 0x3eb1eefa, 0x3eae3303, 0x3eaa7ac0,
0x3ea6c66a, 0x3ea31636, 0x3e9f6a5d, 0x3e9bc316, 0x3e982097, 0x3e948319,
0x3e90ead3, 0x3e8d57fc, 0x3e89cacd, 0x3e86437c, 0x3e82c241, 0x3e7e8eaa,
0x3e77a5de, 0x3e70ca8f, 0x3e69fd2c, 0x3e633e26, 0x3e5c8ded, 0x3e55ecf2,
0x3e4f5ba5, 0x3e48da79, 0x3e4269de, 0x3e3c0a46, 0x3e35bc23, 0x3e2f7fe7,
0x3e295605, 0x3e233ef0, 0x3e1d3b1c, 0x3e174afe, 0x3e116f08, 0x3e0ba7b2,
0x3e05f571, 0x3e0058bb, 0x3df5a413, 0x3deac3a7, 0x3de01126, 0x3dd58d86,
0x3dcb39bf, 0x3dc116cc, 0x3db725ab, 0x3dad675d, 0x3da3dce9, 0x3d9a8756,
0x3d9167b5, 0x3d887f19, 0x3d7f9d38, 0x3d6eaebd, 0x3d5e3510, 0x3d4e3293,
0x3d3ea9ba, 0x3d2f9d0e, 0x3d210f33, 0x3d1302e6, 0x3d057b06, 0x3cf0f52e,
0x3cd8098d, 0x3cc039eb, 0x3ca98d81, 0x3c940c13, 0x3c7f7c1d, 0x3c59595d,
0x3c35c45b, 0x3c14d40b, 0x3bed453b, 0x3bb69d19, 0x3b85f871, 0x3b37623a,
0x3ae0ee32, 0x3a61d1c5, 0x398b03f6, 0x00000000
};
const int32_t window_hamm_hex[] = {
0x3da3d70a, 0x3da3f4f1, 0x3da44ea4, 0x3da4e41d, 0x3da5b554, 0x3da6c239,
0x3da80abd, 0x3da98ecb, 0x3dab4e4a, 0x3dad491d, 0x3daf7f25, 0x3db1f03d,
0x3db49c3e, 0x3db782fd, 0x3dbaa449, 0x3dbdfff1, 0x3dc195be, 0x3dc56575,
0x3dc96ed9, 0x3dcdb1a8, 0x3dd22d9d, 0x3dd6e26e, 0x3ddbcfd0, 0x3de0f572,
0x3de65301, 0x3debe825, 0x3df1b484, 0x3df7b7c0, 0x3dfdf176, 0x3e0230a1,
0x3e05835d, 0x3e08f0ba, 0x3e0c7880, 0x3e101a75, 0x3e13d65f, 0x3e17ac00,
0x3e1b9b1b, 0x3e1fa36f, 0x3e23c4bc, 0x3e27febd, 0x3e2c512e, 0x3e30bbc9,
0x3e353e46, 0x3e39d85c, 0x3e3e89c0, 0x3e435226, 0x3e483140, 0x3e4d26be,
0x3e523251, 0x3e5753a7, 0x3e5c8a6b, 0x3e61d64a, 0x3e6736ec, 0x3e6cabfc,
0x3e72351f, 0x3e77d1fd, 0x3e7d8239, 0x3e81a2bc, 0x3e848dae, 0x3e8781c3,
0x3e8a7eca, 0x3e8d8495, 0x3e9092f0, 0x3e93a9ab, 0x3e96c894, 0x3e99ef77,
0x3e9d1e22, 0x3ea05460, 0x3ea391ff, 0x3ea6d6c8, 0x3eaa2286, 0x3ead7505,
0x3eb0ce0f, 0x3eb42d6c, 0x3eb792e6, 0x3ebafe46, 0x3ebe6f54, 0x3ec1e5d9,
0x3ec5619c, 0x3ec8e264, 0x3ecc67f8, 0x3ecff220, 0x3ed380a2, 0x3ed71344,
0x3edaa9cb, 0x3ede43fe, 0x3ee1e1a3, 0x3ee5827d, 0x3ee92653, 0x3eeccce9,
0x3ef07604, 0x3ef42168, 0x3ef7ceda, 0x3efb7e1d, 0x3eff2ef7, 0x3f017096,
0x3f034a3f, 0x3f052459, 0x3f06fec5, 0x3f08d967, 0x3f0ab41f, 0x3f0c8ed0,
0x3f0e695b, 0x3f1043a2, 0x3f121d87, 0x3f13f6ec, 0x3f15cfb4, 0x3f17a7bf,
0x3f197ef0, 0x3f1b5529, 0x3f1d2a4d, 0x3f1efe3d, 0x3f20d0db, 0x3f22a20b,
0x3f2471ae, 0x3f263fa8, 0x3f280bda, 0x3f29d628, 0x3f2b9e74, 0x3f2d64a2,
0x3f2f2895, 0x3f30ea30, 0x3f32a956, 0x3f3465ec, 0x3f361fd4, 0x3f37d6f3,
0x3f398b2d, 0x3f3b3c66, 0x3f3cea83, 0x3f3e9569, 0x3f403cfb, 0x3f41e121,
0x3f4381be, 0x3f451eb8, 0x3f46b7f6, 0x3f484d5d, 0x3f49ded3, 0x3f4b6c3f,
0x3f4cf588, 0x3f4e7a94, 0x3f4ffb4c, 0x3f517796, 0x3f52ef5a, 0x3f546282,
0x3f55d0f4, 0x3f573a9a, 0x3f589f5d, 0x3f59ff26, 0x3f5b59df, 0x3f5caf72,
0x3f5dffc9, 0x3f5f4acf, 0x3f60906f, 0x3f61d093, 0x3f630b29, 0x3f64401b,
0x3f656f57, 0x3f6698c9, 0x3f67bc5d, 0x3f68da03, 0x3f69f1a6, 0x3f6b0337,
0x3f6c0ea3, 0x3f6d13d9, 0x3f6e12c9, 0x3f6f0b62, 0x3f6ffd95, 0x3f70e953,
0x3f71ce8c, 0x3f72ad32, 0x3f738537, 0x3f74568d, 0x3f752127, 0x3f75e4f8,
0x3f76a1f3, 0x3f77580d, 0x3f780739, 0x3f78af6e, 0x3f79509f, 0x3f79eac3,
0x3f7a7dd1, 0x3f7b09be, 0x3f7b8e83, 0x3f7c0c15, 0x3f7c826e, 0x3f7cf187,
0x3f7d5957, 0x3f7db9d8, 0x3f7e1305, 0x3f7e64d7, 0x3f7eaf4a, 0x3f7ef258,
0x3f7f2dfe, 0x3f7f6237, 0x3f7f8f00, 0x3f7fb457, 0x3f7fd239, 0x3f7fe8a4,
0x3f7ff797, 0x3f7fff11, 0x3f7fff11, 0x3f7ff797, 0x3f7fe8a4, 0x3f7fd239,
0x3f7fb457, 0x3f7f8f00, 0x3f7f6237, 0x3f7f2dfe, 0x3f7ef258, 0x3f7eaf4a,
0x3f7e64d7, 0x3f7e1305, 0x3f7db9d8, 0x3f7d5957, 0x3f7cf187, 0x3f7c826e,
0x3f7c0c15, 0x3f7b8e83, 0x3f7b09be, 0x3f7a7dd1, 0x3f79eac3, 0x3f79509f,
0x3f78af6e, 0x3f780739, 0x3f77580d, 0x3f76a1f3, 0x3f75e4f8, 0x3f752127,
0x3f74568d, 0x3f738537, 0x3f72ad32, 0x3f71ce8c, 0x3f70e953, 0x3f6ffd95,
0x3f6f0b62, 0x3f6e12c9, 0x3f6d13d9, 0x3f6c0ea3, 0x3f6b0337, 0x3f69f1a6,
0x3f68da03, 0x3f67bc5d, 0x3f6698c9, 0x3f656f57, 0x3f64401b, 0x3f630b29,
0x3f61d093, 0x3f60906f, 0x3f5f4acf, 0x3f5dffc9, 0x3f5caf72, 0x3f5b59df,
0x3f59ff26, 0x3f589f5d, 0x3f573a9a, 0x3f55d0f4, 0x3f546282, 0x3f52ef5a,
0x3f517796, 0x3f4ffb4c, 0x3f4e7a94, 0x3f4cf588, 0x3f4b6c3f, 0x3f49ded3,
0x3f484d5d, 0x3f46b7f6, 0x3f451eb8, 0x3f4381be, 0x3f41e121, 0x3f403cfb,
0x3f3e9569, 0x3f3cea83, 0x3f3b3c66, 0x3f398b2d, 0x3f37d6f3, 0x3f361fd4,
0x3f3465ec, 0x3f32a956, 0x3f30ea30, 0x3f2f2895, 0x3f2d64a2, 0x3f2b9e74,
0x3f29d628, 0x3f280bda, 0x3f263fa8, 0x3f2471ae, 0x3f22a20b, 0x3f20d0db,
0x3f1efe3d, 0x3f1d2a4d, 0x3f1b5529, 0x3f197ef0, 0x3f17a7bf, 0x3f15cfb4,
0x3f13f6ec, 0x3f121d87, 0x3f1043a2, 0x3f0e695b, 0x3f0c8ed0, 0x3f0ab41f,
0x3f08d967, 0x3f06fec5, 0x3f052459, 0x3f034a3f, 0x3f017096, 0x3eff2ef7,
0x3efb7e1d, 0x3ef7ceda, 0x3ef42168, 0x3ef07604, 0x3eeccce9, 0x3ee92653,
0x3ee5827d, 0x3ee1e1a3, 0x3ede43fe, 0x3edaa9cb, 0x3ed71344, 0x3ed380a2,
0x3ecff220, 0x3ecc67f8, 0x3ec8e264, 0x3ec5619c, 0x3ec1e5d9, 0x3ebe6f54,
0x3ebafe46, 0x3eb792e6, 0x3eb42d6c, 0x3eb0ce0f, 0x3ead7505, 0x3eaa2286,
0x3ea6d6c8, 0x3ea391ff, 0x3ea05460, 0x3e9d1e22, 0x3e99ef77, 0x3e96c894,
0x3e93a9ab, 0x3e9092f0, 0x3e8d8495, 0x3e8a7eca, 0x3e8781c3, 0x3e848dae,
0x3e81a2bc, 0x3e7d8239, 0x3e77d1fd, 0x3e72351f, 0x3e6cabfc, 0x3e6736ec,
0x3e61d64a, 0x3e5c8a6b, 0x3e5753a7, 0x3e523251, 0x3e4d26be, 0x3e483140,
0x3e435226, 0x3e3e89c0, 0x3e39d85c, 0x3e353e46, 0x3e30bbc9, 0x3e2c512e,
0x3e27febd, 0x3e23c4bc, 0x3e1fa36f, 0x3e1b9b1b, 0x3e17ac00, 0x3e13d65f,
0x3e101a75, 0x3e0c7880, 0x3e08f0ba, 0x3e05835d, 0x3e0230a1, 0x3dfdf176,
0x3df7b7c0, 0x3df1b484, 0x3debe825, 0x3de65301, 0x3de0f572, 0x3ddbcfd0,
0x3dd6e26e, 0x3dd22d9d, 0x3dcdb1a8, 0x3dc96ed9, 0x3dc56575, 0x3dc195be,
0x3dbdfff1, 0x3dbaa449, 0x3db782fd, 0x3db49c3e, 0x3db1f03d, 0x3daf7f25,
0x3dad491d, 0x3dab4e4a, 0x3da98ecb, 0x3da80abd, 0x3da6c239, 0x3da5b554,
0x3da4e41d, 0x3da44ea4, 0x3da3f4f1, 0x3da3d70a
};
const int global_cmvn_mean_hex[] = {
0x413d6566, 0x4147923f, 0x4156ab15, 0x41613d12, 0x416b155b, 0x41722783,
0x4176cd05, 0x4178532a, 0x417aa3c3, 0x417aed19, 0x417d4d2c, 0x417e6abb,
0x41805848, 0x418122ab, 0x41812b23, 0x418161a8, 0x41810ef9, 0x4180863a,
0x41815d8f, 0x417ff8b2, 0x417de2aa, 0x4180a5f2, 0x417e8bd1, 0x418041ac,
0x417f2d60, 0x4180487f, 0x417eb835, 0x418018d8, 0x417ef8c1, 0x417ea302,
0x417f30cf, 0x417ea0bb, 0x417ebac2, 0x417faab6, 0x417fca4d, 0x41805e45,
0x4180e308, 0x4180ef3e, 0x418109fc, 0x4180afa3, 0x418113e2, 0x4180c915,
0x41819f86, 0x418190bf, 0x418220bd, 0x4182f2e5, 0x4183e1c7, 0x41843eec,
0x4184b066, 0x418574db, 0x41852611, 0x4184fc81, 0x41851b2a, 0x4185a1c7,
0x41861152, 0x41868c28, 0x41871930, 0x41871f83, 0x41868893, 0x4185d919,
0x4185664b, 0x418480a6, 0x41840e3a, 0x41836ace, 0x4182b217, 0x4181cb79,
0x4180fb13, 0x418098b9, 0x41805ded, 0x417ff69a, 0x417f49bd, 0x417ecef8,
0x417e286c, 0x417d9135, 0x417cfff4, 0x417ca8f7, 0x417b2e8f, 0x41773788,
0x4170b095, 0x4167417f};
const int global_cmvn_std_hex[] = {
0x4040335e, 0x405235d3, 0x40589be4, 0x4054261f, 0x40544ba2, 0x40575418,
0x405b6528, 0x40617999, 0x40605fcf, 0x405c9c6d, 0x40590796, 0x405899fc,
0x405810b8, 0x40587c40, 0x40592b5e, 0x4057fb12, 0x4057028b, 0x405515d7,
0x4053d714, 0x405418c7, 0x405536bc, 0x4052f54e, 0x4052d382, 0x4051201d,
0x4050a8d2, 0x4050857f, 0x404ffe85, 0x4050a0da, 0x40517a8a, 0x40508862,
0x40504f68, 0x404f3159, 0x404f0930, 0x404e8a2e, 0x404e7383, 0x404eb185,
0x404edaa9, 0x404efed2, 0x404ea8f4, 0x404f6d0d, 0x404ee9d9, 0x404f4cca,
0x404fb13f, 0x405051c5, 0x40503f5e, 0x4050df6e, 0x4052974e, 0x4053d421,
0x40544d48, 0x40544ec8, 0x40550e57, 0x40558287, 0x4055d122, 0x4056b22a,
0x4058ea5c, 0x405acbc3, 0x405a89e7, 0x405a88ed, 0x405afadb, 0x405a1c60,
0x405a6f46, 0x405b0a24, 0x405b5f44, 0x405cc0a9, 0x405d984b, 0x405ef9b8,
0x4061178a, 0x406262bf, 0x40644904, 0x40660b20, 0x4067f7f1, 0x406a35e5,
0x406c1e97, 0x406e16a9, 0x406eadb1, 0x406d0cba, 0x406d9ca0, 0x406f5a14,
0x406e84a7, 0x406cd985};
const int global_cmvn_mean_online_hex[] = {
0x413d5d27, 0x414785ae, 0x4156986a, 0x41612a4e, 0x416b063e, 0x41721c9b,
0x4176c505, 0x41784b5b, 0x417a9575, 0x417adfb2, 0x417d4153, 0x417e611e,
0x41805288, 0x41811c27, 0x4181250c, 0x41815cd4, 0x41810b77, 0x4180817c,
0x41815881, 0x417feaf2, 0x417dd2bf, 0x41809f37, 0x417e7b47, 0x41803a6a,
0x417f1ff4, 0x41804382, 0x417ead10, 0x41801220, 0x417eeb28, 0x417e9801,
0x417f26b9, 0x417e95f9, 0x417eac06, 0x417f9aa5, 0x417fbb16, 0x41805651,
0x4180daaa, 0x4180e84c, 0x41810566, 0x4180ab2c, 0x418111b0, 0x4180c6cc,
0x41819e27, 0x418190cc, 0x4182205c, 0x4182f265, 0x4183e1a2, 0x41844012,
0x4184b0cd, 0x41857447, 0x418527f7, 0x4184fdc6, 0x41851ad2, 0x4185a148,
0x41860f8b, 0x41868888, 0x418712e4, 0x41871702, 0x41867ec3, 0x4185cc48,
0x418559b4, 0x41847855, 0x418408f4, 0x418368f4, 0x4182b718, 0x4181d76d,
0x41810e52, 0x4180b204, 0x418078a4, 0x41801179, 0x417f5579, 0x417e93b7,
0x417d6f2c, 0x417c1a0b, 0x417a6c7a, 0x41787d18, 0x4174eceb, 0x416e3ed3,
0x41644af8, 0x41566dd4
};
const int global_cmvn_std_online_hex[] = {
0x40408fdd, 0x405293b6, 0x4058f2d2, 0x40546ddb, 0x4054984c, 0x4057971b,
0x405ba086, 0x4061afa7, 0x4060a24c, 0x405cbb7e, 0x405923f7, 0x4058c91f,
0x40585cf3, 0x4058c22a, 0x40594960, 0x405824a6, 0x405703f3, 0x40556377,
0x4053e02d, 0x40540a7e, 0x405553c7, 0x4052ead5, 0x4052d23d, 0x40510308,
0x4050a2f3, 0x40505b81, 0x404fed20, 0x4050a372, 0x40515196, 0x40504810,
0x40501fdd, 0x404f2225, 0x404f0931, 0x404e8a2b, 0x404e773b, 0x404ea782,
0x404ee17d, 0x404ef49c, 0x404e884d, 0x404f696b, 0x404edd0e, 0x404f23cc,
0x404f74d4, 0x40501e89, 0x405009f3, 0x4050c422, 0x4052902b, 0x4053987c,
0x40542997, 0x40543695, 0x4054cbef, 0x40553947, 0x4055ab7c, 0x4056887c,
0x4058b710, 0x405a8d28, 0x405a6a27, 0x405a6b3b, 0x405ac8d3, 0x405a031d,
0x405a2158, 0x405abb1b, 0x405b1350, 0x405c98c0, 0x405d5cf9, 0x405ead5b,
0x40609748, 0x4061dfb9, 0x4063aa9f, 0x40655831, 0x40671a35, 0x40694bf5,
0x406b1f59, 0x406cb49b, 0x406cf19e, 0x406b592b, 0x406b757c, 0x406c866d,
0x406ac24f, 0x406678d9
};
const unsigned int paraformer_cmvn_mean_hex[] = {
0xc104fd75, 0xc1099d56, 0xc119dad7, 0xc126f9a7, 0xc133681f, 0xc13e221f,
0xc145cc83, 0xc14a3166, 0xc14e1bda, 0xc14d4a62, 0xc14e41a9, 0xc14f4e7b,
0xc153297e, 0xc1567ee5, 0xc157dbab, 0xc158dfa4, 0xc158e6f9, 0xc1584e70,
0xc15aecea, 0xc15886b8, 0xc156bcb4, 0xc15a7ba9, 0xc1581d34, 0xc15c0a48,
0xc15c463f, 0xc15dfc3b, 0xc15bb28b, 0xc15b4413, 0xc158f8c0, 0xc1588ede,
0xc158c880, 0xc158ff19, 0xc159815a, 0xc159ed72, 0xc15a458d, 0xc15a93d3,
0xc15a06ec, 0xc15953d8, 0xc1592e92, 0xc1579518, 0xc1587d76, 0xc157bc56,
0xc159c47c, 0xc15a5ac4, 0xc15b7286, 0xc15cab60, 0xc15e7f8d, 0xc1607ee5,
0xc162e9ad, 0xc165bdb0, 0xc167bf3e, 0xc169a0a5, 0xc16b4b68, 0xc16d5682,
0xc16ebd51, 0xc170197a, 0xc170d1cc, 0xc1707fc1, 0xc16fd830, 0xc16ec4b1,
0xc16de888, 0xc16d3b06, 0xc16cc155, 0xc16c4e31, 0xc16b6abe, 0xc169cde8,
0xc1684578, 0xc166c2a4, 0xc165d326, 0xc164df46, 0xc163b4ad, 0xc1632d19,
0xc162a94a, 0xc16280fc, 0xc161ae3e, 0xc15fec42, 0xc15cbadc, 0xc15664c3,
0xc14c6d5d, 0xc13b64ae, 0xc104fd75, 0xc1099d56, 0xc119dad7, 0xc126f9a7,
0xc133681f, 0xc13e221f, 0xc145cc83, 0xc14a3166, 0xc14e1bda, 0xc14d4a62,
0xc14e41a9, 0xc14f4e7b, 0xc153297e, 0xc1567ee5, 0xc157dbab, 0xc158dfa4,
0xc158e6f9, 0xc1584e70, 0xc15aecea, 0xc15886b8, 0xc156bcb4, 0xc15a7ba9,
0xc1581d34, 0xc15c0a48, 0xc15c463f, 0xc15dfc3b, 0xc15bb28b, 0xc15b4413,
0xc158f8c0, 0xc1588ede, 0xc158c880, 0xc158ff19, 0xc159815a, 0xc159ed72,
0xc15a458d, 0xc15a93d3, 0xc15a06ec, 0xc15953d8, 0xc1592e92, 0xc1579518,
0xc1587d76, 0xc157bc56, 0xc159c47c, 0xc15a5ac4, 0xc15b7286, 0xc15cab60,
0xc15e7f8d, 0xc1607ee5, 0xc162e9ad, 0xc165bdb0, 0xc167bf3e, 0xc169a0a5,
0xc16b4b68, 0xc16d5682, 0xc16ebd51, 0xc170197a, 0xc170d1cc, 0xc1707fc1,
0xc16fd830, 0xc16ec4b1, 0xc16de888, 0xc16d3b06, 0xc16cc155, 0xc16c4e31,
0xc16b6abe, 0xc169cde8, 0xc1684578, 0xc166c2a4, 0xc165d326, 0xc164df46,
0xc163b4ad, 0xc1632d19, 0xc162a94a, 0xc16280fc, 0xc161ae3e, 0xc15fec42,
0xc15cbadc, 0xc15664c3, 0xc14c6d5d, 0xc13b64ae, 0xc104fd75, 0xc1099d56,
0xc119dad7, 0xc126f9a7, 0xc133681f, 0xc13e221f, 0xc145cc83, 0xc14a3166,
0xc14e1bda, 0xc14d4a62, 0xc14e41a9, 0xc14f4e7b, 0xc153297e, 0xc1567ee5,
0xc157dbab, 0xc158dfa4, 0xc158e6f9, 0xc1584e70, 0xc15aecea, 0xc15886b8,
0xc156bcb4, 0xc15a7ba9, 0xc1581d34, 0xc15c0a48, 0xc15c463f, 0xc15dfc3b,
0xc15bb28b, 0xc15b4413, 0xc158f8c0, 0xc1588ede, 0xc158c880, 0xc158ff19,
0xc159815a, 0xc159ed72, 0xc15a458d, 0xc15a93d3, 0xc15a06ec, 0xc15953d8,
0xc1592e92, 0xc1579518, 0xc1587d76, 0xc157bc56, 0xc159c47c, 0xc15a5ac4,
0xc15b7286, 0xc15cab60, 0xc15e7f8d, 0xc1607ee5, 0xc162e9ad, 0xc165bdb0,
0xc167bf3e, 0xc169a0a5, 0xc16b4b68, 0xc16d5682, 0xc16ebd51, 0xc170197a,
0xc170d1cc, 0xc1707fc1, 0xc16fd830, 0xc16ec4b1, 0xc16de888, 0xc16d3b06,
0xc16cc155, 0xc16c4e31, 0xc16b6abe, 0xc169cde8, 0xc1684578, 0xc166c2a4,
0xc165d326, 0xc164df46, 0xc163b4ad, 0xc1632d19, 0xc162a94a, 0xc16280fc,
0xc161ae3e, 0xc15fec42, 0xc15cbadc, 0xc15664c3, 0xc14c6d5d, 0xc13b64ae,
0xc104fd75, 0xc1099d56, 0xc119dad7, 0xc126f9a7, 0xc133681f, 0xc13e221f,
0xc145cc83, 0xc14a3166, 0xc14e1bda, 0xc14d4a62, 0xc14e41a9, 0xc14f4e7b,
0xc153297e, 0xc1567ee5, 0xc157dbab, 0xc158dfa4, 0xc158e6f9, 0xc1584e70,
0xc15aecea, 0xc15886b8, 0xc156bcb4, 0xc15a7ba9, 0xc1581d34, 0xc15c0a48,
0xc15c463f, 0xc15dfc3b, 0xc15bb28b, 0xc15b4413, 0xc158f8c0, 0xc1588ede,
0xc158c880, 0xc158ff19, 0xc159815a, 0xc159ed72, 0xc15a458d, 0xc15a93d3,
0xc15a06ec, 0xc15953d8, 0xc1592e92, 0xc1579518, 0xc1587d76, 0xc157bc56,
0xc159c47c, 0xc15a5ac4, 0xc15b7286, 0xc15cab60, 0xc15e7f8d, 0xc1607ee5,
0xc162e9ad, 0xc165bdb0, 0xc167bf3e, 0xc169a0a5, 0xc16b4b68, 0xc16d5682,
0xc16ebd51, 0xc170197a, 0xc170d1cc, 0xc1707fc1, 0xc16fd830, 0xc16ec4b1,
0xc16de888, 0xc16d3b06, 0xc16cc155, 0xc16c4e31, 0xc16b6abe, 0xc169cde8,
0xc1684578, 0xc166c2a4, 0xc165d326, 0xc164df46, 0xc163b4ad, 0xc1632d19,
0xc162a94a, 0xc16280fc, 0xc161ae3e, 0xc15fec42, 0xc15cbadc, 0xc15664c3,
0xc14c6d5d, 0xc13b64ae, 0xc104fd75, 0xc1099d56, 0xc119dad7, 0xc126f9a7,
0xc133681f, 0xc13e221f, 0xc145cc83, 0xc14a3166, 0xc14e1bda, 0xc14d4a62,
0xc14e41a9, 0xc14f4e7b, 0xc153297e, 0xc1567ee5, 0xc157dbab, 0xc158dfa4,
0xc158e6f9, 0xc1584e70, 0xc15aecea, 0xc15886b8, 0xc156bcb4, 0xc15a7ba9,
0xc1581d34, 0xc15c0a48, 0xc15c463f, 0xc15dfc3b, 0xc15bb28b, 0xc15b4413,
0xc158f8c0, 0xc1588ede, 0xc158c880, 0xc158ff19, 0xc159815a, 0xc159ed72,
0xc15a458d, 0xc15a93d3, 0xc15a06ec, 0xc15953d8, 0xc1592e92, 0xc1579518,
0xc1587d76, 0xc157bc56, 0xc159c47c, 0xc15a5ac4, 0xc15b7286, 0xc15cab60,
0xc15e7f8d, 0xc1607ee5, 0xc162e9ad, 0xc165bdb0, 0xc167bf3e, 0xc169a0a5,
0xc16b4b68, 0xc16d5682, 0xc16ebd51, 0xc170197a, 0xc170d1cc, 0xc1707fc1,
0xc16fd830, 0xc16ec4b1, 0xc16de888, 0xc16d3b06, 0xc16cc155, 0xc16c4e31,
0xc16b6abe, 0xc169cde8, 0xc1684578, 0xc166c2a4, 0xc165d326, 0xc164df46,
0xc163b4ad, 0xc1632d19, 0xc162a94a, 0xc16280fc, 0xc161ae3e, 0xc15fec42,
0xc15cbadc, 0xc15664c3, 0xc14c6d5d, 0xc13b64ae, 0xc104fd75, 0xc1099d56,
0xc119dad7, 0xc126f9a7, 0xc133681f, 0xc13e221f, 0xc145cc83, 0xc14a3166,
0xc14e1bda, 0xc14d4a62, 0xc14e41a9, 0xc14f4e7b, 0xc153297e, 0xc1567ee5,
0xc157dbab, 0xc158dfa4, 0xc158e6f9, 0xc1584e70, 0xc15aecea, 0xc15886b8,
0xc156bcb4, 0xc15a7ba9, 0xc1581d34, 0xc15c0a48, 0xc15c463f, 0xc15dfc3b,
0xc15bb28b, 0xc15b4413, 0xc158f8c0, 0xc1588ede, 0xc158c880, 0xc158ff19,
0xc159815a, 0xc159ed72, 0xc15a458d, 0xc15a93d3, 0xc15a06ec, 0xc15953d8,
0xc1592e92, 0xc1579518, 0xc1587d76, 0xc157bc56, 0xc159c47c, 0xc15a5ac4,
0xc15b7286, 0xc15cab60, 0xc15e7f8d, 0xc1607ee5, 0xc162e9ad, 0xc165bdb0,
0xc167bf3e, 0xc169a0a5, 0xc16b4b68, 0xc16d5682, 0xc16ebd51, 0xc170197a,
0xc170d1cc, 0xc1707fc1, 0xc16fd830, 0xc16ec4b1, 0xc16de888, 0xc16d3b06,
0xc16cc155, 0xc16c4e31, 0xc16b6abe, 0xc169cde8, 0xc1684578, 0xc166c2a4,
0xc165d326, 0xc164df46, 0xc163b4ad, 0xc1632d19, 0xc162a94a, 0xc16280fc,
0xc161ae3e, 0xc15fec42, 0xc15cbadc, 0xc15664c3, 0xc14c6d5d, 0xc13b64ae,
0xc104fd75, 0xc1099d56, 0xc119dad7, 0xc126f9a7, 0xc133681f, 0xc13e221f,
0xc145cc83, 0xc14a3166, 0xc14e1bda, 0xc14d4a62, 0xc14e41a9, 0xc14f4e7b,
0xc153297e, 0xc1567ee5, 0xc157dbab, 0xc158dfa4, 0xc158e6f9, 0xc1584e70,
0xc15aecea, 0xc15886b8, 0xc156bcb4, 0xc15a7ba9, 0xc1581d34, 0xc15c0a48,
0xc15c463f, 0xc15dfc3b, 0xc15bb28b, 0xc15b4413, 0xc158f8c0, 0xc1588ede,
0xc158c880, 0xc158ff19, 0xc159815a, 0xc159ed72, 0xc15a458d, 0xc15a93d3,
0xc15a06ec, 0xc15953d8, 0xc1592e92, 0xc1579518, 0xc1587d76, 0xc157bc56,
0xc159c47c, 0xc15a5ac4, 0xc15b7286, 0xc15cab60, 0xc15e7f8d, 0xc1607ee5,
0xc162e9ad, 0xc165bdb0, 0xc167bf3e, 0xc169a0a5, 0xc16b4b68, 0xc16d5682,
0xc16ebd51, 0xc170197a, 0xc170d1cc, 0xc1707fc1, 0xc16fd830, 0xc16ec4b1,
0xc16de888, 0xc16d3b06, 0xc16cc155, 0xc16c4e31, 0xc16b6abe, 0xc169cde8,
0xc1684578, 0xc166c2a4, 0xc165d326, 0xc164df46, 0xc163b4ad, 0xc1632d19,
0xc162a94a, 0xc16280fc, 0xc161ae3e, 0xc15fec42, 0xc15cbadc, 0xc15664c3,
0xc14c6d5d, 0xc13b64ae};
const unsigned int paraformer_cmvn_var_hex[] = {
0x40619618, 0x405fb77c, 0x405d3028, 0x405bef11, 0x405a189d, 0x4057aad5,
0x4054f9cc, 0x40518e8c, 0x404fffdd, 0x40510d0d, 0x4052400d, 0x4052bab0,
0x40526416, 0x40515cb8, 0x40506aee, 0x404fef8d, 0x404ff527, 0x40505b95,
0x4050d61c, 0x4051d0a5, 0x4052abd2, 0x4052f14b, 0x4053d196, 0x4054800d,
0x405545f2, 0x4055d71f, 0x40567588, 0x4056de4d, 0x40579b72, 0x40584d35,
0x4058cd2f, 0x40594731, 0x4059a53f, 0x405a00ed, 0x405a34c1, 0x405a406e,
0x405a1748, 0x405a0300, 0x405a1547, 0x405a66a7, 0x405a9be4, 0x405b04b2,
0x405b5754, 0x405b9189, 0x405b9016, 0x405b7a07, 0x405b63f9, 0x405b3f45,
0x405b0cb4, 0x405ac80b, 0x405ac1f7, 0x405abbd9, 0x405ac86a, 0x405ad72b,
0x405af2f0, 0x405ab465, 0x405a6364, 0x405a1350, 0x4059baa3, 0x4059911d,
0x40597921, 0x40595564, 0x40593b8d, 0x4059310f, 0x40594e46, 0x40599bae,
0x4059e703, 0x4059feec, 0x405a053a, 0x4059feaa, 0x4059d7a0, 0x40599386,
0x40592d0e, 0x4058ce4c, 0x40587335, 0x4058396a, 0x40584ee1, 0x4058925a,
0x40592f6d, 0x405a9f0a, 0x40619618, 0x405fb77c, 0x405d3028, 0x405bef11,
0x405a189d, 0x4057aad5, 0x4054f9cc, 0x40518e8c, 0x404fffdd, 0x40510d0d,
0x4052400d, 0x4052bab0, 0x40526416, 0x40515cb8, 0x40506aee, 0x404fef8d,
0x404ff527, 0x40505b95, 0x4050d61c, 0x4051d0a5, 0x4052abd2, 0x4052f14b,
0x4053d196, 0x4054800d, 0x405545f2, 0x4055d71f, 0x40567588, 0x4056de4d,
0x40579b72, 0x40584d35, 0x4058cd2f, 0x40594731, 0x4059a53f, 0x405a00ed,
0x405a34c1, 0x405a406e, 0x405a1748, 0x405a0300, 0x405a1547, 0x405a66a7,
0x405a9be4, 0x405b04b2, 0x405b5754, 0x405b9189, 0x405b9016, 0x405b7a07,
0x405b63f9, 0x405b3f45, 0x405b0cb4, 0x405ac80b, 0x405ac1f7, 0x405abbd9,
0x405ac86a, 0x405ad72b, 0x405af2f0, 0x405ab465, 0x405a6364, 0x405a1350,
0x4059baa3, 0x4059911d, 0x40597921, 0x40595564, 0x40593b8d, 0x4059310f,
0x40594e46, 0x40599bae, 0x4059e703, 0x4059feec, 0x405a053a, 0x4059feaa,
0x4059d7a0, 0x40599386, 0x40592d0e, 0x4058ce4c, 0x40587335, 0x4058396a,
0x40584ee1, 0x4058925a, 0x40592f6d, 0x405a9f0a, 0x40619618, 0x405fb77c,
0x405d3028, 0x405bef11, 0x405a189d, 0x4057aad5, 0x4054f9cc, 0x40518e8c,
0x404fffdd, 0x40510d0d, 0x4052400d, 0x4052bab0, 0x40526416, 0x40515cb8,
0x40506aee, 0x404fef8d, 0x404ff527, 0x40505b95, 0x4050d61c, 0x4051d0a5,
0x4052abd2, 0x4052f14b, 0x4053d196, 0x4054800d, 0x405545f2, 0x4055d71f,
0x40567588, 0x4056de4d, 0x40579b72, 0x40584d35, 0x4058cd2f, 0x40594731,
0x4059a53f, 0x405a00ed, 0x405a34c1, 0x405a406e, 0x405a1748, 0x405a0300,
0x405a1547, 0x405a66a7, 0x405a9be4, 0x405b04b2, 0x405b5754, 0x405b9189,
0x405b9016, 0x405b7a07, 0x405b63f9, 0x405b3f45, 0x405b0cb4, 0x405ac80b,
0x405ac1f7, 0x405abbd9, 0x405ac86a, 0x405ad72b, 0x405af2f0, 0x405ab465,
0x405a6364, 0x405a1350, 0x4059baa3, 0x4059911d, 0x40597921, 0x40595564,
0x40593b8d, 0x4059310f, 0x40594e46, 0x40599bae, 0x4059e703, 0x4059feec,
0x405a053a, 0x4059feaa, 0x4059d7a0, 0x40599386, 0x40592d0e, 0x4058ce4c,
0x40587335, 0x4058396a, 0x40584ee1, 0x4058925a, 0x40592f6d, 0x405a9f0a,
0x40619618, 0x405fb77c, 0x405d3028, 0x405bef11, 0x405a189d, 0x4057aad5,
0x4054f9cc, 0x40518e8c, 0x404fffdd, 0x40510d0d, 0x4052400d, 0x4052bab0,
0x40526416, 0x40515cb8, 0x40506aee, 0x404fef8d, 0x404ff527, 0x40505b95,
0x4050d61c, 0x4051d0a5, 0x4052abd2, 0x4052f14b, 0x4053d196, 0x4054800d,
0x405545f2, 0x4055d71f, 0x40567588, 0x4056de4d, 0x40579b72, 0x40584d35,
0x4058cd2f, 0x40594731, 0x4059a53f, 0x405a00ed, 0x405a34c1, 0x405a406e,
0x405a1748, 0x405a0300, 0x405a1547, 0x405a66a7, 0x405a9be4, 0x405b04b2,
0x405b5754, 0x405b9189, 0x405b9016, 0x405b7a07, 0x405b63f9, 0x405b3f45,
0x405b0cb4, 0x405ac80b, 0x405ac1f7, 0x405abbd9, 0x405ac86a, 0x405ad72b,
0x405af2f0, 0x405ab465, 0x405a6364, 0x405a1350, 0x4059baa3, 0x4059911d,
0x40597921, 0x40595564, 0x40593b8d, 0x4059310f, 0x40594e46, 0x40599bae,
0x4059e703, 0x4059feec, 0x405a053a, 0x4059feaa, 0x4059d7a0, 0x40599386,
0x40592d0e, 0x4058ce4c, 0x40587335, 0x4058396a, 0x40584ee1, 0x4058925a,
0x40592f6d, 0x405a9f0a, 0x40619618, 0x405fb77c, 0x405d3028, 0x405bef11,
0x405a189d, 0x4057aad5, 0x4054f9cc, 0x40518e8c, 0x404fffdd, 0x40510d0d,
0x4052400d, 0x4052bab0, 0x40526416, 0x40515cb8, 0x40506aee, 0x404fef8d,
0x404ff527, 0x40505b95, 0x4050d61c, 0x4051d0a5, 0x4052abd2, 0x4052f14b,
0x4053d196, 0x4054800d, 0x405545f2, 0x4055d71f, 0x40567588, 0x4056de4d,
0x40579b72, 0x40584d35, 0x4058cd2f, 0x40594731, 0x4059a53f, 0x405a00ed,
0x405a34c1, 0x405a406e, 0x405a1748, 0x405a0300, 0x405a1547, 0x405a66a7,
0x405a9be4, 0x405b04b2, 0x405b5754, 0x405b9189, 0x405b9016, 0x405b7a07,
0x405b63f9, 0x405b3f45, 0x405b0cb4, 0x405ac80b, 0x405ac1f7, 0x405abbd9,
0x405ac86a, 0x405ad72b, 0x405af2f0, 0x405ab465, 0x405a6364, 0x405a1350,
0x4059baa3, 0x4059911d, 0x40597921, 0x40595564, 0x40593b8d, 0x4059310f,
0x40594e46, 0x40599bae, 0x4059e703, 0x4059feec, 0x405a053a, 0x4059feaa,
0x4059d7a0, 0x40599386, 0x40592d0e, 0x4058ce4c, 0x40587335, 0x4058396a,
0x40584ee1, 0x4058925a, 0x40592f6d, 0x405a9f0a, 0x40619618, 0x405fb77c,
0x405d3028, 0x405bef11, 0x405a189d, 0x4057aad5, 0x4054f9cc, 0x40518e8c,
0x404fffdd, 0x40510d0d, 0x4052400d, 0x4052bab0, 0x40526416, 0x40515cb8,
0x40506aee, 0x404fef8d, 0x404ff527, 0x40505b95, 0x4050d61c, 0x4051d0a5,
0x4052abd2, 0x4052f14b, 0x4053d196, 0x4054800d, 0x405545f2, 0x4055d71f,
0x40567588, 0x4056de4d, 0x40579b72, 0x40584d35, 0x4058cd2f, 0x40594731,
0x4059a53f, 0x405a00ed, 0x405a34c1, 0x405a406e, 0x405a1748, 0x405a0300,
0x405a1547, 0x405a66a7, 0x405a9be4, 0x405b04b2, 0x405b5754, 0x405b9189,
0x405b9016, 0x405b7a07, 0x405b63f9, 0x405b3f45, 0x405b0cb4, 0x405ac80b,
0x405ac1f7, 0x405abbd9, 0x405ac86a, 0x405ad72b, 0x405af2f0, 0x405ab465,
0x405a6364, 0x405a1350, 0x4059baa3, 0x4059911d, 0x40597921, 0x40595564,
0x40593b8d, 0x4059310f, 0x40594e46, 0x40599bae, 0x4059e703, 0x4059feec,
0x405a053a, 0x4059feaa, 0x4059d7a0, 0x40599386, 0x40592d0e, 0x4058ce4c,
0x40587335, 0x4058396a, 0x40584ee1, 0x4058925a, 0x40592f6d, 0x405a9f0a,
0x40619618, 0x405fb77c, 0x405d3028, 0x405bef11, 0x405a189d, 0x4057aad5,
0x4054f9cc, 0x40518e8c, 0x404fffdd, 0x40510d0d, 0x4052400d, 0x4052bab0,
0x40526416, 0x40515cb8, 0x40506aee, 0x404fef8d, 0x404ff527, 0x40505b95,
0x4050d61c, 0x4051d0a5, 0x4052abd2, 0x4052f14b, 0x4053d196, 0x4054800d,
0x405545f2, 0x4055d71f, 0x40567588, 0x4056de4d, 0x40579b72, 0x40584d35,
0x4058cd2f, 0x40594731, 0x4059a53f, 0x405a00ed, 0x405a34c1, 0x405a406e,
0x405a1748, 0x405a0300, 0x405a1547, 0x405a66a7, 0x405a9be4, 0x405b04b2,
0x405b5754, 0x405b9189, 0x405b9016, 0x405b7a07, 0x405b63f9, 0x405b3f45,
0x405b0cb4, 0x405ac80b, 0x405ac1f7, 0x405abbd9, 0x405ac86a, 0x405ad72b,
0x405af2f0, 0x405ab465, 0x405a6364, 0x405a1350, 0x4059baa3, 0x4059911d,
0x40597921, 0x40595564, 0x40593b8d, 0x4059310f, 0x40594e46, 0x40599bae,
0x4059e703, 0x4059feec, 0x405a053a, 0x4059feaa, 0x4059d7a0, 0x40599386,
0x40592d0e, 0x4058ce4c, 0x40587335, 0x4058396a, 0x40584ee1, 0x4058925a,
0x40592f6d, 0x405a9f0a
};
const int pos_enc_coe_hex[] = {
0x3f800000, 0x3f84b063, 0x3f898cc0, 0x3f8e96b2, 0x3f93cfe5, 0x3f993a15,
0x3f9ed70c, 0x3fa4a8a8, 0x3faab0d5, 0x3fb0f193, 0x3fb76cf5, 0x3fbe2520,
0x3fc51c50, 0x3fcc54d2, 0x3fd3d10c, 0x3fdb9378, 0x3fe39ea9, 0x3febf549,
0x3ff49a1b, 0x3ffd8ffe, 0x40036cf4, 0x40083d78, 0x400d3b22, 0x40126799,
0x4017c496, 0x401d53df, 0x4023174b, 0x402910c4, 0x402f4244, 0x4035adda,
0x403c55a4, 0x40433bd9, 0x404a62c2, 0x4051ccbd, 0x40597c3f, 0x406173d4,
0x4069b621, 0x407245e2, 0x407b25ed, 0x40822c9a, 0x4086f161, 0x408be2e0,
0x409102bc, 0x409652a6, 0x409bd461, 0x40a189c1, 0x40a774aa, 0x40ad9711,
0x40b3f300, 0x40ba8a92, 0x40c15ff6, 0x40c8756f, 0x40cfcd58, 0x40d76a1e,
0x40df4e48, 0x40e77c73, 0x40eff755, 0x40f8c1be, 0x4100ef4c, 0x4105a873,
0x410a8de6, 0x410fa144, 0x4114e43b, 0x411a588a, 0x41200000, 0x4125dc7c,
0x412beff0, 0x41323c5f, 0x4138c3df, 0x413f889a, 0x41468cd0, 0x414dd2d2,
0x41555d0a, 0x415d2df7, 0x41654832, 0x416dae69, 0x41766364, 0x417f6a07,
0x418462a7, 0x41893c2b, 0x418e432a, 0x4193794e, 0x4198e051, 0x419e79ff,
0x41a44831, 0x41aa4cd6, 0x41b089ea, 0x41b70180, 0x41bdb5bc, 0x41c4a8d7,
0x41cbdd1e, 0x41d354f5, 0x41db12d6, 0x41e31950, 0x41eb6b0d, 0x41f40ad0,
0x41fcfb72, 0x42031ff6, 0x4207eda7, 0x420ce865, 0x421211d5, 0x42176bad,
0x421cf7b4, 0x4222b7c0, 0x4228adb9, 0x422edb98, 0x4235436b, 0x423be74f,
0x4242c979, 0x4249ec31, 0x425151d4, 0x4258fcd6, 0x4260efc0, 0x42692d37,
0x4271b7f3, 0x427a92cb, 0x4281e057, 0x4286a253, 0x428b90ed, 0x4290adc8,
0x4295fa95, 0x429b7917, 0x42a12b1f, 0x42a71290, 0x42ad3160, 0x42b38995,
0x42ba1d4a, 0x42c0eead, 0x42c80000, 0x42cf539b, 0x42d6ebec, 0x42decb76,
0x42e6f4d6, 0x42ef6ac1, 0x42f83003, 0x4300a3c3, 0x43055a26, 0x430a3cbb,
0x430f4d1f, 0x43148d01, 0x4319fe1e, 0x431fa244, 0x43257b51, 0x432b8b36,
0x4331d3f4, 0x433857a1, 0x433f1865, 0x4346187e, 0x434d5a3e, 0x4354e00b,
0x435cac64, 0x4364c1e0, 0x436d232b, 0x4375d30c, 0x437ed466, 0x43841519,
0x4388ebc5, 0x438defd2, 0x439322e8, 0x439886c2, 0x439e1d27, 0x43a3e7f3,
0x43a9e911, 0x43b0227e, 0x43b6964a, 0x43bd4698, 0x43c435a1, 0x43cb65b0,
0x43d2d927, 0x43da927e, 0x43e29445, 0x43eae123, 0x43f37bd8, 0x43fc673e,
0x4402d325, 0x44079e06, 0x440c95d8, 0x4411bc42, 0x441712f8, 0x441c9bbf,
0x4422586d, 0x44284ae8, 0x442e7528, 0x4434d93a, 0x443b793b, 0x4442575d,
0x444975e6, 0x4450d734, 0x44587db7, 0x44606bfa, 0x4468a49c, 0x44712a58,
0x447a0000, 0x44819441, 0x44865373, 0x448b3f2a, 0x44905906, 0x4495a2b9,
0x449b1e02, 0x44a0ccb4, 0x44a6b0b0, 0x44accbe9, 0x44b32067, 0x44b9b042,
0x44c07da6, 0x44c78ad5, 0x44ceda26, 0x44d66e03, 0x44de48f1, 0x44e66d89,
0x44eede7f, 0x44f79e9e, 0x45005867, 0x45050c07, 0x4509ebbf, 0x450ef92c,
0x451435fb, 0x4519a3e8, 0x451f44bf, 0x45251a60, 0x452b26b7, 0x45316bc7,
0x4537eba3, 0x453ea872, 0x4545a471, 0x454ce1f0, 0x45546355, 0x455c2b1d,
0x45643bdc, 0x456c983e, 0x45754309, 0x457e3f1c, 0x4583c7b8, 0x45889b8f,
0x458d9cab, 0x4592ccb6, 0x45982d67, 0x459dc087, 0x45a387ee, 0x45a98587,
0x45afbb4e, 0x45b62b53, 0x45bcd7b6, 0x45c3c2af, 0x45caee88, 0x45d25da1,
0x45da1272, 0x45e20f88, 0x45ea5789, 0x45f2ed34, 0x45fbd360, 0x46028680,
0x46074e93, 0x460c437c, 0x461166e2, 0x4616ba77};
const int pos_enc_div_term_hex[] = {
0x3f800000, 0x3f76f410, 0x3f6e39f8, 0x3f65ced3, 0x3f5dafd7, 0x3f55da52,
0x3f4e4bac, 0x3f470165, 0x3f3ff911, 0x3f39305c, 0x3f32a506, 0x3f2c54e5,
0x3f263de0, 0x3f205df3, 0x3f1ab32b, 0x3f153ba8, 0x3f0ff59a, 0x3f0adf41,
0x3f05f6ee, 0x3f013b01, 0x3ef953cf, 0x3ef0843c, 0x3ee80460, 0x3edfd167,
0x3ed7e89b, 0x3ed0475c, 0x3ec8eb24, 0x3ec1d181, 0x3ebaf81a, 0x3eb45caa,
0x3eadfcff, 0x3ea7d6fd, 0x3ea1e89b, 0x3e9c2fe1, 0x3e96aaea, 0x3e9157e1,
0x3e8c3504, 0x3e87409d, 0x3e827909, 0x3e7bb965, 0x3e72d424, 0x3e6a3f5c,
0x3e61f836, 0x3e59fbf3, 0x3e5247ed, 0x3e4ad998, 0x3e43ae7c, 0x3e3cc43a,
0x3e361887, 0x3e2fa92d, 0x3e29740a, 0x3e23770f, 0x3e1db040, 0x3e181db4,
0x3e12bd91, 0x3e0d8e0f, 0x3e088d77, 0x3e03ba20, 0x3dfe24e1, 0x3df529bb,
0x3dec7fd5, 0x3de42450, 0x3ddc1466, 0x3dd44d6c, 0x3dcccccd, 0x3dc5900d,
0x3dbe94c7, 0x3db7d8a9, 0x3db15978, 0x3dab150e, 0x3da50957, 0x3d9f3451,
0x3d99940e, 0x3d9426b0, 0x3d8eea6c, 0x3d89dd84, 0x3d84fe4d, 0x3d804b29,
0x3d778512, 0x3d6ec5da, 0x3d6655c3, 0x3d5e3202, 0x3d5657e4, 0x3d4ec4ce,
0x3d47763f, 0x3d4069ca, 0x3d399d19, 0x3d330dec, 0x3d2cba15, 0x3d269f7d,
0x3d20bc1d, 0x3d1b0e01, 0x3d159348, 0x3d104a21, 0x3d0b30cc, 0x3d064597,
0x3d0186e2, 0x3cf9e635, 0x3cf11176, 0x3ce88c9c, 0x3ce054d2, 0x3cd86761,
0x3cd0c1a8, 0x3cc9611d, 0x3cc24350, 0x3cbb65e3, 0x3cb4c691, 0x3cae6328,
0x3ca8398b, 0x3ca247ad, 0x3c9c8b97, 0x3c970362, 0x3c91ad39, 0x3c8c8757,
0x3c879008, 0x3c82c5a5, 0x3c7c4d33, 0x3c7362b9, 0x3c6ac8e7, 0x3c627ce5,
0x3c5a7bf1, 0x3c52c366, 0x3c4b50b4, 0x3c442163, 0x3c3d3311, 0x3c368373,
0x3c301052, 0x3c29d789, 0x3c23d70a, 0x3c1e0cd7, 0x3c187705, 0x3c1313ba,
0x3c0de12d, 0x3c08dda5, 0x3c040779, 0x3bfeba1b, 0x3bf5b9b0, 0x3bed0ab3,
0x3be4aa46, 0x3bdc95a0, 0x3bd4ca14, 0x3bcd450e, 0x3bc6040e, 0x3bbf04ae,
0x3bb8449c, 0x3bb1c19b, 0x3bab7983, 0x3ba56a3f, 0x3b9f91cc, 0x3b99ee3b,
0x3b947dae, 0x3b8f3e56, 0x3b8a2e77, 0x3b854c64, 0x3b80967d, 0x3b781668,
0x3b6f520d, 0x3b66dd02, 0x3b5eb47a, 0x3b56d5bf, 0x3b4f3e37, 0x3b47eb5e,
0x3b40dac5, 0x3b3a0a16, 0x3b33770f, 0x3b2d1f81, 0x3b270153, 0x3b211a7e,
0x3b1b690d, 0x3b15eb1c, 0x3b109edb, 0x3b0b8287, 0x3b06946f, 0x3b01d2f1,
0x3afa78f1, 0x3af19f03, 0x3ae91528, 0x3ae0d88b, 0x3ad8e673, 0x3ad13c3c,
0x3ac9d75c, 0x3ac2b561, 0x3abbd3ec, 0x3ab530b7, 0x3aaec98e, 0x3aa89c52,
0x3aa2a6f6, 0x3a9ce782, 0x3a975c0e, 0x3a9202c3, 0x3a8cd9db, 0x3a87dfa1,
0x3a83126f, 0x3a7ce158, 0x3a73f1a2, 0x3a6b52c4, 0x3a6301e2, 0x3a5afc3b,
0x3a533f27, 0x3a4bc816, 0x3a44948c, 0x3a3da229, 0x3a36ee9e, 0x3a3077b3,
0x3a2a3b43, 0x3a24373e, 0x3a1e69a5, 0x3a18d08b, 0x3a136a16, 0x3a0e347c,
0x3a092e02, 0x3a0454ff, 0x39ff4fad, 0x39f649f8, 0x39ed95e3, 0x39e5308a,
0x39dd1726, 0x39d54706, 0x39cdbd95, 0x39c67853, 0x39bf74d7, 0x39b8b0cf,
0x39b229fb, 0x39abde33, 0x39a5cb5f, 0x399fef7e, 0x399a489e, 0x3994d4df,
0x398f9272, 0x398a7f9b, 0x39859aa9, 0x3980e1fe, 0x3978a814, 0x396fde93,
0x39676491, 0x395f373e, 0x395753e5, 0x394fb7e7, 0x394860c1, 0x39414c02,
0x393a7753, 0x3933e06f, 0x392d8529, 0x39276363, 0x39217917, 0x391bc44d,
0x39164323, 0x3910f3c6, 0x390bd472, 0x3906e374, 0x39021f2b, 0x38fb0c03,
0x38f22ce3, 0x38e99e04, 0x38e15c92, 0x38d965ce};
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment