SOUND Archives - icodebroker

[C#/COMMON/NAUDIO/.NET8] FSK (Frequency Shift Keying) 변조 사용하기

■ FSK (Frequency Shift Keying) 변조를 사용하는 방법을 보여준다. [Encoder 프로젝트] ▶ Program.cs


using System;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;

using NAudio.Wave;

namespace DECODER;

/// <summary>
/// 디코더
/// </summary>
class Decoder
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static
    //////////////////////////////////////////////////////////////////////////////// Private

    #region 다음 2의 거듭 제곱 구하기 - NextPowerOfTwo(value)

    /// <summary>
    /// 다음 2의 거듭 제곱 구하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns></returns>
    /// <remarks>입력값보다 큰 가장 작은 2의 거듭 제곱을 계산한다.</remarks>
    private static int NextPowerOfTwo(int value)
    {
        int power = 1;

        while(power < value)
        {
            power <<= 1;
        }

        return power;
    }

    #endregion
    #region 비트 반전하기 - BitReverse(bitValue, bitCount)

    /// <summary>
    /// 비트 반전하기
    /// </summary>
    /// <param name="bitValue">비트 값</param>
    /// <param name="bitCount">비트 수</param>
    /// <returns>반전 비트 값</returns>
    private static int BitReverse(int bitValue, int bitCount)
    {
        int reversed = 0;

        for(int i = 0; i < bitCount; i++)
        {
            int nextBit = (bitValue >> i) & 1;

            reversed |= (nextBit << (bitCount - i - 1));
        }

        return reversed;
    }

    #endregion
    #region FFT 처리하기 - FFT(complexArray)

    /// <summary>
    /// FFT 처리하기
    /// </summary>
    /// <param name="complexArray">복소수 배열</param>
    private static void FFT(Complex[] complexArray)
    {
        int complexArrayLength = complexArray.Length;

        if(complexArrayLength <= 1)
        {
            return;
        }

        // Bit reversal permutation
        int m1 = (int)Math.Log(complexArrayLength, 2);

        for(int i = 0; i < complexArrayLength; i++)
        {
            int j = BitReverse(i, m1);

            if(j > i)
            {
                Complex t = complexArray[i];

                complexArray[i] = complexArray[j];
                complexArray[j] = t;
            }
        }

        // Cooley-Tukey FFT
        for(int s = 1; s <= m1; s++)
        {
            int m2 = 1 << s;

            Complex wm = Complex.Exp(-2.0 * Math.PI * Complex.ImaginaryOne / m2);

            for(int k = 0; k < complexArrayLength; k += m2)
            {
                Complex w = 1;

                for(int j = 0; j < m2 / 2; j++)
                {
                    int index1 = k + j;
                    int index2 = k + j + m2 / 2;

                    Complex t = w * complexArray[index2];
                    Complex u = complexArray[index1];

                    complexArray[index1] = u + t;
                    complexArray[index2] = u - t;

                    w *= wm;
                }
            }
        }
    }

    #endregion
    #region 프로그램 시작하기 - Main(argumentArray)

    /// <summary>
    /// 프로그램 시작하기
    /// </summary>
    /// <param name="argumentArray">인자 배열</param>
    private static void Main(string[] argumentArray)
    {
        if(argumentArray.Length != 2)
        {
            Console.WriteLine("사용법 : decoder.exe source.wav target.zip");

            return;
        }

        string sourceFilePath = argumentArray[0];
        string targetFilePath = argumentArray[1];

        int    samplingFrequency = 44100; // 샘플링 주파수
        double durationPerBit    = 0.01;  // 각 비트의 지속 시간 (초)
        int    sampleCountPerBit = (int)(samplingFrequency * durationPerBit);

        int frequency0 = 1000; // '0'에 대한 주파수
        int frequency1 = 2000; // '1'에 대한 주파수

        // 시작 및 종료 마커를 설정한다.
        string startMarkerBitString = "1111000011110000";
        string endMarkerBitString   = "0000111100001111";

        // WAV 파일을 읽는다.
        float[] signalArray;

        using(AudioFileReader audioFileReader = new(sourceFilePath))
        {
            int totalSampleCount = (int)audioFileReader.Length / (audioFileReader.WaveFormat.BitsPerSample / 8);

            signalArray = new float[totalSampleCount];

            int readSampleCount = audioFileReader.Read(signalArray, 0, totalSampleCount);
        }

        int bitCount = signalArray.Length / sampleCountPerBit;

        StringBuilder bitStringBuilder = new StringBuilder();

        for(int i = 0; i < bitCount; i++)
        {
            int start = i * sampleCountPerBit;
            int end   = start + sampleCountPerBit;

            if(end > signalArray.Length)
            {
                break;
            }

            float[] segmentArray = new float[sampleCountPerBit];

            Array.Copy(signalArray, start, segmentArray, 0, sampleCountPerBit);

            // 입력 배열 길이를 가장 가까운 2의 거듭제곱으로 패딩한다.
            int paddedLength = NextPowerOfTwo(segmentArray.Length);

            Complex[] fftComplexArray = new Complex[paddedLength];

            for(int j = 0; j < segmentArray.Length; j++)
            {
                fftComplexArray[j] = new Complex(segmentArray[j], 0);
            }

            for(int j = segmentArray.Length; j < paddedLength; j++)
            {
                fftComplexArray[j] = Complex.Zero;
            }

            // 주파수 분석을 위한 FFT를 수행한다.
            FFT(fftComplexArray);

            double[] magnitudeArray = fftComplexArray.Take(paddedLength / 2).Select(c => c.Magnitude).ToArray();

            int peakIndex = Array.IndexOf(magnitudeArray, magnitudeArray.Max());

            double peakFrequency = (double)peakIndex * samplingFrequency / paddedLength;

            // 주파수에 따라 비트를 결정한다.
            if(Math.Abs(peakFrequency - frequency0) < 100)
            {
                bitStringBuilder.Append('0');
            }
            else if(Math.Abs(peakFrequency - frequency1) < 100)
            {
                bitStringBuilder.Append('1');
            }
            else
            {
                bitStringBuilder.Append('?');
            }
        }

        string bitStream = bitStringBuilder.ToString();

        // 비트 스트림에서 시작 및 종료 마커를 찾는다.
        int startMarkerIndex = bitStream.IndexOf(startMarkerBitString);
        int endMarkerIndex   = bitStream.IndexOf(endMarkerBitString);

        if(startMarkerIndex == -1 || endMarkerIndex == -1)
        {
            Console.WriteLine("시작 또는 종료 마커를 찾을 수 없습니다.");

            return;
        }

        int dataStart = startMarkerIndex + startMarkerBitString.Length;
        int dataEnd   = endMarkerIndex;

        string dataBitStream = bitStream.Substring(dataStart, dataEnd - dataStart);

        // 파일 크기를 추출한다. (첫 32비트)
        if(dataBitStream.Length < 32)
        {
            Console.WriteLine("파일 크기 정보를 읽을 수 없습니다.");

            return;
        }

        string fileSizeString = dataBitStream.Substring(0, 32);

        dataBitStream = dataBitStream.Substring(32);

        // 파일 크기를 정수로 변환한다.
        int fileSize = Convert.ToInt32(fileSizeString, 2);

        // 결정할 수 없는 비트를 제거한다.
        dataBitStream = dataBitStream.Replace("?", "");

        // 비트를 바이트로 변환한다.
        int byteCount = dataBitStream.Length / 8;

        byte[] dataByteArray = new byte[byteCount];

        for(int i = 0; i < byteCount; i++)
        {
            string byteBitString = dataBitStream.Substring(i * 8, 8);

            dataByteArray[i] = Convert.ToByte(byteBitString, 2);
        }

        // 파일 크기에 따라 데이터를 자른다.
        if(dataByteArray.Length > fileSize)
        {
            byte[] tempByteArray = new byte[fileSize];

            Array.Copy(dataByteArray, tempByteArray, fileSize);

            dataByteArray = tempByteArray;
        }

        // 복원된 파일을 저장한다.
        File.WriteAllBytes(targetFilePath, dataByteArray);

        Console.WriteLine("디코딩 완료 : " + targetFilePath);
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

using System;

using System.IO;

using System.Linq;

using System.Numerics;

using System.Text;

using NAudio.Wave;

namespace DECODER;

/// <summary>

/// 디코더

/// </summary>

class Decoder

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 다음 2의 거듭 제곱 구하기 - NextPowerOfTwo(value)

/// <summary>

/// 다음 2의 거듭 제곱 구하기

/// </summary>

/// <param name="value">값</param>

/// <returns></returns>

/// <remarks>입력값보다 큰 가장 작은 2의 거듭 제곱을 계산한다.</remarks>

private static int NextPowerOfTwo(int value)

{

int power = 1;

while(power < value)

{

power <<= 1;

}

return power;

}

#endregion

#region 비트 반전하기 - BitReverse(bitValue, bitCount)

/// <summary>

/// 비트 반전하기

/// </summary>

/// <param name="bitValue">비트 값</param>

/// <param name="bitCount">비트 수</param>

/// <returns>반전 비트 값</returns>

private static int BitReverse(int bitValue, int bitCount)

{

int reversed = 0;

for(int i = 0; i < bitCount; i++)

{

int nextBit = (bitValue >> i) & 1;

reversed |= (nextBit << (bitCount - i - 1));

}

return reversed;

}

#endregion

#region FFT 처리하기 - FFT(complexArray)

/// <summary>

/// FFT 처리하기

/// </summary>

/// <param name="complexArray">복소수 배열</param>

private static void FFT(Complex[] complexArray)

{

int complexArrayLength = complexArray.Length;

if(complexArrayLength <= 1)

{

return;

}

// Bit reversal permutation

int m1 = (int)Math.Log(complexArrayLength, 2);

for(int i = 0; i < complexArrayLength; i++)

{

int j = BitReverse(i, m1);

if(j > i)

{

Complex t = complexArray[i];

complexArray[i] = complexArray[j];

complexArray[j] = t;

}

// Cooley-Tukey FFT

for(int s = 1; s <= m1; s++)

{

int m2 = 1 << s;

Complex wm = Complex.Exp(-2.0 * Math.PI * Complex.ImaginaryOne / m2);

for(int k = 0; k < complexArrayLength; k += m2)

{

Complex w = 1;

for(int j = 0; j < m2 / 2; j++)

{

int index1 = k + j;

int index2 = k + j + m2 / 2;

Complex t = w * complexArray[index2];

Complex u = complexArray[index1];

complexArray[index1] = u + t;

complexArray[index2] = u - t;

w *= wm;

}

#endregion

#region 프로그램 시작하기 - Main(argumentArray)

/// <summary>

/// 프로그램 시작하기

/// </summary>

/// <param name="argumentArray">인자 배열</param>

private static void Main(string[] argumentArray)

{

if(argumentArray.Length != 2)

{

Console.WriteLine("사용법 : decoder.exe source.wav target.zip");

return;

}

string sourceFilePath = argumentArray[0];

string targetFilePath = argumentArray[1];

int samplingFrequency = 44100; // 샘플링 주파수

double durationPerBit = 0.01; // 각 비트의 지속 시간 (초)

int sampleCountPerBit = (int)(samplingFrequency * durationPerBit);

int frequency0 = 1000; // '0'에 대한 주파수

int frequency1 = 2000; // '1'에 대한 주파수

// 시작 및 종료 마커를 설정한다.

string startMarkerBitString = "1111000011110000";

string endMarkerBitString = "0000111100001111";

// WAV 파일을 읽는다.

float[] signalArray;

using(AudioFileReader audioFileReader = new(sourceFilePath))

{

int totalSampleCount = (int)audioFileReader.Length / (audioFileReader.WaveFormat.BitsPerSample / 8);

signalArray = new float[totalSampleCount];

int readSampleCount = audioFileReader.Read(signalArray, 0, totalSampleCount);

}

int bitCount = signalArray.Length / sampleCountPerBit;

StringBuilder bitStringBuilder = new StringBuilder();

for(int i = 0; i < bitCount; i++)

{

int start = i * sampleCountPerBit;

int end = start + sampleCountPerBit;

if(end > signalArray.Length)

{

break;

}

float[] segmentArray = new float[sampleCountPerBit];

Array.Copy(signalArray, start, segmentArray, 0, sampleCountPerBit);

// 입력 배열 길이를 가장 가까운 2의 거듭제곱으로 패딩한다.

int paddedLength = NextPowerOfTwo(segmentArray.Length);

Complex[] fftComplexArray = new Complex[paddedLength];

for(int j = 0; j < segmentArray.Length; j++)

{

fftComplexArray[j] = new Complex(segmentArray[j], 0);

}

for(int j = segmentArray.Length; j < paddedLength; j++)

{

fftComplexArray[j] = Complex.Zero;

}

// 주파수 분석을 위한 FFT를 수행한다.

FFT(fftComplexArray);

double[] magnitudeArray = fftComplexArray.Take(paddedLength / 2).Select(c => c.Magnitude).ToArray();

int peakIndex = Array.IndexOf(magnitudeArray, magnitudeArray.Max());

double peakFrequency = (double)peakIndex * samplingFrequency / paddedLength;

// 주파수에 따라 비트를 결정한다.

if(Math.Abs(peakFrequency - frequency0) < 100)

{

bitStringBuilder.Append('0');

}

else if(Math.Abs(peakFrequency - frequency1) < 100)

{

bitStringBuilder.Append('1');

}

else

{

bitStringBuilder.Append('?');

}

string bitStream = bitStringBuilder.ToString();

// 비트 스트림에서 시작 및 종료 마커를 찾는다.

int startMarkerIndex = bitStream.IndexOf(startMarkerBitString);

int endMarkerIndex = bitStream.IndexOf(endMarkerBitString);

if(startMarkerIndex == -1 || endMarkerIndex == -1)

{

Console.WriteLine("시작 또는 종료 마커를 찾을 수 없습니다.");

return;

}

int dataStart = startMarkerIndex + startMarkerBitString.Length;

int dataEnd = endMarkerIndex;

string dataBitStream = bitStream.Substring(dataStart, dataEnd - dataStart);

// 파일 크기를 추출한다. (첫 32비트)

if(dataBitStream.Length < 32)

{

Console.WriteLine("파일 크기 정보를 읽을 수 없습니다.");

return;

}

string fileSizeString = dataBitStream.Substring(0, 32);

dataBitStream = dataBitStream.Substring(32);

// 파일 크기를 정수로 변환한다.

int fileSize = Convert.ToInt32(fileSizeString, 2);

// 결정할 수 없는 비트를 제거한다.

dataBitStream = dataBitStream.Replace("?", "");

// 비트를 바이트로 변환한다.

int byteCount = dataBitStream.Length / 8;

byte[] dataByteArray = new byte[byteCount];

for(int i = 0; i < byteCount; i++)

{

string byteBitString = dataBitStream.Substring(i * 8, 8);

dataByteArray[i] = Convert.ToByte(byteBitString, 2);

}

// 파일 크기에 따라 데이터를 자른다.

if(dataByteArray.Length > fileSize)

{

byte[] tempByteArray = new byte[fileSize];

Array.Copy(dataByteArray, tempByteArray, fileSize);

dataByteArray = tempByteArray;

}

// 복원된 파일을 저장한다.

File.WriteAllBytes(targetFilePath, dataByteArray);

Console.WriteLine("디코딩 완료 : " + targetFilePath);

}

#endregion

}

[Decoder 프로젝트] ▶ requirements.txt


using System;
using System.IO;
using System.Linq;

using NAudio.Wave;

namespace ENCODER;

/// <summary>
/// 인코더
/// </summary>
class Encoder
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static
    //////////////////////////////////////////////////////////////////////////////// Private

    #region 프로그램 시작하기 - Main(argumentArray)

    /// <summary>
    /// 프로그램 시작하기
    /// </summary>
    /// <param name="argumentArray">인자 배열</param>
    private static void Main(string[] argumentArray)
    {
        if(argumentArray.Length != 2)
        {
            Console.WriteLine("사용법 : encoder.exe source.zip target.wav");

            return;
        }

        string sourceFilePath = argumentArray[0];
        string targetFilePath = argumentArray[1];

        // 소스 파일을 읽는다.
        byte[] sourceFileByteArray = File.ReadAllBytes(sourceFilePath);

        int sourceFileSize = sourceFileByteArray.Length;

        // 바이트를 비트로 변환한다.
        string dataBitString = string.Join(string.Empty, sourceFileByteArray.Select(sourceByte => Convert.ToString(sourceByte, 2).PadLeft(8, '0')));

        // 파일 크기를 헤더에 추가한다. (32비트로 표현)
        string fileSizeBitString = Convert.ToString(sourceFileSize, 2).PadLeft(32, '0');

        // 시작 및 종료 마커 문자열을 설정한다.
        string startMarkerString = "1111000011110000";
        string endMarkerString   = "0000111100001111";

        // 전체 비트 스트림을 생성한다.
        string bitStreamString = startMarkerString + fileSizeBitString + dataBitString + endMarkerString;

        // 파라미터를 설정한다.
        int    samplingFrequency = 44100; // 샘플링 주파수
        double durationPerBit    = 0.01;  // 각 비트의 지속 시간 (초)
        int    sampleCountPerBit = (int)(samplingFrequency * durationPerBit);

        int frequency0 = 1000; // '0'에 대한 주파수
        int frequency1 = 2000; // '1'에 대한 주파수

        // 신호를 생성한다.
        float[] signalArray = new float[bitStreamString.Length * sampleCountPerBit];

        int bitStreamStringLength = bitStreamString.Length;

        for(int i = 0; i < bitStreamStringLength; i++)
        {
            char bitCharacter = bitStreamString[i];

            int frequency = bitCharacter == '1' ? frequency1 : frequency0;

            for(int j = 0; j < sampleCountPerBit; j++)
            {
                double t = (double)j / samplingFrequency;

                signalArray[i * sampleCountPerBit + j] = (float)Math.Sin(2 * Math.PI * frequency * t);
            }
        }

        // 신호를 정규화한다.
        float maximumAmplitude = signalArray.Max(x => Math.Abs(x));

        for(int i = 0; i < signalArray.Length; i++)
        {
            signalArray[i] = signalArray[i] / maximumAmplitude;
        }

        // WAV 파일로 저장한다.
        using(WaveFileWriter waveFileWriter = new WaveFileWriter(targetFilePath, new WaveFormat(samplingFrequency, 16, 1)))
        {
            waveFileWriter.WriteSamples(signalArray, 0, signalArray.Length);
        }

        Console.WriteLine("인코딩 완료 : " + targetFilePath);
    }

    #endregion
}

100

101

using System;

using System.IO;

using System.Linq;

using NAudio.Wave;

namespace ENCODER;

/// <summary>

/// 인코더

/// </summary>

class Encoder

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main(argumentArray)

/// <summary>

/// 프로그램 시작하기

/// </summary>

/// <param name="argumentArray">인자 배열</param>

private static void Main(string[] argumentArray)

{

if(argumentArray.Length != 2)

{

Console.WriteLine("사용법 : encoder.exe source.zip target.wav");

return;

}

string sourceFilePath = argumentArray[0];

string targetFilePath = argumentArray[1];

// 소스 파일을 읽는다.

byte[] sourceFileByteArray = File.ReadAllBytes(sourceFilePath);

int sourceFileSize = sourceFileByteArray.Length;

// 바이트를 비트로 변환한다.

string dataBitString = string.Join(string.Empty, sourceFileByteArray.Select(sourceByte => Convert.ToString(sourceByte, 2).PadLeft(8, '0')));

// 파일 크기를 헤더에 추가한다. (32비트로 표현)

string fileSizeBitString = Convert.ToString(sourceFileSize, 2).PadLeft(32, '0');

// 시작 및 종료 마커 문자열을 설정한다.

string startMarkerString = "1111000011110000";

string endMarkerString = "0000111100001111";

// 전체 비트 스트림을 생성한다.

string bitStreamString = startMarkerString + fileSizeBitString + dataBitString + endMarkerString;

// 파라미터를 설정한다.

int samplingFrequency = 44100; // 샘플링 주파수

double durationPerBit = 0.01; // 각 비트의 지속 시간 (초)

int sampleCountPerBit = (int)(samplingFrequency * durationPerBit);

int frequency0 = 1000; // '0'에 대한 주파수

int frequency1 = 2000; // '1'에 대한 주파수

// 신호를 생성한다.

float[] signalArray = new float[bitStreamString.Length * sampleCountPerBit];

int bitStreamStringLength = bitStreamString.Length;

for(int i = 0; i < bitStreamStringLength; i++)

{

char bitCharacter = bitStreamString[i];

int frequency = bitCharacter == '1' ? frequency1 : frequency0;

for(int j = 0; j < sampleCountPerBit; j++)

{

double t = (double)j / samplingFrequency;

signalArray[i * sampleCountPerBit + j] = (float)Math.Sin(2 * Math.PI * frequency * t);

}

// 신호를 정규화한다.

float maximumAmplitude = signalArray.Max(x => Math.Abs(x));

for(int i = 0; i < signalArray.Length; i++)

{

signalArray[i] = signalArray[i] / maximumAmplitude;

}

// WAV 파일로 저장한다.

using(WaveFileWriter waveFileWriter = new WaveFileWriter(targetFilePath, new WaveFormat(samplingFrequency, 16, 1)))

{

waveFileWriter.WriteSamples(signalArray, 0, signalArray.Length);

}

Console.WriteLine("인코딩 완료 : " + targetFilePath);

}

#endregion

}

TestSolution.zip

[PYTHON/SCIPY] FSK (Frequency Shift Keying) 변조 사용하기

■ FSK (Frequency Shift Keying) 변조를 사용하는 방법을 보여준다. ▶ main.py


import numpy            as np
import scipy.io.wavfile as wav

from scipy.signal import butter
from scipy.signal import lfilter

# FSK 변조 매개 변수
SAMPLE_RATE  = 44100
FREQUENCY_0  = 2000  # 0을 나타내는 주파수
FREQUENCY_1  = 4000  # 1을 나타내는 주파수
BIT_DURATION = 0.01  # 각 비트의 지속 시간 (초)

def generateSine(frequency, duration):
    t = np.linspace(0, duration, int(SAMPLE_RATE * duration), False)
    return np.sin(2 * np.pi * frequency * t)

def modulateFSK(bitString):
    targetList = []
    for bit in bitString:
        if bit == '0':
            targetList.extend(generateSine(FREQUENCY_0, BIT_DURATION))
        else:
            targetList.extend(generateSine(FREQUENCY_1, BIT_DURATION))
    return np.array(targetList)

def addNoise(signal, snrDB): # sndDB : Signal-to-Noise Ratio in decibels
    signalPower = np.mean(signal ** 2)
    noisePower  = signalPower / (10 ** (snrDB / 10))
    noise       = np.random.normal(0, np.sqrt(noisePower), len(signal))
    return signal + noise

def butterBandpass(lowcut, highcut, samplingFrequency, order = 5):
    nyq  = 0.5 * samplingFrequency
    low  = lowcut / nyq
    high = highcut / nyq
    b, a = butter(order, [low, high], btype = "band")
    return b, a

def butterBandpassFilter(data, lowCut, highCut, samplingFrequency, order = 5):
    b, a = butterBandpass(lowCut, highCut, samplingFrequency, order=order)
    y = lfilter(b, a, data)
    return y

def demodulateFSK(signalNDArray):
    ndArrayFiltered0 = butterBandpassFilter(signalNDArray, FREQUENCY_0 - 200, FREQUENCY_0 + 200, SAMPLE_RATE)
    ndArrayFiltered1 = butterBandpassFilter(signalNDArray, FREQUENCY_1 - 200, FREQUENCY_1 + 200, SAMPLE_RATE)

    sampleCountPerBit = int(BIT_DURATION * SAMPLE_RATE)

    energy0NDArray = np.array([np.sum(ndArrayFiltered0[i:i + sampleCountPerBit] ** 2) for i in range(0, len(ndArrayFiltered0), sampleCountPerBit)])
    energy1NDArray = np.array([np.sum(ndArrayFiltered1[i:i + sampleCountPerBit] ** 2) for i in range(0, len(ndArrayFiltered1), sampleCountPerBit)])

    return "".join(["0" if e0 > e1 else "1" for e0, e1 in zip(energy0NDArray, energy1NDArray)])

def encodeFile(sourceFilePath, filePathEncoded, snrDB = 20):
    with open(sourceFilePath, "rb") as bufferedReader:
        readBytes = bufferedReader.read()

    bitString = "".join(format(byte, "08b") for byte in readBytes)

    # 동기화를 위한 프리앰블 추가한다.
    preambleString = "10" * 10  # 10번의 1, 0을 반복한다.
    bitString      = preambleString + bitString

    # FSK 변조를 처리한다.
    ndArrayModulated = modulateFSK(bitString)

    # 잡음을 추가한다.
    ndArrayAddedNoisySignal = addNoise(ndArrayModulated, snrDB)

    # WAV 파일로 저장한다.
    wav.write(filePathEncoded, SAMPLE_RATE, (ndArrayAddedNoisySignal * 32767).astype(np.int16))

def decodeFile(filePathEncoded, filePathDecoded):
    sampleRate, ndArray = wav.read(filePathEncoded)

    # 배열값을 float로 정규화한다.
    signalNDArray = ndArray.astype(float) / 32767.0

    # FSK 복조를 처리한다.
    stringDemodulated = demodulateFSK(signalNDArray)

    # 프리앰블을 제거하고 동기화를 처리한다.
    preambleString = "10" * 10

    synchronizationIndex = stringDemodulated.index(preambleString) + len(preambleString)

    stringDemodulated = stringDemodulated[synchronizationIndex:]

    # 비트 문자열을 바이트로 변환한다.
    bytesDecoded = bytes(int(stringDemodulated[i:i + 8], 2) for i in range(0, len(stringDemodulated), 8))

    # 파일로 저장한다.
    with open(filePathDecoded, "wb") as bufferedWriter:
        bufferedWriter.write(bytesDecoded)

sourceFilePath  = "source.zip"
filePathEncoded = "target.wav"
filePathDecoded = "target.zip"

encodeFile(sourceFilePath , filePathEncoded)
decodeFile(filePathEncoded, filePathDecoded)

100

101

102

103

104

import numpy as np

import scipy.io.wavfile as wav

from scipy.signal import butter

from scipy.signal import lfilter

# FSK 변조 매개 변수

SAMPLE_RATE = 44100

FREQUENCY_0 = 2000 # 0을 나타내는 주파수

FREQUENCY_1 = 4000 # 1을 나타내는 주파수

BIT_DURATION = 0.01 # 각 비트의 지속 시간 (초)

def generateSine(frequency, duration):

t = np.linspace(0, duration, int(SAMPLE_RATE * duration), False)

return np.sin(2 * np.pi * frequency * t)

def modulateFSK(bitString):

targetList = []

for bit in bitString:

if bit == '0':

targetList.extend(generateSine(FREQUENCY_0, BIT_DURATION))

else:

targetList.extend(generateSine(FREQUENCY_1, BIT_DURATION))

return np.array(targetList)

def addNoise(signal, snrDB): # sndDB : Signal-to-Noise Ratio in decibels

signalPower = np.mean(signal ** 2)

noisePower = signalPower / (10 ** (snrDB / 10))

noise = np.random.normal(0, np.sqrt(noisePower), len(signal))

return signal + noise

def butterBandpass(lowcut, highcut, samplingFrequency, order = 5):

nyq = 0.5 * samplingFrequency

low = lowcut / nyq

high = highcut / nyq

b, a = butter(order, [low, high], btype = "band")

return b, a

def butterBandpassFilter(data, lowCut, highCut, samplingFrequency, order = 5):

b, a = butterBandpass(lowCut, highCut, samplingFrequency, order=order)

y = lfilter(b, a, data)

return y

def demodulateFSK(signalNDArray):

ndArrayFiltered0 = butterBandpassFilter(signalNDArray, FREQUENCY_0 - 200, FREQUENCY_0 + 200, SAMPLE_RATE)

ndArrayFiltered1 = butterBandpassFilter(signalNDArray, FREQUENCY_1 - 200, FREQUENCY_1 + 200, SAMPLE_RATE)

sampleCountPerBit = int(BIT_DURATION * SAMPLE_RATE)

energy0NDArray = np.array([np.sum(ndArrayFiltered0[i:i + sampleCountPerBit] ** 2) for i in range(0, len(ndArrayFiltered0), sampleCountPerBit)])

energy1NDArray = np.array([np.sum(ndArrayFiltered1[i:i + sampleCountPerBit] ** 2) for i in range(0, len(ndArrayFiltered1), sampleCountPerBit)])

return "".join(["0" if e0 > e1 else "1" for e0, e1 in zip(energy0NDArray, energy1NDArray)])

def encodeFile(sourceFilePath, filePathEncoded, snrDB = 20):

with open(sourceFilePath, "rb") as bufferedReader:

readBytes = bufferedReader.read()

bitString = "".join(format(byte, "08b") for byte in readBytes)

# 동기화를 위한 프리앰블 추가한다.

preambleString = "10" * 10 # 10번의 1, 0을 반복한다.

bitString = preambleString + bitString

# FSK 변조를 처리한다.

ndArrayModulated = modulateFSK(bitString)

# 잡음을 추가한다.

ndArrayAddedNoisySignal = addNoise(ndArrayModulated, snrDB)

# WAV 파일로 저장한다.

wav.write(filePathEncoded, SAMPLE_RATE, (ndArrayAddedNoisySignal * 32767).astype(np.int16))

def decodeFile(filePathEncoded, filePathDecoded):

sampleRate, ndArray = wav.read(filePathEncoded)

# 배열값을 float로 정규화한다.

signalNDArray = ndArray.astype(float) / 32767.0

# FSK 복조를 처리한다.

stringDemodulated = demodulateFSK(signalNDArray)

# 프리앰블을 제거하고 동기화를 처리한다.

preambleString = "10" * 10

synchronizationIndex = stringDemodulated.index(preambleString) + len(preambleString)

stringDemodulated = stringDemodulated[synchronizationIndex:]

# 비트 문자열을 바이트로 변환한다.

bytesDecoded = bytes(int(stringDemodulated[i:i + 8], 2) for i in range(0, len(stringDemodulated), 8))

# 파일로 저장한다.

with open(filePathDecoded, "wb") as bufferedWriter:

bufferedWriter.write(bytesDecoded)

sourceFilePath = "source.zip"

filePathEncoded = "target.wav"

filePathDecoded = "target.zip"

encodeFile(sourceFilePath , filePathEncoded)

decodeFile(filePathEncoded, filePathDecoded)

▶ requirements.txt


numpy==2.1.1
scipy==1.14.1

numpy==2.1.1

scipy==1.14.1

※ pip install scipy 명령을 실행했다.

[PYTHON/PYDUB] AudioSegment 클래스 : from_mp3 정적 메소드/export 메소드를 사용해 오디오 파일 잘라내기

■ AudioSegment 클래스의from_mp3 정적 메소드/export 메소드를 사용해 오디오 파일을 잘라내는 방법을 보여준다. ※ FFMPEG이 사전에 설치되어야 한다. ▶ main.py


from pydub import AudioSegment

audioSegment1 = AudioSegment.from_mp3("source.mp3")

audioSegment2 = audioSegment1[:5000] # 5초

audioSegment2.export("result.mp3", format = "mp3")

from pydub import AudioSegment

audioSegment1 = AudioSegment.from_mp3("source.mp3")

audioSegment2 = audioSegment1[:5000] # 5초

audioSegment2.export("result.mp3", format = "mp3")

▶ requirements.txt

[PYTHON/COMMON] pydub 패키지 설치하기

■ pydub 패키지를 설치하는 방법을 보여준다. 1. 명령 프롬프트를 실행한다. 2. 명령 프롬프트에서 아래 명령을 실행한다. ▶ 실행 명령


pip install pydub

pip install pydub

[C#/WINUI3/.NET6] ElementSoundPlayer 클래스 : State/SpatialAudioMode 정적 속성과 Play 정적 메소드 사용하기

■ ElementSoundPlayer 클래스의 State/SpatialAudioMode 정적 속성과 Play 정적 메소드를 사용하는 방법을 보여준다. ▶ MainPage.xaml


<?xml version="1.0" encoding="utf-8"?>
<Page x:Class="TestProject.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel
        HorizontalAlignment="Center"
        VerticalAlignment="Center">
        <ToggleSwitch Name="soundToggleSwitch"
            HorizontalAlignment="Center"
            OffContent="Sound Off"
            OnContent="Sound On" />
        <StackPanel
            Margin="0 30 0 0"
            Orientation="Vertical">
            <CheckBox Name="spatialAudioCheckBox"
                IsEnabled="False"
                Content="Enable Spatial Audio" />
            <TextBlock
                Margin="0 10 0 0"
                Text="Can only enable spatial audio when sound is on!"
                Foreground="{ThemeResource SystemColorHotlightColor}"
                Style="{ThemeResource CaptionTextBlockStyle}"
                FontStyle="Italic" />
        </StackPanel>
        <Grid Margin="0 30 0 0">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*"    />
            </Grid.ColumnDefinitions>
            <Button Name="playSoundButton" Grid.Column="0"
                Content="Play Sound"
                ElementSoundMode="Off"
                HorizontalAlignment="Left" />
            <ComboBox Name="soundSelectionComboBox" Grid.Column="1"
                Header="Pick Custom Sound"
                SelectedIndex="1"
                HorizontalAlignment="Right"
                Margin="50 0 0 0">
                <ComboBoxItem>Focus</ComboBoxItem>
                <ComboBoxItem>Invoke</ComboBoxItem>
                <ComboBoxItem>Show</ComboBoxItem>
                <ComboBoxItem>Hide</ComboBoxItem>
                <ComboBoxItem>MoveNext</ComboBoxItem>
                <ComboBoxItem>MovePrevious</ComboBoxItem>
                <ComboBoxItem>GoBack</ComboBoxItem>
            </ComboBox>
        </Grid>
    </StackPanel>
</Page>

<?xml version="1.0" encoding="utf-8"?>

<Page x:Class="TestProject.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

<StackPanel

HorizontalAlignment="Center"

VerticalAlignment="Center">

<ToggleSwitch Name="soundToggleSwitch"

HorizontalAlignment="Center"

OffContent="Sound Off"

OnContent="Sound On" />

<StackPanel

Margin="0 30 0 0"

Orientation="Vertical">

<CheckBox Name="spatialAudioCheckBox"

IsEnabled="False"

Content="Enable Spatial Audio" />

<TextBlock

Margin="0 10 0 0"

Text="Can only enable spatial audio when sound is on!"

Foreground="{ThemeResource SystemColorHotlightColor}"

Style="{ThemeResource CaptionTextBlockStyle}"

FontStyle="Italic" />

</StackPanel>

<Grid.ColumnDefinitions>

</Grid.ColumnDefinitions>

<Button Name="playSoundButton" Grid.Column="0"

Content="Play Sound"

ElementSoundMode="Off"

HorizontalAlignment="Left" />

<ComboBox Name="soundSelectionComboBox" Grid.Column="1"

Header="Pick Custom Sound"

SelectedIndex="1"

HorizontalAlignment="Right"

Margin="50 0 0 0">

<ComboBoxItem>Focus</ComboBoxItem>

<ComboBoxItem>Invoke</ComboBoxItem>

<ComboBoxItem>MoveNext</ComboBoxItem>

<ComboBoxItem>MovePrevious</ComboBoxItem>

<ComboBoxItem>GoBack</ComboBoxItem>

</ComboBox>

</Grid>

</StackPanel>

</Page>

▶ MainPage.xaml.cs


using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

namespace TestProject
{
    /// <summary>
    /// 메인 페이지
    /// </summary>
    public sealed partial class MainPage : Page
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainPage()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainPage()
        {
            InitializeComponent();

            this.soundToggleSwitch.Toggled      += soundToggleSwitch_Toggled;
            this.spatialAudioCheckBox.Checked   += enableSpatialAudioCheckBox_Checked;
            this.spatialAudioCheckBox.Unchecked += spatialAudioCheckBox_Unchecked;
            this.playSoundButton.Click          += playSoundButton_Click;

            if(ElementSoundPlayer.State == ElementSoundPlayerState.On)
            {
                this.soundToggleSwitch.IsOn = true;
            }

            if(ElementSoundPlayer.SpatialAudioMode == ElementSpatialAudioMode.On && soundToggleSwitch.IsOn == true)
            {
                this.spatialAudioCheckBox.IsChecked = true;
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Sound 토글 스위치 토글시 처리하기 - soundToggleSwitch_Toggled(sender, e)

        /// <summary>
        /// Sound 토글 스위치 토글시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void soundToggleSwitch_Toggled(object sender, RoutedEventArgs e)
        {
            if(this.soundToggleSwitch.IsOn == true)
            {
                this.spatialAudioCheckBox.IsEnabled = true;

                ElementSoundPlayer.State = ElementSoundPlayerState.On;
            }
            else
            {
                this.spatialAudioCheckBox.IsEnabled = false;
                this.spatialAudioCheckBox.IsChecked = false;

                ElementSoundPlayer.State            = ElementSoundPlayerState.Off;
                ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.Off;
            }
        }

        #endregion
        #region Enable Spatial Audio 체크 박스 체크시 처리하기 - enableSpatialAudioCheckBox_Checked(sender, e)

        /// <summary>
        /// Enable Spatial Audio 체크 박스 체크시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void enableSpatialAudioCheckBox_Checked(object sender, RoutedEventArgs e)
        {
            if(this.soundToggleSwitch.IsOn == true)
            {
                ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.On;
            }
        }

        #endregion
        #region Enable Spatial Audio 체크 박스 체크 해제시 처리하기 - spatialAudioCheckBox_Unchecked(sender, e)

        /// <summary>
        /// Enable Spatial Audio 체크 박스 체크 해제시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void spatialAudioCheckBox_Unchecked(object sender, RoutedEventArgs e)
        {
            if(this.soundToggleSwitch.IsOn == true)
            {
                ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.Off;
            }
        }

        #endregion
        #region Play Sound 버튼 클릭시 처리하기 - playSoundButton_Click(sender, e)

        /// <summary>
        /// Play Sound 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void playSoundButton_Click(object sender, RoutedEventArgs e)
        {
            ElementSoundPlayer.Play((ElementSoundKind)this.soundSelectionComboBox.SelectedIndex);
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

using Microsoft.UI.Xaml;

using Microsoft.UI.Xaml.Controls;

namespace TestProject

{

/// <summary>

/// 메인 페이지

/// </summary>

public sealed partial class MainPage : Page

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainPage()

/// <summary>

/// 생성자

/// </summary>

public MainPage()

{

InitializeComponent();

this.soundToggleSwitch.Toggled += soundToggleSwitch_Toggled;

this.spatialAudioCheckBox.Checked += enableSpatialAudioCheckBox_Checked;

this.spatialAudioCheckBox.Unchecked += spatialAudioCheckBox_Unchecked;

this.playSoundButton.Click += playSoundButton_Click;

if(ElementSoundPlayer.State == ElementSoundPlayerState.On)

{

this.soundToggleSwitch.IsOn = true;

}

if(ElementSoundPlayer.SpatialAudioMode == ElementSpatialAudioMode.On && soundToggleSwitch.IsOn == true)

{

this.spatialAudioCheckBox.IsChecked = true;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Sound 토글 스위치 토글시 처리하기 - soundToggleSwitch_Toggled(sender, e)

/// <summary>

/// Sound 토글 스위치 토글시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void soundToggleSwitch_Toggled(object sender, RoutedEventArgs e)

{

if(this.soundToggleSwitch.IsOn == true)

{

this.spatialAudioCheckBox.IsEnabled = true;

ElementSoundPlayer.State = ElementSoundPlayerState.On;

}

else

{

this.spatialAudioCheckBox.IsEnabled = false;

this.spatialAudioCheckBox.IsChecked = false;

ElementSoundPlayer.State = ElementSoundPlayerState.Off;

ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.Off;

}

#endregion

#region Enable Spatial Audio 체크 박스 체크시 처리하기 - enableSpatialAudioCheckBox_Checked(sender, e)

/// <summary>

/// Enable Spatial Audio 체크 박스 체크시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void enableSpatialAudioCheckBox_Checked(object sender, RoutedEventArgs e)

{

if(this.soundToggleSwitch.IsOn == true)

{

ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.On;

}

#endregion

#region Enable Spatial Audio 체크 박스 체크 해제시 처리하기 - spatialAudioCheckBox_Unchecked(sender, e)

/// <summary>

/// Enable Spatial Audio 체크 박스 체크 해제시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void spatialAudioCheckBox_Unchecked(object sender, RoutedEventArgs e)

{

if(this.soundToggleSwitch.IsOn == true)

{

ElementSoundPlayer.SpatialAudioMode = ElementSpatialAudioMode.Off;

}

#endregion

#region Play Sound 버튼 클릭시 처리하기 - playSoundButton_Click(sender, e)

/// <summary>

/// Play Sound 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void playSoundButton_Click(object sender, RoutedEventArgs e)

{

ElementSoundPlayer.Play((ElementSoundKind)this.soundSelectionComboBox.SelectedIndex);

}

#endregion

}

TestProject.zip

[HTML/HTML5] audio 엘리먼트 : 오디오 재생하기

■ audio 엘리먼트에서 오디오를 재생하는 방법을 보여준다. ▶ test.html


<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
    </head>
    <body>
        <audio controls preload autoplay>
            <source src="sample.ogg" />
        </audio>
    </body>
</html>

<!DOCTYPE html>

<html>

<head>

</head>

<body>

</audio>

</body>

</html>

sample.ogg

[C#/COMMON/AUDIOSWITCHER] CoreAudioDevice 클래스 : VolumeChanged 속성을 사용해 사운드 볼륨 변경시 처리하기

■ CoreAudioDevice 클래스의 VolumeChanged 속성을 사용해 사운드 볼륨 변경시 처리하는 방법을 보여준다. ▶ VolumeChangedObserver.cs


using System;

using AudioSwitcher.AudioApi;

namespace TestProject
{
    /// <summary>
    /// 볼륨 변경시 관찰자
    /// </summary>
    public class VolumeChangedObserver : IObserver<DeviceVolumeChangedArgs>
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 변경시 처리하기 - OnNext(args)

        /// <summary>
        /// 변경시 처리하기
        /// </summary>
        /// <param name="args">이벤트 인자</param>
        public virtual void OnNext(DeviceVolumeChangedArgs args)
        {
            Console.WriteLine($"현재 볼륨 : {args.Volume}");
        }

        #endregion
        #region 에러시 처리하기 - OnError(e)

        /// <summary>
        /// 에러시 처리하기
        /// </summary>
        /// <param name="e">예외</param>
        public virtual void OnError(Exception e)
        {
            Console.WriteLine(e.Message);
        }

        #endregion
        #region 완료시 처리하기 - OnCompleted()

        /// <summary>
        /// 완료시 처리하기
        /// </summary>
        public virtual void OnCompleted()
        {
            Console.WriteLine("완료");
        }

        #endregion
    }
}

using System;

using AudioSwitcher.AudioApi;

namespace TestProject

{

/// <summary>

/// 볼륨 변경시 관찰자

/// </summary>

public class VolumeChangedObserver : IObserver<DeviceVolumeChangedArgs>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 변경시 처리하기 - OnNext(args)

/// <summary>

/// 변경시 처리하기

/// </summary>

/// <param name="args">이벤트 인자</param>

public virtual void OnNext(DeviceVolumeChangedArgs args)

{

Console.WriteLine($"현재 볼륨 : {args.Volume}");

}

#endregion

#region 에러시 처리하기 - OnError(e)

/// <summary>

/// 에러시 처리하기

/// </summary>

/// <param name="e">예외</param>

public virtual void OnError(Exception e)

{

Console.WriteLine(e.Message);

}

#endregion

#region 완료시 처리하기 - OnCompleted()

/// <summary>

/// 완료시 처리하기

/// </summary>

public virtual void OnCompleted()

{

Console.WriteLine("완료");

}

#endregion

}

▶ Program.cs


using System;

using AudioSwitcher.AudioApi;
using AudioSwitcher.AudioApi.CoreAudio;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            CoreAudioDevice coreAudioDevice = new CoreAudioController().DefaultPlaybackDevice;

            IObserver<DeviceVolumeChangedArgs> observer = new VolumeChangedObserver();

            using(IDisposable disposable = coreAudioDevice.VolumeChanged.Subscribe(observer))
            {
                Console.WriteLine("프로그램을 종료하려면 아무 키나 눌러주시기 바랍니다.");

                Console.ReadKey(false);
            }
        }

        #endregion
    }
}

using System;

using AudioSwitcher.AudioApi;

using AudioSwitcher.AudioApi.CoreAudio;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

CoreAudioDevice coreAudioDevice = new CoreAudioController().DefaultPlaybackDevice;

IObserver<DeviceVolumeChangedArgs> observer = new VolumeChangedObserver();

using(IDisposable disposable = coreAudioDevice.VolumeChanged.Subscribe(observer))

{

Console.WriteLine("프로그램을 종료하려면 아무 키나 눌러주시기 바랍니다.");

Console.ReadKey(false);

}

#endregion

}

TestProject.zip

[C#/COMMON/AUDIOSWITCHER] CoreAudioDevice 클래스 : Volume 속성을 사용해 사운드 볼륨 크기 강제하기

■ CoreAudioDevice 클래스의 Volume 속성을 사용해 사운드 볼륨 크기를 강제하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading;

using AudioSwitcher.AudioApi.CoreAudio;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            CoreAudioDevice coreAudioDevice = new CoreAudioController().DefaultPlaybackDevice;

            Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);

            while(true)
            {
                if(coreAudioDevice.Volume > 20)
                {
                    coreAudioDevice.Volume = 20;

                    Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);
                }
                else if(coreAudioDevice.Volume < 10)
                {
                    coreAudioDevice.Volume = 10;

                    Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);
                }

                Thread.Sleep(300);
            }
        }

        #endregion
    }
}

using System;

using System.Threading;

using AudioSwitcher.AudioApi.CoreAudio;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

CoreAudioDevice coreAudioDevice = new CoreAudioController().DefaultPlaybackDevice;

Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);

while(true)

{

if(coreAudioDevice.Volume > 20)

{

coreAudioDevice.Volume = 20;

Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);

}

else if(coreAudioDevice.Volume < 10)

{

coreAudioDevice.Volume = 10;

Console.WriteLine("현재 볼륨 : " + coreAudioDevice.Volume);

}

Thread.Sleep(300);

}

#endregion

}

TestProject.zip

[C#/COMMON/AUDIOSWITCHER] AudioSwitcher.AudioApi.CoreAudio 누겟 설치하기

■ AudioSwitcher.AudioApi.CoreAudio 누겟을 설치하는 방법을 보여준다. 1. Visual Studio를 실행한다. 2. [도구] / [NuGet 패키지 관리자] / [패키지 관리자 콘솔] 메뉴를 실행한다.

[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

[RUST/COMMON] 크레이트 설치 : hound

■ hound 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
hound = "3.4.0"

...

[dependencies]

hound = "3.4.0"

[C#/MAUI/.NET6] Plugin.Maui.Audio 누겟 설치하기

■ Plugin.Maui.Audio 누겟을 설치하는 방법을 보여준다. 1. Visual Studio를 실행한다. 2. [도구] / [NuGet 패키지 관리자] / [패키지 관리자 콘솔] 메뉴를 실행한다.

[C#/MAUI/.NET6] MP3 음악 파일 재생하기

■ MP3 음악 파일을 재생하는 방법을 보여준다. ▶ MainPage.xaml


<?xml version="1.0" encoding="utf-8" ?>
<ContentPage x:Class="TestProject.MainPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
    <VerticalStackLayout
        HorizontalOptions="Center"
        VerticalOptions="Center"
        Spacing="30">
        <HorizontalStackLayout
            HorizontalOptions="Center"
            Spacing="30">
            <Image>
                <Image.Source>
                    <FontImageSource x:Name="playFontImageSource"
                        FontFamily="ionicons"
                        Size="48"
                        Color="Black"
                        Glyph="&#xf488;" />
                </Image.Source>
                <Image.GestureRecognizers>
                    <TapGestureRecognizer x:Name="playTapGestureRecognizer"
                        NumberOfTapsRequired="1" />
                </Image.GestureRecognizers>
            </Image>
            <Image>
                <Image.Source>
                    <FontImageSource x:Name="pauseFontImageSource"
                        FontFamily="ionicons"
                        Size="48"
                        Color="Gray"
                        Glyph="&#xf478;" />
                </Image.Source>
                <Image.GestureRecognizers>
                    <TapGestureRecognizer x:Name="pauseTapGestureRecognizer"
                        NumberOfTapsRequired="1" />
                </Image.GestureRecognizers>
            </Image>
            <Image>
                <Image.Source>
                    <FontImageSource x:Name="stopFontImageSource"
                        FontFamily="ionicons"
                        Size="48"
                        Color="Gray"
                        Glyph="&#xf21a;" />
                </Image.Source>
                <Image.GestureRecognizers>
                    <TapGestureRecognizer x:Name="stopTapGestureRecognizer"
                        NumberOfTapsRequired="1" />
                </Image.GestureRecognizers>
            </Image>
        </HorizontalStackLayout>
            <Slider x:Name="volumeSlider"
                WidthRequest="300"
                Minimum="0"
                Maximum="1"
                Value="0.3"/>
    </VerticalStackLayout>
</ContentPage>

<?xml version="1.0" encoding="utf-8" ?>

<ContentPage x:Class="TestProject.MainPage"

xmlns="http://schemas.microsoft.com/dotnet/2021/maui"

xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

<VerticalStackLayout

HorizontalOptions="Center"

VerticalOptions="Center"

Spacing="30">

<HorizontalStackLayout

HorizontalOptions="Center"

Spacing="30">

<Image>

<Image.Source>

<FontImageSource x:Name="playFontImageSource"

FontFamily="ionicons"

Size="48"

Color="Black"

Glyph="" />

</Image.Source>

<Image.GestureRecognizers>

<TapGestureRecognizer x:Name="playTapGestureRecognizer"

NumberOfTapsRequired="1" />

</Image.GestureRecognizers>

</Image>

<Image>

<Image.Source>

<FontImageSource x:Name="pauseFontImageSource"

FontFamily="ionicons"

Size="48"

Color="Gray"

Glyph="" />

</Image.Source>

<Image.GestureRecognizers>

<TapGestureRecognizer x:Name="pauseTapGestureRecognizer"

NumberOfTapsRequired="1" />

</Image.GestureRecognizers>

</Image>

<Image>

<Image.Source>

<FontImageSource x:Name="stopFontImageSource"

FontFamily="ionicons"

Size="48"

Color="Gray"

Glyph="" />

</Image.Source>

<Image.GestureRecognizers>

<TapGestureRecognizer x:Name="stopTapGestureRecognizer"

NumberOfTapsRequired="1" />

</Image.GestureRecognizers>

</Image>

</HorizontalStackLayout>

<Slider x:Name="volumeSlider"

WidthRequest="300"

Minimum="0"

Maximum="1"

Value="0.3"/>

</VerticalStackLayout>

</ContentPage>

▶ MainPage.xaml.cs


using Plugin.Maui.Audio;

namespace TestProject;

/// <summary>
/// 메인 페이지
/// </summary>
public partial class MainPage : ContentPage
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 오디오 관리자
    /// </summary>
    private IAudioManager audioManager;

    /// <summary>
    /// 오디오 재생자
    /// </summary>
    private IAudioPlayer audioPlayer;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - MainPage()

    /// <summary>
    /// 생성자
    /// </summary>
    public MainPage()
    {
        InitializeComponent();

        this.audioManager = new AudioManager();

        Loaded                                += ContentPage_Loaded;
        this.playTapGestureRecognizer.Tapped  += playTapGestureRecognizer_Tapped;
        this.volumeSlider.ValueChanged        += volumeSlider_ValueChanged;
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region 컨텐트 페이지 로드시 처리하기 - ContentPage_Loaded(sender, e)

    /// <summary>
    /// 컨텐트 페이지 로드시 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private async void ContentPage_Loaded(object sender, EventArgs e)
    {
        this.audioPlayer = this.audioManager.CreatePlayer(await FileSystem.OpenAppPackageFileAsync("sample.mp3"));

        this.audioPlayer.Volume = this.volumeSlider.Value;

        this.audioPlayer.PlaybackEnded += audioPlayer_PlaybackEnded;
    }

    #endregion
    #region 오디오 재생자 재생 종료시 처리하기 - audioPlayer_PlaybackEnded(sender, e)

    /// <summary>
    /// 오디오 재생자 재생 종료시 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private void audioPlayer_PlaybackEnded(object sender, EventArgs e)
    {
        this.playTapGestureRecognizer.Tapped  -= playTapGestureRecognizer_Tapped;
        this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  -= stopTapGestureRecognizer_Tapped;

        this.playTapGestureRecognizer.Tapped  += playTapGestureRecognizer_Tapped;

        this.playFontImageSource.Color  = Colors.Black;
        this.pauseFontImageSource.Color = Colors.Gray;
        this.stopFontImageSource.Color  = Colors.Gray;
    }

    #endregion
    #region 재생 탭 제스처 인식기 탭 처리하기 - playTapGestureRecognizer_Tapped(sender, e)

    /// <summary>
    /// 재생 탭 제스처 인식기 탭 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private void playTapGestureRecognizer_Tapped(object sender, EventArgs e)
    {
        this.playTapGestureRecognizer.Tapped  -= playTapGestureRecognizer_Tapped;
        this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  -= stopTapGestureRecognizer_Tapped;

        this.pauseTapGestureRecognizer.Tapped += pauseTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  += stopTapGestureRecognizer_Tapped;

        this.playFontImageSource.Color  = Colors.Gray;
        this.pauseFontImageSource.Color = Colors.Black;
        this.stopFontImageSource.Color  = Colors.Black;

        this.audioPlayer.Play();
    }

    #endregion
    #region 중지 탭 제스처 인식기 탭 처리하기 - pauseTapGestureRecognizer_Tapped(sender, e)

    /// <summary>
    /// 중지 탭 제스처 인식기 탭 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private void pauseTapGestureRecognizer_Tapped(object sender, EventArgs e)
    {
        this.playTapGestureRecognizer.Tapped  -= playTapGestureRecognizer_Tapped;
        this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  -= stopTapGestureRecognizer_Tapped;

        this.playTapGestureRecognizer.Tapped  += playTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  += stopTapGestureRecognizer_Tapped;

        this.playFontImageSource.Color  = Colors.Black;
        this.pauseFontImageSource.Color = Colors.Gray;
        this.stopFontImageSource.Color  = Colors.Black;

        this.audioPlayer.Pause();
    }

    #endregion
    #region 중단 탭 제스처 인식기 탭 처리하기 - stopTapGestureRecognizer_Tapped(sender, e)

    /// <summary>
    /// 중단 탭 제스처 인식기 탭 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private void stopTapGestureRecognizer_Tapped(object sender, EventArgs e)
    {
        this.playTapGestureRecognizer.Tapped  -= playTapGestureRecognizer_Tapped;
        this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;
        this.stopTapGestureRecognizer.Tapped  -= stopTapGestureRecognizer_Tapped;

        this.playTapGestureRecognizer.Tapped  += playTapGestureRecognizer_Tapped;

        this.playFontImageSource.Color  = Colors.Black;
        this.pauseFontImageSource.Color = Colors.Gray;
        this.stopFontImageSource.Color  = Colors.Gray;

        this.audioPlayer.Stop();
    }

    #endregion
    #region 볼륨 슬라이더 값 변경시 처리하기 - volumeSlider_ValueChanged(sender, e)

    /// <summary>
    /// 볼륨 슬라이더 값 변경시 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private void volumeSlider_ValueChanged(object sender, ValueChangedEventArgs e)
    {
        this.audioPlayer.Volume = this.volumeSlider.Value;
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

using Plugin.Maui.Audio;

namespace TestProject;

/// <summary>

/// 메인 페이지

/// </summary>

public partial class MainPage : ContentPage

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 오디오 관리자

/// </summary>

private IAudioManager audioManager;

/// <summary>

/// 오디오 재생자

/// </summary>

private IAudioPlayer audioPlayer;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainPage()

/// <summary>

/// 생성자

/// </summary>

public MainPage()

{

InitializeComponent();

this.audioManager = new AudioManager();

Loaded += ContentPage_Loaded;

this.playTapGestureRecognizer.Tapped += playTapGestureRecognizer_Tapped;

this.volumeSlider.ValueChanged += volumeSlider_ValueChanged;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 컨텐트 페이지 로드시 처리하기 - ContentPage_Loaded(sender, e)

/// <summary>

/// 컨텐트 페이지 로드시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private async void ContentPage_Loaded(object sender, EventArgs e)

{

this.audioPlayer = this.audioManager.CreatePlayer(await FileSystem.OpenAppPackageFileAsync("sample.mp3"));

this.audioPlayer.Volume = this.volumeSlider.Value;

this.audioPlayer.PlaybackEnded += audioPlayer_PlaybackEnded;

}

#endregion

#region 오디오 재생자 재생 종료시 처리하기 - audioPlayer_PlaybackEnded(sender, e)

/// <summary>

/// 오디오 재생자 재생 종료시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void audioPlayer_PlaybackEnded(object sender, EventArgs e)

{

this.playTapGestureRecognizer.Tapped -= playTapGestureRecognizer_Tapped;

this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped -= stopTapGestureRecognizer_Tapped;

this.playTapGestureRecognizer.Tapped += playTapGestureRecognizer_Tapped;

this.playFontImageSource.Color = Colors.Black;

this.pauseFontImageSource.Color = Colors.Gray;

this.stopFontImageSource.Color = Colors.Gray;

}

#endregion

#region 재생 탭 제스처 인식기 탭 처리하기 - playTapGestureRecognizer_Tapped(sender, e)

/// <summary>

/// 재생 탭 제스처 인식기 탭 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void playTapGestureRecognizer_Tapped(object sender, EventArgs e)

{

this.playTapGestureRecognizer.Tapped -= playTapGestureRecognizer_Tapped;

this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped -= stopTapGestureRecognizer_Tapped;

this.pauseTapGestureRecognizer.Tapped += pauseTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped += stopTapGestureRecognizer_Tapped;

this.playFontImageSource.Color = Colors.Gray;

this.pauseFontImageSource.Color = Colors.Black;

this.stopFontImageSource.Color = Colors.Black;

this.audioPlayer.Play();

}

#endregion

#region 중지 탭 제스처 인식기 탭 처리하기 - pauseTapGestureRecognizer_Tapped(sender, e)

/// <summary>

/// 중지 탭 제스처 인식기 탭 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void pauseTapGestureRecognizer_Tapped(object sender, EventArgs e)

{

this.playTapGestureRecognizer.Tapped -= playTapGestureRecognizer_Tapped;

this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped -= stopTapGestureRecognizer_Tapped;

this.playTapGestureRecognizer.Tapped += playTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped += stopTapGestureRecognizer_Tapped;

this.playFontImageSource.Color = Colors.Black;

this.pauseFontImageSource.Color = Colors.Gray;

this.stopFontImageSource.Color = Colors.Black;

this.audioPlayer.Pause();

}

#endregion

#region 중단 탭 제스처 인식기 탭 처리하기 - stopTapGestureRecognizer_Tapped(sender, e)

/// <summary>

/// 중단 탭 제스처 인식기 탭 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void stopTapGestureRecognizer_Tapped(object sender, EventArgs e)

{

this.playTapGestureRecognizer.Tapped -= playTapGestureRecognizer_Tapped;

this.pauseTapGestureRecognizer.Tapped -= pauseTapGestureRecognizer_Tapped;

this.stopTapGestureRecognizer.Tapped -= stopTapGestureRecognizer_Tapped;

this.playTapGestureRecognizer.Tapped += playTapGestureRecognizer_Tapped;

this.playFontImageSource.Color = Colors.Black;

this.pauseFontImageSource.Color = Colors.Gray;

this.stopFontImageSource.Color = Colors.Gray;

this.audioPlayer.Stop();

}

#endregion

#region 볼륨 슬라이더 값 변경시 처리하기 - volumeSlider_ValueChanged(sender, e)

/// <summary>

/// 볼륨 슬라이더 값 변경시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void volumeSlider_ValueChanged(object sender, ValueChangedEventArgs e)

{

this.audioPlayer.Volume = this.volumeSlider.Value;

}

#endregion

}

TestProject.zip

[C#/WINFORM/.NET6] SoundPlayer 클래스 : PlaySync 메소드를 사용해 비프음 만들기

■ SoundPlayer 클래스의 PlaySync 메소드를 사용해 비프음을 만드는 방법을 보여준다. ▶ SoundPlayer.cs


using System.Media;

namespace TestProject
{
    /// <summary>
    /// 사운드 헬퍼
    /// </summary>
    public static class SoundHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        // C
        public const int C0 = 16;
        public const int C1 = 33;
        public const int C2 = 65;
        public const int C3 = 131;
        public const int C4 = 262;
        public const int C5 = 523;
        public const int C6 = 1046;
        public const int C7 = 2093;

        // C#
        public const int CS0 = 17;
        public const int CS1 = 35;
        public const int CS2 = 69;
        public const int CS3 = 139;
        public const int CS4 = 277;
        public const int CS5 = 554;
        public const int CS6 = 1109;
        public const int CS7 = 2217;

        // D
        public const int D0 = 18;
        public const int D1 = 37;
        public const int D2 = 73;
        public const int D3 = 147;
        public const int D4 = 294;
        public const int D5 = 587;
        public const int D6 = 1175;
        public const int D7 = 2349;

        // D#
        public const int DS0 = 19;
        public const int DS1 = 39;
        public const int DS2 = 78;
        public const int DS3 = 155;
        public const int DS4 = 311;
        public const int DS5 = 622;
        public const int DS6 = 1244;
        public const int DS7 = 2489;

        // E
        public const int E0 = 21;
        public const int E1 = 41;
        public const int E2 = 82;
        public const int E3 = 165;
        public const int E4 = 330;
        public const int E5 = 659;
        public const int E6 = 1328;
        public const int E7 = 2637;

        // F
        public const int F0 = 22;
        public const int F1 = 44;
        public const int F2 = 87;
        public const int F3 = 175;
        public const int F4 = 349;
        public const int F5 = 698;
        public const int F6 = 1397;
        public const int F7 = 2794;

        // F#
        public const int FS0 = 23;
        public const int FS1 = 46;
        public const int FS2 = 92;
        public const int FS3 = 185;
        public const int FS4 = 370;
        public const int FS5 = 740;
        public const int FS6 = 1480;
        public const int FS7 = 2960;

        // G
        public const int G0 = 24;
        public const int G1 = 49;
        public const int G2 = 98;
        public const int G3 = 196;
        public const int G4 = 392;
        public const int G5 = 784;
        public const int G6 = 1568;
        public const int G7 = 3136;

        // G#
        public const int GS0 = 26;
        public const int GS1 = 52;
        public const int GS2 = 104;
        public const int GS3 = 208;
        public const int GS4 = 415;
        public const int GS5 = 831;
        public const int GS6 = 1661;
        public const int GS7 = 3322;

        // A
        public const int A0 = 27;
        public const int A1 = 55;
        public const int A2 = 110;
        public const int A3 = 220;
        public const int A4 = 440;
        public const int A5 = 880;
        public const int A6 = 1760;
        public const int A7 = 3520;

        // A#
        public const int AS0 = 29;
        public const int AS1 = 58;
        public const int AS2 = 116;
        public const int AS3 = 233;
        public const int AS4 = 466;
        public const int AS5 = 932;
        public const int AS6 = 1865;
        public const int AS7 = 3729;

        // B
        public const int B0 = 31;
        public const int B1 = 62;
        public const int B2 = 123;
        public const int B3 = 245;
        public const int B4 = 494;
        public const int B5 = 988;
        public const int B6 = 1975;
        public const int B7 = 3951;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 비프음 발생시키기 - Beep(amplitude, frequency, duration)

        /// <summary>
        /// 비프음 발생시키기
        /// </summary>
        /// <param name="amplitude">진폭</param>
        /// <param name="frequency">주파수</param>
        /// <param name="duration">지속 시간</param>
        public static void Beep(int amplitude, int frequency, int duration)
        {
            double a           = ((amplitude * (Math.Pow(2, 15))) / 1000) - 1;
            double deltaFT     = 2 * Math.PI * frequency / 44100.0;
            int    sampleCount = 441 * duration / 10;
            int    byteCount   = sampleCount * 4;
            int[]  hdrArray    = new int[]
            {
                0x46464952,
                36 + byteCount,
                0x45564157,
                0x20746D66,
                16,
                0x20001,
                44100,
                176400,
                0x100004,
                0x61746164,
                byteCount
            };

            using(MemoryStream stream = new MemoryStream(44 + byteCount))
            {
                using(BinaryWriter writer = new BinaryWriter(stream))
                {
                    for(int i = 0; i < hdrArray.Length; i++)
                    {
                        writer.Write(hdrArray[i]);
                    }

                    for(int t = 0; t < sampleCount; t++)
                    {
                        short Sample = Convert.ToInt16(a * Math.Sin(deltaFT * t));

                        writer.Write(Sample);
                        writer.Write(Sample);
                    }

                    writer.Flush();

                    stream.Seek(0, SeekOrigin.Begin);

                    using(SoundPlayer soundPlayer = new SoundPlayer(stream))
                    {
                        soundPlayer.PlaySync();
                    }
                }
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

using System.Media;

namespace TestProject

{

/// <summary>

/// 사운드 헬퍼

/// </summary>

public static class SoundHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

// C

public const int C0 = 16;

public const int C1 = 33;

public const int C2 = 65;

public const int C3 = 131;

public const int C4 = 262;

public const int C5 = 523;

public const int C6 = 1046;

public const int C7 = 2093;

// C#

public const int CS0 = 17;

public const int CS1 = 35;

public const int CS2 = 69;

public const int CS3 = 139;

public const int CS4 = 277;

public const int CS5 = 554;

public const int CS6 = 1109;

public const int CS7 = 2217;

// D

public const int D0 = 18;

public const int D1 = 37;

public const int D2 = 73;

public const int D3 = 147;

public const int D4 = 294;

public const int D5 = 587;

public const int D6 = 1175;

public const int D7 = 2349;

// D#

public const int DS0 = 19;

public const int DS1 = 39;

public const int DS2 = 78;

public const int DS3 = 155;

public const int DS4 = 311;

public const int DS5 = 622;

public const int DS6 = 1244;

public const int DS7 = 2489;

// E

public const int E0 = 21;

public const int E1 = 41;

public const int E2 = 82;

public const int E3 = 165;

public const int E4 = 330;

public const int E5 = 659;

public const int E6 = 1328;

public const int E7 = 2637;

// F

public const int F0 = 22;

public const int F1 = 44;

public const int F2 = 87;

public const int F3 = 175;

public const int F4 = 349;

public const int F5 = 698;

public const int F6 = 1397;

public const int F7 = 2794;

// F#

public const int FS0 = 23;

public const int FS1 = 46;

public const int FS2 = 92;

public const int FS3 = 185;

public const int FS4 = 370;

public const int FS5 = 740;

public const int FS6 = 1480;

public const int FS7 = 2960;

// G

public const int G0 = 24;

public const int G1 = 49;

public const int G2 = 98;

public const int G3 = 196;

public const int G4 = 392;

public const int G5 = 784;

public const int G6 = 1568;

public const int G7 = 3136;

// G#

public const int GS0 = 26;

public const int GS1 = 52;

public const int GS2 = 104;

public const int GS3 = 208;

public const int GS4 = 415;

public const int GS5 = 831;

public const int GS6 = 1661;

public const int GS7 = 3322;

// A

public const int A0 = 27;

public const int A1 = 55;

public const int A2 = 110;

public const int A3 = 220;

public const int A4 = 440;

public const int A5 = 880;

public const int A6 = 1760;

public const int A7 = 3520;

// A#

public const int AS0 = 29;

public const int AS1 = 58;

public const int AS2 = 116;

public const int AS3 = 233;

public const int AS4 = 466;

public const int AS5 = 932;

public const int AS6 = 1865;

public const int AS7 = 3729;

// B

public const int B0 = 31;

public const int B1 = 62;

public const int B2 = 123;

public const int B3 = 245;

public const int B4 = 494;

public const int B5 = 988;

public const int B6 = 1975;

public const int B7 = 3951;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 비프음 발생시키기 - Beep(amplitude, frequency, duration)

/// <summary>

/// 비프음 발생시키기

/// </summary>

/// <param name="amplitude">진폭</param>

/// <param name="frequency">주파수</param>

/// <param name="duration">지속 시간</param>

public static void Beep(int amplitude, int frequency, int duration)

{

double a = ((amplitude * (Math.Pow(2, 15))) / 1000) - 1;

double deltaFT = 2 * Math.PI * frequency / 44100.0;

int sampleCount = 441 * duration / 10;

int byteCount = sampleCount * 4;

int[] hdrArray = new int[]

{

0x46464952,

36 + byteCount,

0x45564157,

0x20746D66,

16,

0x20001,

44100,

176400,

0x100004,

0x61746164,

byteCount

};

using(MemoryStream stream = new MemoryStream(44 + byteCount))

{

using(BinaryWriter writer = new BinaryWriter(stream))

{

for(int i = 0; i < hdrArray.Length; i++)

{

writer.Write(hdrArray[i]);

}

for(int t = 0; t < sampleCount; t++)

{

short Sample = Convert.ToInt16(a * Math.Sin(deltaFT * t));

writer.Write(Sample);

}

writer.Flush();

stream.Seek(0, SeekOrigin.Begin);

using(SoundPlayer soundPlayer = new SoundPlayer(stream))

{

soundPlayer.PlaySync();

}

#endregion

}

▶ MainForm.cs


namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.playButton.Click += playButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 재생하기 버튼 클릭시 처리하기 - playButton_Click(sender, e)

        /// <summary>
        /// 재생하기 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void playButton_Click(object sender, EventArgs e)
        {
            SoundHelper.Beep(300, SoundHelper.C3, 100);
            SoundHelper.Beep(300, SoundHelper.D3, 100);
            SoundHelper.Beep(300, SoundHelper.E3, 100);
            SoundHelper.Beep(300, SoundHelper.F3, 100);
            SoundHelper.Beep(300, SoundHelper.A3, 100);
            SoundHelper.Beep(300, SoundHelper.B3, 100);
        }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.playButton.Click += playButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 재생하기 버튼 클릭시 처리하기 - playButton_Click(sender, e)

/// <summary>

/// 재생하기 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void playButton_Click(object sender, EventArgs e)

{

SoundHelper.Beep(300, SoundHelper.C3, 100);

SoundHelper.Beep(300, SoundHelper.D3, 100);

SoundHelper.Beep(300, SoundHelper.E3, 100);

SoundHelper.Beep(300, SoundHelper.F3, 100);

SoundHelper.Beep(300, SoundHelper.A3, 100);

SoundHelper.Beep(300, SoundHelper.B3, 100);

}

#endregion

}

TestProject.zip

[C#/MAUI/.NET6] ITextToSpeech 인터페이스 : SpeakAsync 정적 메소드에서 텍스트를 음성으로 출력할 때 취소하기

■ ITextToSpeech 인터페이스의 SpeakAsync 정적 메소드에서 텍스트를 음성으로 출력할 때 취소하는 방법을 보여준다. ▶ MainPage.xaml


<?xml version="1.0" encoding="utf-8" ?>
<ContentPage x:Class="TestProject.MainPage"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
    <Grid
        ColumnDefinitions="*,Auto,*"
        RowDefinitions="*,Auto,Auto,10,Auto,*">
        <Label Grid.Row="1" Grid.Column="1"
            HorizontalOptions="Start"
            Text="메시지" />
        <Entry x:Name="messageEntry" Grid.Row="2" Grid.Column="1"
            HorizontalOptions="StartAndExpand"
            WidthRequest="300" />
        <Button x:Name="startButton" Grid.Row="4" Grid.Column="1"
            HorizontalOptions="Center"
            Margin="0,10,0,0"
            WidthRequest="150"
            Text="음성 출력 시작" />
    </Grid>
</ContentPage>

<?xml version="1.0" encoding="utf-8" ?>

<ContentPage x:Class="TestProject.MainPage"

xmlns="http://schemas.microsoft.com/dotnet/2021/maui"

xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">

<Grid

ColumnDefinitions="*,Auto,*"

RowDefinitions="*,Auto,Auto,10,Auto,*">

<Label Grid.Row="1" Grid.Column="1"

HorizontalOptions="Start"

Text="메시지" />

<Entry x:Name="messageEntry" Grid.Row="2" Grid.Column="1"

HorizontalOptions="StartAndExpand"

WidthRequest="300" />

<Button x:Name="startButton" Grid.Row="4" Grid.Column="1"

HorizontalOptions="Center"

Margin="0,10,0,0"

WidthRequest="150"

Text="음성 출력 시작" />

</Grid>

</ContentPage>

▶ MainPage.xaml.cs


namespace TestProject;

/// <summary>
/// 메인 페이지
/// </summary>
public partial class MainPage : ContentPage
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 취소 토큰 소스
    /// </summary>
    private CancellationTokenSource cancellationTokenSource = null;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - MainPage()

    /// <summary>
    /// 생성자
    /// </summary>
    public MainPage()
    {
        InitializeComponent();

        this.startButton.Clicked += startButton_Clicked;
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region 음성 출력 시작 버튼 클릭시 처리하기 - startButton_Clicked(sender, e)

    /// <summary>
    /// 음성 출력 시작 버튼 클릭시 처리하기
    /// </summary>
    /// <param name="sender">이벤트 발생자</param>
    /// <param name="e">이벤트 인자</param>
    private async void startButton_Clicked(object sender, EventArgs e)
    {
        if(this.startButton.Text == "음성 출력 시작")
        {
            string message = this.messageEntry.Text;

            if(string.IsNullOrWhiteSpace(message))
            {
                await DisplayAlert("INFORMATION", "메시지를 입력해주시기 바랍니다.", "확인");

                return;
            }

            this.startButton.Text = "음성 출력 중단";

            this.cancellationTokenSource = new CancellationTokenSource();

            _ = TextToSpeech.Default.SpeakAsync(message, cancelToken : this.cancellationTokenSource.Token).ContinueWith
            (
                (t) =>
                {
                    this.cancellationTokenSource.Dispose();

                    this.cancellationTokenSource = null;

                    this.startButton.Text = "음성 출력 시작";
                },
                TaskScheduler.FromCurrentSynchronizationContext()
            );
        }
        else
        {
            if(this.cancellationTokenSource != null)
            {
                if(!this.cancellationTokenSource.IsCancellationRequested)
                {
                    this.cancellationTokenSource.Cancel();
                }
            }
        }
    }

    #endregion
}

namespace TestProject;

/// <summary>

/// 메인 페이지

/// </summary>

public partial class MainPage : ContentPage

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 취소 토큰 소스

/// </summary>

private CancellationTokenSource cancellationTokenSource = null;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainPage()

/// <summary>

/// 생성자

/// </summary>

public MainPage()

{

InitializeComponent();

this.startButton.Clicked += startButton_Clicked;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 음성 출력 시작 버튼 클릭시 처리하기 - startButton_Clicked(sender, e)

/// <summary>

/// 음성 출력 시작 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private async void startButton_Clicked(object sender, EventArgs e)

{

if(this.startButton.Text == "음성 출력 시작")

{

string message = this.messageEntry.Text;

if(string.IsNullOrWhiteSpace(message))

{

await DisplayAlert("INFORMATION", "메시지를 입력해주시기 바랍니다.", "확인");

return;

}

this.startButton.Text = "음성 출력 중단";

this.cancellationTokenSource = new CancellationTokenSource();

_ = TextToSpeech.Default.SpeakAsync(message, cancelToken : this.cancellationTokenSource.Token).ContinueWith

(

(t) =>

{

this.cancellationTokenSource.Dispose();

this.cancellationTokenSource = null;

this.startButton.Text = "음성 출력 시작";

TaskScheduler.FromCurrentSynchronizationContext()

);

}

else

{

if(this.cancellationTokenSource != null)

{

if(!this.cancellationTokenSource.IsCancellationRequested)

{

this.cancellationTokenSource.Cancel();

}

#endregion

}

TestProject.zip

[C#/MAUI/.NET6] ITextToSpeech 인터페이스 : SpeakAsync 메소드를 사용해 텍스트를 음성으로 출력하기

■ ITextToSpeech 인터페이스의 SpeakAsync 메소드를 사용해 텍스트를 음성으로 출력하는 방법을 보여준다. ▶ 예제 코드 (C#)


await TextToSpeech.Default.SpeakAsync("Hello World");

await TextToSpeech.Default.SpeakAsync("Hello World");