HOUND Archives - icodebroker

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 FM(Frequency Modulation) 음원 WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 FM(Frequency Modulation) 음원의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/fm.rs


use std::f32::consts;

pub const SAMPLE_RATE : f32 = 44100.0;

pub struct Note
{
    pub scale  : i32,       // 음계
    pub length : isize,     // 음표 길이
    pub gain   : f32,       // 음량
    pub params : (f32, f32) // 음색 매개변수
}

pub fn make_fm(wave_vector : &mut Vec<f32>, note : Note)
{
    let frequency : f32 = get_frequency(note.scale);

    let a : f32 = 2.0 * consts::PI * frequency / SAMPLE_RATE;

    let wave_vector_length : usize = note.length as usize;

    let mut temporary_wave_vector1 :Vec<f32> = vec![0.0; wave_vector_length];

    for i in 0..(note.length as usize)
    {
        let t : f32 = i as f32;

        let sin1 : f32 = note.params.0 * (a * t).sin();
        let sin2 : f32 = note.params.1 * (a * t + sin1).sin();
        let sin3 : f32 = (a * t + sin2).sin();

        temporary_wave_vector1[i] = sin3;
    }

    let attack  : usize = 3;
    let decay   : usize = attack + 200;
    let sustain : f32 = 0.90;
    let release : usize = (wave_vector_length as f32 * 0.4) as usize;

    let temporary_wave_vector2 : Vec<f32> = temporary_wave_vector1.into_iter().enumerate().map
    (
        |(index, value)|
        {
            let v1 : f32 = (value * note.gain) as f32;

            if index < attack { return index as f32 / attack as f32 * v1; }

            let v2 : f32 = v1 * sustain;

            if index < decay
            {
                let dec : f32 = (1.0 - (index as f32 / decay as f32)) * (1.0 - sustain) * v1.abs();

                return if v2 > 0.0 { v1 + dec } else { v1 - dec }
            }
            else if index > (wave_vector_length - release)
            {
                let i : usize = index - (wave_vector_length - release);

                return (1.0 - i as f32 / release as f32) * v2;
            }

            return v2;
        }
    ).collect();

    wave_vector.extend(temporary_wave_vector2);

}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
pub fn calculate_note_length(bpm : usize, note : usize) -> isize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as isize;
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

use std::f32::consts;

pub const SAMPLE_RATE : f32 = 44100.0;

pub struct Note

{

pub scale : i32, // 음계

pub length : isize, // 음표 길이

pub gain : f32, // 음량

pub params : (f32, f32) // 음색 매개변수

}

pub fn make_fm(wave_vector : &mut Vec<f32>, note : Note)

{

let frequency : f32 = get_frequency(note.scale);

let a : f32 = 2.0 * consts::PI * frequency / SAMPLE_RATE;

let wave_vector_length : usize = note.length as usize;

let mut temporary_wave_vector1 :Vec<f32> = vec![0.0; wave_vector_length];

for i in 0..(note.length as usize)

{

let t : f32 = i as f32;

let sin1 : f32 = note.params.0 * (a * t).sin();

let sin2 : f32 = note.params.1 * (a * t + sin1).sin();

let sin3 : f32 = (a * t + sin2).sin();

temporary_wave_vector1[i] = sin3;

}

let attack : usize = 3;

let decay : usize = attack + 200;

let sustain : f32 = 0.90;

let release : usize = (wave_vector_length as f32 * 0.4) as usize;

let temporary_wave_vector2 : Vec<f32> = temporary_wave_vector1.into_iter().enumerate().map

(

|(index, value)|

{

let v1 : f32 = (value * note.gain) as f32;

if index < attack { return index as f32 / attack as f32 * v1; }

let v2 : f32 = v1 * sustain;

if index < decay

{

let dec : f32 = (1.0 - (index as f32 / decay as f32)) * (1.0 - sustain) * v1.abs();

return if v2 > 0.0 { v1 + dec } else { v1 - dec }

}

else if index > (wave_vector_length - release)

{

let i : usize = index - (wave_vector_length - release);

return (1.0 - i as f32 / release as f32) * v2;

}

return v2;

}

).collect();

wave_vector.extend(temporary_wave_vector2);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

pub fn calculate_note_length(bpm : usize, note : usize) -> isize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as isize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

▶ src/main.rs

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 펄스파(pulse wave) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 펄스파(pulse wave)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/pulse.wav", wav_spec).unwrap();

    let mut wave_vector : Vec<f32> = vec![];

    let bpm : usize = 120;

    [0.3, 0.1, 0.7, 0.5].iter().for_each
    (
        |duty : &f32|
        {
            [60, 64, 67, 72].iter().for_each
            (
                |scale : &i32|
                {
                    wave_vector.extend(get_pulse_wave_vector(*scale, calculate_note_length(bpm, 4), 0.5, *duty));
                }
            );
        }
    );

    for value in wave_vector.into_iter()
    {
        wav_writer.write_sample(value).unwrap();
    }
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note : usize) -> usize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;
}

