audio

package module
v0.0.0-...-c5379f9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 11, 2024 License: MIT Imports: 4 Imported by: 21

README

Production ready/stable version available under a dedicated org

go-audio for the non-playground version.

See sub packages

GoDoc

Build Status

Documentation

Overview

Package audio is a work in progress package containing audio related sub packages.

The APIs are not stable, the code is unfinalized and should not be used in production.

See sub packages.

Index

Constants

This section is empty.

Variables

View Source 
var (

	// FormatMono225008bBE mono 8bit 22.5kHz AIFF like format.
	FormatMono225008bBE = &Format{
		NumChannels: 1,
		SampleRate:  22500,
		BitDepth:    8,
		Endianness:  binary.BigEndian,
	}
	// FormatMono2250016bBE mono 16bit 22.5kHz AIFF like format.
	FormatMono2250016bBE = &Format{
		NumChannels: 1,
		SampleRate:  22500,
		BitDepth:    16,
		Endianness:  binary.BigEndian,
	}
	// FormatMono441008bBE mono 8bit 44.1kHz AIFF like format.
	FormatMono441008bBE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    8,
		Endianness:  binary.BigEndian,
	}
	// FormatMono4410016bBE mono 16bit 44.1kHz AIFF like format.
	FormatMono4410016bBE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    16,
		Endianness:  binary.BigEndian,
	}
	// FormatMono4410024bBE mono 24bit 44.1kHz AIFF like format.
	FormatMono4410024bBE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    24,
		Endianness:  binary.BigEndian,
	}
	// FormatMono4410032bBE mono 32bit 44.1kHz AIFF like format.
	FormatMono4410032bBE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    32,
		Endianness:  binary.BigEndian,
	}

	// FormatStereo225008bBE Stereo 8bit 22.5kHz AIFF like format.
	FormatStereo225008bBE = &Format{
		NumChannels: 2,
		SampleRate:  22500,
		BitDepth:    8,
		Endianness:  binary.BigEndian,
	}
	// FormatStereo2250016bBE Stereo 16bit 22.5kHz AIFF like format.
	FormatStereo2250016bBE = &Format{
		NumChannels: 2,
		SampleRate:  22500,
		BitDepth:    16,
		Endianness:  binary.BigEndian,
	}
	// FormatStereo441008bBE Stereo 8bit 44.1kHz AIFF like format.
	FormatStereo441008bBE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    8,
		Endianness:  binary.BigEndian,
	}
	// FormatStereo4410016bBE Stereo 16bit 44.1kHz AIFF like format.
	FormatStereo4410016bBE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    16,
		Endianness:  binary.BigEndian,
	}
	// FormatStereo4410024bBE Stereo 24bit 44.1kHz AIFF like format.
	FormatStereo4410024bBE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    24,
		Endianness:  binary.BigEndian,
	}
	// FormatStereo4410032bBE Stereo 32bit 44.1kHz AIFF like format.
	FormatStereo4410032bBE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    32,
		Endianness:  binary.BigEndian,
	}

	// FormatMono225008bLE mono 8bit 22.5kHz AIFF like format.
	FormatMono225008bLE = &Format{
		NumChannels: 1,
		SampleRate:  22500,
		BitDepth:    8,
		Endianness:  binary.LittleEndian,
	}
	// FormatMono2250016bLE mono 16bit 22.5kHz AIFF like format.
	FormatMono2250016bLE = &Format{
		NumChannels: 1,
		SampleRate:  22500,
		BitDepth:    16,
		Endianness:  binary.LittleEndian,
	}
	// FormatMono441008bLE mono 8bit 44.1kHz AIFF like format.
	FormatMono441008bLE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    8,
		Endianness:  binary.LittleEndian,
	}
	// FormatMono4410016bLE mono 16bit 44.1kHz AIFF like format.
	FormatMono4410016bLE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    16,
		Endianness:  binary.LittleEndian,
	}
	// FormatMono4410024bLE mono 24bit 44.1kHz AIFF like format.
	FormatMono4410024bLE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    24,
		Endianness:  binary.LittleEndian,
	}
	// FormatMono4410032bLE mono 32bit 44.1kHz AIFF like format.
	FormatMono4410032bLE = &Format{
		NumChannels: 1,
		SampleRate:  44100,
		BitDepth:    32,
		Endianness:  binary.LittleEndian,
	}

	// FormatStereo225008bLE Stereo 8bit 22.5kHz AIFF like format.
	FormatStereo225008bLE = &Format{
		NumChannels: 2,
		SampleRate:  22500,
		BitDepth:    8,
		Endianness:  binary.LittleEndian,
	}
	// FormatStereo2250016bLE Stereo 16bit 22.5kHz AIFF like format.
	FormatStereo2250016bLE = &Format{
		NumChannels: 2,
		SampleRate:  22500,
		BitDepth:    16,
		Endianness:  binary.LittleEndian,
	}
	// FormatStereo441008bLE Stereo 8bit 44.1kHz AIFF like format.
	FormatStereo441008bLE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    8,
		Endianness:  binary.LittleEndian,
	}
	// FormatStereo4410016bLE Stereo 16bit 44.1kHz AIFF like format.
	FormatStereo4410016bLE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    16,
		Endianness:  binary.LittleEndian,
	}
	// FormatStereo4410024bLE Stereo 24bit 44.1kHz AIFF like format.
	FormatStereo4410024bLE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    24,
		Endianness:  binary.LittleEndian,
	}
	// FormatStereo4410032bLE Stereo 32bit 44.1kHz AIFF like format.
	FormatStereo4410032bLE = &Format{
		NumChannels: 2,
		SampleRate:  44100,
		BitDepth:    32,
		Endianness:  binary.LittleEndian,
	}
)
View Source 
var (
	ErrInvalidBuffer = errors.New("invalid buffer")
)
View Source 
var (
	// RootA or concert A is the reference frequency for A4.
	// Modify this package variable if you need to change it to 435 (classical) or
	// 415 (baroque). Methods refering to this root A note will use this variable.
	RootA = 440.0
)

