1 /**
2 * Copyright 2021 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "common/common.h"
18 #include "include/api/types.h"
19 #include "utils/log_adapter.h"
20
21 #include "minddata/dataset/include/dataset/audio.h"
22 #include "minddata/dataset/include/dataset/datasets.h"
23 #include "minddata/dataset/include/dataset/transforms.h"
24
25 using namespace mindspore::dataset;
26 using mindspore::LogStream;
27 using mindspore::ExceptionType::NoExceptionType;
28 using mindspore::MsLogLevel::INFO;
29 using namespace std;
30
31 class MindDataTestPipeline : public UT::DatasetOpTesting {
32 protected:
33 };
34
TEST_F(MindDataTestPipeline,TestAmplitudeToDBPipeline)35 TEST_F(MindDataTestPipeline, TestAmplitudeToDBPipeline) {
36 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAmplitudeToDBPipeline.";
37 // Original waveform
38 std::shared_ptr<SchemaObj> schema = Schema();
39 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
40 std::shared_ptr<Dataset> ds = RandomData(50, schema);
41 EXPECT_NE(ds, nullptr);
42
43 ds = ds->SetNumWorkers(4);
44 EXPECT_NE(ds, nullptr);
45
46 auto amplitude_to_db_op = audio::AmplitudeToDB();
47
48 ds = ds->Map({amplitude_to_db_op});
49 EXPECT_NE(ds, nullptr);
50
51 std::shared_ptr<Iterator> iter = ds->CreateIterator();
52 EXPECT_NE(ds, nullptr);
53
54 std::unordered_map<std::string, mindspore::MSTensor> row;
55 ASSERT_OK(iter->GetNextRow(&row));
56
57 std::vector<int64_t> expected = {2, 200};
58
59 int i = 0;
60 while (row.size() != 0) {
61 auto col = row["inputData"];
62 ASSERT_EQ(col.Shape(), expected);
63 ASSERT_EQ(col.Shape().size(), 2);
64 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
65 ASSERT_OK(iter->GetNextRow(&row));
66 i++;
67 }
68 EXPECT_EQ(i, 50);
69
70 iter->Stop();
71 }
72
TEST_F(MindDataTestPipeline,TestAmplitudeToDBWrongArgs)73 TEST_F(MindDataTestPipeline, TestAmplitudeToDBWrongArgs) {
74 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAmplitudeToDBWrongArgs.";
75 // Original waveform
76 std::shared_ptr<SchemaObj> schema = Schema();
77 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
78 std::shared_ptr<Dataset> ds = RandomData(50, schema);
79 EXPECT_NE(ds, nullptr);
80
81 ds = ds->SetNumWorkers(4);
82 EXPECT_NE(ds, nullptr);
83
84 auto amplitude_to_db_op = audio::AmplitudeToDB(ScaleType::kPower, 1.0, -1e-10, 80.0);
85
86 ds = ds->Map({amplitude_to_db_op});
87 EXPECT_NE(ds, nullptr);
88
89 std::shared_ptr<Iterator> iter = ds->CreateIterator();
90 // Expect failure
91 EXPECT_EQ(iter, nullptr);
92 }
93
TEST_F(MindDataTestPipeline,TestBandBiquadBasic)94 TEST_F(MindDataTestPipeline, TestBandBiquadBasic) {
95 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandBiquadBasic.";
96 // Original waveform
97 std::shared_ptr<SchemaObj> schema = Schema();
98 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
99 std::shared_ptr<Dataset> ds = RandomData(50, schema);
100 EXPECT_NE(ds, nullptr);
101
102 ds = ds->SetNumWorkers(4);
103 EXPECT_NE(ds, nullptr);
104
105 auto BandBiquadOp = audio::BandBiquad(44100, 200.0);
106
107 ds = ds->Map({BandBiquadOp});
108 EXPECT_NE(ds, nullptr);
109
110 // Filtered waveform by bandbiquad
111 std::shared_ptr<Iterator> iter = ds->CreateIterator();
112 EXPECT_NE(ds, nullptr);
113
114 std::unordered_map<std::string, mindspore::MSTensor> row;
115 ASSERT_OK(iter->GetNextRow(&row));
116
117 std::vector<int64_t> expected = {2, 200};
118
119 int i = 0;
120 while (row.size() != 0) {
121 auto col = row["inputData"];
122 ASSERT_EQ(col.Shape(), expected);
123 ASSERT_EQ(col.Shape().size(), 2);
124 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
125 ASSERT_OK(iter->GetNextRow(&row));
126 i++;
127 }
128 EXPECT_EQ(i, 50);
129
130 iter->Stop();
131 }
132
TEST_F(MindDataTestPipeline,TestBandBiquadParamCheck)133 TEST_F(MindDataTestPipeline, TestBandBiquadParamCheck) {
134 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandBiquadParamCheck.";
135 std::shared_ptr<SchemaObj> schema = Schema();
136 // Original waveform
137 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
138 std::shared_ptr<Dataset> ds = RandomData(50, schema);
139 std::shared_ptr<Dataset> ds01;
140 std::shared_ptr<Dataset> ds02;
141 EXPECT_NE(ds, nullptr);
142
143 // Check sample_rate
144 MS_LOG(INFO) << "sample_rate is zero.";
145 auto band_biquad_op_01 = audio::BandBiquad(0, 200);
146 ds01 = ds->Map({band_biquad_op_01});
147 EXPECT_NE(ds01, nullptr);
148
149 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
150 EXPECT_EQ(iter01, nullptr);
151
152 // Check Q_
153 MS_LOG(INFO) << "Q_ is zero.";
154 auto band_biquad_op_02 = audio::BandBiquad(44100, 200, 0);
155 ds02 = ds->Map({band_biquad_op_02});
156 EXPECT_NE(ds02, nullptr);
157
158 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
159 EXPECT_EQ(iter02, nullptr);
160 }
161
TEST_F(MindDataTestPipeline,TestAllpassBiquadBasic)162 TEST_F(MindDataTestPipeline, TestAllpassBiquadBasic) {
163 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAllpassBiquadBasic.";
164 // Original waveform
165 std::shared_ptr<SchemaObj> schema = Schema();
166 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
167 std::shared_ptr<Dataset> ds = RandomData(50, schema);
168 EXPECT_NE(ds, nullptr);
169
170 ds = ds->SetNumWorkers(4);
171 EXPECT_NE(ds, nullptr);
172
173 auto AllpassBiquadOp = audio::AllpassBiquad(44100, 200.0);
174
175 ds = ds->Map({AllpassBiquadOp});
176 EXPECT_NE(ds, nullptr);
177
178 // Filtered waveform by allpassbiquad
179 std::shared_ptr<Iterator> iter = ds->CreateIterator();
180 EXPECT_NE(ds, nullptr);
181
182 std::unordered_map<std::string, mindspore::MSTensor> row;
183 ASSERT_OK(iter->GetNextRow(&row));
184
185 std::vector<int64_t> expected = {2, 200};
186
187 int i = 0;
188 while (row.size() != 0) {
189 auto col = row["inputData"];
190 ASSERT_EQ(col.Shape(), expected);
191 ASSERT_EQ(col.Shape().size(), 2);
192 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
193 ASSERT_OK(iter->GetNextRow(&row));
194 i++;
195 }
196 EXPECT_EQ(i, 50);
197
198 iter->Stop();
199 }
200
TEST_F(MindDataTestPipeline,TestAllpassBiquadParamCheck)201 TEST_F(MindDataTestPipeline, TestAllpassBiquadParamCheck) {
202 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAllpassBiquadParamCheck.";
203 std::shared_ptr<SchemaObj> schema = Schema();
204 // Original waveform
205 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
206 std::shared_ptr<Dataset> ds = RandomData(50, schema);
207 std::shared_ptr<Dataset> ds01;
208 std::shared_ptr<Dataset> ds02;
209 EXPECT_NE(ds, nullptr);
210
211 // Check sample_rate
212 MS_LOG(INFO) << "Sample_rate_ is zero.";
213 auto allpass_biquad_op_01 = audio::AllpassBiquad(0, 200.0, 0.707);
214 ds01 = ds->Map({allpass_biquad_op_01});
215 EXPECT_NE(ds01, nullptr);
216
217 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
218 EXPECT_EQ(iter01, nullptr);
219
220 // Check Q_
221 MS_LOG(INFO) << "Q_ is zero.";
222 auto allpass_biquad_op_02 = audio::AllpassBiquad(44100, 200, 0);
223 ds02 = ds->Map({allpass_biquad_op_02});
224 EXPECT_NE(ds02, nullptr);
225
226 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
227 EXPECT_EQ(iter02, nullptr);
228 }
229
TEST_F(MindDataTestPipeline,TestBandpassBiquadBasic)230 TEST_F(MindDataTestPipeline, TestBandpassBiquadBasic) {
231 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandpassBiquadBasic.";
232 // Original waveform
233 std::shared_ptr<SchemaObj> schema = Schema();
234 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
235 std::shared_ptr<Dataset> ds = RandomData(50, schema);
236 EXPECT_NE(ds, nullptr);
237
238 ds = ds->SetNumWorkers(4);
239 EXPECT_NE(ds, nullptr);
240
241 auto BandpassBiquadOp = audio::BandpassBiquad(44100, 200.0);
242
243 ds = ds->Map({BandpassBiquadOp});
244 EXPECT_NE(ds, nullptr);
245
246 // Filtered waveform by bandpassbiquad
247 std::shared_ptr<Iterator> iter = ds->CreateIterator();
248 EXPECT_NE(ds, nullptr);
249
250 std::unordered_map<std::string, mindspore::MSTensor> row;
251 ASSERT_OK(iter->GetNextRow(&row));
252
253 std::vector<int64_t> expected = {2, 200};
254
255 int i = 0;
256 while (row.size() != 0) {
257 auto col = row["inputData"];
258 ASSERT_EQ(col.Shape(), expected);
259 ASSERT_EQ(col.Shape().size(), 2);
260 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
261 ASSERT_OK(iter->GetNextRow(&row));
262 i++;
263 }
264 EXPECT_EQ(i, 50);
265
266 iter->Stop();
267 }
268
TEST_F(MindDataTestPipeline,TestBandpassBiquadParamCheck)269 TEST_F(MindDataTestPipeline, TestBandpassBiquadParamCheck) {
270 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandpassBiquadParamCheck.";
271 std::shared_ptr<SchemaObj> schema = Schema();
272 // Original waveform
273 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
274 std::shared_ptr<Dataset> ds = RandomData(50, schema);
275 std::shared_ptr<Dataset> ds01;
276 std::shared_ptr<Dataset> ds02;
277 EXPECT_NE(ds, nullptr);
278
279 // Check sample_rate
280 MS_LOG(INFO) << "sample_rate is zero.";
281 auto bandpass_biquad_op_01 = audio::BandpassBiquad(0, 200);
282 ds01 = ds->Map({bandpass_biquad_op_01});
283 EXPECT_NE(ds01, nullptr);
284
285 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
286 EXPECT_EQ(iter01, nullptr);
287
288 // Check Q_
289 MS_LOG(INFO) << "Q_ is zero.";
290 auto bandpass_biquad_op_02 = audio::BandpassBiquad(44100, 200, 0);
291 ds02 = ds->Map({bandpass_biquad_op_02});
292 EXPECT_NE(ds02, nullptr);
293
294 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
295 EXPECT_EQ(iter02, nullptr);
296 }
297
TEST_F(MindDataTestPipeline,TestBandrejectBiquadBasic)298 TEST_F(MindDataTestPipeline, TestBandrejectBiquadBasic) {
299 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandrejectBiquadBasic.";
300 // Original waveform
301 std::shared_ptr<SchemaObj> schema = Schema();
302 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
303 std::shared_ptr<Dataset> ds = RandomData(50, schema);
304 EXPECT_NE(ds, nullptr);
305
306 ds = ds->SetNumWorkers(4);
307 EXPECT_NE(ds, nullptr);
308
309 auto BandrejectBiquadOp = audio::BandrejectBiquad(44100, 200.0);
310
311 ds = ds->Map({BandrejectBiquadOp});
312 EXPECT_NE(ds, nullptr);
313
314 // Filtered waveform by bandrejectbiquad
315 std::shared_ptr<Iterator> iter = ds->CreateIterator();
316 EXPECT_NE(ds, nullptr);
317
318 std::unordered_map<std::string, mindspore::MSTensor> row;
319 ASSERT_OK(iter->GetNextRow(&row));
320
321 std::vector<int64_t> expected = {2, 200};
322
323 int i = 0;
324 while (row.size() != 0) {
325 auto col = row["inputData"];
326 ASSERT_EQ(col.Shape(), expected);
327 ASSERT_EQ(col.Shape().size(), 2);
328 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
329 ASSERT_OK(iter->GetNextRow(&row));
330 i++;
331 }
332 EXPECT_EQ(i, 50);
333
334 iter->Stop();
335 }
336
TEST_F(MindDataTestPipeline,TestBandrejectBiquadParamCheck)337 TEST_F(MindDataTestPipeline, TestBandrejectBiquadParamCheck) {
338 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBandrejectBiquadParamCheck.";
339 std::shared_ptr<SchemaObj> schema = Schema();
340 // Original waveform
341 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
342 std::shared_ptr<Dataset> ds = RandomData(50, schema);
343 std::shared_ptr<Dataset> ds01;
344 std::shared_ptr<Dataset> ds02;
345 EXPECT_NE(ds, nullptr);
346
347 // Check sample_rate
348 MS_LOG(INFO) << "sample_rate is zero.";
349 auto bandreject_biquad_op_01 = audio::BandrejectBiquad(0, 200);
350 ds01 = ds->Map({bandreject_biquad_op_01});
351 EXPECT_NE(ds01, nullptr);
352
353 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
354 EXPECT_EQ(iter01, nullptr);
355
356 // Check Q_
357 MS_LOG(INFO) << "Q_ is zero.";
358 auto bandreject_biquad_op_02 = audio::BandrejectBiquad(44100, 200, 0);
359 ds02 = ds->Map({bandreject_biquad_op_02});
360 EXPECT_NE(ds02, nullptr);
361
362 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
363 EXPECT_EQ(iter02, nullptr);
364 }
365
TEST_F(MindDataTestPipeline,TestBassBiquadBasic)366 TEST_F(MindDataTestPipeline, TestBassBiquadBasic) {
367 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBassBiquadBasic.";
368 // Original waveform
369 std::shared_ptr<SchemaObj> schema = Schema();
370 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
371 std::shared_ptr<Dataset> ds = RandomData(50, schema);
372 EXPECT_NE(ds, nullptr);
373
374 ds = ds->SetNumWorkers(4);
375 EXPECT_NE(ds, nullptr);
376
377 auto BassBiquadOp = audio::BassBiquad(44100, 50, 200.0);
378
379 ds = ds->Map({BassBiquadOp});
380 EXPECT_NE(ds, nullptr);
381
382 // Filtered waveform by bassbiquad
383 std::shared_ptr<Iterator> iter = ds->CreateIterator();
384 EXPECT_NE(ds, nullptr);
385
386 std::unordered_map<std::string, mindspore::MSTensor> row;
387 ASSERT_OK(iter->GetNextRow(&row));
388
389 std::vector<int64_t> expected = {2, 200};
390
391 int i = 0;
392 while (row.size() != 0) {
393 auto col = row["inputData"];
394 ASSERT_EQ(col.Shape(), expected);
395 ASSERT_EQ(col.Shape().size(), 2);
396 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
397 ASSERT_OK(iter->GetNextRow(&row));
398 i++;
399 }
400 EXPECT_EQ(i, 50);
401
402 iter->Stop();
403 }
404
TEST_F(MindDataTestPipeline,TestBassBiquadParamCheck)405 TEST_F(MindDataTestPipeline, TestBassBiquadParamCheck) {
406 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBassBiquadParamCheck.";
407 std::shared_ptr<SchemaObj> schema = Schema();
408 // Original waveform
409 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
410 std::shared_ptr<Dataset> ds = RandomData(50, schema);
411 std::shared_ptr<Dataset> ds01;
412 std::shared_ptr<Dataset> ds02;
413 EXPECT_NE(ds, nullptr);
414
415 // Check sample_rate
416 MS_LOG(INFO) << "sample_rate is zero.";
417 auto bass_biquad_op_01 = audio::BassBiquad(0, 50, 200.0);
418 ds01 = ds->Map({bass_biquad_op_01});
419 EXPECT_NE(ds01, nullptr);
420
421 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
422 EXPECT_EQ(iter01, nullptr);
423
424 // Check Q_
425 MS_LOG(INFO) << "Q_ is zero.";
426 auto bass_biquad_op_02 = audio::BassBiquad(44100, 50, 200.0, 0);
427 ds02 = ds->Map({bass_biquad_op_02});
428 EXPECT_NE(ds02, nullptr);
429
430 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
431 EXPECT_EQ(iter02, nullptr);
432 }
433
TEST_F(MindDataTestPipeline,TestAnglePipeline)434 TEST_F(MindDataTestPipeline, TestAnglePipeline) {
435 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAnglePipeline.";
436
437 std::shared_ptr<SchemaObj> schema = Schema();
438 ASSERT_OK(schema->add_column("complex", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
439 std::shared_ptr<Dataset> ds = RandomData(50, schema);
440 EXPECT_NE(ds, nullptr);
441
442 ds = ds->SetNumWorkers(4);
443 EXPECT_NE(ds, nullptr);
444
445 auto angle_op = audio::Angle();
446
447 ds = ds->Map({angle_op});
448 EXPECT_NE(ds, nullptr);
449
450 std::shared_ptr<Iterator> iter = ds->CreateIterator();
451 EXPECT_NE(ds, nullptr);
452
453 std::unordered_map<std::string, mindspore::MSTensor> row;
454 ASSERT_OK(iter->GetNextRow(&row));
455
456 std::vector<int64_t> expected = {2};
457
458 int i = 0;
459 while (row.size() != 0) {
460 auto col = row["complex"];
461 ASSERT_EQ(col.Shape(), expected);
462 ASSERT_EQ(col.Shape().size(), 1);
463 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
464 ASSERT_OK(iter->GetNextRow(&row));
465 i++;
466 }
467 EXPECT_EQ(i, 50);
468
469 iter->Stop();
470 }
471
TEST_F(MindDataTestPipeline,TestAnglePipelineError)472 TEST_F(MindDataTestPipeline, TestAnglePipelineError) {
473 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestAnglePipelineError.";
474
475 std::shared_ptr<SchemaObj> schema = Schema();
476 ASSERT_OK(schema->add_column("complex", mindspore::DataType::kNumberTypeFloat32, {3, 2, 1}));
477 std::shared_ptr<Dataset> ds = RandomData(4, schema);
478 EXPECT_NE(ds, nullptr);
479
480 ds = ds->SetNumWorkers(4);
481 EXPECT_NE(ds, nullptr);
482
483 auto angle_op = audio::Angle();
484
485 ds = ds->Map({angle_op});
486 EXPECT_NE(ds, nullptr);
487
488 std::shared_ptr<Iterator> iter = ds->CreateIterator();
489 std::unordered_map<std::string, mindspore::MSTensor> row;
490 EXPECT_ERROR(iter->GetNextRow(&row));
491 }
492
TEST_F(MindDataTestPipeline,TestEqualizerBiquadSuccess)493 TEST_F(MindDataTestPipeline, TestEqualizerBiquadSuccess) {
494 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestEqualizerBiquadSuccess.";
495
496 // Create an input tensor
497 std::shared_ptr<SchemaObj> schema = Schema();
498 ASSERT_OK(schema->add_column("col1", mindspore::DataType::kNumberTypeFloat32, {1, 200}));
499 std::shared_ptr<Dataset> ds = RandomData(8, schema);
500 EXPECT_NE(ds, nullptr);
501
502 // Create a filter object
503 std::shared_ptr<TensorTransform> equalizer_biquad(new audio::EqualizerBiquad(44100, 3.5, 5.5, 0.707));
504 auto ds1 = ds->Map({equalizer_biquad}, {"col1"}, {"audio"});
505 EXPECT_NE(ds1, nullptr);
506 std::shared_ptr<Iterator> iter = ds1->CreateIterator();
507 EXPECT_NE(iter, nullptr);
508 std::unordered_map<std::string, mindspore::MSTensor> row;
509 ASSERT_OK(iter->GetNextRow(&row));
510 uint64_t i = 0;
511 while (row.size() != 0) {
512 i++;
513 ASSERT_OK(iter->GetNextRow(&row));
514 }
515 EXPECT_EQ(i, 8);
516 iter->Stop();
517 }
518
TEST_F(MindDataTestPipeline,TestEqualizerBiquadWrongArgs)519 TEST_F(MindDataTestPipeline, TestEqualizerBiquadWrongArgs) {
520 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestEqualizerBiquadWrongArgs.";
521 std::shared_ptr<SchemaObj> schema = Schema();
522 // Original waveform
523 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 10}));
524 std::shared_ptr<Dataset> ds = RandomData(50, schema);
525 std::shared_ptr<Dataset> ds01;
526 std::shared_ptr<Dataset> ds02;
527 EXPECT_NE(ds, nullptr);
528
529 // Check sample_rate
530 MS_LOG(INFO) << "sample_rate is zero.";
531 auto equalizer_biquad_op_01 = audio::EqualizerBiquad(0, 200.0, 5.5, 0.7);
532 ds01 = ds->Map({equalizer_biquad_op_01});
533 EXPECT_NE(ds01, nullptr);
534
535 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
536 EXPECT_EQ(iter01, nullptr);
537
538 // Check Q
539 MS_LOG(INFO) << "Q is zero.";
540 auto equalizer_biquad_op_02 = audio::EqualizerBiquad(44100, 2000.0, 5.5, 0);
541 ds02 = ds->Map({equalizer_biquad_op_02});
542 EXPECT_NE(ds02, nullptr);
543
544 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
545 EXPECT_EQ(iter02, nullptr);
546 }
547
TEST_F(MindDataTestPipeline,TestLowpassBiquadSuccess)548 TEST_F(MindDataTestPipeline, TestLowpassBiquadSuccess) {
549 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestLowpassBiquadSuccess.";
550
551 // Create an input tensor
552 std::shared_ptr<SchemaObj> schema = Schema();
553 ASSERT_OK(schema->add_column("col1", mindspore::DataType::kNumberTypeFloat32, {1, 200}));
554 std::shared_ptr<Dataset> ds = RandomData(8, schema);
555 EXPECT_NE(ds, nullptr);
556
557 // Create a filter object
558 std::shared_ptr<TensorTransform> lowpass_biquad(new audio::LowpassBiquad(44100, 3000.5, 0.707));
559 auto ds1 = ds->Map({lowpass_biquad}, {"col1"}, {"audio"});
560 EXPECT_NE(ds1, nullptr);
561 std::shared_ptr<Iterator> iter = ds1->CreateIterator();
562 EXPECT_NE(iter, nullptr);
563 std::unordered_map<std::string, mindspore::MSTensor> row;
564 ASSERT_OK(iter->GetNextRow(&row));
565 uint64_t i = 0;
566 while (row.size() != 0) {
567 i++;
568 ASSERT_OK(iter->GetNextRow(&row));
569 }
570 EXPECT_EQ(i, 8);
571 iter->Stop();
572 }
573
TEST_F(MindDataTestPipeline,TestLowpassBiquadWrongArgs)574 TEST_F(MindDataTestPipeline, TestLowpassBiquadWrongArgs) {
575 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestLowpassBiquadWrongArgs.";
576 std::shared_ptr<SchemaObj> schema = Schema();
577 // Original waveform
578 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 10}));
579 std::shared_ptr<Dataset> ds = RandomData(50, schema);
580 std::shared_ptr<Dataset> ds01;
581 std::shared_ptr<Dataset> ds02;
582 EXPECT_NE(ds, nullptr);
583
584 // Check sample_rate
585 MS_LOG(INFO) << "sample_rate is zero.";
586 auto lowpass_biquad_op_01 = audio::LowpassBiquad(0, 200.0, 0.7);
587 ds01 = ds->Map({lowpass_biquad_op_01});
588 EXPECT_NE(ds01, nullptr);
589
590 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
591 EXPECT_EQ(iter01, nullptr);
592
593 // Check Q
594 MS_LOG(INFO) << "Q is zero.";
595 auto lowpass_biquad_op_02 = audio::LowpassBiquad(44100, 2000.0, 0);
596 ds02 = ds->Map({lowpass_biquad_op_02});
597 EXPECT_NE(ds02, nullptr);
598
599 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
600 EXPECT_EQ(iter02, nullptr);
601 }
602
TEST_F(MindDataTestPipeline,TestFrequencyMaskingPipeline)603 TEST_F(MindDataTestPipeline, TestFrequencyMaskingPipeline) {
604 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFrequencyMaskingPipeline.";
605 // Original waveform
606 std::shared_ptr<SchemaObj> schema = Schema();
607 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {200, 200}));
608 std::shared_ptr<Dataset> ds = RandomData(50, schema);
609 EXPECT_NE(ds, nullptr);
610
611 ds = ds->SetNumWorkers(4);
612 EXPECT_NE(ds, nullptr);
613
614 auto frequencymasking = audio::FrequencyMasking(true, 6);
615
616 ds = ds->Map({frequencymasking});
617 EXPECT_NE(ds, nullptr);
618
619 std::shared_ptr<Iterator> iter = ds->CreateIterator();
620 EXPECT_NE(ds, nullptr);
621
622 std::unordered_map<std::string, mindspore::MSTensor> row;
623 ASSERT_OK(iter->GetNextRow(&row));
624
625 std::vector<int64_t> expected = {200, 200};
626
627 int i = 0;
628 while (row.size() != 0) {
629 auto col = row["inputData"];
630 ASSERT_EQ(col.Shape(), expected);
631 ASSERT_EQ(col.Shape().size(), 2);
632 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
633 ASSERT_OK(iter->GetNextRow(&row));
634 i++;
635 }
636 EXPECT_EQ(i, 50);
637
638 iter->Stop();
639 }
640
TEST_F(MindDataTestPipeline,TestFrequencyMaskingWrongArgs)641 TEST_F(MindDataTestPipeline, TestFrequencyMaskingWrongArgs) {
642 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFrequencyMaskingWrongArgs.";
643 // Original waveform
644 std::shared_ptr<SchemaObj> schema = Schema();
645 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {20, 20}));
646 std::shared_ptr<Dataset> ds = RandomData(50, schema);
647 EXPECT_NE(ds, nullptr);
648
649 ds = ds->SetNumWorkers(4);
650 EXPECT_NE(ds, nullptr);
651
652 auto frequencymasking = audio::FrequencyMasking(true, -100);
653
654 ds = ds->Map({frequencymasking});
655 EXPECT_NE(ds, nullptr);
656
657 // Filtered waveform by bandbiquad
658 std::shared_ptr<Iterator> iter = ds->CreateIterator();
659 // Expect failure
660 EXPECT_EQ(iter, nullptr);
661 }
662
TEST_F(MindDataTestPipeline,TestComplexNormBasic)663 TEST_F(MindDataTestPipeline, TestComplexNormBasic) {
664 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestComplexNormBasic.";
665
666 // Original waveform
667 std::shared_ptr<SchemaObj> schema = Schema();
668 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt64, {3, 2, 4, 2}));
669 std::shared_ptr<Dataset> ds = RandomData(50, schema);
670 EXPECT_NE(ds, nullptr);
671
672 ds = ds->SetNumWorkers(4);
673 EXPECT_NE(ds, nullptr);
674
675 auto ComplexNormOp = audio::ComplexNorm(3.0);
676
677 ds = ds->Map({ComplexNormOp});
678 EXPECT_NE(ds, nullptr);
679
680 // Filtered waveform by ComplexNorm
681 std::shared_ptr<Iterator> iter = ds->CreateIterator();
682 EXPECT_NE(ds, nullptr);
683
684 std::unordered_map<std::string, mindspore::MSTensor> row;
685 ASSERT_OK(iter->GetNextRow(&row));
686
687 std::vector<int64_t> expected = {3, 2, 4};
688
689 int i = 0;
690 while (row.size() != 0) {
691 auto col = row["inputData"];
692 ASSERT_EQ(col.Shape(), expected);
693 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
694 ASSERT_OK(iter->GetNextRow(&row));
695 i++;
696 }
697 EXPECT_EQ(i, 50);
698
699 iter->Stop();
700 }
701
TEST_F(MindDataTestPipeline,TestComplexNormWrongArgs)702 TEST_F(MindDataTestPipeline, TestComplexNormWrongArgs) {
703 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestComplexNormWrongArgs.";
704
705 // Original waveform
706 std::shared_ptr<SchemaObj> schema = Schema();
707 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt64, {3, 2, 4, 2}));
708 std::shared_ptr<Dataset> ds = RandomData(50, schema);
709 EXPECT_NE(ds, nullptr);
710
711 ds = ds->SetNumWorkers(4);
712 EXPECT_NE(ds, nullptr);
713
714 auto ComplexNormOp = audio::ComplexNorm(-10);
715
716 ds = ds->Map({ComplexNormOp});
717 std::shared_ptr<Iterator> iter1 = ds->CreateIterator();
718 EXPECT_EQ(iter1, nullptr);
719 }
720
TEST_F(MindDataTestPipeline,TestContrastBasic)721 TEST_F(MindDataTestPipeline, TestContrastBasic) {
722 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestContrastBasic.";
723 // Original waveform
724 std::shared_ptr<SchemaObj> schema = Schema();
725 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
726 std::shared_ptr<Dataset> ds = RandomData(50, schema);
727 EXPECT_NE(ds, nullptr);
728
729 ds = ds->SetNumWorkers(4);
730 EXPECT_NE(ds, nullptr);
731
732 auto ContrastOp = audio::Contrast();
733
734 ds = ds->Map({ContrastOp});
735 EXPECT_NE(ds, nullptr);
736
737 std::shared_ptr<Iterator> iter = ds->CreateIterator();
738 EXPECT_NE(ds, nullptr);
739
740 std::unordered_map<std::string, mindspore::MSTensor> row;
741 ASSERT_OK(iter->GetNextRow(&row));
742
743 std::vector<int64_t> expected = {2, 200};
744
745 int i = 0;
746 while (row.size() != 0) {
747 auto col = row["inputData"];
748 ASSERT_EQ(col.Shape(), expected);
749 ASSERT_EQ(col.Shape().size(), 2);
750 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
751 ASSERT_OK(iter->GetNextRow(&row));
752 i++;
753 }
754 EXPECT_EQ(i, 50);
755
756 iter->Stop();
757 }
758
TEST_F(MindDataTestPipeline,TestContrastParamCheck)759 TEST_F(MindDataTestPipeline, TestContrastParamCheck) {
760 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestContrastParamCheck.";
761 std::shared_ptr<SchemaObj> schema = Schema();
762 // Original waveform
763 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat64, {2, 200}));
764 std::shared_ptr<Dataset> ds = RandomData(50, schema);
765 std::shared_ptr<Dataset> ds01;
766 std::shared_ptr<Dataset> ds02;
767 EXPECT_NE(ds, nullptr);
768
769 // Check enhancement_amount
770 MS_LOG(INFO) << "enhancement_amount is negative.";
771 auto contrast_op_01 = audio::Contrast(-10);
772 ds01 = ds->Map({contrast_op_01});
773 EXPECT_NE(ds01, nullptr);
774
775 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
776 EXPECT_EQ(iter01, nullptr);
777
778 MS_LOG(INFO) << "enhancement_amount is out of range.";
779 auto contrast_op_02 = audio::Contrast(101);
780 ds02 = ds->Map({contrast_op_02});
781 EXPECT_NE(ds02, nullptr);
782
783 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
784 EXPECT_EQ(iter02, nullptr);
785 }
786
TEST_F(MindDataTestPipeline,TestDeemphBiquadPipeline)787 TEST_F(MindDataTestPipeline, TestDeemphBiquadPipeline) {
788 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestDeemphBiquadPipeline.";
789 // Original waveform
790 std::shared_ptr<SchemaObj> schema = Schema();
791 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
792 std::shared_ptr<Dataset> ds = RandomData(50, schema);
793 EXPECT_NE(ds, nullptr);
794
795 ds = ds->SetNumWorkers(4);
796 EXPECT_NE(ds, nullptr);
797
798 auto DeemphBiquadOp = audio::DeemphBiquad(44100);
799
800 ds = ds->Map({DeemphBiquadOp});
801 EXPECT_NE(ds, nullptr);
802
803 // Filtered waveform by deemphbiquad
804 std::shared_ptr<Iterator> iter = ds->CreateIterator();
805 EXPECT_NE(ds, nullptr);
806
807 std::unordered_map<std::string, mindspore::MSTensor> row;
808 ASSERT_OK(iter->GetNextRow(&row));
809
810 std::vector<int64_t> expected = {2, 200};
811
812 int i = 0;
813 while (row.size() != 0) {
814 auto col = row["inputData"];
815 ASSERT_EQ(col.Shape(), expected);
816 ASSERT_EQ(col.Shape().size(), 2);
817 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
818 ASSERT_OK(iter->GetNextRow(&row));
819 i++;
820 }
821 EXPECT_EQ(i, 50);
822
823 iter->Stop();
824 }
825
TEST_F(MindDataTestPipeline,TestDeemphBiquadWrongArgs)826 TEST_F(MindDataTestPipeline, TestDeemphBiquadWrongArgs) {
827 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestDeemphBiquadWrongArgs.";
828 std::shared_ptr<SchemaObj> schema = Schema();
829 // Original waveform
830 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
831 std::shared_ptr<Dataset> ds = RandomData(50, schema);
832 std::shared_ptr<Dataset> ds01;
833 EXPECT_NE(ds, nullptr);
834
835 // Check sample_rate
836 MS_LOG(INFO) << "Sample_rate_ is zero.";
837 auto deemph_biquad_op_01 = audio::DeemphBiquad(0);
838 ds01 = ds->Map({deemph_biquad_op_01});
839 EXPECT_NE(ds01, nullptr);
840
841 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
842 EXPECT_EQ(iter01, nullptr);
843 }
844
TEST_F(MindDataTestPipeline,TestHighpassBiquadSuccess)845 TEST_F(MindDataTestPipeline, TestHighpassBiquadSuccess) {
846 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestHighpassBiquadSuccess.";
847
848 // Create an input tensor
849 std::shared_ptr<SchemaObj> schema = Schema();
850 ASSERT_OK(schema->add_column("col1", mindspore::DataType::kNumberTypeFloat32, {1, 200}));
851 std::shared_ptr<Dataset> ds = RandomData(8, schema);
852 EXPECT_NE(ds, nullptr);
853
854 // Create a filter object
855 std::shared_ptr<TensorTransform> highpass_biquad(new audio::HighpassBiquad(44100, 3000.5, 0.707));
856 auto ds1 = ds->Map({highpass_biquad}, {"col1"}, {"audio"});
857 EXPECT_NE(ds1, nullptr);
858 std::shared_ptr<Iterator> iter = ds1->CreateIterator();
859 EXPECT_NE(iter, nullptr);
860 std::unordered_map<std::string, mindspore::MSTensor> row;
861 ASSERT_OK(iter->GetNextRow(&row));
862 uint64_t i = 0;
863 while (row.size() != 0) {
864 i++;
865 ASSERT_OK(iter->GetNextRow(&row));
866 }
867 EXPECT_EQ(i, 8);
868 iter->Stop();
869 }
870
TEST_F(MindDataTestPipeline,TestHighpassBiquadWrongArgs)871 TEST_F(MindDataTestPipeline, TestHighpassBiquadWrongArgs) {
872 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestHighpassBiquadWrongArgs.";
873 std::shared_ptr<SchemaObj> schema = Schema();
874 // Original waveform
875 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 10}));
876 std::shared_ptr<Dataset> ds = RandomData(50, schema);
877 std::shared_ptr<Dataset> ds01;
878 std::shared_ptr<Dataset> ds02;
879 EXPECT_NE(ds, nullptr);
880
881 // Check sample_rate
882 MS_LOG(INFO) << "sample_rate is zero.";
883 auto highpass_biquad_op_01 = audio::HighpassBiquad(0, 200.0, 0.7);
884 ds01 = ds->Map({highpass_biquad_op_01});
885 EXPECT_NE(ds01, nullptr);
886
887 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
888 EXPECT_EQ(iter01, nullptr);
889
890 // Check Q
891 MS_LOG(INFO) << "Q is zero.";
892 auto highpass_biquad_op_02 = audio::HighpassBiquad(44100, 2000.0, 0);
893 ds02 = ds->Map({highpass_biquad_op_02});
894 EXPECT_NE(ds02, nullptr);
895
896 std::shared_ptr<Iterator> iter02 = ds02->CreateIterator();
897 EXPECT_EQ(iter02, nullptr);
898 }
899
TEST_F(MindDataTestPipeline,TestMuLawDecodingBasic)900 TEST_F(MindDataTestPipeline, TestMuLawDecodingBasic) {
901 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestMuLawDecodingBasic.";
902
903 // Original waveform
904 std::shared_ptr<SchemaObj> schema = Schema();
905 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt64, {1, 100}));
906 std::shared_ptr<Dataset> ds = RandomData(50, schema);
907 EXPECT_NE(ds, nullptr);
908
909 ds = ds->SetNumWorkers(4);
910 EXPECT_NE(ds, nullptr);
911
912 auto MuLawDecodingOp = audio::MuLawDecoding();
913
914 ds = ds->Map({MuLawDecodingOp});
915 EXPECT_NE(ds, nullptr);
916
917 // Filtered waveform by MuLawDecoding
918 std::shared_ptr<Iterator> iter = ds->CreateIterator();
919 EXPECT_NE(ds, nullptr);
920
921 std::unordered_map<std::string, mindspore::MSTensor> row;
922 ASSERT_OK(iter->GetNextRow(&row));
923
924 std::vector<int64_t> expected = {1, 100};
925
926 int i = 0;
927 while (row.size() != 0) {
928 auto col = row["inputData"];
929 ASSERT_EQ(col.Shape(), expected);
930 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
931 ASSERT_OK(iter->GetNextRow(&row));
932 i++;
933 }
934 EXPECT_EQ(i, 50);
935
936 iter->Stop();
937 }
938
TEST_F(MindDataTestPipeline,TestMuLawDecodingWrongArgs)939 TEST_F(MindDataTestPipeline, TestMuLawDecodingWrongArgs) {
940 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestMuLawDecodingWrongArgs.";
941
942 // Original waveform
943 std::shared_ptr<SchemaObj> schema = Schema();
944 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt64, {1, 100}));
945 std::shared_ptr<Dataset> ds = RandomData(50, schema);
946 EXPECT_NE(ds, nullptr);
947
948 ds = ds->SetNumWorkers(4);
949 EXPECT_NE(ds, nullptr);
950
951 auto MuLawDecodingOp = audio::MuLawDecoding(-10);
952
953 ds = ds->Map({MuLawDecodingOp});
954 std::shared_ptr<Iterator> iter1 = ds->CreateIterator();
955 EXPECT_EQ(iter1, nullptr);
956 }
957
TEST_F(MindDataTestPipeline,TestLfilterPipeline)958 TEST_F(MindDataTestPipeline, TestLfilterPipeline) {
959 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestLfilterPipeline.";
960 // Original waveform
961 std::shared_ptr<SchemaObj> schema = Schema();
962 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
963 std::shared_ptr<Dataset> ds = RandomData(50, schema);
964 EXPECT_NE(ds, nullptr);
965
966 ds = ds->SetNumWorkers(4);
967 EXPECT_NE(ds, nullptr);
968
969 std::vector<float> a_coeffs = {0.1, 0.2, 0.3};
970 std::vector<float> b_coeffs = {0.1, 0.2, 0.3};
971 auto LFilterOp = audio::LFilter(a_coeffs, b_coeffs);
972
973 ds = ds->Map({LFilterOp});
974 EXPECT_NE(ds, nullptr);
975
976 // Filtered waveform by lfilter
977 std::shared_ptr<Iterator> iter = ds->CreateIterator();
978 EXPECT_NE(ds, nullptr);
979
980 std::unordered_map<std::string, mindspore::MSTensor> row;
981 ASSERT_OK(iter->GetNextRow(&row));
982
983 std::vector<int64_t> expected = {2, 200};
984
985 int i = 0;
986 while (row.size() != 0) {
987 auto col = row["inputData"];
988 ASSERT_EQ(col.Shape(), expected);
989 ASSERT_EQ(col.Shape().size(), 2);
990 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
991 ASSERT_OK(iter->GetNextRow(&row));
992 i++;
993 }
994 EXPECT_EQ(i, 50);
995
996 iter->Stop();
997 }
998
TEST_F(MindDataTestPipeline,TestLfilterWrongArgs)999 TEST_F(MindDataTestPipeline, TestLfilterWrongArgs) {
1000 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestLfilterWrongArgs.";
1001 std::shared_ptr<SchemaObj> schema = Schema();
1002 // Original waveform
1003 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
1004 std::shared_ptr<Dataset> ds = RandomData(50, schema);
1005 std::shared_ptr<Dataset> ds01;
1006 EXPECT_NE(ds, nullptr);
1007
1008 // Check sample_rate
1009 MS_LOG(INFO) << "a_coeffs size not equal to b_coeffs";
1010 std::vector<float> a_coeffs = {0.1, 0.2, 0.3};
1011 std::vector<float> b_coeffs = {0.1, 0.2};
1012 auto LFilterOp = audio::LFilter(a_coeffs, b_coeffs);
1013 ds01 = ds->Map({LFilterOp});
1014 EXPECT_NE(ds01, nullptr);
1015
1016 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
1017 EXPECT_EQ(iter01, nullptr);
1018 }
1019
TEST_F(MindDataTestPipeline,TestDCShiftPipeline)1020 TEST_F(MindDataTestPipeline, TestDCShiftPipeline) {
1021 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestDCShiftPipeline.";
1022
1023 std::shared_ptr<SchemaObj> schema = Schema();
1024 ASSERT_OK(schema->add_column("waveform", mindspore::DataType::kNumberTypeFloat32, {1, 2, 100}));
1025 std::shared_ptr<Dataset> ds = RandomData(50, schema);
1026 EXPECT_NE(ds, nullptr);
1027
1028 auto dc_shift_op = audio::DCShift(0.8, 0.02);
1029
1030 ds = ds->Map({dc_shift_op});
1031 EXPECT_NE(ds, nullptr);
1032
1033 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1034 EXPECT_NE(ds, nullptr);
1035
1036 std::unordered_map<std::string, mindspore::MSTensor> row;
1037 ASSERT_OK(iter->GetNextRow(&row));
1038
1039 std::vector<int64_t> expected = {1, 2, 100};
1040
1041 int i = 0;
1042 while (row.size() != 0) {
1043 auto col = row["waveform"];
1044 ASSERT_EQ(col.Shape(), expected);
1045 ASSERT_EQ(col.Shape().size(), 3);
1046 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1047 ASSERT_OK(iter->GetNextRow(&row));
1048 i++;
1049 }
1050 EXPECT_EQ(i, 50);
1051
1052 iter->Stop();
1053 }
1054
TEST_F(MindDataTestPipeline,TestDCShiftPipelineError)1055 TEST_F(MindDataTestPipeline, TestDCShiftPipelineError) {
1056 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestDCShiftPipelineError.";
1057 std::shared_ptr<SchemaObj> schema = Schema();
1058 ASSERT_OK(schema->add_column("waveform", mindspore::DataType::kNumberTypeFloat32, {100}));
1059 std::shared_ptr<Dataset> ds = RandomData(4, schema);
1060 EXPECT_NE(ds, nullptr);
1061
1062 auto dc_shift_op = audio::DCShift(3, 0.02);
1063
1064 ds = ds->Map({dc_shift_op});
1065 EXPECT_NE(ds, nullptr);
1066
1067 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1068 EXPECT_EQ(iter, nullptr);
1069 }
1070
TEST_F(MindDataTestPipeline,TestBiquadBasic)1071 TEST_F(MindDataTestPipeline, TestBiquadBasic) {
1072 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBiquadBasic.";
1073 // Original waveform
1074 std::shared_ptr<SchemaObj> schema = Schema();
1075 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 200}));
1076 std::shared_ptr<Dataset> ds = RandomData(50, schema);
1077 EXPECT_NE(ds, nullptr);
1078
1079 ds = ds->SetNumWorkers(4);
1080 EXPECT_NE(ds, nullptr);
1081
1082 auto BiquadOp = audio::Biquad(0.01, 0.02, 0.13, 1, 0.12, 0.3);
1083
1084 ds = ds->Map({BiquadOp});
1085 EXPECT_NE(ds, nullptr);
1086
1087 // Filtered waveform by biquad
1088 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1089 EXPECT_NE(ds, nullptr);
1090
1091 std::unordered_map<std::string, mindspore::MSTensor> row;
1092 ASSERT_OK(iter->GetNextRow(&row));
1093
1094 std::vector<int64_t> expected = {2, 200};
1095
1096 int i = 0;
1097 while (row.size() != 0) {
1098 auto col = row["inputData"];
1099 ASSERT_EQ(col.Shape(), expected);
1100 ASSERT_EQ(col.Shape().size(), 2);
1101 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1102 ASSERT_OK(iter->GetNextRow(&row));
1103 i++;
1104 }
1105 EXPECT_EQ(i, 50);
1106
1107 iter->Stop();
1108 }
1109
TEST_F(MindDataTestPipeline,TestBiquadParamCheck)1110 TEST_F(MindDataTestPipeline, TestBiquadParamCheck) {
1111 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBiquadParamCheck.";
1112 std::shared_ptr<SchemaObj> schema = Schema();
1113 // Original waveform
1114 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
1115 std::shared_ptr<Dataset> ds = RandomData(50, schema);
1116 std::shared_ptr<Dataset> ds01;
1117 EXPECT_NE(ds, nullptr);
1118
1119 // Check a0
1120 MS_LOG(INFO) << "a0 is zero.";
1121 auto biquad_op_01 = audio::Biquad(0.01, 0.02, 0.13, 0, 0.12, 0.3);
1122 ds01 = ds->Map({biquad_op_01});
1123 EXPECT_NE(ds01, nullptr);
1124
1125 std::shared_ptr<Iterator> iter01 = ds01->CreateIterator();
1126 EXPECT_EQ(iter01, nullptr);
1127 }
1128
TEST_F(MindDataTestPipeline,TestFadeWithPipeline)1129 TEST_F(MindDataTestPipeline, TestFadeWithPipeline) {
1130 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithPipeline.";
1131 std::shared_ptr<SchemaObj> schema = Schema();
1132 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {1, 200}));
1133 std::shared_ptr<Dataset> ds = RandomData(50, schema);
1134 EXPECT_NE(ds, nullptr);
1135
1136 ds = ds->SetNumWorkers(4);
1137 EXPECT_NE(ds, nullptr);
1138
1139 auto fade_op = audio::Fade(20, 30, FadeShape::kExponential);
1140
1141 ds = ds->Map({fade_op});
1142 EXPECT_NE(ds, nullptr);
1143
1144 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1145 EXPECT_NE(iter, nullptr);
1146
1147 std::unordered_map<std::string, mindspore::MSTensor> row;
1148 ASSERT_OK(iter->GetNextRow(&row));
1149
1150 std::vector<int64_t> expected = {1, 200};
1151
1152 int i = 0;
1153 while (row.size() != 0) {
1154 auto col = row["inputData"];
1155 ASSERT_EQ(col.Shape(), expected);
1156 ASSERT_EQ(col.Shape().size(), 2);
1157 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1158 ASSERT_OK(iter->GetNextRow(&row));
1159 i++;
1160 }
1161 EXPECT_EQ(i, 50);
1162
1163 iter->Stop();
1164 }
1165
TEST_F(MindDataTestPipeline,TestFadeWithLinear)1166 TEST_F(MindDataTestPipeline, TestFadeWithLinear) {
1167 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithLinear.";
1168 std::shared_ptr<SchemaObj> schema = Schema();
1169 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {2, 10}));
1170 std::shared_ptr<Dataset> ds = RandomData(10, schema);
1171 EXPECT_NE(ds, nullptr);
1172
1173 ds = ds->SetNumWorkers(4);
1174 EXPECT_NE(ds, nullptr);
1175
1176 auto fade_op = audio::Fade(5, 5, FadeShape::kLinear);
1177
1178 ds = ds->Map({fade_op});
1179 EXPECT_NE(ds, nullptr);
1180
1181 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1182 EXPECT_NE(iter, nullptr);
1183
1184 std::unordered_map<std::string, mindspore::MSTensor> row;
1185 ASSERT_OK(iter->GetNextRow(&row));
1186
1187 std::vector<int64_t> expected = {2, 10};
1188
1189 int i = 0;
1190 while (row.size() != 0) {
1191 auto col = row["inputData"];
1192 ASSERT_EQ(col.Shape(), expected);
1193 ASSERT_EQ(col.Shape().size(), 2);
1194 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1195 ASSERT_OK(iter->GetNextRow(&row));
1196 i++;
1197 }
1198 EXPECT_EQ(i, 10);
1199
1200 iter->Stop();
1201 }
1202
TEST_F(MindDataTestPipeline,TestFadeWithLogarithmic)1203 TEST_F(MindDataTestPipeline, TestFadeWithLogarithmic) {
1204 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithLogarithmic.";
1205 std::shared_ptr<SchemaObj> schema = Schema();
1206 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat64, {1, 150}));
1207 std::shared_ptr<Dataset> ds = RandomData(30, schema);
1208 EXPECT_NE(ds, nullptr);
1209
1210 ds = ds->SetNumWorkers(4);
1211 EXPECT_NE(ds, nullptr);
1212
1213 auto fade_op = audio::Fade(80, 100, FadeShape::kLogarithmic);
1214
1215 ds = ds->Map({fade_op});
1216 EXPECT_NE(ds, nullptr);
1217
1218 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1219 EXPECT_NE(iter, nullptr);
1220
1221 std::unordered_map<std::string, mindspore::MSTensor> row;
1222 ASSERT_OK(iter->GetNextRow(&row));
1223
1224 std::vector<int64_t> expected = {1, 150};
1225
1226 int i = 0;
1227 while (row.size() != 0) {
1228 auto col = row["inputData"];
1229 ASSERT_EQ(col.Shape(), expected);
1230 ASSERT_EQ(col.Shape().size(), 2);
1231 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat64);
1232 ASSERT_OK(iter->GetNextRow(&row));
1233 i++;
1234 }
1235 EXPECT_EQ(i, 30);
1236
1237 iter->Stop();
1238 }
1239
TEST_F(MindDataTestPipeline,TestFadeWithQuarterSine)1240 TEST_F(MindDataTestPipeline, TestFadeWithQuarterSine) {
1241 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithQuarterSine.";
1242 std::shared_ptr<SchemaObj> schema = Schema();
1243 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt32, {20, 20000}));
1244 std::shared_ptr<Dataset> ds = RandomData(40, schema);
1245 EXPECT_NE(ds, nullptr);
1246
1247 ds = ds->SetNumWorkers(4);
1248 EXPECT_NE(ds, nullptr);
1249
1250 auto fade_op = audio::Fade(1000, 1000, FadeShape::kQuarterSine);
1251
1252 ds = ds->Map({fade_op});
1253 EXPECT_NE(ds, nullptr);
1254
1255 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1256 EXPECT_NE(iter, nullptr);
1257
1258 std::unordered_map<std::string, mindspore::MSTensor> row;
1259 ASSERT_OK(iter->GetNextRow(&row));
1260
1261 std::vector<int64_t> expected = {20, 20000};
1262
1263 int i = 0;
1264 while (row.size() != 0) {
1265 auto col = row["inputData"];
1266 ASSERT_EQ(col.Shape(), expected);
1267 ASSERT_EQ(col.Shape().size(), 2);
1268 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1269 ASSERT_OK(iter->GetNextRow(&row));
1270 i++;
1271 }
1272 EXPECT_EQ(i, 40);
1273
1274 iter->Stop();
1275 }
1276
TEST_F(MindDataTestPipeline,TestFadeWithHalfSine)1277 TEST_F(MindDataTestPipeline, TestFadeWithHalfSine) {
1278 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithHalfSine.";
1279 std::shared_ptr<SchemaObj> schema = Schema();
1280 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeInt16, {1, 200}));
1281 std::shared_ptr<Dataset> ds = RandomData(40, schema);
1282 EXPECT_NE(ds, nullptr);
1283
1284 ds = ds->SetNumWorkers(4);
1285 EXPECT_NE(ds, nullptr);
1286
1287 auto fade_op = audio::Fade(100, 100, FadeShape::kHalfSine);
1288
1289 ds = ds->Map({fade_op});
1290 EXPECT_NE(ds, nullptr);
1291
1292 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1293 EXPECT_NE(iter, nullptr);
1294
1295 std::unordered_map<std::string, mindspore::MSTensor> row;
1296 ASSERT_OK(iter->GetNextRow(&row));
1297
1298 std::vector<int64_t> expected = {1, 200};
1299
1300 int i = 0;
1301 while (row.size() != 0) {
1302 auto col = row["inputData"];
1303 ASSERT_EQ(col.Shape(), expected);
1304 ASSERT_EQ(col.Shape().size(), 2);
1305 ASSERT_EQ(col.DataType(), mindspore::DataType::kNumberTypeFloat32);
1306 ASSERT_OK(iter->GetNextRow(&row));
1307 i++;
1308 }
1309 EXPECT_EQ(i, 40);
1310
1311 iter->Stop();
1312 }
1313
TEST_F(MindDataTestPipeline,TestFadeWithInvalidArg)1314 TEST_F(MindDataTestPipeline, TestFadeWithInvalidArg) {
1315 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestFadeWithInvalidArg.";
1316 std::shared_ptr<SchemaObj> schema = Schema();
1317 ASSERT_OK(schema->add_column("inputData", mindspore::DataType::kNumberTypeFloat32, {1, 200}));
1318 std::shared_ptr<Dataset> ds_01 = RandomData(50, schema);
1319 EXPECT_NE(ds_01, nullptr);
1320
1321 ds_01 = ds_01->SetNumWorkers(4);
1322 EXPECT_NE(ds_01, nullptr);
1323
1324 auto fade_op_01 = audio::Fade(-20, 30, FadeShape::kLogarithmic);
1325
1326 ds_01 = ds_01->Map({fade_op_01});
1327 EXPECT_NE(ds_01, nullptr);
1328 // Expect failure, fade in length less than zero
1329 std::shared_ptr<Iterator> iter_01 = ds_01->CreateIterator();
1330 EXPECT_EQ(iter_01, nullptr);
1331
1332 std::shared_ptr<Dataset> ds_02 = RandomData(50, schema);
1333 EXPECT_NE(ds_02, nullptr);
1334
1335 ds_02 = ds_02->SetNumWorkers(4);
1336 EXPECT_NE(ds_02, nullptr);
1337
1338 auto fade_op_02 = audio::Fade(5, -3, FadeShape::kExponential);
1339
1340 ds_02 = ds_02->Map({fade_op_02});
1341 EXPECT_NE(ds_02, nullptr);
1342 // Expect failure, fade out length less than zero
1343 std::shared_ptr<Iterator> iter_02 = ds_02->CreateIterator();
1344 EXPECT_EQ(iter_02, nullptr);
1345 }
1346
TEST_F(MindDataTestPipeline,TestMagphase)1347 TEST_F(MindDataTestPipeline, TestMagphase) {
1348 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestMagphase.";
1349
1350 float power = 2.0;
1351 std::shared_ptr<SchemaObj> schema = Schema();
1352 ASSERT_OK(schema->add_column("col1", mindspore::DataType::kNumberTypeFloat32, {1, 2}));
1353 std::shared_ptr<Dataset> ds = RandomData(8, schema);
1354 EXPECT_NE(ds, nullptr);
1355 std::shared_ptr<TensorTransform> magphase(new audio::Magphase(power));
1356 auto ds1 = ds->Map({magphase}, {"col1"}, {"mag", "phase"});
1357 EXPECT_NE(ds1, nullptr);
1358 std::shared_ptr<Iterator> iter = ds1->CreateIterator();
1359 EXPECT_NE(iter, nullptr);
1360 std::unordered_map<std::string, mindspore::MSTensor> row;
1361 ASSERT_OK(iter->GetNextRow(&row));
1362 uint64_t i = 0;
1363 while (row.size() != 0) {
1364 i++;
1365 ASSERT_OK(iter->GetNextRow(&row));
1366 }
1367 EXPECT_EQ(i, 8);
1368 iter->Stop();
1369 }
1370
TEST_F(MindDataTestPipeline,TestMagphaseWrongArgs)1371 TEST_F(MindDataTestPipeline, TestMagphaseWrongArgs) {
1372 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestMagphaseWrongArgs.";
1373
1374 float power_wrong = -1.0;
1375 std::shared_ptr<TensorTransform> magphase(new audio::Magphase(power_wrong));
1376 std::unordered_map<std::string, mindspore::MSTensor> row;
1377
1378 //Magphase: power must be greater than or equal to 0.
1379 std::shared_ptr<SchemaObj> schema = Schema();
1380 ASSERT_OK(schema->add_column("col1", mindspore::DataType::kNumberTypeFloat32, {2, 2}));
1381 std::shared_ptr<Dataset> ds = RandomData(8, schema);
1382 EXPECT_NE(ds, nullptr);
1383 ds = ds->Map({magphase}, {"col1"}, {"mag", "phase"});
1384 EXPECT_NE(ds, nullptr);
1385 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1386 EXPECT_EQ(iter, nullptr);
1387 }
1388