// scale       : 음계, 예) 60(도), 64(미), 67(솔)
// note_length : 음표 길이 (샘플 수)
// gain        : 출력
// duty        : 듀티
fn get_pulse_wave_vector(scale : i32, note_length : usize, gain : f32, duty : f32) -> Vec<f32>
{
    let frequency : f32 = get_frequency(scale);

    let interval : f32 = SAMPLE_RATE / frequency;

    let mut wave_vector : Vec<f32> = vec![0.0; note_length];

    for i in 0..note_length
    {
        let saw : f32 = (i as f32 / interval) % 1.0;

        wave_vector[i] = if saw > duty { -1.0 } else { 1.0 };
    }

    return wave_vector.into_iter().map(|v: f32| (v * gain) as f32).collect();
}

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/pulse.wav", wav_spec).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

[0.3, 0.1, 0.7, 0.5].iter().for_each

(

|duty : &f32|

{

[60, 64, 67, 72].iter().for_each

(

|scale : &i32|

{

wave_vector.extend(get_pulse_wave_vector(*scale, calculate_note_length(bpm, 4), 0.5, *duty));

}

);

}

);

for value in wave_vector.into_iter()

{

wav_writer.write_sample(value).unwrap();

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note : usize) -> usize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

// note_length : 음표 길이 (샘플 수)

// gain : 출력

// duty : 듀티

fn get_pulse_wave_vector(scale : i32, note_length : usize, gain : f32, duty : f32) -> Vec<f32>

{

let frequency : f32 = get_frequency(scale);

let interval : f32 = SAMPLE_RATE / frequency;

let mut wave_vector : Vec<f32> = vec![0.0; note_length];

for i in 0..note_length

{

let saw : f32 = (i as f32 / interval) % 1.0;

wave_vector[i] = if saw > duty { -1.0 } else { 1.0 };

}

return wave_vector.into_iter().map(|v: f32| (v * gain) as f32).collect();

}

test_project.zip

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 백색 잡음(white noise) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 백색 잡음(white noise)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"
rand = "0.8.4"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

rand = "0.8.4"

▶ src/main.rs


use std::fs;
use std::io;

use hound;
use rand::prelude::*;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float
    };

    let mut wave_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/noise.wav", wav_spec).unwrap();

    let mut wave_vector : Vec<f32> = vec![];

    let bpm : usize = 120;

    wave_vector.extend(get_noise_wave_vector(2.0, -1.0, calculate_note_length(bpm, 2)));
    wave_vector.extend(get_noise_wave_vector(0.2,  0.8, calculate_note_length(bpm, 2)));
    wave_vector.extend(get_noise_wave_vector(0.8, -1.0, calculate_note_length(bpm, 2)));

    for value in wave_vector.into_iter()
    {
        wave_writer.write_sample(value).unwrap();
    }
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note: usize) -> usize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;
}

