1 #include "audio/wave_reader.h"
2 #include "audio/wave_writer.h"
3 #include "rkaudio_preprocess.h"
4 #include "rkaudio_sed.h"
5
6 #include <time.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string>
10 #include <string.h>
11 #include <assert.h>
12 #include <iostream>
13
14 #ifndef IN_SIZE
15 #define IN_SIZE 256
16 #endif
17
18 #define ENABLE_WAKEUP 0
19 #define ENABLE_COMMAND 0
20
21 #define Single_TEST 1
22 //#define Array_SET
23 typedef unsigned char SKV_BYTE;
24 #define ENABLE_DBG 0
25 //#define ENABLE_RX
26 #include <errno.h>
27 #include <dlfcn.h>
28
29
test_cmd()30 int test_cmd()
31 {
32 printf("\nin cmd test\n");
33 char* in_filename = (char*)"test_16k_2mic_cmd.wav";;
34 char* out_filename = (char*)"test_16k_2mic_cmd_out.wav";
35 // for wave reader
36 wave_reader* wr;
37 wave_reader_error rerror;
38
39 // for wave writer
40 wave_writer* ww;
41 wave_writer_error werror;
42 wave_writer_format format;
43
44 #if ENABLE_WAKEUP && ENABLE_COMMAND
45 int num_wakeup = 0;
46 int cmd_id = 0;
47 float asr_score = 0.0f, cmd_score = 0.0f;
48 #endif
49 int is_wakeup = 0;
50
51 wr = wave_reader_open(in_filename, &rerror);
52 if (!wr) {
53 printf("rerror=%d\n", rerror);
54 return -1;
55 }
56 clock_t startTime, endTime;
57 double Total_time = 0.0;
58 double Total_sample = 0.0;
59 float Spe_time = 0.0;
60
61 printf("filename=%s format=%d num_channels=%d sample_rate=%d sample_bits=%d num_samples=%d\n",in_filename,wave_reader_get_format(wr),
62 wave_reader_get_num_channels(wr),wave_reader_get_sample_rate(wr),wave_reader_get_sample_bits(wr),wave_reader_get_num_samples(wr));
63
64 int mSampleRate = wave_reader_get_sample_rate(wr);
65 int mBitPerSample = wave_reader_get_sample_bits(wr);
66 int mNumChannel = wave_reader_get_num_channels(wr);
67 int num_ref_channel = NUM_REF_CHANNEL;
68 int num_src_channel = mNumChannel - NUM_REF_CHANNEL;
69 printf("ref = %d, src=%d\n", num_ref_channel, num_src_channel);
70 int read_size = IN_SIZE * mNumChannel * mBitPerSample / 8;
71 SKV_BYTE* in = (SKV_BYTE*)malloc(read_size * sizeof(SKV_BYTE));
72 short* out = (short*)malloc(IN_SIZE * 1 * sizeof(short));
73 format.num_channels = 1;
74 format.sample_rate = wave_reader_get_sample_rate(wr);
75 format.sample_bits = wave_reader_get_sample_bits(wr);
76 ww = wave_writer_open(out_filename, &format, &werror);
77 if (!ww)
78 {
79 printf("werror=%d\n", werror);
80
81 wave_reader_close(wr);
82 return -1;
83 }
84 //rkaudio_asr_set_param(0.3, 0.72, 0.5);
85 RKAUDIOParam param;
86 memset(¶m, 0, sizeof(RKAUDIOParam));
87 param.model_en = RKAUDIO_EN_BF;
88 param.aec_param = rkaudio_aec_param_init();
89 param.bf_param = rkaudio_preprocess_param_init();
90 param.rx_param = rkaudio_rx_param_init();
91 void* st_ptr = NULL;
92
93 st_ptr = rkaudio_preprocess_init(mSampleRate, mBitPerSample, num_src_channel, num_ref_channel, ¶m);
94
95 if (st_ptr == NULL)
96 {
97 printf("Failed to create audio preprocess handle\n");
98 return -1;
99 }
100
101 int cnt = 0, in_size, out_size, res, frame_cot = 0;
102 startTime = clock();
103 while (0 < (res = wave_reader_get_samples(wr, IN_SIZE, in)))
104 {
105 cnt++;
106 in_size = res * (mBitPerSample / 16) * mNumChannel;
107 out_size = rkaudio_preprocess_short(st_ptr, (short*)in, out, in_size, &is_wakeup);
108 int targ_Doa = rkaudio_Doa_invoke(st_ptr);
109 int targ_ang , targ_pth;
110 //rkaudio_Cir_Doa_invoke(st_ptr, &targ_ang, &targ_pth);
111 wave_writer_put_samples(ww, IN_SIZE, out);
112 Total_sample = Total_sample + out_size;
113 #if ENABLE_WAKEUP && ENABLE_COMMAND
114
115 if (frame_cot == 0 && is_wakeup == 1)
116 {
117 frame_cot = 250;/*����10s������ʵȴ�ʱ��*/
118 num_wakeup = num_wakeup + 1;
119 printf("%f, [%d], Hi, I am XiaoRui\n", cnt*0.016, num_wakeup);
120 }
121 if (frame_cot > 0) {
122 frame_cot--;
123 rkaudio_preprocess_get_cmd_id(st_ptr, &cmd_score, &cmd_id);
124 if (cmd_id != 0) {
125 printf("%f,, cmd=%d\n\n", cnt*0.016, cmd_id);
126 frame_cot = 0;
127 is_wakeup = 0;
128 } else if (frame_cot == 0) {
129 is_wakeup = 0;
130 }
131 }
132 if (cnt == 3750) {
133 printf("stop\n");
134 }
135 #elif ENABLE_WAKEUP
136 if (is_wakeup)
137 {
138 num_wakeup = num_wakeup + 1;
139 printf("[%d], Hi, I am Xiaorui, is_wakeup = %d\n", num_wakeup, is_wakeup);
140 is_wakeup = 0;
141 //printf("targ_ang is %d,targ_pth is %d\n", targ_ang, targ_pth);
142 }
143 #endif
144 }
145 endTime = clock();
146 Total_time = endTime - startTime;
147 Spe_time = Total_sample / mSampleRate;
148 printf("Finished, speech_time = %f, cost_time = %f\n", Spe_time, Total_time / CLOCKS_PER_SEC);
149
150 wave_writer_close(ww, &werror);
151 wave_reader_close(wr);
152 free(in);
153 free(out);
154
155 if (st_ptr)
156 rkaudio_preprocess_destory(st_ptr);
157 rkaudio_param_deinit(¶m);
158
159 return 0;
160 }
161
test_aec()162 int test_aec()
163 {
164 #undef IN_SIZE
165 #define IN_SIZE 256
166
167 printf("\nin aec test\n");
168 //char* in_filename = (char*)"human.wav";;
169 //char* out_filename = (char*)"human_out.wav";
170 char* in_filename = (char*)"rkaudio_test_2a1.wav";;
171 char* out_filename = (char*)"rkaudio_test_2a1_out.wav";
172 // for wave reader
173 wave_reader* wr;
174 wave_reader_error rerror;
175
176 // for wave writer
177 wave_writer* ww;
178 wave_writer_error werror;
179 wave_writer_format format;
180
181 int is_wakeup = 0;
182 wr = wave_reader_open(in_filename, &rerror);
183 if (!wr) {
184 printf("rerror=%d\n", rerror);
185 return -1;
186 }
187 clock_t startTime, endTime;
188 double Total_time = 0.0;
189 double Total_sample = 0.0;
190 float Spe_time = 0.0;
191
192 printf("filename=%s format=%d num_channels=%d sample_rate=%d sample_bits=%d num_samples=%d\n",in_filename,wave_reader_get_format(wr),
193 wave_reader_get_num_channels(wr),wave_reader_get_sample_rate(wr),wave_reader_get_sample_bits(wr),wave_reader_get_num_samples(wr));
194
195 int mSampleRate = wave_reader_get_sample_rate(wr);
196 int mBitPerSample = wave_reader_get_sample_bits(wr);
197 int mNumChannel = wave_reader_get_num_channels(wr);
198 int num_ref_channel = NUM_REF_CHANNEL;
199 int num_src_channel = mNumChannel - NUM_REF_CHANNEL;
200
201 int read_size = IN_SIZE * mNumChannel * mBitPerSample / 8;
202 SKV_BYTE* in = (SKV_BYTE*)malloc(read_size * sizeof(SKV_BYTE));
203 short* out = (short*)malloc(IN_SIZE * 1 * sizeof(short));
204
205 format.num_channels = 1;
206 format.sample_rate = wave_reader_get_sample_rate(wr);
207 format.sample_bits = wave_reader_get_sample_bits(wr);
208 ww = wave_writer_open(out_filename, &format, &werror);
209 if (!ww)
210 {
211 printf("werror=%d\n", werror);
212
213 wave_reader_close(wr);
214 return -1;
215 }
216 //rkaudio_asr_set_param(0.3, 0.72, 0.5);
217 RKAUDIOParam param;
218 memset(¶m, 0, sizeof(RKAUDIOParam));
219 param.model_en = RKAUDIO_EN_AEC | RKAUDIO_EN_BF;
220 param.aec_param = rkaudio_aec_param_init();
221 param.bf_param = rkaudio_preprocess_param_init();
222 param.rx_param = rkaudio_rx_param_init();
223 void* st_ptr = NULL;
224
225 st_ptr = rkaudio_preprocess_init(mSampleRate, mBitPerSample, num_src_channel, num_ref_channel, ¶m);
226 if (st_ptr == NULL)
227 {
228 printf("Failed to create audio preprocess handle\n");
229 return -1;
230 }
231
232 int cnt = 0, in_size, out_size, res, frame_cot = 0;
233 startTime = clock();
234 while (0 < (res = wave_reader_get_samples(wr, IN_SIZE, in)))
235 {
236 cnt++;
237 in_size = res * (mBitPerSample / 16) * mNumChannel;
238 out_size = rkaudio_preprocess_short(st_ptr, (short*)in, out, in_size, &is_wakeup);
239 int targ_Doa = rkaudio_Doa_invoke(st_ptr);
240 int targ_ang , targ_pth;
241 //rkaudio_Cir_Doa_invoke(st_ptr, &targ_ang, &targ_pth);
242 wave_writer_put_samples(ww, IN_SIZE, out);
243 Total_sample = Total_sample + out_size;
244 }
245 endTime = clock();
246 Total_time = endTime - startTime;
247 Spe_time = Total_sample / mSampleRate;
248 printf("Finished, speech_time = %f, cost_time = %f\n", Spe_time, Total_time / CLOCKS_PER_SEC);
249
250 wave_writer_close(ww, &werror);
251 wave_reader_close(wr);
252 free(in);
253 free(out);
254
255 if (st_ptr)
256 rkaudio_preprocess_destory(st_ptr);
257 rkaudio_param_deinit(¶m);
258
259 return 0;
260 }
261
262 extern "C" int rkaudio_agc_short_process(void *st_ptr, short *in, short *out);
263 extern "C" void rkaudio_agc_short_destroy(void *st_ptr);
264 extern "C" void *rkaudio_agc_short_init(int frame_len, int sampling_rate, int chan, void* param_);
265
test_agc()266 int test_agc()
267 {
268 #undef IN_SIZE
269 #define IN_SIZE 256
270
271 printf("\nin aec test\n");
272 char* in_filename = (char*)"test_16k_1a1.wav";;
273 char* out_filename = (char*)"test_16k_1a1_out.wav";
274 // for wave reader
275 wave_reader* wr;
276 wave_reader_error rerror;
277
278 // for wave writer
279 wave_writer* ww;
280 wave_writer_error werror;
281 wave_writer_format format;
282
283 int is_wakeup = 0;
284 wr = wave_reader_open(in_filename, &rerror);
285 if (!wr) {
286 printf("rerror=%d\n", rerror);
287 return -1;
288 }
289 clock_t startTime, endTime;
290 double Total_time = 0.0;
291 double Total_sample = 0.0;
292 float Spe_time = 0.0;
293
294 printf("filename=%s format=%d num_channels=%d sample_rate=%d sample_bits=%d num_samples=%d\n",in_filename,wave_reader_get_format(wr),
295 wave_reader_get_num_channels(wr),wave_reader_get_sample_rate(wr),wave_reader_get_sample_bits(wr),wave_reader_get_num_samples(wr));
296
297 int mSampleRate = wave_reader_get_sample_rate(wr);
298 int mBitPerSample = wave_reader_get_sample_bits(wr);
299 int mNumChannel = wave_reader_get_num_channels(wr);
300
301 int read_size = IN_SIZE * mNumChannel * mBitPerSample / 8;
302 SKV_BYTE* in = (SKV_BYTE*)malloc(read_size * sizeof(SKV_BYTE));
303 short* out = (short*)malloc(read_size * sizeof(short));
304
305 format.num_channels = mNumChannel;
306 format.sample_rate = wave_reader_get_sample_rate(wr);
307 format.sample_bits = wave_reader_get_sample_bits(wr);
308 ww = wave_writer_open(out_filename, &format, &werror);
309 if (!ww)
310 {
311 printf("werror=%d\n", werror);
312
313 wave_reader_close(wr);
314 return -1;
315 }
316 //rkaudio_asr_set_param(0.3, 0.72, 0.5);
317 void *param = rkaudio_agc_param_init();
318 void *st_ptr = rkaudio_agc_short_init(IN_SIZE, 44100, mNumChannel, param);
319 if (st_ptr == NULL)
320 {
321 printf("Failed to create audio preprocess handle\n");
322 return -1;
323 }
324 free(param);
325
326 int cnt = 0, in_size, out_size, res, frame_cot = 0;
327 startTime = clock();
328 while (0 < (res = wave_reader_get_samples(wr, IN_SIZE, in)))
329 {
330 cnt++;
331 in_size = res * (mBitPerSample / 16) * mNumChannel;
332 out_size = rkaudio_agc_short_process(st_ptr, (short*)in, out);
333 wave_writer_put_samples(ww, IN_SIZE, out);
334 Total_sample = Total_sample + out_size;
335 }
336 endTime = clock();
337 Total_time = endTime - startTime;
338 Spe_time = Total_sample / mSampleRate;
339 printf("Finished, speech_time = %f, cost_time = %f\n", Spe_time, Total_time / CLOCKS_PER_SEC);
340
341 wave_writer_close(ww, &werror);
342 wave_reader_close(wr);
343 free(in);
344 free(out);
345
346 if (st_ptr)
347 rkaudio_agc_short_destroy(st_ptr);
348 return 0;
349 }
350
test_sed()351 int test_sed()
352 {
353 #undef IN_SIZE
354 #define IN_SIZE 256
355 printf("\nin sed test\n");
356
357 double Total_sample = 0.0;
358 // ��ȡ���ݲ�����
359 clock_t startTime, endTime;
360 /* For Debug */
361 int out_size = 0, in_size = 0, res = 0;
362 #if ENABLE_8k
363 char* in_filename = (char*)"babycry_8k.wav";
364 char* out_filename = (char*)"babycry_8k_out.wav";
365 #else
366 char* in_filename = (char*)"test_16K_sed.wav";
367 char* out_filename = (char*)"test_16K_sed_out.wav";
368 #endif
369
370 // for wave reader
371 wave_reader* wr;
372 wave_reader_error rerror;
373
374 // for wave writer
375 wave_writer* ww;
376 wave_writer_error werror;
377 wave_writer_format format;
378
379 // ��ȡ������Ƶ
380 wr = wave_reader_open(in_filename, &rerror);
381 if (!wr) {
382 printf("rerror=%d\n", rerror);
383 return -1;
384 }
385
386 int mSampleRate = wave_reader_get_sample_rate(wr);
387 int mBitPerSample = wave_reader_get_sample_bits(wr);
388 int mNumChannel = wave_reader_get_num_channels(wr);
389
390 // ������
391 if (mNumChannel > 1) {
392 printf("This algorithm is a single channel algorithm and will run on the first channel of data\n");
393 }
394
395 // ÿ�ζ�ȡ���ݴ�С
396 int read_size = IN_SIZE * mNumChannel * mBitPerSample / 8;
397 SKV_BYTE* in = (SKV_BYTE*)malloc(read_size * sizeof(SKV_BYTE));
398 int out_res_num = 5;
399 short* out = (short*)malloc(IN_SIZE * out_res_num * sizeof(short));
400 // �����Ƶ��ʽ����
401 format.num_channels =5;
402 format.sample_rate = mSampleRate;
403 format.sample_bits = mBitPerSample;
404 ww = wave_writer_open(out_filename, &format, &werror);
405 // �����Ƶ����ʧ��
406 if (!ww)
407 {
408 printf("werror=%d\n", werror);
409 wave_reader_close(wr);
410 return -1;
411 }
412
413 // �����¼�����ʼ��
414 RKAudioSedRes sed_res;
415 RKAudioSedParam* sed_param = rkaudio_sed_param_init();
416 void* st_sed = rkaudio_sed_init(mSampleRate, mBitPerSample, mNumChannel, sed_param);
417 //char initres = rkaudio_sed_init_res(st_sed);
418 rkaudio_sed_param_destroy(sed_param);
419 if (st_sed == NULL) {
420 printf("Failed to create baby cry handle\n");
421 return -1;
422 }
423
424 startTime = clock();
425 int cnt = 0;
426 while (0 < (res = wave_reader_get_samples(wr, IN_SIZE, in)))
427 {
428 in_size = res * (mBitPerSample / 8) * mNumChannel;
429 cnt++;
430 out_size = rkaudio_sed_process(st_sed, (short*)in, in_size / 2, &sed_res);
431 //float lsd_res = rkaudio_sed_lsd_db(st_sed);
432 if (out_size < 0)
433 fprintf(stderr, "bcd process return error=%d\n", out_size);
434
435 //printf("lsd=%d,snr=%d,bcd=%d,buz_res=%d,gbs_res=%d\n", sed_res.lsd_res, sed_res.snr_res, sed_res.bcd_res, sed_res.buz_res, sed_res.gbs_res);
436
437 // �����������
438 for (int i = 0; i < IN_SIZE; i++) {
439 *(out + out_res_num * i) = 10000 * sed_res.snr_res;
440 *(out + out_res_num * i + 1) = 10000 * sed_res.lsd_res;
441 *(out + out_res_num * i + 2) = 10000 * sed_res.bcd_res;
442 *(out + out_res_num * i + 3) = 10000 * sed_res.buz_res;
443 *(out + out_res_num * i + 4) = 10000 * sed_res.gbs_res;
444 }
445 wave_writer_put_samples(ww, IN_SIZE, out);
446 Total_sample += in_size / 2 / mNumChannel;
447 //if (cnt % 63 == 0)
448 // printf("cnt = %d\n", cnt);
449 }
450 endTime = clock();
451
452 printf("Finished, speech_time = %f, cost_time = %f\n", \
453 Total_sample / mSampleRate, (double)(endTime - startTime) / CLOCKS_PER_SEC);
454
455 wave_writer_close(ww, &werror);
456 wave_reader_close(wr);
457
458 free(in);
459 free(out);
460
461 // �ͷ�
462 if (st_sed)
463 rkaudio_sed_destroy(st_sed);
464
465 return 0;
466 }
467
468
main()469 int main()
470 {
471 test_aec();
472 //test_agc();
473 test_sed();
474 }
475