200sc / klangsynthese Goto Github PK

The existing controller type is meaningless, and requires waveforms to link into a potentially inaccurate file type to make themselves.

We'll need to reverse the decoding process to encode arbitrary PCM data as MP3 or WAV. This isn't a feature I am personally concerned about but it should be on the roadmap somewhere.

The error we get is:

ALSA lib pulse.c:243:(pulse_connect) PulseAudio: Unable to connect: Connection terminated

I believe the fix for this is for the linux encoding file to keep around a few audio references and re-assign new audios as they come in to be played.

dls files and sf2 files are probably the first targets for loading in instruments, to then determine how we can fit those instruments into our wave function syntax.

There should be either klangsynthese.Load/SaveFile or audio.Load/SaveFile that take in file names and switch to the appropriate sub-package depending on the extension of the file name.

This is an important missing feature for working with wave samples taken from dls or sf2 files.

In writing filters, a lot of the work involves low level audio manipulation on the byte level, and it'd be nice if that went to a sub-package.

Right now we allegedly have FLAC support, and tests, but on the test files that could be found our tests don't run.

Right now we support 16-bit audio. It is trivial but a good amount of work to extend what we have to support other bit depths. Some research into what bit depths would be meaningful would help, and if there's some conflict between, say, float64 and int64 encoding styles that we need more information for.

Along the way we should look into if there's a better way to resolve filters on audio of different bit depths than just using a switch.

Come up with expected table outputs for waves and manipulations on waves. Make sure to explore peak and minimum values for options.

I think the memory usage is stable and it's taking a long time to play, about 15 seconds.
WAV plays instantly.

I'm using Windows 10, mp3 file size 3,4MB

(Sorry my english)

code

package main

import "time"
import audio "github.com/200sc/klangsynthese"

func main() {
	player, _ := audio.LoadFile("fazenda.mp3")
	println("Tocando")
	if err := <-player.Play(); err != nil {
		panic(err)
	}
	time.Sleep(player.PlayLength())
}

Should start looking at making sure tests actually cover sufficient code portions

We need to be able to recognize when a field in a RIFF structure is supposed to be the length for a different field in the same RIFF structure.

I don't have a way to test on Darwin in the first place right now, so this will be on hold until that changes or someone who can test it can take this over.

It'd be nice to have an automated way to test that audio was actually played out of a device.

It would be great to support ogg files.

The mentioned interface, which is a little harsh because it requires that you be able to convert your buffer to the three buffer types that go-audio has canonized.

Filters right now act on a single audio, and while that audio could be a Multi it would be good to have a pattern that explicitly took in n audio streams and combined them like a module in a synthesizer.

Suspicion leads me to think this has to do with not closing audio streams we are done with.

Such as:

Breaker (see BFXR)
Tan (BFXR)
Pulse Triangle
Dual Square (see Bosca Ceoil)
Dual Saw (Bosca Ceoil)

White noise
Pink noise
Brown noise (?)
Noise of arbitrary energy