// range       : 범위
// shift       : 시프트
// note_length : 음표 길이 (샘플 수)
fn get_noise_wave_vector(range : f32, shift : f32, note_length : usize) -> Vec<f32>
{
    let mut wave_vector : Vec<f32> = vec![0.0; note_length];

    let mut thread_rng : ThreadRng = rand::thread_rng();

    for i in 0..note_length
    {
        wave_vector[i] = thread_rng.gen::<f32>() * range + shift;
    }

    let gain : f32 = 0.5;

    return wave_vector.into_iter().map(|v : f32| (v * gain) as f32).collect();
}

use std::fs;

use std::io;

use hound;

use rand::prelude::*;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float

};

let mut wave_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/noise.wav", wav_spec).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

wave_vector.extend(get_noise_wave_vector(2.0, -1.0, calculate_note_length(bpm, 2)));

wave_vector.extend(get_noise_wave_vector(0.2, 0.8, calculate_note_length(bpm, 2)));

wave_vector.extend(get_noise_wave_vector(0.8, -1.0, calculate_note_length(bpm, 2)));

for value in wave_vector.into_iter()

{

wave_writer.write_sample(value).unwrap();

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note: usize) -> usize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;

}

// range : 범위

// shift : 시프트

// note_length : 음표 길이 (샘플 수)

fn get_noise_wave_vector(range : f32, shift : f32, note_length : usize) -> Vec<f32>

{

let mut wave_vector : Vec<f32> = vec![0.0; note_length];

let mut thread_rng : ThreadRng = rand::thread_rng();

for i in 0..note_length

{

wave_vector[i] = thread_rng.gen::<f32>() * range + shift;

}

let gain : f32 = 0.5;

return wave_vector.into_iter().map(|v : f32| (v * gain) as f32).collect();

}

test_project.zip

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 삼각파(triangle wave) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 삼각파(triangle wave)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float,
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/tri.wav", wav_spec).unwrap();

    let mut wave_vector : Vec<f32> = vec![];

    let bpm : usize = 120;

    [60, 64, 67, 64, 60, 64, 67, 72].iter().for_each
    (
        |scale: &i32|
        {
            wave_vector.extend(get_triangle_wave_vector(*scale, calculate_note_length(bpm, 8), 0.5));
        }
    );

    for wave in wave_vector.into_iter()
    {
        wav_writer.write_sample(wave).unwrap();
    }
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note : usize) -> usize
{
    return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;
}

// scale       : 음계, 예) 60(도), 64(미), 67(솔)
// note_length : 음표 길이 (샘플 수)
// gain        : 출력
fn get_triangle_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>
{
    let frequency : f32 = get_frequency(scale);

    let interval : f32 = SAMPLE_RATE / frequency;

    let mut wave_vector : Vec<f32> = vec![0.0; note_length];

    let half_interval : f32 = interval / 2.0;

    for i in 0..note_length
    {
        let temporary_value : f32 = i as f32 / half_interval;

        let mut value : f32 = 2.0 * (temporary_value % 1.0) - 1.0;

        let is_climbing : bool = temporary_value.floor() as usize % 2 == 0;

        value = if is_climbing { value } else { -value };

        wave_vector[i] = value;
    }

    return wave_vector.into_iter().map(|value : f32| (value * gain) as f32).collect();
}

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float,

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/tri.wav", wav_spec).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

[60, 64, 67, 64, 60, 64, 67, 72].iter().for_each

(

|scale: &i32|

{

wave_vector.extend(get_triangle_wave_vector(*scale, calculate_note_length(bpm, 8), 0.5));

}

);

for wave in wave_vector.into_iter()

{

wav_writer.write_sample(wave).unwrap();

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note : usize) -> usize

