【毕业设计】基于程序化生成和音频检测的生态仿真与3D内容生成系统----音频检测算法设计

已于 2023-04-20 16:41:22 修改
阅读量457 收藏
点赞数 2
分类专栏： 学习日志 CUC 文章标签： 音视频
于 2023-04-16 18:55:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelloveyatou/article/details/130185539
版权

(2条消息) 【开发日志】2022.09.02 ZENO----Audio----Beat detection algorithm----Combine Wav&Mp3_minimp3 和 ffmpeg_EndlessDaydream的博客-CSDN博客https://blog.csdn.net/Angelloveyatou/article/details/126670613

4 音频检测算法设计

4.1 节拍检测算法

4.1.1 节拍检测算法

要实现节拍检测算法，我们首先需要计算所选频率范围内的声音能量。我们可以通过使用FFT分析并将所选范围内频率箱的平方幅度相加来做到这一点。然后，我们计算当前播放位置之前一段时间（例如，几秒钟）的平均能量。

获得平均能量后，将其与所选频率范围内声音的当前能量进行比较。如果两种能量之间的差异超过一定的阈值，我们可以得出结论，有一个节拍。可以调整阈值以控制节拍检测的灵敏度。

为了实时实现算法，我们需要维护先前能量值的缓冲区，并在每次计算能量时更新它。我们可以使用圆形缓冲区来存储能量值，并使用指针来跟踪缓冲区中的当前位置。

节拍检测算法并不完美，可能会错过某些节拍或检测误报。但是，它可以很好地近似歌曲的节奏，并可用于同步视觉效果或触发游戏或交互式应用程序中的事件。

节拍检测算法是用于分析音频信号以确定其节奏或节拍的算法。以下是一些常见的节拍检测算法：

1.自相关函数法：该方法通过计算信号的自相关函数来检测节拍。信号的自相关函数将显示信号与其自身在时间上的延迟之间的相关性。当信号具有重复的模式时，自相关函数将具有明显的峰值，这些峰值对应于信号的节拍。

2.峰值检测法：该方法通过寻找信号中的峰值来检测节拍。通常，这些峰值与信号的强度或能量相关。在一段时间内检测到的峰值数量将与该时间段内的节拍数量相匹配。

3.快速傅里叶变换法：该方法通过对信号进行快速傅里叶变换（FFT）来检测节拍。 FFT将信号转换为频率域，其中可以检测到频率和强度。可以根据频率域中的能量峰值来确定信号的节拍。

4.基于模型的方法：该方法使用基于时间的模型来检测节拍。模型将信号表示为一系列时序事件，并使用模型来识别节拍模式。

这些算法可以单独或组合使用，以获得更准确的节拍检测结果。

本系统使用基于声能的简单统计模型计算。

4.1.2 基于声能的简单统计模型检测节拍

本系统是基于声能的简单统计模型实现简单的节拍检测算法，基本思想是利用音频数据的能量变化来检测节奏。计算当前播放前几秒钟声音的平均能量，并将其与声音的当前能量进行比较，如果能量差超过某个阈值，可以说有一个节拍。

使用 1024 个样本的窗口大小和 44100 Hz 的采样率，我们需要一个 44100/1024 = 43 个元素的缓冲区来存储 1 秒的历史记录。此样本的值可以从FFT分析中获得。

我们将分析集中在频谱的第一小节中，这样做的原因是检查声音的较低频率以捕捉电池的踢鼓和军鼓的使用，电池是跟踪歌曲节奏的最常用乐器之一。在我们的实验中，我们将采用 60hz-130hz 的低音范围，我们将在其中找到底鼓，以及中低音 301hz-750hz，在那里可以找到军鼓声音。中低音包含大多数乐器的低次谐波，通常被视为低音存在范围。

因此，我们需要获取此范围内的声音信息，并获取FFT结果的相应元素。要获得FFT结果中每个元素的频率，我们只需要计算频率分割（44100/1024 = 43）并将其乘以数据数组的索引。所以第一个组件存储范围 0-43Hz 的结果，第二个组件存储 43-86Hz，第三个 86-129Hz 的结果......

算法

假设 k 和 k+n 是实际处理范围的极限，FFT[i] 是 i 位置的频率幅度。我们可以计算范围的当前能量为

 我们需要将此值与接下来的 42 个样本一起存储，以获得 1 秒的历史记录 （H）。

 

