Example #1
0
func main() {
	wavOut, err := os.Create("Test.wav")
	checkErr(err)
	defer wavOut.Close()

	meta := wav.File{
		Channels:        1,
		SampleRate:      rate,
		SignificantBits: bits,
	}

	writer, err := meta.NewWriter(wavOut)
	checkErr(err)
	defer writer.Close()

	start := time.Now()

	var freq float64
	freq = 0.0001
	for n := 0; n < 50*rate; n += 1 {
		y := int32(0.8 * math.Pow(2, bits-1) * math.Sin(freq*float64(n)))
		freq += 0.000002

		err = writer.WriteInt32(y)
		checkErr(err)
	}

	fmt.Printf("Simulation Done. Took:%v\n", time.Since(start))
}
Example #2
0
func (wr *WAVRecorder) Record() {
	var err error

	fmt.Println("*** Audio recording started")

	if wr.file, err = os.Create(fmt.Sprintf("audio.wav")); err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
	}

	meta := wav.File{
		Channels:        1,
		SampleRate:      44100 * 2,
		SignificantBits: 16,
	}

	if wr.wavWriter, err = meta.NewWriter(wr.file); err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
	}
}
Example #3
0
// WriteSoundToWav creates a file at a path, and writes the given sound in the .wav format.
func WriteSoundToWav(s sounds.Sound, path string) error {
	// Create file first, only if it doesn't exist:
	if _, err := os.Stat(path); err == nil {
		panic("File already exists! Please delete first")
		return os.ErrExist
	}
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		file.Close()
	}()

	// Create a .wav writer for the file
	var wf = wav.File{
		SampleRate:      uint32(sounds.CyclesPerSecond),
		Channels:        1,
		SignificantBits: 16,
	}
	writer, err := wf.NewWriter(file)
	if err != nil {
		return err
	}
	defer writer.Close()

	// Starts the sound, and accesses its sample stream.
	s.Start()
	samples := s.GetSamples()
	defer s.Stop()

	// Write a single sample at a time, as per the .wav writer API.
	b := make([]byte, 2)
	for sample := range samples {
		toNumber := uint16(sample * normScale) // Inverse the read scaling
		binary.LittleEndian.PutUint16(b, uint16(toNumber))
		writer.WriteSample(b)
	}
	return nil
}
Example #4
0
func rebuildSound(centers []centroid, i uint64, bitrate int, samplerate int) {
	new_array := make([]int32, i, i)
	wav_out, err := os.Create("out.wav")
	defer wav_out.Close()

	meta := wav.File{
		Channels:        1,
		SampleRate:      uint32(samplerate),
		SignificantBits: uint16(bitrate / samplerate),
	}

	writer, err := meta.NewWriter(wav_out)
	defer writer.Close()
	checkErr(err)
	for q := 0; q < len(centers); q++ {
		for u := 0; u < len(centers[q].points); u++ {
			new_array[centers[q].points[u].t] = int32(centers[q].center.x)
		}
	}
	for p := range new_array {
		writer.WriteInt32(new_array[p])
	}
}