{

return ((4.0 / note as f32) * (60.0 / bpm as f32) * SAMPLE_RATE) as usize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

// note_length : 음표 길이 (샘플 수)

// gain : 출력

fn get_triangle_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>

{

let frequency : f32 = get_frequency(scale);

let interval : f32 = SAMPLE_RATE / frequency;

let mut wave_vector : Vec<f32> = vec![0.0; note_length];

let half_interval : f32 = interval / 2.0;

for i in 0..note_length

{

let temporary_value : f32 = i as f32 / half_interval;

let mut value : f32 = 2.0 * (temporary_value % 1.0) - 1.0;

let is_climbing : bool = temporary_value.floor() as usize % 2 == 0;

value = if is_climbing { value } else { -value };

wave_vector[i] = value;

}

return wave_vector.into_iter().map(|value : f32| (value * gain) as f32).collect();

}

test_project.zip

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 방형파(square wave) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 방형파(square wave)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float,
    };

    let mut wave_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/sq.wav", wav_spec).unwrap();

    let mut wave_vector : Vec<f32> = vec![];

    let bpm : usize = 120;

    [60, 64, 67, 64, 60, 64, 67, 72].iter().for_each
    (
        |sacle : &i32|
        {
            wave_vector.extend(get_square_wave_vector(*sacle, calculate_note_length(bpm, 8), 0.5));
        }
    );

    for v in wave_vector.into_iter()
    {
        wave_writer.write_sample(v).unwrap();
    }
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note : usize) -> usize
{
    let base_length : f32 = (60.0 / bpm as f32) * SAMPLE_RATE;

    return ((4.0 / note as f32) * base_length) as usize;
}

// scale       : 음계, 예) 60(도), 64(미), 67(솔)
// note_length : 음표 길이 (샘플 수)
// gain        : 출력
fn get_square_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>
{
    let frequency : f32 = get_frequency(scale);

    let interval : f32 = SAMPLE_RATE / frequency;

    let mut wave_vector :Vec<f32> = vec![0.0; note_length];

    let half_frequency : usize = (interval / 2.0) as usize;

    for i in 0..note_length
    {
        let value : usize = (i / half_frequency) % 2;

        wave_vector[i] = if value == 0 { -1.0 } else { 1.0 };
    }

    wave_vector.into_iter().map(|v| (v * gain) as f32).collect()
}

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float,

};

let mut wave_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/sq.wav", wav_spec).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

[60, 64, 67, 64, 60, 64, 67, 72].iter().for_each

(

|sacle : &i32|

{

wave_vector.extend(get_square_wave_vector(*sacle, calculate_note_length(bpm, 8), 0.5));

}

);

for v in wave_vector.into_iter()

{

wave_writer.write_sample(v).unwrap();

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note : usize) -> usize

{

let base_length : f32 = (60.0 / bpm as f32) * SAMPLE_RATE;

return ((4.0 / note as f32) * base_length) as usize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

// note_length : 음표 길이 (샘플 수)

// gain : 출력

fn get_square_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>

{

let frequency : f32 = get_frequency(scale);

let interval : f32 = SAMPLE_RATE / frequency;

let mut wave_vector :Vec<f32> = vec![0.0; note_length];

let half_frequency : usize = (interval / 2.0) as usize;

for i in 0..note_length

{

let value : usize = (i / half_frequency) % 2;

wave_vector[i] = if value == 0 { -1.0 } else { 1.0 };

}

wave_vector.into_iter().map(|v| (v * gain) as f32).collect()

}

test_project.zip

[RUST/HOUND] 음정에서 주파수 구하기

■ 음정에서 주파수를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


fn get_frequency(note : i32) -> f32
{
    return 440.0 * 2.0f32.powf((note - 69) as f32 / 12.0);
}

println!("{}", get_frequency(60)); // 도
println!("{}", get_frequency(64)); // 미
println!("{}", get_frequency(67)); // 솔

/*
261.62555
329.62756
391.99542
*/

fn get_frequency(note : i32) -> f32

{

return 440.0 * 2.0f32.powf((note - 69) as f32 / 12.0);

}

println!("{}", get_frequency(60)); // 도

println!("{}", get_frequency(64)); // 미

println!("{}", get_frequency(67)); // 솔

261.62555

329.62756

391.99542

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 톱니파(sawtooth wave) WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 톱니파(sawtooth wave)의 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::io;
use std::fs;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 32,
        sample_format   : hound::SampleFormat::Float,
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create
    (
        "d:/saw.wav",
        wav_spec
    ).unwrap();

    let mut wave_vector : Vec<f32> = vec![];
    let bpm             : usize    = 120;

    wave_vector.extend(get_sawtooth_wave_vector(60, calculate_note_length(bpm, 4), 0.5));
    wave_vector.extend(get_sawtooth_wave_vector(64, calculate_note_length(bpm, 4), 0.5));
    wave_vector.extend(get_sawtooth_wave_vector(67, calculate_note_length(bpm, 4), 0.5));

    for v in wave_vector.into_iter()
    {
        wav_writer.write_sample(v).unwrap();
    }
}