现在可以使用此历史记录计算波段的平均值 

 

通常，超过平均值加其一半的值是检测节拍的良好阈值。但是我们可以使用历史值的方差来调整这个因子。在像硬摇滚或摇滚乐这样非常嘈杂的音乐中，节拍检测变得有点狡猾，因此我们需要降低更高方差值的阈值。

我们可以定义一条线（方差，阈值）方程来表示阈值和方差之间的关系。以 （0， 1.55） （0.02， 1.25） 作为这条线的两个点。

 

我们的 FFT 结果在 0..1 范围内，因此方差值也在 0..1 范围内。

最后检测到节拍，如果

 

输出1 ，反之输出0，从而生成01序列输出到下一个结点。

为了实现该算法，我定义了一些变量来存储历史数据、采样频率和窗口大小等信息，并编写一些辅助函数来计算平均值、方差和阈值等。另外，为了存储历史数据，我使用双端队列（deque）容器，以便在开头插入新元素并在末尾删除最旧的元素。

本系统检测节拍具体步骤如下：

1.将音频数据按窗口大小进行分割，并计算每个窗口内的平均能量。

2.从频谱中选取低音范围，如60hz-130hz的范围，来捕捉电池的踢鼓和军鼓的使用。

3.对于每个窗口内的数据，在低音范围内计算其FFT结果，并获取相应的频率幅度。

4.根据一定历史记录的范围，如1秒内的历史数据，计算当前时间点的能量值和历史数据的平均能量。

5.根据历史数据的方差调整平均能量值的阈值。

6.判断当前时间点的能量值是否超过阈值，并根据一定规则来检测节拍。

4.1.3 本系统中部分音频结点 