Functions

func AvgInt 

func AvgInt(xs ...int) int

AvgInt averages the int values passed

func IeeeFloatToInt 

func IeeeFloatToInt(b [10]byte) int

IeeeFloatToInt converts a 10 byte IEEE float into an int.

func Int32toInt24LEBytes 

func Int32toInt24LEBytes(n int32) []byte

Int32toInt24LEBytes converts a int32 into a 3 byte int24 representation

func IntMaxSignedValue 

func IntMaxSignedValue(b int) int

IntMaxSignedValue returns the max value of an integer based on its memory size

func IntToIeeeFloat 

func IntToIeeeFloat(i int) [10]byte

IntToIeeeFloat converts an int into a 10 byte IEEE float.

func Uint24to32 

func Uint24to32(bytes []byte) uint32

Uint24to32 converts a 3 byte uint23 into a uint32 BigEndian!

func Uint32toUint24Bytes 

func Uint32toUint24Bytes(n uint32) []byte

Uint32toUint24Bytes converts a uint32 into a 3 byte uint24 representation

Types

type DataFormat 

type DataFormat int

DataFormat is an enum type to indicate the underlying data format used. 

const (
	// Unknown refers to an unknown format
	Unknown DataFormat = iota
	// Integer represents the int type.
	// it represents the native int format used in audio buffers.
	Integer
	// Float represents the float64 type.
	// It represents the native float format used in audio buffers.
	Float
	// Byte represents the byte type.
	Byte
)

type Format 

type Format struct {
	// NumChannels is the number of channels contained in the data
	NumChannels int
	// SampleRate is the sampling rate in Hz
	SampleRate int
	// BitDepth is the number of bits of data for each sample
	BitDepth int
	// Endianess indicate how the byte order of underlying bytes
	Endianness binary.ByteOrder
}

Format is a high level representation of the underlying data.

type PCMBuffer 

type PCMBuffer struct {
	// Format describes the format of the buffer data.
	Format *Format
	// Ints is a store for audio sample data as integers.
	Ints []int
	// Floats is a store for audio samples data as float64.
	Floats []float64
	// Bytes is a store for audio samples data as raw bytes.
	Bytes []byte
	// DataType indicates the primary format used for the underlying data.
	// The consumer of the buffer might want to look at this value to know what store
	// to use to optimaly retrieve data.
	DataType DataFormat
	// contains filtered or unexported fields
}

PCMBuffer encapsulates uncompressed audio data and provides useful methods to read/manipulate this PCM data.

func NewPCMByteBuffer 

func NewPCMByteBuffer(data []byte, format *Format) *PCMBuffer

NewPCMByteBuffer returns a new PCM buffer backed by the passed float samples

func NewPCMFloatBuffer 

func NewPCMFloatBuffer(data []float64, format *Format) *PCMBuffer

NewPCMFloatBuffer returns a new PCM buffer backed by the passed float samples

func NewPCMIntBuffer 

func NewPCMIntBuffer(data []int, format *Format) *PCMBuffer

NewPCMIntBuffer returns a new PCM buffer backed by the passed integer samples

func (*PCMBuffer) AsFloat32s 

func (b *PCMBuffer) AsFloat32s() (out []float32)

AsFloat32s returns the buffer samples as float32 sample values.