// scale : 음계, 예) 60(도), 64(미), 67(솔)
fn get_frequency(scale : i32) -> f32
{
    return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);
}

// bpm  : 분당 박자, beats per minute
// note : 음표 예) 4(4분 음표)
fn calculate_note_length(bpm : usize, note : usize) -> usize
{
    let base_length : f32 = (60.0 / bpm as f32) * SAMPLE_RATE;

    return ((4.0 / note as f32) * base_length) as usize;
}

// scale       : 음계, 예) 60(도), 64(미), 67(솔)
// note_length : 음표 길이 (샘플 수)
// gain        : 출력
fn get_sawtooth_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>
{
    let frequency : f32 = get_frequency(scale);

    let interval : f32 = SAMPLE_RATE / frequency;

    let mut wave_vector : Vec<f32> = vec![0.0; note_length];

    for i in 0..note_length
    {
        let pif : f32 = (i as f32 / interval) % 1.0;

        wave_vector[i] = pif * 2.0 - 1.0;
    }

    return wave_vector.into_iter().map(|value : f32| (value * gain) as f32).collect();
}

use std::io;

use std::fs;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 32,

sample_format : hound::SampleFormat::Float,

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create

(

"d:/saw.wav",

wav_spec

).unwrap();

let mut wave_vector : Vec<f32> = vec![];

let bpm : usize = 120;

wave_vector.extend(get_sawtooth_wave_vector(60, calculate_note_length(bpm, 4), 0.5));

wave_vector.extend(get_sawtooth_wave_vector(64, calculate_note_length(bpm, 4), 0.5));

wave_vector.extend(get_sawtooth_wave_vector(67, calculate_note_length(bpm, 4), 0.5));

for v in wave_vector.into_iter()