算法实现 

    struct AudioBeats : zeno::INode {
        std::deque<double> H;
        virtual void apply() override {
            auto wave = get_input<PrimitiveObject>("wave");
            float threshold = get_input<NumericObject>("threshold")->get<float>();
            auto start_time = get_input<NumericObject>("time")->get<float>();
            float sampleFrequency = wave->userData().get<zeno::NumericObject>("SampleRate")->get<float>();
            int start_index = int(sampleFrequency * start_time);
            int duration_count = 1024;
            auto fft = Aquila::FftFactory::getFft(duration_count);
            std::vector<double> samples;
            samples.resize(duration_count);
            for (auto i = 0; i < duration_count; i++) {
//                if (start_index + i >= wave->size()) {
//                    break;
//                }
                samples[i] = wave->attr<float>("value")[min((start_index + i), wave->size()-1)];
                
                //if (start_index + i >= wave->size()) {
                //    break;
                //}
                //samples[i] = wave->attr<float>("value")[start_index + i];
            }
            Aquila::SpectrumType spectrums = fft->fft(samples.data());

            {
                double E = 0;
                for (const auto& spectrum: spectrums) {
                    E += spectrum.real() * spectrum.real() + spectrum.imag() * spectrum.imag();
                }
                E /= duration_count;
                H.push_back(E);
            }

            while (H.size() > 43) {
                H.pop_front();
            }
            double avg_H = 0;
            for (const auto& E: H) {
                avg_H += E;
            }
            avg_H /= H.size();

            double var_H = 0;
            for (const auto& E: H) {
                var_H += (E - avg_H) * (E - avg_H);
            }
            var_H /= H.size();
            int beat = H.back() - threshold > (-15 * var_H + 1.55) * avg_H;
            set_output("beat", std::make_shared<NumericObject>(beat));
            set_output("var_H", std::make_shared<NumericObject>((float)var_H));


            auto output_H = std::make_shared<ListObject>();
            for (int i = 0; i < 43 - H.size(); i++) {
                output_H->arr.emplace_back(std::make_shared<NumericObject>((float)0));
            }
            for (const auto & h: H) {
                output_H->arr.emplace_back(std::make_shared<NumericObject>((float)h));
            }
            set_output("H", output_H);

            auto output_E = std::make_shared<ListObject>();
            for (const auto& spectrum: spectrums) {
                double e = spectrum.real() * spectrum.real() + spectrum.imag() * spectrum.imag();
                output_E->arr.emplace_back(std::make_shared<NumericObject>((float)e));
            }
            set_output("E", output_E);
        }
    };

    ZENDEFNODE(AudioBeats, {
        {
            "wave",
            {"float", "time", "0"},
            {"float", "threshold", "0.005"},
        },
        {
            "beat",
            "var_H",
            "H",
            "E",
        },
        {},
        {
            "audio"
        },
    });

    struct AudioEnergy : zeno::INode {
        double minE = std::numeric_limits<double>::max();
        double maxE = std::numeric_limits<double>::min();
        std::vector<double> init;
        virtual void apply() override {
            auto wave = get_input<PrimitiveObject>("wave");
            int duration_count = 1024;
            if (init.empty()) {
                auto fft = Aquila::FftFactory::getFft(duration_count);
                int clip_count = wave->size() / duration_count;
                init.reserve(clip_count);
                for (auto i = 0; i < clip_count; i++) {
                    std::vector<double> samples;
                    samples.resize(duration_count);
                    for (auto j = 0; j < duration_count; j++) {
                        samples[j] = wave->attr<float>("value")[min(duration_count * i + j, wave->size()-1)];
                    }
                    Aquila::SpectrumType spectrums = fft->fft(samples.data());
                    {
                        double E = 0;
                        for (const auto& spectrum: spectrums) {
                            E += spectrum.real() * spectrum.real() + spectrum.imag() * spectrum.imag();
                        }
                        E /= duration_count;
                        minE = min(minE, E);
                        maxE = max(maxE, E);
                        init.push_back(E);
                    }
                }
    //            for (auto i = 0; i < clip_count; i++) {
    //                init[i] = init[i] / maxE;
    //            }
            }

    //        auto vis = std::make_shared<PrimitiveObject>();
    //        vis->resize(init.size());
    //        auto &index = vis->add_attr<float>("index");
    //        auto &listE = vis->add_attr<float>("E");
    //        for (auto i = 0; i < init.size(); i++) {
    //            index[i] = i;
    //            listE[i] = init[i];
    //        }
    //        set_output("vis", vis);

            set_output("minE", std::make_shared<NumericObject>((float)minE));
            set_output("maxE", std::make_shared<NumericObject>((float)maxE));

            auto start_time = get_input2<float>("time");
            float sampleFrequency = wave->userData().get<zeno::NumericObject>("SampleRate")->get<float>();
            int start_index = int(sampleFrequency * start_time);
            auto fft = Aquila::FftFactory::getFft(duration_count);
            std::vector<double> samples;
            samples.resize(duration_count);
            for (auto i = 0; i < duration_count; i++) {
                samples[i] = wave->attr<float>("value")[min((start_index + i), wave->size()-1)];
            }
            Aquila::SpectrumType spectrums = fft->fft(samples.data());
            double E = 0;
            for (const auto& spectrum: spectrums) {
                E += spectrum.real() * spectrum.real() + spectrum.imag() * spectrum.imag();
            }
            E /= duration_count;
            set_output("E", std::make_shared<NumericObject>((float)E));
            double uniE = (E - minE) / (maxE - minE);
            set_output("uniE", std::make_shared<NumericObject>((float)uniE));
            start_index /= duration_count;
            start_index = min(start_index, init.size() - 1);
            std::vector<double> _queue;
            for (int i = max(start_index - 43, 0); i < start_index; i++) {
                _queue.push_back((init[i] - minE) / (maxE - minE));
            }
            if (_queue.size() > 0) {
                double avg_H = 0;
                for (const double & e: _queue) {
                    avg_H += e;
                }
                avg_H /= _queue.size();
                double var_H = 0;
                for (const double & e: _queue) {
                    var_H += (e - avg_H) * (e - avg_H);
                }
                var_H /= _queue.size();
                double std_H = sqrt(var_H);
    //            zeno::log_info("E: {}, avg_H: {}, std_H: {}, var_H: {}", uniE, avg_H, std_H, var_H);
                float threshold = get_input2<float>("threshold");
                int beat = uniE > avg_H + std_H * threshold;
                set_output("beat", std::make_shared<NumericObject>(beat));
            }
            else {
                set_output("beat", std::make_shared<NumericObject>(0));
            }
        }
    };
    ZENDEFNODE(AudioEnergy, {
        {
            "wave",
            {"float", "time", "0"},
            {"float", "threshold", "1"},
        },
        {
            "beat",
            "E",
            "uniE",
            "minE",
            "maxE",
//            "vis",
        },
        {},
        {
            "audio"
        },
    });

    struct AudioFFT : zeno::INode {
        virtual void apply() override {
            auto wave = get_input<PrimitiveObject>("wave");
            int duration_count = 1024;
            auto start_time = get_input2<float>("time");
            float sampleFrequency = wave->userData().get<zeno::NumericObject>("SampleRate")->get<float>();
            int start_index = int(sampleFrequency * start_time);
            std::vector<double> samples;
            samples.resize(duration_count+1);
            for (auto i = 0; i < duration_count+1; i++) {
                samples[i] = wave->attr<float>("value")[min((start_index + i), wave->size()-1)];
            }
            auto pre_emphasis = get_input2<int>("preEmphasis");
            if (pre_emphasis) {
                auto alpha = get_input2<float>("preEmphasisAlpha");
                for (auto i = 0; i < duration_count; i++) {
                    samples[i] = samples[i+1] - alpha * samples[i];
                }
            }
            samples.pop_back();
            auto hamming_window = get_input2<int>("hammingWindow");
            if (hamming_window) {
                for (auto i = 0; i < duration_count; i++) {
                    double i_value = 0.54 - 0.46 * std::cos(2.0 * M_PI * i / (duration_count - 1));
                    samples[i] = samples[i] * i_value;
                }
            }

            auto fft = Aquila::FftFactory::getFft(duration_count);
            Aquila::SpectrumType spectrums = fft->fft(samples.data());

            auto fft_prim = std::make_shared<PrimitiveObject>();
            fft_prim->resize(duration_count / 2 + 1);
            auto &freq = fft_prim->add_attr<float>("freq");
            auto &real = fft_prim->add_attr<float>("real");
            auto &image = fft_prim->add_attr<float>("image");
            auto &square = fft_prim->add_attr<float>("square");
            auto &power = fft_prim->add_attr<float>("power");
            for (std::size_t i = 0; i < fft_prim->verts.size(); ++i) {
                float r = spectrums[i].real();
                float im = spectrums[i].imag();
                freq[i] = float(i);
                real[i] = r;
                image[i] = im;
                float square_v = r * r + im * im;
                square[i] = square_v;
                power[i] = square_v / duration_count;
            }
            set_output("FFTPrim", fft_prim);
        }
    };
    ZENDEFNODE(AudioFFT, {
        {
            "wave",
            {"float", "time", "0"},
            {"bool", "preEmphasis", "0"},
            {"float", "preEmphasisAlpha", "0.97"},
            {"bool", "hammingWindow", "1"},
        },
        {
            "FFTPrim",
        },
        {},
        {
            "audio"
        },
    });
    struct MelFilter : zeno::INode {
        virtual void apply() override {
            auto fftPrim = get_input<PrimitiveObject>("FFTPrim");
            auto &power = fftPrim->attr<float>("power");
            auto sampleFreq = get_input2<float>("sampleFreq");
            auto rangePerFilter = get_input2<float>("rangePerFilter");
            float halfFreq = sampleFreq / 2;
            auto count = get_input2<int>("count");
            std::vector<float> hz_points;
            float mel_fh = 2595.0 * log10(1+halfFreq/700.0);
            for (int i = 0; i <= count + 1; i++) {
                float mel = mel_fh * i / (count + 1);
                float hz = 700.0 * (pow(10.0, mel / 2595.0) - 1);
                hz_points.push_back(hz);
            }
            std::vector<int> bin;
            for (const auto& hz: hz_points) {
                int index = (1024.0+1.0) * hz / sampleFreq;
                bin.push_back(index);
            }
            auto fbank = std::make_shared<PrimitiveObject>();
            fbank->resize(count);
            auto& fbank_v = fbank->add_attr<float>("fbank");
            for (auto i = 1; i <= count; i++) {
                int s = bin[i-1];
                int m = bin[i];
                int e = bin[i+1];
                s = (int) zaudio::lerp(m, s, rangePerFilter);
                e = (int) zaudio::lerp(m, e, rangePerFilter);
                float total = 0;
                for (auto i = s; i < m; i++) {
                    float cof = (float)(m - i) / (float)(m - s);
                    total += power[i] * cof;
                }
                for (auto i = m; i < e; i++) {
                    float cof = 1 - (float)(m - i) / (float)(e - m);
                    total += power[i] * cof;
                }
                if (total == 0) {
                    fbank_v[i-1] = std::numeric_limits<float>::min();
                }
                else {
                    fbank_v[i-1] = log(total);
                }
            }
            auto indexType = get_input2<std::string>("indexType");
            if (indexType == "index") {
                auto& index = fbank->add_attr<float>("i");
                for (auto i = 1; i <= count; i++) {
                    index[i-1] = (float)(i-1);
                };
            } else if (indexType == "indexdivcount") {
                auto& index = fbank->add_attr<float>("i");
                for (auto i = 1; i <= count; i++) {
                    index[i-1] = (float)(i-1) /count;
                };
            }
            set_output("FilterBank", fbank);
        }
    };
    ZENDEFNODE(MelFilter, {
        {
            "FFTPrim",
            {"int", "count", "15"},
            {"float", "sampleFreq", "44100"},
            {"float", "rangePerFilter", "1"},
            {"enum none index indexdivcount", "indexType", "index"},
        },
        {
            "FilterBank",
        },
        {},
        {
            "audio",
        },
    });
} // namespace zeno

