diff --git a/vibration_convert/core/native/include/vibration_convert_core.h b/vibration_convert/core/native/include/vibration_convert_core.h new file mode 100644 index 0000000000000000000000000000000000000000..9757ba43c50c90a9bad82ecbf469e65dfcb0ab99 --- /dev/null +++ b/vibration_convert/core/native/include/vibration_convert_core.h @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef VIBRATION_CONVERT_CORE_H +#define VIBRATION_CONVERT_CORE_H + +#include +#include + +#include + +#include "frequency_estimation.h" +#include "intensity_processor.h" +#include "onset.h" +#include "peak_finder.h" +#include "singleton.h" +#include "vibration_convert_type.h" + +namespace OHOS { +namespace Sensors { +/** + * Merge data with onset and transient +*/ +struct UnionTransientEvent { + bool transientEventFlag = false;; + int32_t onsetIdx { 0 }; + double onsetTime { 0.0 }; + + UnionTransientEvent() = default; + UnionTransientEvent(int32_t onsetIdx, double onsetTime, bool transientEventFlag = false) : + transientEventFlag(transientEventFlag), onsetIdx(onsetIdx), onsetTime(onsetTime) {} +}; + +struct IntensityData { + double rmseEnvelope { 0.0 }; + double rmseTimex { 0.0 }; + double rmseBand { 0.0 }; + int32_t rmseIntensityNorm { 0 }; + double rmseTimeNorm { 0.0 }; + + IntensityData() = default; + IntensityData(double envelope, double time, double band, int32_t intensityNorm, double timeNorm) : + rmseEnvelope(envelope), rmseTimex(time), rmseBand(band), rmseIntensityNorm(intensityNorm), + rmseTimeNorm(timeNorm) {} +}; + +struct ContinuousEvent { + double time { 0.0 }; + double duration { 0.0 }; + int32_t intensity { 0 }; + int32_t frequency { 0 }; + + ContinuousEvent(double time, double duration, int32_t intensity, int32_t frequency) : time(time), duration(duration), + intensity(intensity), frequency(frequency) {} +}; + +struct TransientEvent { + double time { 0.0 }; + int32_t intensity { 0 }; + int32_t frequency { 0 }; + + TransientEvent(double time, int32_t intensity, int32_t frequency) : time(time), intensity(intensity), + frequency(frequency) {} +}; + +/** + * @brief The system parameters for converting audio to vibration will be read out from the system parameter + * file in the future + */ +struct ConvertSystemParameters { + /** if the # flag is Yes, long and short events are stored in blocks, and if No, they are stored in + * chronological order*/ + bool blockStoreFlag { false }; + /** Has the onset alignment algorithm been used */ + bool onsetBacktrackFlag { false }; + /** Should use absolute time or window start time */ + bool useAbsTimeFlag { true }; + /** Linear processing for intensity. */ + bool intensityUseLinearFlag { true }; + /** Segmented envelope processing. */ + bool splitSegmentFlag { false }; + /** The energy difference within an envelope is less than c_ i_ combinate_ Delta is merged, + * with a value range of<5 */ + bool intensityCmbFlag { true }; + /** Monotonic merging within the envelope, if c_monotonicity_flag is true, + * c_slop_cmb_flag There's no need to deal. */ + bool monotonicityCmbFlag { false }; + /** Support monotonic adjacent point slopes less than c_slop_delta, and c_slop_cmb_flag with true then merge. */ + bool slopCmbFlag { false }; + /** When calculating intensity, align the center and add half frames of 0 at the beginning and end respectively. */ + bool centerPaddingFlag { true }; +}; + +class VibrationConvertCore : public Singleton { +public: + VibrationConvertCore() = default; + ~VibrationConvertCore() = default; + + /** + * @brief Convert audio files to haptic events. + * + * @param audioSetting: the set audio sampling threshold. For details, see {@link AudioSetting}. + * @param audioDatas: the audio data. + * @param hapticEvents: the information of the event, after translated. For details, see {@link HapticEvent}. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + */ + int32_t ConvertAudioToHaptic(const AudioSetting &audioSetting, const std::vector &audioDatas, + std::vector &hapticEvents); + +private: + DISALLOW_COPY_AND_MOVE(VibrationConvertCore); + int32_t ResampleAudioData(const std::vector &srcDatas); + std::vector PreprocessAudioData(); + int32_t PreprocessParameter(const std::vector &datas, int32_t &onsetHopLength, double &lowerDelta); + std::vector MapOnsetHop(const std::vector &drwIdxs, int32_t onsetHopLength); + double CalcRmsLowerData(size_t dataSize, const std::vector &rmses, const std::vector &newDrwIdxs); + int32_t CalcOnsetHopLength(const std::vector &datas, double rmseMax, size_t newDrwIdxLen, + bool &continuousEventFlag, int32_t &newOnsetHopLen); + /** + * Before vibration conversion, amplitude density is used to classify audio files, determine whether there are + * long events in the audio files, and adjust the onset detection window. + */ + int32_t IsIncludeContinuoustEvent(const std::vector &datas, int32_t &longestCount, + double &unzeroDensity, bool &isIncludeContinuoustEvent); + int32_t ConvertTransientEvent(const std::vector &datas, int32_t onsetHopLength, + std::vector &unionTransientEvents); + std::vector DetectOnset(const std::vector &audioDatas, int32_t onsetHopLength); + std::vector IsTransientEvent(const std::vector &datas, const std::vector &onsetIdxs); + void GetUnzeroCount(const std::vector &localDatas, int32_t &unzeroCount, double &unzeroDensity); + bool IsTransientEventFlag(int32_t unzeroCount, double unzeroDensity); + void TranslateAnchorPoint(const std::vector &litudePeakPos, + std::vector &unionTransientEvents); + void TranslateAnchorPoint(int32_t amplitudePeakPos, int32_t &litudePeakIdx, double &litudePeakTime); + int32_t DetectRmsIntensity(const std::vector &datas, double rmsILowerDelta, + std::vector &intensityDatas); + std::vector DetectFrequency(const std::vector &datas, const std::vector &rmseIntensityNorms); + std::vector StartTimeNormalize(int32_t rmseLen); + +private: + void OutputTransientEvents(const std::vector &unionTransientEvents, + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes); + void OutputTransientEventsByInsertTime(const std::vector &onsetTimes, + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes); + void OutputTransientEventsAlign(const std::vector &unionTransientEvents, + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes); + void OutputTransientEventsDirect(const std::vector &unionTransientEvents, + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes); + void AddTransientEventData(TransientEvent transientEvent); + void OutputAllContinuousEvent(const std::vector &intensityDatas, + const std::vector transientIndexs, const std::vector &freqNorms, + const std::vector &transientEventFlags); + void OutputAllContinuousEventByUnseg(const std::vector &intensityDatas, + const std::vector transientIndexs, const std::vector &freqNorms, + const std::vector &transientEventFlags); + void FillDefaultContinuousEvents(const std::vector &rmseTimeNorms, std::vector ×, + std::vector &durations); + int32_t InsertTransientEvent(const std::vector &rmseTimeNorms, + const std::vector &transientIndexs, const std::vector &transientEventFlags, + std::vector ×, std::vector &durations); + void MergeContinuousEvents(const std::vector &interContinuousEvents); + void AddContinuousEventData(const ContinuousEvent &continuousEvent); + void StoreHapticEvent(); + void StoreEventSequence(); + void StoreEventBlock(); + void CombinateContinuousEvents(const std::vector &continuousEvents, int32_t startIdx, int32_t endIdx); + /** + * Using transient events instead of onse + */ + void EmplaceOnsetTime(bool flag, int32_t idx, double time, std::vector &unionTransientEvents); + std::vector GetLocalEnvelope(const std::vector &datas); + bool GetRmseLowerDelta(double lowerDelta, const std::vector &rmses, double &lowestDelta); + bool GetTransientEventFlag(const std::vector &datas, int32_t onsetIdx); + std::vector GetTransientEventFlags(const std::vector &datas, const std::vector &onsetIdxs); + +private: + ConvertSystemParameters systemPara_; + AudioSetting audioSetting_; + std::vector srcAudioDatas_; + std::vector continuousEvents_; + std::vector transientEvents_; + std::vector hapticEvents_; + bool continuousEventExistFlag_ { false }; + IntensityProcessor intensityProcessor_; + FrequencyEstimation frequencyEstimation_; + PeakFinder peakFinder_; + Onset onset_; + int32_t onsetMinSkip_ { 0 }; +}; +} // namespace Sensors +} // namespace OHOS +#endif // VIBRATION_CONVERT_CORE_H \ No newline at end of file diff --git a/vibration_convert/core/native/include/vibration_convert_type.h b/vibration_convert/core/native/include/vibration_convert_type.h new file mode 100644 index 0000000000000000000000000000000000000000..f180bca35be6c799443179644d3eff481f972ec4 --- /dev/null +++ b/vibration_convert/core/native/include/vibration_convert_type.h @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef VIBRATION_CONVERT_TYPE_H +#define VIBRATION_CONVERT_TYPE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Enumerates basic event enumeration of haptic. + * + * @since 1.0 + */ +typedef enum EventTag { + /** Continuous event. */ + EVENT_TAG_CONTINUOUS = 0, + /** Transient event. */ + EVENT_TAG_TRANSIENT = 1, +} VibrateTag; + +/** + * @brief Basic event-parameters definition of haptic. + * + * The parameters include the haptic basic event enumeration, start time, duration, intensity and frequency. + * + * @since 1.0 + */ +struct HapticEvent { + /** Basic event enumeration of haptic. */ + VibrateTag vibrateTag; + /** Start time. */ + int32_t startTime { 0 }; + /** Duration. */ + int32_t duration { 0 }; + /** Intensity. */ + int32_t intensity { 0 }; + /** Frequency. */ + int32_t frequency { 0 }; +}; + +/** + * @brief Defines the audio setting parameters. + * + * The parameters include the setting transient detection treshold and intensity treshold and + * frequency treshold and frequency range. + * + * @since 1.0 + */ +struct AudioSetting { + /** 0-100. */ + int32_t transientDetection { 0 }; + /** 0-100. */ + int32_t intensityTreshold { 0 }; + /** 0-100. */ + int32_t frequencyTreshold { 0 }; + /**< Max frequency(Hz). */ + int32_t frequencyMaxValue { 0 }; + /**< Min frequency(Hz). */ + int32_t frequencyMinValue { 0 }; +}; + +/** + * @brief Defines the audio file attribute. + * + * Parameters include data sampling frequency, data sampling duration, raw data number. + * + * @since 1.0 + */ +struct AudioAttribute { + /** sampling frequency. */ + uint32_t sampleRate { 0 }; + /** data sampling duration. */ + uint32_t duration { 0 }; + /** number of raw data. */ + uint32_t dataCount { 0 }; +}; + +/** + * @brief Defines the audio file data. + * + * Parameters include the number of data after the sampling interval, + * audio data, and data maximum and minimum. + * + * @since 1.0 + */ +struct AudioData { + /** data minimum. */ + double min { 0.0 }; + /** data maximum. */ + double max { 0.0 }; + /** audio data. */ + std::vector audioDatas; +}; + +/** + * @brief Defines the audio file attribute. + * + * Parameters include ChunkID, ChunkSize, Format, FmtChannels, SampleRate, ByteRate, BitsPerSample. + * + * @since 1.0 + */ +struct AttributeChunk { + char chunkID[4] { 0 }; //'R','I','F','F' + uint32_t chunkSize { 0 }; + char format[4] { 0 }; //'W','A','V','E' + char fmtID[4] { 0 }; + uint32_t fmtSize { 0 }; + uint16_t fmtTag { 0 }; + uint16_t fmtChannels { 0 }; + uint32_t sampleRate { 0 }; + uint32_t byteRate { 0 }; + uint16_t blockAilgn { 0 }; + uint16_t bitsPerSample { 0 }; + char dataID[4] { 0 }; //'d','a','t','a' + uint32_t dataSize { 0 }; +}; + +struct RawFileDescriptor { + int32_t fd = 0; + int64_t offset = 0; + int64_t length = -1; +}; + +/** @} */ +#ifdef __cplusplus +}; +#endif +#endif // VIBRATION_CONVERT_TYPE_H diff --git a/vibration_convert/core/native/src/vibration_convert_core.cpp b/vibration_convert/core/native/src/vibration_convert_core.cpp index f491b1a36617308355b29a56fb664c5ab74ccbc0..dc08e3cfaf120a838cc2247efe529a7b856e90e6 100644 --- a/vibration_convert/core/native/src/vibration_convert_core.cpp +++ b/vibration_convert/core/native/src/vibration_convert_core.cpp @@ -64,16 +64,16 @@ constexpr int32_t ADSR_BOUNDARY_STATUS_ONE { 1 }; constexpr int32_t ADSR_BOUNDARY_STATUS_BOTH { 2 }; } // namespace -int32_t VibrationConvertCore::ConvertAudioToHaptic(const AudioSetting &audioSetting, const std::vector &audioData, +int32_t VibrationConvertCore::ConvertAudioToHaptic(const AudioSetting &audioSetting, const std::vector &audioDatas, std::vector &hapticEvents) { CALL_LOG_ENTER; - if (audioData.empty()) { - SEN_HILOGE("audioData is empty"); + if (audioDatas.empty()) { + SEN_HILOGE("audioDatas is empty"); return Sensors::ERROR; } audioSetting_ = audioSetting; - int32_t ret = ResampleAudioData(audioData); + int32_t ret = ResampleAudioData(audioDatas); if (ret != Sensors::SUCCESS) { SEN_HILOGE("ResampleAudioData failed"); return ret; @@ -90,33 +90,33 @@ int32_t VibrationConvertCore::ConvertAudioToHaptic(const AudioSetting &audioSett SEN_HILOGE("ConvertTransientEvent failed"); return Sensors::ERROR; } - std::vector intensityData; - // Processing intensity data, output parameters:intensityData - ret = DetectRmsIntensity(data, rmsILowerDelta, intensityData); + std::vector intensityDatas; + // Processing intensity data, output parameters:intensityDatas + ret = DetectRmsIntensity(data, rmsILowerDelta, intensityDatas); if (ret != Sensors::SUCCESS) { SEN_HILOGE("DetectRmsIntensity failed"); return ret; } // Frequency detection std::vector rmseIntensityNorm; - for (size_t i = 0; i < intensityData.size(); i++) { - rmseIntensityNorm.push_back(intensityData[i].rmseIntensityNorm); + for (size_t i = 0; i < intensityDatas.size(); i++) { + rmseIntensityNorm.push_back(intensityDatas[i].rmseIntensityNorm); } - std::vector freqNorm = DetectFrequency(data, rmseIntensityNorm); - if (freqNorm.empty()) { + std::vector freqNorms = DetectFrequency(data, rmseIntensityNorm); + if (freqNorms.empty()) { SEN_HILOGE("DetectFrequency failed"); return Sensors::ERROR; } std::vector transientIndexes; - std::vector transientEventTime; - // Output all Transient events, output parameters: transientIndex transientEventTime - OutputTransientEvents(unionTransientEvents, intensityData, freqNorm, transientIndexes, transientEventTime); + std::vector transientEventTimes; + // Output all Transient events, output parameters: transientIndex transientEventTimes + OutputTransientEvents(unionTransientEvents, intensityDatas, freqNorms, transientIndexes, transientEventTimes); if (continuousEventExistFlag_) { std::vector transientEventFlags; for (size_t i = 0; i < unionTransientEvents.size(); i++) { transientEventFlags.push_back(unionTransientEvents[i].transientEventFlag); } - OutputAllContinuousEvent(intensityData, transientIndexes, freqNorm, transientEventFlags); + OutputAllContinuousEvent(intensityDatas, transientIndexes, freqNorms, transientEventFlags); } StoreHapticEvent(); hapticEvents = hapticEvents_; @@ -125,17 +125,17 @@ int32_t VibrationConvertCore::ConvertAudioToHaptic(const AudioSetting &audioSett return Sensors::SUCCESS; } -int32_t VibrationConvertCore::ResampleAudioData(const std::vector &srcData) +int32_t VibrationConvertCore::ResampleAudioData(const std::vector &srcDatas) { - if (srcData.empty()) { - SEN_HILOGE("srcData is empty"); + if (srcDatas.empty()) { + SEN_HILOGE("srcDatas is empty"); return Sensors::ERROR; } - size_t originDataSize = srcData.size(); - srcAudioData_.clear(); + size_t originDataSize = srcDatas.size(); + srcAudioDatas_.clear(); for (size_t i = 0; i < (originDataSize - 1); i += RESAMPLE_MULTIPLE) { - srcAudioData_.push_back(srcData[i]); - srcAudioData_.push_back(srcData[i+1]); + srcAudioDatas_.push_back(srcDatas[i]); + srcAudioDatas_.push_back(srcDatas[i+1]); } return Sensors::SUCCESS; } @@ -143,12 +143,12 @@ int32_t VibrationConvertCore::ResampleAudioData(const std::vector &srcDa std::vector VibrationConvertCore::PreprocessAudioData() { CALL_LOG_ENTER; - if (srcAudioData_.empty()) { + if (srcAudioDatas_.empty()) { SEN_HILOGE("invalid parameter"); return {}; } - std::vector absData = srcAudioData_; - std::vector dstData = srcAudioData_; + std::vector absData = srcAudioDatas_; + std::vector dstData = srcAudioDatas_; int32_t silence = 0; int32_t preClearEnd = 0; int32_t absDataSize = static_cast(absData.size()); @@ -188,29 +188,29 @@ std::vector VibrationConvertCore::PreprocessAudioData() return dstData; } -int32_t VibrationConvertCore::PreprocessParameter(const std::vector &data, int32_t &onsetHopLength, +int32_t VibrationConvertCore::PreprocessParameter(const std::vector &datas, int32_t &onsetHopLength, double &lowerDelta) { CALL_LOG_ENTER; - if (data.empty()) { - SEN_HILOGE("data is empty"); + if (datas.empty()) { + SEN_HILOGE("datas is empty"); return Sensors::ERROR; } - std::vector rmse = intensityProcessor_.GetRMS(data, ENERGY_HOP_LEN, systemPara_.centerPaddingFlag); + std::vector rmses = intensityProcessor_.GetRMS(datas, ENERGY_HOP_LEN, systemPara_.centerPaddingFlag); OnsetInfo onsetInfo; - if (onset_.CheckOnset(data, NFFT, onsetHopLength, onsetInfo) != Sensors::SUCCESS) { + if (onset_.CheckOnset(datas, NFFT, onsetHopLength, onsetInfo) != Sensors::SUCCESS) { SEN_HILOGE("CheckOnset Failed"); return Sensors::ERROR; } - std::vector newDrwIdx = MapOnsetHop(onsetInfo.idxs, onsetHopLength); - lowerDelta = CalcRmsLowerData(data.size(), rmse, newDrwIdx); - double rmseMax = *std::max_element(rmse.begin(),rmse.end()); - size_t newDrwIdxLen = newDrwIdx.size(); + std::vector newDrwIdxs = MapOnsetHop(onsetInfo.idxs, onsetHopLength); + lowerDelta = CalcRmsLowerData(datas.size(), rmses, newDrwIdxs); + double rmseMax = *std::max_element(rmses.begin(), rmses.end()); + size_t newDrwIdxLen = newDrwIdxs.size(); bool continuousEventFlag = false; int32_t newOnsetHopLen = onsetHopLength; // Amplitude density is used to classify audio files, determine whether there are long events in the audio file, // and adjust the onset detection window - if (CalcOnsetHopLength(data, rmseMax, newDrwIdxLen, continuousEventFlag, newOnsetHopLen) != Sensors::SUCCESS) { + if (CalcOnsetHopLength(datas, rmseMax, newDrwIdxLen, continuousEventFlag, newOnsetHopLen) != Sensors::SUCCESS) { SEN_HILOGE("CalcOnsetHopLength failed"); return Sensors::ERROR; } @@ -219,7 +219,7 @@ int32_t VibrationConvertCore::PreprocessParameter(const std::vector &dat return Sensors::SUCCESS; } -std::vector VibrationConvertCore::MapOnsetHop(const std::vector &drwIdx, int32_t onsetHopLength) +std::vector VibrationConvertCore::MapOnsetHop(const std::vector &drwIdxs, int32_t onsetHopLength) { if (onsetHopLength == 0) { SEN_HILOGE("onsetHopLength is equal to 0"); @@ -231,29 +231,29 @@ std::vector VibrationConvertCore::MapOnsetHop(const std::vector(round(static_cast(idx) / coef))); } return newIdx; } -bool VibrationConvertCore::GetRmseLowerDelta(double lowerDelta, const std::vector &rmse, double &deltaByTime) +bool VibrationConvertCore::GetRmseLowerDelta(double lowerDelta, const std::vector &rmses, double &deltaByTime) { - int32_t rmseSize = static_cast(rmse.size()); - double rmseMax = *std::max_element(rmse.begin(),rmse.end()); - double rmseMin = *std::min_element(rmse.begin(),rmse.end()); + int32_t rmseSize = static_cast(rmses.size()); + double rmseMax = *std::max_element(rmses.begin(), rmses.end()); + double rmseMin = *std::min_element(rmses.begin(), rmses.end()); double rmseRange = rmseMax - rmseMin; int32_t i = 0; deltaByTime = lowerDelta; for (i = 0; i < rmseSize; ++i) { - if (rmse[i] > lowerDelta) { + if (rmses[i] > lowerDelta) { break; } } double rmsTimePerFrame = static_cast(ENERGY_HOP_LEN) / SAMPLE_RATE; int32_t j = rmseSize - 1; for (; j >= 0 ; j = (j - 1)) { - if (rmse[j] > lowerDelta) { + if (rmses[j] > lowerDelta) { break; } } @@ -268,12 +268,12 @@ bool VibrationConvertCore::GetRmseLowerDelta(double lowerDelta, const std::vecto return false; } -double VibrationConvertCore::CalcRmsLowerData(size_t dataSize, const std::vector &rmse, - const std::vector &newDrwIdx) +double VibrationConvertCore::CalcRmsLowerData(size_t dataSize, const std::vector &rmses, + const std::vector &newDrwIdxs) { double soundSizeDelta = 0.0; - double rmseMax = *std::max_element(rmse.begin(),rmse.end()); - double rmseMin = *std::min_element(rmse.begin(),rmse.end()); + double rmseMax = *std::max_element(rmses.begin(), rmses.end()); + double rmseMin = *std::min_element(rmses.begin(), rmses.end()); double rmseRange = rmseMax - rmseMin; if (rmseMax > RMSEMAX_THRESHOLD_HIGH) { soundSizeDelta = rmseRange * RMSE_LOWDELTA_RATIO_HIGH + rmseMin; @@ -283,11 +283,11 @@ double VibrationConvertCore::CalcRmsLowerData(size_t dataSize, const std::vector soundSizeDelta = rmseRange * RMSE_LOWDELTA_RATIO_LOW + rmseMin; } double lowerDelta = 0.0; - if (newDrwIdx.size() > 0) { + if (newDrwIdxs.size() > 0) { for (int32_t i = 0; i < RMSE_LOWDELTA_ITERATION_TIMES; i++) { - int32_t j = newDrwIdx[0]; + int32_t j = newDrwIdxs[0]; lowerDelta = rmseRange * (RMSE_LOWDELTA_RATIO_HIGH - i * RMSE_LOWDELTA_RATIO_STEP ) + rmseMin; - if ((rmse[j] > lowerDelta) || (rmse[j + 1] > lowerDelta)) { + if ((rmses[j] > lowerDelta) || (rmses[j + 1] > lowerDelta)) { break; } } @@ -299,7 +299,7 @@ double VibrationConvertCore::CalcRmsLowerData(size_t dataSize, const std::vector return audioDurationDelta; } double soundDurationDelta = soundSizeDelta; - bool findFlag = GetRmseLowerDelta(soundSizeDelta, rmse, soundDurationDelta); + bool findFlag = GetRmseLowerDelta(soundSizeDelta, rmses, soundDurationDelta); if (findFlag) { return soundDurationDelta; } @@ -309,17 +309,17 @@ double VibrationConvertCore::CalcRmsLowerData(size_t dataSize, const std::vector return lowerDelta; } -int32_t VibrationConvertCore::CalcOnsetHopLength(const std::vector &data, double rmseMax, +int32_t VibrationConvertCore::CalcOnsetHopLength(const std::vector &datas, double rmseMax, size_t newDrwIdxLen, bool &continuousEventFlag, int32_t &newOnsetHopLen) { - if (data.empty()) { - SEN_HILOGE("invalid parameter"); + if (datas.empty()) { + SEN_HILOGE("Invalid parameter"); return Sensors::ERROR; } int32_t longestCount = 0; double unzeroDensity = 0.0; bool continuousEventExistFlag = false; - int32_t ret = IsIncludeContinuoustEvent(data, longestCount, unzeroDensity, continuousEventExistFlag); + int32_t ret = IsIncludeContinuoustEvent(datas, longestCount, unzeroDensity, continuousEventExistFlag); if (ret != Sensors::SUCCESS) { SEN_HILOGE("IsIncludeContinuoustEvent failed"); return ret; @@ -336,57 +336,57 @@ int32_t VibrationConvertCore::CalcOnsetHopLength(const std::vector &data return Sensors::SUCCESS; } -std::vector VibrationConvertCore::GetLocalEnvelope(const std::vector &data) +std::vector VibrationConvertCore::GetLocalEnvelope(const std::vector &datas) { - if (data.empty()) { + if (datas.empty()) { SEN_HILOGE("invalid parameter"); return {}; } - std::vector envelope = data; - for (auto &elem : envelope) { + std::vector envelopes = datas; + for (auto &elem : envelopes) { elem = std::fabs(elem); } - double threshold = COEF * (*std::max_element(envelope.begin(), envelope.end())); - for (auto &elem : envelope) { + double threshold = COEF * (*std::max_element(envelopes.begin(), envelopes.end())); + for (auto &elem : envelopes) { if (elem < threshold) { elem = 0; } } - size_t dataSize = envelope.size(); + size_t dataSize = envelopes.size(); for (size_t i = 0; i < dataSize; ++i) { if ((i + LOCAL_ENVELOPE_MAX_LEN) > dataSize) { break; } std::vector segmentEnvelope; for (size_t j = i; j < (i + LOCAL_ENVELOPE_MAX_LEN); ++j) { - segmentEnvelope.push_back(envelope[j]); + segmentEnvelope.push_back(envelopes[j]); } - envelope[i] = *std::max_element(segmentEnvelope.begin(), segmentEnvelope.end()); + envelopes[i] = *std::max_element(segmentEnvelope.begin(), segmentEnvelope.end()); } - return envelope; + return envelopes; } -int32_t VibrationConvertCore::IsIncludeContinuoustEvent(const std::vector &data, +int32_t VibrationConvertCore::IsIncludeContinuoustEvent(const std::vector &datas, int32_t &longestCount, double &unzeroDensity, bool &isIncludeContinuoustEvent) { // envelope must be a non-negative number. - std::vector envelope = GetLocalEnvelope(data); - if (envelope.empty()) { + std::vector envelopes = GetLocalEnvelope(datas); + if (envelopes.empty()) { SEN_HILOGE("GetLocalEnvelope failed"); return Sensors::ERROR; } - size_t envelopeSize = envelope.size(); + size_t envelopeSize = envelopes.size(); size_t j = 0; size_t k = 0; int32_t atLeastCnt = 2 * ENERGY_HOP_LEN; int32_t adsrCompleteStatus = ADSR_BOUNDARY_STATUS_NONE; std::vector countList; for (size_t i = 0; i < envelopeSize; ++i) { - if ((envelope[i] >= EPS_MIN) && (adsrCompleteStatus == ADSR_BOUNDARY_STATUS_NONE)) { + if ((envelopes[i] >= EPS_MIN) && (adsrCompleteStatus == ADSR_BOUNDARY_STATUS_NONE)) { j = i; adsrCompleteStatus = ADSR_BOUNDARY_STATUS_ONE; } - if ((envelope[i] < EPS_MIN) && (adsrCompleteStatus == ADSR_BOUNDARY_STATUS_ONE)) { + if ((envelopes[i] < EPS_MIN) && (adsrCompleteStatus == ADSR_BOUNDARY_STATUS_ONE)) { k = i; adsrCompleteStatus = ADSR_BOUNDARY_STATUS_BOTH; } @@ -513,27 +513,27 @@ void VibrationConvertCore::EmplaceOnsetTime(bool flag, int32_t idx, double time, } } -int32_t VibrationConvertCore::ConvertTransientEvent(const std::vector &data, int32_t onsetHopLength, +int32_t VibrationConvertCore::ConvertTransientEvent(const std::vector &datas, int32_t onsetHopLength, std::vector &unionTransientEvents) { CALL_LOG_ENTER; - if (data.empty()) { - SEN_HILOGE("data is empty"); + if (datas.empty()) { + SEN_HILOGE("datas is empty"); return Sensors::ERROR; } // Using System Methods to Detect Onset - std::vector unionTransientValues = DetectOnset(data, onsetHopLength); + std::vector unionTransientValues = DetectOnset(datas, onsetHopLength); // Is the onset just a transient event std::vector onsetIdxs; for (size_t i = 0; i < unionTransientValues.size(); i++) { onsetIdxs.push_back(unionTransientValues[i].onsetIdx); } - std::vector transientEventFlags = IsTransientEvent(data, onsetIdxs); + std::vector transientEventFlags = IsTransientEvent(datas, onsetIdxs); for (size_t i = 0; i < unionTransientValues.size(); i++) { unionTransientValues[i].transientEventFlag = transientEventFlags[i]; } IsolatedEnvelopeInfo isolatedEnvelopeInfo; - int32_t ret = peakFinder_.ObtainTransientByAmplitude(data, isolatedEnvelopeInfo); + int32_t ret = peakFinder_.ObtainTransientByAmplitude(datas, isolatedEnvelopeInfo); if (ret != Sensors::SUCCESS) { SEN_HILOGE("ObtainTransientByAmplitude failed."); return ret; @@ -573,11 +573,11 @@ int32_t VibrationConvertCore::ConvertTransientEvent(const std::vector &d return Sensors::SUCCESS; } -std::vector VibrationConvertCore::DetectOnset(const std::vector &data, +std::vector VibrationConvertCore::DetectOnset(const std::vector &datas, int32_t onsetHopLength) { OnsetInfo onsetInfo; - if (onset_.CheckOnset(data, NFFT, onsetHopLength, onsetInfo) != Sensors::SUCCESS) { + if (onset_.CheckOnset(datas, NFFT, onsetHopLength, onsetInfo) != Sensors::SUCCESS) { SEN_HILOGE("CheckOnset Failed"); return {}; } @@ -591,7 +591,7 @@ std::vector VibrationConvertCore::DetectOnset(const std::ve for (size_t i = 1; i < newIdx.size(); ++i) { idxDiff.push_back(newIdx[i] - newIdx[i - 1]); } - minSkip = *std::min_element(idxDiff.begin(),idxDiff.end()); + minSkip = *std::min_element(idxDiff.begin(), idxDiff.end()); } if (minSkip < ONSET_MINSKIP_MIN) { SEN_HILOGE("minSkip is less than 1"); @@ -613,10 +613,10 @@ std::vector VibrationConvertCore::DetectOnset(const std::ve return unionTransientEvents; } -bool VibrationConvertCore::GetTransientEventFlag(const std::vector &data, int32_t onsetIdx) +bool VibrationConvertCore::GetTransientEventFlag(const std::vector &datas, int32_t onsetIdx) { - if (data.empty()) { - SEN_HILOGE("data is empty"); + if (datas.empty()) { + SEN_HILOGE("datas is empty"); return false; } int32_t partLen = ONSET_ONE_WIN; @@ -627,25 +627,25 @@ bool VibrationConvertCore::GetTransientEventFlag(const std::vector &data if (beginIdx < 0) { beginIdx = 0; } - int32_t dataSize = static_cast(data.size()); + int32_t dataSize = static_cast(datas.size()); if (endIdx >= dataSize) { endIdx = dataSize - 1; } - std::vector localData; + std::vector localDatas; for (int32_t i = beginIdx; i <= endIdx; ++i) { - localData.push_back(data[i]); + localDatas.push_back(datas[i]); } double unzeroDensity = 0.0; int32_t unzeroCount = 0; // Output parameter: unzeroCnt unzeroDensity - GetUnzeroCount(localData, unzeroCount, unzeroDensity); + GetUnzeroCount(localDatas, unzeroCount, unzeroDensity); return IsTransientEventFlag(unzeroCount, unzeroDensity); } -std::vector VibrationConvertCore::GetTransientEventFlags(const std::vector &data, +std::vector VibrationConvertCore::GetTransientEventFlags(const std::vector &datas, const std::vector &onsetIdxs) { - if (data.empty() || (onsetIdxs.size() <= 1)) { + if (datas.empty() || (onsetIdxs.size() <= 1)) { SEN_HILOGE("Invalid parameter"); return {}; } @@ -672,13 +672,13 @@ std::vector VibrationConvertCore::GetTransientEventFlags(const std::vector if ((i != 0) && (beginIdx < onsetIdxs[i - 1] * ENERGY_HOP_LEN)) { beginIdx = onsetIdxs[i - 1] * ENERGY_HOP_LEN; } - int32_t dataSize = static_cast(data.size()); + int32_t dataSize = static_cast(datas.size()); if (endIdx >= dataSize) { endIdx = dataSize - 1; } std::vector localData; for (int32_t j = beginIdx; j <= endIdx; ++j) { - localData.push_back(data[i]); + localData.push_back(datas[i]); } double unzeroDensity = 0.0; int32_t unzeroCount = 0; @@ -688,33 +688,33 @@ std::vector VibrationConvertCore::GetTransientEventFlags(const std::vector return transientEventFlags; } -std::vector VibrationConvertCore::IsTransientEvent(const std::vector &data, +std::vector VibrationConvertCore::IsTransientEvent(const std::vector &datas, const std::vector &onsetIdxs) { - if (data.empty() || onsetIdxs.empty()) { - SEN_HILOGE("data or onsetIdxs is empty"); + if (datas.empty() || onsetIdxs.empty()) { + SEN_HILOGE("datas or onsetIdxs is empty"); return {}; } std::vector transientEventFlags; if (onsetIdxs.size() == 1) { - bool transientEventFlag = GetTransientEventFlag(data, onsetIdxs[0]); + bool transientEventFlag = GetTransientEventFlag(datas, onsetIdxs[0]); transientEventFlags.push_back(transientEventFlag); } else { - transientEventFlags = GetTransientEventFlags(data, onsetIdxs); + transientEventFlags = GetTransientEventFlags(datas, onsetIdxs); } return transientEventFlags; } -void VibrationConvertCore::GetUnzeroCount(const std::vector &localData, +void VibrationConvertCore::GetUnzeroCount(const std::vector &localDatas, int32_t &unzeroCount, double &unzeroDensity) { - if (localData.empty()) { + if (localDatas.empty()) { unzeroCount = 0; unzeroDensity = 0; - SEN_HILOGE("localData is empty"); + SEN_HILOGE("localDatas is empty"); return; } - std::vector envelope = localData; + std::vector envelope = localDatas; for (auto &elem : envelope) { elem = std::fabs(elem); if (elem < LOWER_AMP) { @@ -780,43 +780,43 @@ void VibrationConvertCore::TranslateAnchorPoint(int32_t amplitudePeakPos, int32_ } } -std::vector VibrationConvertCore::DetectFrequency(const std::vector &data, - const std::vector &rmseIntensityNorm) +std::vector VibrationConvertCore::DetectFrequency(const std::vector &datas, + const std::vector &rmseIntensityNorms) { CALL_LOG_ENTER; - std::vector zcr = frequencyEstimation_.GetZeroCrossingRate(data, FRAME_LEN, ENERGY_HOP_LEN); - for (auto &elem : zcr) { + std::vector zcrs = frequencyEstimation_.GetZeroCrossingRate(datas, FRAME_LEN, ENERGY_HOP_LEN); + for (auto &elem : zcrs) { elem = elem * SAMPLE_RATE * F_HALF; } std::vector voiceSegmentFlag = peakFinder_.GetVoiceSegmentFlag(); - std::vector freqNorm; - frequencyEstimation_.FreqPostProcess(zcr, voiceSegmentFlag, rmseIntensityNorm, freqNorm); - return freqNorm; + std::vector freqNorms; + frequencyEstimation_.FreqPostProcess(zcrs, voiceSegmentFlag, rmseIntensityNorms, freqNorms); + return freqNorms; } -int32_t VibrationConvertCore::DetectRmsIntensity(const std::vector &data, double rmsILowerDelta, - std::vector &intensityData) +int32_t VibrationConvertCore::DetectRmsIntensity(const std::vector &datas, double rmsILowerDelta, + std::vector &intensityDatas) { CALL_LOG_ENTER; - std::vector rmse = intensityProcessor_.GetRMS(data, ENERGY_HOP_LEN, systemPara_.centerPaddingFlag); - if (rmse.empty()) { - SEN_HILOGE("rmse is empty"); + std::vector rmses = intensityProcessor_.GetRMS(datas, ENERGY_HOP_LEN, systemPara_.centerPaddingFlag); + if (rmses.empty()) { + SEN_HILOGE("rmses is empty"); return Sensors::ERROR; } std::vector rmseTime; double rmsTimePerFrame = static_cast(ENERGY_HOP_LEN) / SAMPLE_RATE; - for (auto elem : rmse) { + for (auto elem : rmses) { rmseTime.push_back(elem * rmsTimePerFrame); } std::vector rmseBand; std::vector rmseNorm; - if (intensityProcessor_.RmseNormalize(rmse, rmsILowerDelta, rmseBand, rmseNorm) != Sensors::SUCCESS) { + if (intensityProcessor_.RmseNormalize(rmses, rmsILowerDelta, rmseBand, rmseNorm) != Sensors::SUCCESS) { SEN_HILOGE("RmseNormalize failed"); return Sensors::ERROR; } - std::vector rmseTimeNorm = StartTimeNormalize(rmse.size()); - std::vector ampLin = intensityProcessor_.VolumeInLinary(data, ENERGY_HOP_LEN); - std::vector ampDb = intensityProcessor_.VolumeInDB(data, ENERGY_HOP_LEN); + std::vector rmseTimeNorms = StartTimeNormalize(rmses.size()); + std::vector ampLin = intensityProcessor_.VolumeInLinary(datas, ENERGY_HOP_LEN); + std::vector ampDb = intensityProcessor_.VolumeInDB(datas, ENERGY_HOP_LEN); double ampDbMax = *std::max_element(ampDb.begin(), ampDb.end()); bool intensityUseLinearFlag = systemPara_.intensityUseLinearFlag; if (!intensityUseLinearFlag && (ampDbMax > AMPLITUDE_DB_MAX)) { @@ -824,8 +824,8 @@ int32_t VibrationConvertCore::DetectRmsIntensity(const std::vector &data rmseNorm[i] = ampDb[i] * DB_ZOOM_COEF; } } - for (size_t i = 0; i < rmse.size(); i++) { - intensityData.push_back(IntensityData(rmse[i], rmseTime[i], rmseBand[i], rmseNorm[i], rmseTimeNorm[i])); + for (size_t i = 0; i < rmses.size(); i++) { + intensityDatas.push_back(IntensityData(rmses[i], rmseTime[i], rmseBand[i], rmseNorm[i], rmseTimeNorms[i])); } return Sensors::SUCCESS; } @@ -833,18 +833,18 @@ int32_t VibrationConvertCore::DetectRmsIntensity(const std::vector &data std::vector VibrationConvertCore::StartTimeNormalize(int32_t rmseLen) { CALL_LOG_ENTER; - std::vector rmseTimeNorm; + std::vector rmseTimeNorms; double startTime = 0.0; for (int32_t i = 0; i < rmseLen; ++i) { - rmseTimeNorm.push_back(startTime); + rmseTimeNorms.push_back(startTime); startTime += FRAME_DURATION; } - return rmseTimeNorm; + return rmseTimeNorms; } void VibrationConvertCore::OutputTransientEvents(const std::vector &unionTransientEvents, - const std::vector &intensityData, const std::vector &freqNorm, - std::vector &transientIndex, std::vector &transientEventTime) + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes) { CALL_LOG_ENTER; bool onsetBacktrackFlag = systemPara_.onsetBacktrackFlag; @@ -853,50 +853,50 @@ void VibrationConvertCore::OutputTransientEvents(const std::vector &onsetTimes, - const std::vector &intensityData, const std::vector &freqNorm, - std::vector &transientIndex, std::vector &transientEventTime) + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes) { double rmsTimePerFrame = static_cast(ENERGY_HOP_LEN) / SAMPLE_RATE; for (size_t i = 0; i < onsetTimes.size(); ++i) { bool flag = false; size_t j = 0; - while (j < intensityData.size()) { - if ((onsetTimes[i] >= intensityData[j].rmseTimeNorm) && - (onsetTimes[i] < (intensityData[j].rmseTimeNorm + rmsTimePerFrame))) { + while (j < intensityDatas.size()) { + if ((onsetTimes[i] >= intensityDatas[j].rmseTimeNorm) && + (onsetTimes[i] < (intensityDatas[j].rmseTimeNorm + rmsTimePerFrame))) { flag = true; break; } ++j; } if (flag) { - auto it = std::find(transientIndex.begin(), transientIndex.end(), j); - if (it == transientIndex.end()) { - size_t endIndex = std::min(j + MIN_SKIP, intensityData.size() - 1); + auto it = std::find(transientIndexs.begin(), transientIndexs.end(), j); + if (it == transientIndexs.end()) { + size_t endIndex = std::min(j + MIN_SKIP, intensityDatas.size() - 1); // get max index. size_t maxIndex = j; - double maxRmseEnvelope = intensityData[j].rmseEnvelope; + double maxRmseEnvelope = intensityDatas[j].rmseEnvelope; for (size_t k = (j + 1); k < endIndex; k++) { - if (intensityData[k].rmseEnvelope > maxRmseEnvelope) { - maxRmseEnvelope = intensityData[k].rmseEnvelope; + if (intensityDatas[k].rmseEnvelope > maxRmseEnvelope) { + maxRmseEnvelope = intensityDatas[k].rmseEnvelope; maxIndex = k; } } double onsetTimeNorm = static_cast(round(SAMPLE_IN_MS * onsetTimes[i]) / SAMPLE_IN_MS); - transientEventTime.push_back(onsetTimeNorm); - transientIndex.push_back(j); - AddTransientEventData(TransientEvent(onsetTimeNorm, intensityData[maxIndex].rmseIntensityNorm, - freqNorm[maxIndex])); + transientEventTimes.push_back(onsetTimeNorm); + transientIndexs.push_back(j); + AddTransientEventData(TransientEvent(onsetTimeNorm, intensityDatas[maxIndex].rmseIntensityNorm, + freqNorms[maxIndex])); } } } @@ -914,20 +914,20 @@ void VibrationConvertCore::AddTransientEventData(TransientEvent transientEvent) } void VibrationConvertCore::OutputTransientEventsAlign(const std::vector &unionTransientEvents, - const std::vector &intensityData, const std::vector &freqNorm, - std::vector &transientIndex, std::vector &transientEventTime) + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes) { size_t size = unionTransientEvents.size(); for (size_t i = 1; i < size; ++i) { if ((unionTransientEvents[i].onsetIdx != 0) && (unionTransientEvents[i - 1].onsetIdx == (unionTransientEvents[i].onsetIdx - 1))) { - auto it = find(transientIndex.begin(), transientIndex.end(), unionTransientEvents[i].onsetIdx); - if (it == transientIndex.end()) { + auto it = find(transientIndexs.begin(), transientIndexs.end(), unionTransientEvents[i].onsetIdx); + if (it == transientIndexs.end()) { int32_t index = unionTransientEvents[i].onsetIdx; - transientEventTime.push_back(intensityData[index].rmseTimeNorm); - transientIndex.push_back(index); - AddTransientEventData(TransientEvent(intensityData[index].rmseTimeNorm, - intensityData[index].rmseIntensityNorm, freqNorm[index])); + transientEventTimes.push_back(intensityDatas[index].rmseTimeNorm); + transientIndexs.push_back(index); + AddTransientEventData(TransientEvent(intensityDatas[index].rmseTimeNorm, + intensityDatas[index].rmseIntensityNorm, freqNorms[index])); continue; } } @@ -935,10 +935,10 @@ void VibrationConvertCore::OutputTransientEventsAlign(const std::vector maxRmseEnvelope) { - maxRmseEnvelope = intensityData[k].rmseEnvelope; + if (intensityDatas[k].rmseEnvelope > maxRmseEnvelope) { + maxRmseEnvelope = intensityDatas[k].rmseEnvelope; maxIndex = k; } } @@ -950,10 +950,10 @@ void VibrationConvertCore::OutputTransientEventsAlign(const std::vector &unionTransientEvents, - const std::vector &intensityData, const std::vector &freqNorm, - std::vector &transientIndex, std::vector &transientEventTime) + const std::vector &intensityDatas, const std::vector &freqNorms, + std::vector &transientIndexs, std::vector &transientEventTimes) { size_t size = unionTransientEvents.size(); for (size_t i = 0; i < size; ++i) { - auto it = find(transientIndex.begin(), transientIndex.end(), unionTransientEvents[i].onsetIdx); - if (it == transientIndex.end()) { + auto it = find(transientIndexs.begin(), transientIndexs.end(), unionTransientEvents[i].onsetIdx); + if (it == transientIndexs.end()) { int32_t index = unionTransientEvents[i].onsetIdx; - transientEventTime.push_back(intensityData[index].rmseTimeNorm); - transientIndex.push_back(index); - AddTransientEventData(TransientEvent(intensityData[index].rmseTimeNorm, - intensityData[index].rmseIntensityNorm, freqNorm[index])); + transientEventTimes.push_back(intensityDatas[index].rmseTimeNorm); + transientIndexs.push_back(index); + AddTransientEventData(TransientEvent(intensityDatas[index].rmseTimeNorm, + intensityDatas[index].rmseIntensityNorm, freqNorms[index])); } } } -void VibrationConvertCore::OutputAllContinuousEvent(const std::vector &intensityData, - const std::vector transientIndex, const std::vector &freqNorm, +void VibrationConvertCore::OutputAllContinuousEvent(const std::vector &intensityDatas, + const std::vector transientIndexs, const std::vector &freqNorms, const std::vector &transientEventFlags) { CALL_LOG_ENTER; if (!systemPara_.splitSegmentFlag) { - OutputAllContinuousEventByUnseg(intensityData, transientIndex, freqNorm, transientEventFlags); + OutputAllContinuousEventByUnseg(intensityDatas, transientIndexs, freqNorms, transientEventFlags); } } -void VibrationConvertCore::OutputAllContinuousEventByUnseg(const std::vector &intensityData, - const std::vector transientIndex, const std::vector &freqNorm, +void VibrationConvertCore::OutputAllContinuousEventByUnseg(const std::vector &intensityDatas, + const std::vector transientIndexs, const std::vector &freqNorms, const std::vector &transientEventFlags) { std::vector rmseTimeNorm; - for (size_t i = 0; i < intensityData.size(); i++) { - rmseTimeNorm.push_back(intensityData[i].rmseTimeNorm); + for (size_t i = 0; i < intensityDatas.size(); i++) { + rmseTimeNorm.push_back(intensityDatas[i].rmseTimeNorm); } std::vector times; std::vector durations; FillDefaultContinuousEvents(rmseTimeNorm, times, durations); - int32_t ret = InsertTransientEvent(rmseTimeNorm, transientIndex, transientEventFlags, + int32_t ret = InsertTransientEvent(rmseTimeNorm, transientIndexs, transientEventFlags, times, durations); if (ret != Sensors::SUCCESS) { SEN_HILOGE("InsertTransientEvent failed"); @@ -1018,46 +1018,46 @@ void VibrationConvertCore::OutputAllContinuousEventByUnseg(const std::vector continuousEvents; for (size_t i = 0; i < times.size(); i++) { continuousEvents.push_back(ContinuousEvent(times[i], durations[i], - intensityData[i].rmseIntensityNorm, freqNorm[i])); + intensityDatas[i].rmseIntensityNorm, freqNorms[i])); } MergeContinuousEvents(continuousEvents); } -void VibrationConvertCore::FillDefaultContinuousEvents(const std::vector &rmseTimeNorm, +void VibrationConvertCore::FillDefaultContinuousEvents(const std::vector &rmseTimeNorms, std::vector ×, std::vector &durations) { double value = 0.0; - for (size_t i = 0; i < rmseTimeNorm.size(); ++i) { + for (size_t i = 0; i < rmseTimeNorms.size(); ++i) { times.push_back(value); durations.push_back(FRAME_DURATION); value += FRAME_DURATION; } } -int32_t VibrationConvertCore::InsertTransientEvent(const std::vector &rmseTimeNorm, - const std::vector &transientIndex, const std::vector &transientEventFlags, +int32_t VibrationConvertCore::InsertTransientEvent(const std::vector &rmseTimeNorms, + const std::vector &transientIndexs, const std::vector &transientEventFlags, std::vector ×, std::vector &durations) { - if ((times.empty()) || (transientIndex.size() != transientEventFlags.size())) { + if ((times.empty()) || (transientIndexs.size() != transientEventFlags.size())) { SEN_HILOGE("times is empty"); return Sensors::ERROR; } for (size_t i = 0; i < (times.size() - 1); ++i) { - auto it = find(transientIndex.begin(), transientIndex.end(), i); - if (it == transientIndex.end()) { + auto it = find(transientIndexs.begin(), transientIndexs.end(), i); + if (it == transientIndexs.end()) { continue; } - int32_t index = it - transientIndex.begin(); + int32_t index = it - transientIndexs.begin(); double preDuration = 0.0; if (i > 0) { preDuration = durations[i - 1]; } double transientTime = transientEvents_[index].time; - double preInterDuration = transientTime - rmseTimeNorm[i]; - double postInterDuration = (rmseTimeNorm[i] + FRAME_DURATION) - (transientTime + TRANSIENT_DURATION_DEFAULT); + double preInterDuration = transientTime - rmseTimeNorms[i]; + double postInterDuration = (rmseTimeNorms[i] + FRAME_DURATION) - (transientTime + TRANSIENT_DURATION_DEFAULT); if (IsGreatOrEqual(preInterDuration, CONTINOUS_MIN_DURATION)) { - times[i] = rmseTimeNorm[i]; + times[i] = rmseTimeNorms[i]; durations[i] = preInterDuration; if (IsLessNotEqual(postInterDuration, CONTINOUS_MIN_DURATION)) { times[i + 1] = transientTime + TRANSIENT_DURATION_DEFAULT;