{

wav_writer.write_sample(v).unwrap();

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

fn get_frequency(scale : i32) -> f32

{

return 440.0 * 2.0f32.powf((scale - 69) as f32 / 12.0);

}

// bpm : 분당 박자, beats per minute

// note : 음표 예) 4(4분 음표)

fn calculate_note_length(bpm : usize, note : usize) -> usize

{

let base_length : f32 = (60.0 / bpm as f32) * SAMPLE_RATE;

return ((4.0 / note as f32) * base_length) as usize;

}

// scale : 음계, 예) 60(도), 64(미), 67(솔)

// note_length : 음표 길이 (샘플 수)

// gain : 출력

fn get_sawtooth_wave_vector(scale : i32, note_length : usize, gain : f32) -> Vec<f32>

{

let frequency : f32 = get_frequency(scale);

let interval : f32 = SAMPLE_RATE / frequency;

let mut wave_vector : Vec<f32> = vec![0.0; note_length];

for i in 0..note_length

{

let pif : f32 = (i as f32 / interval) % 1.0;

wave_vector[i] = pif * 2.0 - 1.0;

}

return wave_vector.into_iter().map(|value : f32| (value * gain) as f32).collect();

}

test_project.zip

[RUST/HOUND] MML(Music Macro Language) 연주기 만들기

■ MML(Music Macro Language) 연주기를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

hound = "3.4.0"

▶ wav_writer.rs


use std::f32::consts;
use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

#[derive(Debug)]
pub struct Note
{
    pub note   : i32,
    pub length : i32
}

pub fn write(file_path : &str, note_vector : Vec<Note>, bpm : f32)
{
    let wac_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 16,
        sample_format   : hound::SampleFormat::Int
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create(file_path, wac_spec).unwrap();

    for note in note_vector.into_iter()
    {
        let length : u32 = (4.0 / note.length as f32 * (60.0 / bpm) * SAMPLE_RATE) as u32;

        let tone : f32 = if note.note >= 0 { 440.0 * 2.0f32.powf((note.note - 69) as f32 / 12.0) } else { 0.0 };

        write_tone(&mut wav_writer, tone, length);
    }
}

fn write_tone<W>(wav_writer : &mut hound::WavWriter<W>, tone : f32, length : u32) where W: io::Write + io::Seek
{
    for t in 0..length
    {
        let a : f32 = t as f32 / SAMPLE_RATE;
        let v : f32 = (a * tone * 2.0  * consts::PI).sin();

        wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();
    }
}

use std::f32::consts;

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

#[derive(Debug)]

pub struct Note

{

pub note : i32,

pub length : i32

}

pub fn write(file_path : &str, note_vector : Vec<Note>, bpm : f32)

{

let wac_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 16,

sample_format : hound::SampleFormat::Int

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create(file_path, wac_spec).unwrap();

for note in note_vector.into_iter()

{

let length : u32 = (4.0 / note.length as f32 * (60.0 / bpm) * SAMPLE_RATE) as u32;

let tone : f32 = if note.note >= 0 { 440.0 * 2.0f32.powf((note.note - 69) as f32 / 12.0) } else { 0.0 };

write_tone(&mut wav_writer, tone, length);

}

fn write_tone<W>(wav_writer : &mut hound::WavWriter<W>, tone : f32, length : u32) where W: io::Write + io::Seek

{

for t in 0..length

{

let a : f32 = t as f32 / SAMPLE_RATE;

let v : f32 = (a * tone * 2.0 * consts::PI).sin();

wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();

}

▶ mml_parser.rs


use std::str;

use crate::wav_writer::Note;

pub fn parse(source_string : String) -> Vec<Note>
{
    let mut note_vector : Vec<Note> = vec![];
    let mut octave      : i32 = 5;
    let mut length      : i32 = 4;

    let mut chars : str::Chars = source_string.chars();

    while let Some(character) = chars.next()
    {
        match character
        {
            'a'..='g' =>
            {
                let note : i32 = match character
                {
                    'c' => 0,
                    'd' => 2,
                    'e' => 4,
                    'f' => 5,
                    'g' => 7,
                    'a' => 9,
                    'b' => 11,
                    _   => 0
                };

                let target_note : i32 = note + octave * 12;

                note_vector.push(Note { note : target_note, length });
            },
            'r' =>
            {
                note_vector.push(Note { note : -1, length });
            },
            'o' =>
            {
                let v : char = chars.next().expect("o 다음에 숫자를 지정해주시기 바랍니다.");
                let o : i32 = v as i32 - '0' as i32;

                if o >= 0 && o < 9
                {
                    octave = o;
                }
            },
            'l' =>
            {
                let v : char = chars.next().expect("l 다음에 숫자를 지정해주시기 바랍니다.");
                let l : i32 = v as i32 - '0' as i32;

                if l >= 1 && l <= 9
                {
                    length = l;
                }
            },
            _ => {},
        };
    }

    return note_vector;
}

use std::str;

use crate::wav_writer::Note;

pub fn parse(source_string : String) -> Vec<Note>

{

let mut note_vector : Vec<Note> = vec![];

let mut octave : i32 = 5;

let mut length : i32 = 4;

let mut chars : str::Chars = source_string.chars();

while let Some(character) = chars.next()

{

match character

{

'a'..='g' =>

{

let note : i32 = match character

{

'c' => 0,

'd' => 2,

'e' => 4,

'f' => 5,

'g' => 7,

'a' => 9,

'b' => 11,

_ => 0

};

let target_note : i32 = note + octave * 12;

note_vector.push(Note { note : target_note, length });

'r' =>

{

note_vector.push(Note { note : -1, length });

'o' =>

{

let v : char = chars.next().expect("o 다음에 숫자를 지정해주시기 바랍니다.");

let o : i32 = v as i32 - '0' as i32;

if o >= 0 && o < 9

{

octave = o;

}

'l' =>

{

let v : char = chars.next().expect("l 다음에 숫자를 지정해주시기 바랍니다.");

let l : i32 = v as i32 - '0' as i32;

if l >= 1 && l <= 9

{

length = l;

}

_ => {},

};

}

return note_vector;

}

▶ main.rs


mod mml_parser;
mod wav_writer;

fn main()
{
    let bpm : f32 = 120.0;

    // 산토끼
    let mml_string1 : String = format!
    (
        "{}{}",
        "o4 l4 g l8 ee g e l4 cd l8 edce l4 gs",
        "o5 l8 c o4 l8 g o5 l8 c o4 g o5 c o4 g l4 e g l8 d fed l4 c"
    );

    let note_vector1 : Vec<wav_writer::Note> = mml_parser::parse(mml_string1);

    wav_writer::write("d:/rabbit.wav", note_vector1, bpm);

    // 작은별
    let mml_string2 : String = format!
    (
        "{}{}{}",
        "o5 l4 ccgg aal2g l4 ffee ddl2c",
        "l4 ggff eel2d l4 ggff eel2d",
        "l4 ccgg aal2g l4 ffee ddl2c"
    );

    let note_vector2 : Vec<wav_writer::Note> = mml_parser::parse(mml_string2);

    wav_writer::write("d:/twinkle_star.wav", note_vector2, bpm);
}

mod mml_parser;

mod wav_writer;

fn main()

{

let bpm : f32 = 120.0;

// 산토끼

let mml_string1 : String = format!

(

"{}{}",

"o4 l4 g l8 ee g e l4 cd l8 edce l4 gs",

"o5 l8 c o4 l8 g o5 l8 c o4 g o5 c o4 g l4 e g l8 d fed l4 c"

);

let note_vector1 : Vec<wav_writer::Note> = mml_parser::parse(mml_string1);

wav_writer::write("d:/rabbit.wav", note_vector1, bpm);

// 작은별

let mml_string2 : String = format!

(

"{}{}{}",

"o5 l4 ccgg aal2g l4 ffee ddl2c",

"l4 ggff eel2d l4 ggff eel2d",

"l4 ccgg aal2g l4 ffee ddl2c"

);

let note_vector2 : Vec<wav_writer::Note> = mml_parser::parse(mml_string2);

wav_writer::write("d:/twinkle_star.wav", note_vector2, bpm);

}

test_project.zip

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 동요 WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 동요 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::f32::consts;
use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;
const BPM         : f32 = 122.0; // 템포

#[allow(unused_variables)]
fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE as u32,
        bits_per_sample : 16,
        sample_format   : hound::SampleFormat::Int
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/melody.wav", wav_spec).unwrap();

    // 음정
    let c4 : f32 = 261.626; // 도
    let d4 : f32 = 293.665; // 레
    let e4 : f32 = 329.628; // 미
    let f4 : f32 = 349.228; // 파
    let g4 : f32 = 391.995; // 솔
    let a4 : f32 = 440.000; // 라
    let b4 : f32 = 493.883; // 시
    let c5 : f32 = 523.251; // 도

    // 음 길이
    let l4 : u32 = ((60.0 / BPM) * SAMPLE_RATE) as u32;
    let l2 : u32 = l4 * 2;

    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, a4, l4); // 라
    write_tone(&mut wav_writer, a4, l4); // 라
    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, e4, l2); // 미
    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, g4, l4); // 솔
    write_tone(&mut wav_writer, e4, l4); // 미
    write_tone(&mut wav_writer, e4, l4); // 미
    write_tone(&mut wav_writer, d4, l2); // 레
}

fn write_tone<W>(wav_writer : &mut hound::WavWriter<W>, tone : f32, length : u32) where W : io::Write + io::Seek
{
    for t in 0..length
    {
        let a : f32 = t as f32 / SAMPLE_RATE;
        let v : f32 = (a * tone * 2.0  * consts::PI).sin();

        wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();
    }
}

use std::f32::consts;

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : f32 = 44100.0;

const BPM : f32 = 122.0; // 템포

#[allow(unused_variables)]

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE as u32,

bits_per_sample : 16,

sample_format : hound::SampleFormat::Int

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/melody.wav", wav_spec).unwrap();

// 음정

let c4 : f32 = 261.626; // 도

let d4 : f32 = 293.665; // 레

let e4 : f32 = 329.628; // 미

let f4 : f32 = 349.228; // 파

let g4 : f32 = 391.995; // 솔

let a4 : f32 = 440.000; // 라

let b4 : f32 = 493.883; // 시

let c5 : f32 = 523.251; // 도

// 음 길이

let l4 : u32 = ((60.0 / BPM) * SAMPLE_RATE) as u32;

let l2 : u32 = l4 * 2;

write_tone(&mut wav_writer, g4, l4); // 솔

write_tone(&mut wav_writer, a4, l4); // 라

write_tone(&mut wav_writer, g4, l4); // 솔

write_tone(&mut wav_writer, e4, l2); // 미

write_tone(&mut wav_writer, g4, l4); // 솔

write_tone(&mut wav_writer, e4, l4); // 미

write_tone(&mut wav_writer, d4, l2); // 레

}

fn write_tone<W>(wav_writer : &mut hound::WavWriter<W>, tone : f32, length : u32) where W : io::Write + io::Seek

{

for t in 0..length

{

let a : f32 = t as f32 / SAMPLE_RATE;

let v : f32 = (a * tone * 2.0 * consts::PI).sin();

wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();

}

test_project.zip

[RUST/HOUND] WavWriter 구조체 : write_sample 메소드를 사용해 사인파 WAV 파일 생성하기

■ WavWriter 구조체의 write_sample 메소드를 사용해 사인파 WAV 파일을 생성하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
hound = "3.4.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

hound = "3.4.0"

▶ src/main.rs


use std::f32::consts;
use std::fs;
use std::io;

use hound;

const SAMPLE_RATE : u32 = 44100;
const TONE        : f32 = 440.0; // 440Hz = A

fn main()
{
    let wav_spec : hound::WavSpec = hound::WavSpec
    {
        channels        : 1,
        sample_rate     : SAMPLE_RATE,
        bits_per_sample : 16,
        sample_format   : hound::SampleFormat::Int
    };

    let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/target.wav", wav_spec).unwrap();

    let sample_count : u32 = SAMPLE_RATE * 3; // 3초

    for t in 0..sample_count
    {
        let v : f32 = ((t as f32 / SAMPLE_RATE as f32) * TONE * 2.0 * consts::PI).sin();

        wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();
    }
}

use std::f32::consts;

use std::fs;

use std::io;

use hound;

const SAMPLE_RATE : u32 = 44100;

const TONE : f32 = 440.0; // 440Hz = A

fn main()

{

let wav_spec : hound::WavSpec = hound::WavSpec

{

channels : 1,

sample_rate : SAMPLE_RATE,

bits_per_sample : 16,

sample_format : hound::SampleFormat::Int

};

let mut wav_writer : hound::WavWriter<io::BufWriter<fs::File>> = hound::WavWriter::create("d:/target.wav", wav_spec).unwrap();

let sample_count : u32 = SAMPLE_RATE * 3; // 3초

for t in 0..sample_count

{

let v : f32 = ((t as f32 / SAMPLE_RATE as f32) * TONE * 2.0 * consts::PI).sin();

wav_writer.write_sample((v * i16::MAX as f32) as i16).unwrap();

}

test_project.zip