参考文献

BEAT DETECTION ALGORITHMS.doc (parallelcube.com)https://www.parallelcube.com/web/wp-content/uploads/2018/03/BeatDetectionAlgorithms.pdf

TODO： 

  1. "A Review on Audio Event Detection," H. Su, et al., IEEE Access, vol. 8, pp. 77580-77593, 2020.

  2. "Acoustic Event Detection with SEDNN: A Deep Learning Approach," P. Jaiswal and Y. Han, 2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), Brighton, United Kingdom, 2019, pp. 316-320.

  3. "Event Detection Using Multitask Learning of Auditory Features and Sound Event Classifiers," D. D. Lee, et al., IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 25, no. 6, pp. 1190-1201, 2017.

  4. "Audio Event Detection Using Deep Learning with Mel-Frequency Cepstral Coefficients," S. Gupta, et al., 2019 IEEE 10th Annual Information Technology, Electronics and Mobile Communication Conference (IEMCON), Vancouver, BC, Canada, 2019, pp. 186-191.

  5. "Deep Convolutional Neural Networks for Acoustic Event Detection in Domestic Environments," M. L. Seltzer, et al., IEEE/ACM Transactions on Audio, Speech, and Language Processing, vol. 24, no. 1, pp. 111-125, 2016.

  6. "Environmental Sound Classification with Convolutional Neural Networks," J. Salamon, et al., IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), Brisbane, QLD, Australia, 2015, pp. 732-736.

