effects

Documentation

Overview

Package effects provides additional audio effects for the Beep library.

Index

• func Doppler(quality int, samplesPerMeter float64, s beep.Streamer, ...) beep.Streamer
• func Mono(s beep.Streamer) beep.Streamer
• func Swap(s beep.Streamer) beep.Streamer
• type Gain
  • func (g *Gain) Err() error
  • func (g *Gain) Stream(samples [][2]float64) (n int, ok bool)
• type Pan
  • func (p *Pan) Err() error
  • func (p *Pan) Stream(samples [][2]float64) (n int, ok bool)
• type Volume
  • func (v *Volume) Err() error
  • func (v *Volume) Stream(samples [][2]float64) (n int, ok bool)

Functions

func Doppler

func Doppler(quality int, samplesPerMeter float64, s beep.Streamer, distance func(delta int) float64) beep.Streamer

Doppler simulates a "sound at a distance". If the sound starts at a far distance, it'll take some time to reach the ears of the listener.

The distance of the sound can change dynamically. Doppler adjusts the density of the sound (affecting its speed) to remain consistent with the distance. This is called the Doppler effect.

The arguments are:

quality:         the quality of the underlying resampler (1 or 2 is usually okay)
samplesPerMeter: sample rate / speed of sound
s:               the source streamer
distance:        a function to calculate the current distance; takes number of
                 samples Doppler wants to stream at the moment

This function is experimental and may change any time!

func Mono

func Mono(s beep.Streamer) beep.Streamer

Mono converts the wrapped Streamer to a mono buffer by downmixing the left and right channels together.

The returned Streamer propagates s's errors through Err.

func Swap

func Swap(s beep.Streamer) beep.Streamer

Swap swaps the left and right channel of the wrapped Streamer.

The returned Streamer propagates s's errors through Err.

Types

type Gain

type Gain struct {
	Streamer beep.Streamer
	Gain     float64
}

Gain amplifies the wrapped Streamer. The output of the wrapped Streamer gets multiplied by 1+Gain.

Note that gain is not equivalent to the human perception of volume. Human perception of volume is roughly exponential, while gain only amplifies linearly.

func (*Gain) Err

func (g *Gain) Err() error

Err propagates the wrapped Streamer's errors.

func (*Gain) Stream

func (g *Gain) Stream(samples [][2]float64) (n int, ok bool)

Stream streams the wrapped Streamer amplified by Gain.

type Pan

type Pan struct {
	Streamer beep.Streamer
	Pan      float64
}

Pan balances the wrapped Streamer between the left and the right channel. The Pan field value of -1 means that both original channels go through the left channel. The value of +1 means the same for the right channel. The value of 0 changes nothing.

func (*Pan) Err

func (p *Pan) Err() error

Err propagates the wrapped Streamer's errors.

func (*Pan) Stream

func (p *Pan) Stream(samples [][2]float64) (n int, ok bool)

Stream streams the wrapped Streamer balanced by Pan.

type Volume

type Volume struct {
	Streamer beep.Streamer
	Base     float64
	Volume   float64
	Silent   bool
}

Volume adjusts the volume of the wrapped Streamer in a human-natural way. Human's perception of volume is roughly logarithmic to gain and thus the natural way to adjust volume is exponential.

Natural Base for the exponentiation is somewhere around 2. In order to adjust volume along decibells, pick 10 as the Base and set Volume to dB/10. However, adjusting volume along decibells is nowhere as natural as with bases around 2.

Volume of 0 means no change. Negative Volume will decrease the perceived volume and positive will increase it.

With exponential gain it's impossible to achieve the zero volume. When Silent field is set to true, the output is muted.

func (*Volume) Err

func (v *Volume) Err() error

Err propagates the wrapped Streamer's errors.

func (*Volume) Stream

func (v *Volume) Stream(samples [][2]float64) (n int, ok bool)

Stream streams the wrapped Streamer with volume adjusted according to Base, Volume and Silent fields.