func (*PCMBuffer) AsFloat64s 

func (b *PCMBuffer) AsFloat64s() (out []float64)

AsFloat64s returns the buffer samples as float64 sample values.

func (*PCMBuffer) AsInt16s 

func (b *PCMBuffer) AsInt16s() (out []int16)

AsInt16s returns the buffer samples as int16 sample values.

func (*PCMBuffer) AsInt32s 

func (b *PCMBuffer) AsInt32s() (out []int32)

AsInt32s returns the buffer samples as int32 sample values.

func (*PCMBuffer) AsInt64s 

func (b *PCMBuffer) AsInt64s() (out []int64)

AsInt64s returns the buffer samples as int64 sample values.

func (*PCMBuffer) AsInts 

func (b *PCMBuffer) AsInts() (out []int)

AsInts returns the content of the buffer values as ints.

func (*PCMBuffer) CacheFloat64s 

func (b *PCMBuffer) CacheFloat64s()

CacheFloat64s ensures that the underlying int store is filled up so Floats() can be called knowing that the data is available. Note that if the underlying data is changed, it is the caller responsibility to refresh the cache.

func (*PCMBuffer) CacheInts 

func (b *PCMBuffer) CacheInts()

CacheInts ensures that the underlying int store is filled up so Ints() can be called knowing that the data is available. Note that if the underlying data is changed, it is the caller responsibility to refresh the cache.

func (*PCMBuffer) Clone 

func (b *PCMBuffer) Clone() *PCMBuffer

Clone creates a clean clone that can be modified without changing the source buffer.

func (*PCMBuffer) Len 

func (b *PCMBuffer) Len() int

Len returns the length of the underlying data.

func (*PCMBuffer) Size 

func (b *PCMBuffer) Size() (numFrames int)

Size returns the number of frames contained in the buffer.

func (*PCMBuffer) SwitchPrimaryType 

func (b *PCMBuffer) SwitchPrimaryType(t DataFormat)

SwitchPrimaryType is a convenience method to switch the primary data type. Use this if you process/swap a different type than the original type.

Source Files

View all Source files

Directories

Path Synopsis
Package aiff is a AIFF/AIFC decoder and encoder.
 Package aiff is a AIFF/AIFC decoder and encoder.
caf
caf package implements an Apple Core Audio Format (CAF) parser.
 caf package implements an Apple Core Audio Format (CAF) parser.
cmd/debug
demos
decimator
given a PCM audio file, convert it to mono and decimates it.
 given a PCM audio file, convert it to mono and decimates it.
dsp
analysis
analysis/cmd
filters
windows
cmd
generator example
 generator example
MIDI package is a midi format parser that parses the content of a midi stream and asyncronously send the data to a provided channel or collect the data into an accessible struct,
 MIDI package is a midi format parser that parses the content of a midi stream and asyncronously send the data to a provided channel or collect the data into an accessible struct,
cmd/decoder
cmd/gen
mp3
mp3 is a package used to access mp3 information See: http://sea-mist.se/fou/cuppsats.nsf/all/857e49b9bfa2d753c125722700157b97/$file/Thesis%20report-%20MP3%20Decoder.pdf Uses some code from https://github.com/tcolgate/mp3 under MIT license Tristan Colgate-McFarlane and badgerodon
 mp3 is a package used to access mp3 information See: http://sea-mist.se/fou/cuppsats.nsf/all/857e49b9bfa2d753c125722700157b97/$file/Thesis%20report-%20MP3%20Decoder.pdf Uses some code from https://github.com/tcolgate/mp3 under MIT license Tristan Colgate-McFarlane and badgerodon
cmd/validator
this is a simple tool to validate the mp3 files in a folder
 this is a simple tool to validate the mp3 files in a folder
id3v1
id3v1 is a package allowing the extraction of id3v1 tags.
 id3v1 is a package allowing the extraction of id3v1 tags.
id3v2
Package riff is package implementing a simple Resource Interchange File Format (RIFF) parser with basic support for sub formats such as WAV.
 Package riff is package implementing a simple Resource Interchange File Format (RIFF) parser with basic support for sub formats such as WAV.
riffinfo
riffinfo is a command line tool used to gather information about riff files.
 riffinfo is a command line tool used to gather information about riff files.
filters
filters implement easy to use audio filters.
 filters implement easy to use audio filters.
presenters
Package wav is a package allowing developers to decode and encode audio PCM data using the Waveform Audio File Format https://en.wikipedia.org/wiki/WAV
 Package wav is a package allowing developers to decode and encode audio PCM data using the Waveform Audio File Format https://en.wikipedia.org/wiki/WAV

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.