以上论文介绍了一些常用的音频检测算法，包括深度学习算法和基于特征的传统算法。这些算法可用于识别音频中的各种事件，如说话、喷嚏、汽车鸣笛等。可以根据实际需求选择合适的算法进行实现。

 

EndlessDaydream
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
音频静音检测算法
百鸣的专栏
04-10 1292
基于能量的静音检测算法是根据声音信号的能量来进行判断的。基于短时过零率的静音检测算法是根据声音信号的瞬时频率变化情况来进行判断的。需要注意的是，任何一个静音检测算法都是有误差的，并且不同领域和应用场景中，误差大小的容忍度也是不同的。因此，在实际应用中，我们需要根据实际需要进行合理的选择和调整算法，以得到更准确的结果。下面是一个使用基于能量的算法实现音频静音检测的简单C++代码示例，仅供您参考。请注意，这里的代码只是一个简单的例子，由于不同应用场景和需求的不同，检测算法的具体实现方式也可能有所不同。
音频原始数据能量检测算法
音视频工厂的博客
03-25 4604
很多场合我们需要动态显示实时语音的音量分贝，以展示人的说话声音的大小，以便可以动态条件声音的大小，比较常见的几种音量分贝检测算法有如下几种, 下面做一下简单说明和比较 1、计算音频能量数据和 算法原理： 算法比较简单，首先我们分别累加每个采样点的数值，除以采样个数，得到声音数据求平均能量值。然后再将其做0--32767之间的等比量化。得到1-100的量化值，返回结果。 通过实际测试，通常情况下，人声一般都分布在较低的能量范围内，人说话的声音基本在0-35之间，很难达到5...
节拍识别算法
二毛的博客
02-10 8722
背景最近的一个项目中需要采集音乐的物理信号并从中提取出节拍。首先讨论一下什么是节拍。我们在播放音符时首先是发出声音，然后变强，直到达到最大振幅，然后是衰减阶段。我们检测的音频当中包含的信息由各种乐器和人声组成，所以这些当中的频率范围从70~4000Hz不等。总体流程采集1024个点然后对其进行FFT变换，44.1KHz的采样频率1秒可以采集到43个值。我们得到了每一帧的时域信号的频谱，但是我们并不...
声音事件检测论文
qq_33266320的博客
07-14 1000
一、《智能监控前端系统中异常声音检测的实现》（物理方法）提取包括短时幅度、美尔倒谱系数和差分系数在内的混合特征参数，采用改进的 DTW 算法进行声音识别。二、《基于音频事件检测和分类的音频监控系统背景模型自适应方法研究》进行背景模型自适应从而适应不断变化的音频环境变得十分重要。提出了利用受限的最大似然线性回归方法对背景模型进行自适应。三、《ABNORMAL SOUND EVENT DETECTIO...
信号与系统：音频节奏检测
奔跑吧蚂蚁呀
08-20 761
毕业设计基于Matlab麦克风阵列的TDOA-SRP的声源定位功能仿真算法matlab完整源码.zip
最新发布
05-31
毕业设计基于Matlab麦克风阵列的TDOA-SRP的声源定位功能仿真算法matlab完整源码.zip个人经导师指导并认可通过的高分设计项目，评审分98分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也...
基于DWT-DCT-SVD算法的音频水印嵌入和提取算法MATLAB仿真，
05-07
文件列表中的“6基于DWT-DCT-SVD算法的音频水印嵌入和提取算法MATLAB仿真”可能是一个MATLAB脚本或者程序文件，包含了完整的实现流程，包括音频预处理、水印生成、使用DWT-DCT-SVD进行嵌入、以及水印的提取和检测等...
基于MMSE-SQRD的V-BLAST系统检测算法研究与仿真
01-27
MIMO系统可以增加通信容量和频谱利用率，传统的检测V-Blast...本文提出了一种检测V-Blast系统的Sort-free QRD-M算法，阐述了其基本原理和搜索方式，对其和其它检测算法的检测复杂度和检测性能进行了仿真分析和对比。
基于Mask-RCNN的高精度目标检测和识别matlab仿真+代码仿真操作视频
06-29
2.内容：基于Mask-RCNN的高精度目标检测和识别matlab仿真+代码仿真操作视频 3.用处：用于Mask-RCNN的高精度目标检测和识别算法编程学习 4.指向人群：本硕博等教研学习使用 5.运行注意事项： 使用matlab2021a...
基于K-Best球形译码算法的MIMO信号检测matlab仿真【包含程序操作录像,代码中文注释】
11-01
3.内容：基于K-Best球形译码算法的MIMO信号检测matlab仿真。K-Best球形译码是基于K-Best的球形译码算法，它是一种扩展的译码方法。在传统的球形译码中，通常只保留一个最可能的解，但基于K-Best的球形译码算法在每次...
unity音频节拍实时检测系统源码.zip
08-28
音频节拍器实时检测系统源码，音游节奏游戏学习插件。
语音识别算法有哪些_语音识别特征提取方法
q6q6q的专栏
10-27 1万+
语音识别算法有哪些本文列举了几种不同的语音识别算法。第一种：基于动态时间规整（Dynamic Time Warping）的算法在连续语音识别中仍然是主流方法。该方法的运算量较大，但技术上较简单，识别正确率高。在小词汇量、孤立字（词）识别系统中，也已有许多改进的DTW算法被提出。例如，利用频率尺度的DTW算法进行孤立字（词）识别的方法。第二种：基于参数模型的隐马尔可夫模型（HMM）的方法该算法主要用...
音频节奏检测（Onset Detection）
weixin_43865690的博客
11-09 2740
项目代码下载 https://download.csdn.net/download/weixin_43865690/39129840 1. 前言 最近市场上出现一些多个视频拼接而成MV，其原理是根据音频的节拍变换切换视频。 我在这里讲述下如何进行音频节拍检测。 2. 音频检测一般流程 3. 3.1 原始音频频谱 以1024为窗口（即每次读取1024个采样点）进行量化 WaveDecoder decoder = new WaveDecoder( new FileInputStream( "s
语音识别之端点检测
I AM BACK
03-17 2万+
在之前呢我们已经把portaudio平台搭好了，可以采集声音信号并播放了。那么接下来呢我们就来做一些实质性的东西——自适应端点检测。那么什么是自适应端点检测呢？也就是采集声音信号的时候，开始说话到说话结束，我们把这一段声音信号采集下来进行处理。不然那么多信号都去处理，没有声音也处理那就浪费了很多的空间以及浪费了CPU去做后续的操作。后面的功夫是省了，但是前面的工作就多了。天下可没有白费的午餐！接下
Java实现Shazam声音识别算法
llhhzz1989的博客
09-10 4780
Java实现Shazam声音识别算法 Shazam算法采用傅里叶变换将时域信号转换为频域信号，并获得音频指纹，最后匹配指纹契合度来识别音频。 1、AudioSystem获取音频 奈奎斯特-香农采样定理告诉我们，为了能捕获人类能听到的声音频率，我们的采样速率必须是人类听觉范围的两倍。人类能听到的声音频率范围大约在20Hz到20000Hz之间，所以在录制音频的时候采样率大多是44100Hz。...
语音识别算法原理文档整理（一）
风口上的传奇
06-22 2万+
MFCC提取过程 声音是模拟信号，声音的时域波形只代表声压随时间变化的关系，不能很好的代表声音的特征，因此，必须将声音波形转换为声学特征向量。目前有许多声音特征提取方法，如梅尔频率倒谱系数MFCC、线性预测倒谱系数LPCC、多媒体内容描述接口MPEG7等，其中MFCC是基于倒谱的，更符合人的听觉原理，因而是最普遍、最有效的声音特征提取算法。在提取MFCC前，需要对声音做前期处理，包括模数转换、预...
如何实现两个声音相似度匹配算法？
qq_41861329的博客
03-18 1万+
如我有N多个音频，每段音频中都出现“多一些润滑,少一些摩擦出自:统一润滑油”的广告词，怎么样在可以快速的在每个音频中找出现出广告词的时间段谢谢大神，可以重金，加我QQ1400580033议价...
一个简单的波形包络提取算法
热门推荐
Ivan 的专栏
07-29 5万+
最近做项目要提取一个声音信号的包络波形，所以花了点时间研究各种包络提取的算法。 所谓包络检测又叫幅度解调，在许多领域都有重要的应用。如果载波信号是确定的，那么通常可以采用同步解调的方式，这种方式的信噪比最好，对信号中混入的噪声的抑制能力最强。所谓同步解调是通讯领域通常的叫法。在信号检测领域，这种方式通常称为“相敏检波”，锁相放大器（Lock-in Amplifier）采用的就是这种方式最典型的例
语音情感识别中的音频检测算法学习
a18379692263的博客
10-08 1658
引言：目前大体学习多模态语音情感识别，对语音数据的训练过程有个初步的了解，但对于原始语音音频生成具体的数据特征、以及如何获取有些疑惑，因此通过这篇文章来总结语音情感识别中的音频特征检测算法。 音频检测的关键技术-MFCC特征提取 为了从音频信号中提取语音信息，目前使用的是普遍用于分析音频信号的mfcc值。MFCC（梅尔频率倒谱系数），梅尔频率是基于人耳听觉特性提取出来的，和赫兹频率呈现一个非线性对应关系。梅尔频率倒谱系数是利用好梅尔频率和赫兹频谱关系计算得出的赫兹频谱特征，其主要应用于语...
基于MATLAB的文字识别算法-课程设计实用文档
系统的实现是课程设计的核心内容，学生需要根据所选的算法和方法，利用MATLAB的仿真平台进行算法的实现和验证。这一过程中需要编写相关的代码和脚本，并进行参数调整和优化。实现完成后，学生需要进行系统测试，并对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值