Native Go FLAC encoder/decoder with support for FLAC streams

# flac

[![Go build status](https://github.com/mewkiz/flac/actions/workflows/go.yml/badge.svg?branch=master)](https://github.com/mewkiz/flac/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/mewkiz/flac/badge.svg?branch=master)](https://coveralls.io/github/mewkiz/flac?branch=master)
[![GoDoc](https://pkg.go.dev/badge/github.com/mewkiz/flac)](https://pkg.go.dev/github.com/mewkiz/flac)

This package provides access to [FLAC][1] (Free Lossless Audio Codec) streams.

[1]: http://flac.sourceforge.net/format.html

## Documentation

Documentation provided by GoDoc.

- [flac]: provides access to FLAC (Free Lossless Audio Codec) streams.
    - [frame][flac/frame]: implements access to FLAC audio frames.
    - [meta][flac/meta]: implements access to FLAC metadata blocks.

[flac]: http://pkg.go.dev/github.com/mewkiz/flac
[flac/frame]: http://pkg.go.dev/github.com/mewkiz/flac/frame
[flac/meta]: http://pkg.go.dev/github.com/mewkiz/flac/meta

## Changes

* Version 1.0.14 (TBA)
    - Make parsing more robust against corrupt/malicious FLAC files (see [#77](https://github.com/mewkiz/flac/pull/77)). Thanks to [Alex Svetkin](https://github.com/whisk).

* Version 1.0.13 (2025-07-11)
    - Add support for Fixed prediction encoding of FLAC subframes (see [#76](https://github.com/mewkiz/flac/pull/76)). Thanks to [Michael Braha](https://github.com/braheezy).

* Version 1.0.12 (2024-08-11)
    - Improve performance of `flac.NewSeek()` by using a buffered reader (see [#72](https://github.com/mewkiz/flac/pull/72)).
    - Fix off-by-one error in `Seek` end of stream check (see [#73](https://github.com/mewkiz/flac/pull/73)).

* Version 1.0.11 (2024-08-04)
    - Move example tools to dedicated [mewkiz/flac-tools](https://github.com/mewkiz/flac-tools) repository to reduce external dependencies (see [#62](https://github.com/mewkiz/flac/pull/62)).
    - Fix seek to frame start (see [#71](https://github.com/mewkiz/flac/pull/71)). Thanks to [Mark Kremer](https://github.com/MarkKremer).
    - Simplify internal handling of `io.Closer` element in `flac.Stream` and `flac.Encoder` types (see [#70](https://github.com/mewkiz/flac/pull/70)). Thanks to [Mario Salgado](https://github.com/zalgonoise).

* Version 1.0.10 (2023-11-11)
    - Add support for LPC audio sample encoding (see [#66](https://github.com/mewkiz/flac/pull/66)). Thanks to [Mark Kremer](https://github.com/MarkKremer) for bug fixes and [Mattias Wadman](https://github.com/wader) for the invaluable [fq](https://github.com/wader/fq) tool used to investigate FLAC encoding issues.
    - Replace Travis CI with GitHub actions for CI build status, test status and code coverage [#64](https://github.com/mewkiz/flac/pull/64)). Thanks to [Mark Kremer](https://github.com/MarkKremer).

* Version 1.0.9 (2023-10-24)
    - Fix integer overflow during unfolding of rice residual (see [#61](https://github.com/mewkiz/flac/pull/61)). Thanks to [Mark Kremer](https://github.com/MarkKremer).
    - Fix decoding of escaped partition audio samples (see [#60](https://github.com/mewkiz/flac/issues/60)). Thanks to [Mark Kremer](https://github.com/MarkKremer).
    - Handle frame hashing of audio samples with bits-per-sample not evenly divisible by 8 (see [9d50c9e](https://github.com/mewkiz/flac/commit/9d50c9ee99ba322f487ed60442dc16f22b2affb8)).

* Version 1.0.8 (2023-04-09)
    - Fix race condition when reading meta data (see [#56](https://github.com/mewkiz/flac/pull/56)). Thanks to [Zach Orosz](https://github.com/zachorosz).
    - Fix encoding of 8-bps WAV audio samples (see [#52](https://github.com/mewkiz/flac/pull/52)). Thanks to [Martijn van Beurden](https://github.com/ktmf01).
    - Fix `StreamInfo` block type error message (see [#49](https://github.com/mewkiz/flac/pull/49)).

* Version 1.0.7 (2021-01-28)
    - Add seek API (see [#44](https://github.com/mewkiz/flac/pull/44) and [#46](https://github.com/mewkiz/flac/pull/46)). Thanks to [Craig Swank](https://github.com/cswank).

* Version 1.0.6 (2019-12-20)
    - Add experimental Encoder API to encode audio samples and metadata blocks (see [#32](https://github.com/mewkiz/flac/pull/32)).
    - Use go.mod.
    - Skip ID3v2 data prepended to flac files when parsing (see [36cc17e](https://github.com/mewkiz/flac/commit/36cc17efed51a9bae283d6a3a7a10997492945e7)).
        - Remove dependency on encodebytes. Thanks to [Mikey Dickerson](https://github.com/mdickers47).
    - Add 16kHz test case. Thanks to [Chewxy](https://github.com/chewxy).
    - Fix lint issues (see [#25](https://github.com/mewkiz/flac/issues/25)).

* Version 1.0.5 (2016-05-06)
    - Simplify import paths. Drop use of gopkg.in, and rely on vendoring instead (see [azul3d/engine#1](https://github.com/azul3d/engine/issues/1)).
    - Add FLAC decoding benchmark (see [d675e0a](https://github.com/mewkiz/flac/blob/d675e0aaccf2e43055f56b9b3feeddfdeed402e2/frame/frame_test.go#L60)).

* Version 1.0.4 (2016-02-11)
    - Add API examples to documentation (see [#11](https://github.com/mewkiz/flac/issues/11)).
    - Extend test cases (see [aadf80a](https://github.com/mewkiz/flac/commit/aadf80aa28c463a94b8d5c49757e5a0948613ce2)).

* Version 1.0.3 (2016-02-02)
    - Implement decoding of FLAC files with wasted bits-per-sample (see [#12](https://github.com/mewkiz/flac/issues/12)).
    - Stress test the library using [go-fuzz](https://github.com/dvyukov/go-fuzz) (see [#10](https://github.com/mewkiz/flac/pull/10)). Thanks to [Patrick Mézard](https://github.com/pmezard).

* Version 1.0.2 (2015-06-05)
    - Fix decoding of blocking strategy (see [#9](https://github.com/mewkiz/flac/pull/9)). Thanks to [Sergey Didyk](https://github.com/sdidyk).

* Version 1.0.1 (2015-02-25)
    - Fix two subframe decoding bugs (see [#7](https://github.com/mewkiz/flac/pull/7)). Thanks to [Jonathan MacMillan](https://github.com/perotinus).
    - Add frame decoding test cases.

* Version 1.0.0 (2014-09-30)
    - Initial release.
    - Implement decoding of FLAC files.


flac

# GoAudio 🎶
[![Build
Status](https://travis-ci.com/DylanMeeus/GoAudio.svg?branch=master)](https://travis-ci.com/DylanMeeus/GoAudio)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)


GoAudio is an audio processing library, currently supporting `WAVE` files, although some tools such
as the synth and breakpoints are encoding-agnostic, so you could combine them with a different
library for storing the data and using GoAudio only as a means to generate the waveforms.

# Features

- [Wave file handling](wave)(READ / WRITE Wave files)
- [Synthesizer](synthesizer) - Create different waveforms using different types of oscillators
- [Breakpoints](breakpoint) (create automation tracks / envelopes)


# Blog

If you want to know more about how this code works and what you can do with it, I write about this code and other audio related programs over on my [blog:
dylanmeeus.github.io](https://dylanmeeus.github.io).




GoAudio

[![GoDoc](https://godoc.org/github.com/Comcast/gaad?status.svg)](https://godoc.org/github.com/Comcast/gaad)
[![Build Status](https://travis-ci.org/Comcast/gaad.svg?branch=master)](https://travis-ci.org/Comcast/gaad)
[![Go Report Card](https://goreportcard.com/badge/github.com/Comcast/gaad)](https://goreportcard.com/report/github.com/Comcast/gaad)


# GAAD (Go Advanced Audio Decoder)

Package currently provides AAC parsing capabilities.  This package performs a full parse of AAC-LC and HE-AACv1 bitstreams.  Bitstreams with Parametric Stereo (HE-AACv2) are not yet supported, but AAC bitstream data and SBR data will be extracted. The AAC decode from the parsed data to LPCM (.wav) is not yet implemented.  Please help us expand and test this library!

## AACParser
This package currently supports AAC audio data contained in an ADTS header.  All available data is returned in the `adts` struct and can be accessed as nested objects as presented in the AAC specification.  All parameter names should be verbatim from the AAC specification, if you find an issue with this please file a bug or submit a pull request.  

### AAC Types

| Type      | Description     | CODEC        |
| :-------: | --------------- | :----------: |
| AACLC     | AAC             | mp4a.40.2    |
| HEAAC     | AAC + SBR       | mp4a.40.5    |
| HEAACv2   | AAC + SBR + PS  | mp4a.40.29   |

where:
+ SBR = Spectral band replication
+ PS = Parametric Stereo

### Usage
```go
var []byte buf
buf = <ADTS+AAC data>

// Parsing the buffer
adts, err := gaad.ParseADTS(buf)

// Looping through top level elements and accessing sub-elements
var sbr bool
if adts.Fill_elements != nil {
	for _, e := range adts.Fill_elements {
		if e.Extension_payload != nil &&
			e.Extension_payload.Extension_type == gaad.EXT_SBR_DATA {
			sbr = true
		}
	}
}
```

### VBR vs CBR

VBR (Variable bitrate) and CBR (Constant bitrate) is derived from the bitstream_type attribute in the adif_header section.  It is VBR if bitstream_type is true, and CBR otherwise.

### References

#### ISO/IEC STANDARD 14496-3

```
Title         : Coding of audio-visual objects — Part 3: Audio
File          : ISO_14496-3-4th-Edition.pdf
Edition       : Fourth edition (2009-09-01)
Relevant Sections
    - Page 64   : 1.6.5 Signaling of SBR
    - Page 120  : 1.A.2 AAC Interchange formats
    - Page 489  : 4.4.2 GA bitstream payloads
```
#### Related Books

* Video Demystified (5th Edition) http://my.safaribooksonline.com/book/-/9780750683951

#### Related Links

* http://www.mp4ra.org/codecs.html



gaad

A low-level library to play sound on multiple platforms

# Oto (v3)

[![Go Reference](https://pkg.go.dev/badge/github.com/ebitengine/oto/v3.svg)](https://pkg.go.dev/github.com/ebitengine/oto/v3)
[![Build Status](https://github.com/ebitengine/oto/actions/workflows/test.yml/badge.svg)](https://github.com/ebitengine/oto/actions?query=workflow%3Atest)

A low-level library to play sound.

- [Oto (v3)](#oto-v3)
  - [Platforms](#platforms)
  - [Prerequisite](#prerequisite)
    - [macOS](#macos)
    - [iOS](#ios)
    - [Linux, FreeBSD, OpenBSD](#linux-freebsd-openbsd)
  - [Usage](#usage)
    - [Playing sounds from memory](#playing-sounds-from-memory)
    - [Playing sounds by file streaming](#playing-sounds-by-file-streaming)
    - [Advanced usage](#advanced-usage)
  - [Crosscompiling](#crosscompiling)

## Platforms

- Windows (no Cgo required)
- macOS (no Cgo required)
- Linux (no Cgo required)
- FreeBSD (no Cgo required)
- OpenBSD (no Cgo required)
- Android
- iOS
- WebAssembly (no Cgo required)
- Nintendo Switch
- Xbox

## Prerequisite

On some platforms you will need a C/C++ compiler in your path that Go can use.

- iOS: On newer macOS versions type `clang` on your terminal and a dialog with installation instructions will appear if you don't have it
  - If you get an error with clang use xcode instead `xcode-select --install`
- Console targets may still need a working C/C++ toolchain; if not installed, try [GCC](https://gcc.gnu.org/) or [Clang](https://releases.llvm.org/download.html)

### macOS

Oto requires `AudioToolbox.framework`, but this is automatically linked.

### iOS

Oto requires these frameworks:

- `AVFoundation.framework`
- `AudioToolbox.framework`

Add them to "Linked Frameworks and Libraries" on your Xcode project.

### Linux, FreeBSD, OpenBSD

Oto uses PulseAudio on Linux and BSD systems via the pure-Go package `github.com/jfreymuth/pulse`,
though BSD systems are not tested well.

If the PulseAudio server is not discoverable automatically, set `PULSE_SERVER`.

## Usage

The two main components of Oto are a `Context` and `Players`. The context handles interactions with
the OS and audio drivers, and as such there can only be **one** context in your program.

From a context you can create any number of different players, where each player is given an `io.Reader` that
it reads bytes representing sounds from and plays.

Note that a single `io.Reader` must **not** be used by multiple players.

### Playing sounds from memory

The following is an example of loading and playing an MP3 file:

```go
package main

import (
    "bytes"
    "time"
    "os"

    "github.com/ebitengine/oto/v3"
    "github.com/hajimehoshi/go-mp3"
)

func main() {
    // Read the mp3 file into memory
    fileBytes, err := os.ReadFile("./my-file.mp3")
    if err != nil {
        panic("reading my-file.mp3 failed: " + err.Error())
    }

    // Convert the pure bytes into a reader object that can be used with the mp3 decoder
    fileBytesReader := bytes.NewReader(fileBytes)

    // Decode file
    decodedMp3, err := mp3.NewDecoder(fileBytesReader)
    if err != nil {
        panic("mp3.NewDecoder failed: " + err.Error())
    }

    // Prepare an Oto context (this will use your default audio device) that will
    // play all our sounds. Its configuration can't be changed later.

    op := &oto.NewContextOptions{}

    // Usually 44100 or 48000. Other values might cause distortions in Oto
    op.SampleRate = 44100

    // Number of channels (aka locations) to play sounds from. Either 1 or 2.
    // 1 is mono sound, and 2 is stereo (most speakers are stereo). 
    op.ChannelCount = 2

    // Format of the source. go-mp3's format is signed 16bit integers.
    op.Format = oto.FormatSignedInt16LE

    // Remember that you should **not** create more than one context
    otoCtx, readyChan, err := oto.NewContext(op)
    if err != nil {
        panic("oto.NewContext failed: " + err.Error())
    }
    // It might take a bit for the hardware audio devices to be ready, so we wait on the channel.
    <-readyChan

    // Create a new 'player' that will handle our sound. Paused by default.
    player := otoCtx.NewPlayer(decodedMp3)
    
    // Play starts playing the sound and returns without waiting for it (Play() is async).
    player.Play()

    // We can wait for the sound to finish playing using something like this
    for player.IsPlaying() {
        time.Sleep(time.Millisecond)
    }

    // Now that the sound finished playing, we can restart from the beginning (or go to any location in the sound) using seek
    // newPos, err := player.(io.Seeker).Seek(0, io.SeekStart)
    // if err != nil{
    //     panic("player.Seek failed: " + err.Error())
    // }
    // println("Player is now at position:", newPos)
    // player.Play()
}
```

### Playing sounds by file streaming

The above example loads the entire file into memory and then plays it. This is great for smaller files
but might be an issue if you are playing a long song since it would take too much memory and too long to load.

In such cases you might want to stream the file. Luckily this is very simple, just use `os.Open`:

```go
package main

import (
    "os"
    "time"

    "github.com/ebitengine/oto/v3"
    "github.com/hajimehoshi/go-mp3"
)

func main() {
    // Open the file for reading. Do NOT close before you finish playing!
    file, err := os.Open("./my-file.mp3")
    if err != nil {
        panic("opening my-file.mp3 failed: " + err.Error())
    }

    // Decode file. This process is done as the file plays so it won't
    // load the whole thing into memory.
    decodedMp3, err := mp3.NewDecoder(file)
    if err != nil {
        panic("mp3.NewDecoder failed: " + err.Error())
    }

    // Rest is the same...

    // Close file only after you finish playing
    file.Close()
}
```

The only thing to note about streaming is that the *file* object must be kept alive, otherwise
you might just play static.

To keep it alive not only must you be careful about when you close it, but you might need to keep a reference
to the original file object alive (by for example keeping it in a struct).

### Advanced usage

Players have their own internal audio data buffer, so while for example 200 bytes have been read from the `io.Reader` that
doesn't mean they were all played from the audio device.

Data is moved from io.Reader->internal buffer->audio device, and when the internal buffer moves data to the audio device
is not guaranteed, so there might be a small delay. The amount of data in the buffer can be retrieved
using `Player.BufferedSize()`.

The size of the underlying buffer of a player can also be set by type-asserting the player object:

```go
myPlayer.(oto.BufferSizeSetter).SetBufferSize(newBufferSize)
```

This works because players implement a `Player` interface and a `BufferSizeSetter` interface.

## Crosscompiling

Crosscompiling to macOS, Windows, Linux or BSD is as easy as setting `GOOS=darwin`, `GOOS=windows`,
`GOOS=linux` or `GOOS=freebsd` (or your particular BSD flavor) respectively.

To crosscompile for other platforms, make sure the libraries for the target architecture are installed, and set 
`CGO_ENABLED=1` as Go disables [Cgo](https://golang.org/cmd/cgo/#hdr-Using_cgo_with_the_go_command) on crosscompiles by default.


Go bindings for the PortAudio audio I/O library

# portaudio

This package provides an interface to the [PortAudio](http://www.portaudio.com/) audio I/O library.  See the [package documentation](https://pkg.go.dev/github.com/gordonklaus/portaudio) for details.

To build this package you must first have the PortAudio development headers and libraries installed.  Some systems provide a package for this; e.g., on Ubuntu you would want to run `apt-get install portaudio19-dev`.  On other systems you might have to install from source.

Thanks to sqweek for motivating and contributing to host API and device enumeration.


PortAudio

# id3v2

Implementation of ID3 v2.3 and v2.4 in native Go.

## Installation

```
go get -u github.com/bogem/id3v2/v2
```

## Documentation

https://pkg.go.dev/github.com/bogem/id3v2/v2

## Usage example

```go
package main

import (
	"fmt"
	"log"

	"github.com/bogem/id3v2/v2"
)

func main() {
	tag, err := id3v2.Open("file.mp3", id3v2.Options{Parse: true})
	if err != nil {
 		log.Fatal("Error while opening mp3 file: ", err)
 	}
	defer tag.Close()

	// Read tags
	fmt.Println(tag.Artist())
	fmt.Println(tag.Title())

	// Set tags
	tag.SetArtist("Aphex Twin")
	tag.SetTitle("Xtal")

	comment := id3v2.CommentFrame{
		Encoding:    id3v2.EncodingUTF8,
		Language:    "eng",
		Description: "My opinion",
		Text:        "I like this song!",
	}
	tag.AddCommentFrame(comment)

	// Write tag to file.mp3
	if err = tag.Save(); err != nil {
		log.Fatal("Error while saving a tag: ", err)
	}
}
```

## Read multiple frames

```go
pictures := tag.GetFrames(tag.CommonID("Attached picture"))
for _, f := range pictures {
	pic, ok := f.(id3v2.PictureFrame)
	if !ok {
		log.Fatal("Couldn't assert picture frame")
	}

	// Do something with picture frame
	fmt.Println(pic.Description)
}
```

## Encodings

For example, if you want to set comment frame with custom encoding,
you may do the following:

```go
comment := id3v2.CommentFrame{
	Encoding:    id3v2.EncodingUTF16,
	Language:    "ger",
	Description: "Tier",
	Text:        "Der Löwe",
}
tag.AddCommentFrame(comment)
```

`Text` field will be automatically encoded with UTF-16BE with BOM and written to w.

UTF-8 is default for v2.4, ISO-8859-1 - for v2.3.


id3v2

## malgo
[![Build Status](https://github.com/gen2brain/malgo/actions/workflows/build.yml/badge.svg)](https://github.com/gen2brain/malgo/actions)
[![GoDoc](https://godoc.org/github.com/gen2brain/malgo?status.svg)](https://godoc.org/github.com/gen2brain/malgo) 
[![Go Report Card](https://goreportcard.com/badge/github.com/gen2brain/malgo?branch=master)](https://goreportcard.com/report/github.com/gen2brain/malgo) 


Go bindings for [miniaudio](https://github.com/dr-soft/miniaudio) library.

Requires `cgo` but does not require linking to anything on the Windows/macOS and it links only `-ldl` on Linux/BSDs.

### Installation

    go get -u github.com/gen2brain/malgo

### Documentation

Documentation on [GoDoc](https://godoc.org/github.com/gen2brain/malgo). Also check [examples](https://github.com/gen2brain/malgo/tree/master/_examples).

### Platforms

* Windows (WASAPI, DirectSound, WinMM)
* Linux (PulseAudio, ALSA, JACK)
* FreeBSD/NetBSD/OpenBSD (OSS/audio(4)/sndio)
* macOS/iOS (CoreAudio)
* Android (OpenSL|ES, AAudio)

malgo

# minimp3

[![Go Reference](https://pkg.go.dev/badge/github.com/tosone/minimp3.svg)](https://pkg.go.dev/github.com/tosone/minimp3) [![Builder](https://github.com/tosone/minimp3/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/tosone/minimp3/actions/workflows/ci.yaml) [![codecov](https://codecov.io/gh/tosone/minimp3/branch/main/graph/badge.svg?token=LUIF0jZw6E)](https://codecov.io/gh/tosone/minimp3)

Decode mp3 base on <https://github.com/lieff/minimp3>

## Installation

1. The first need Go installed (version 1.15+ is required), then you can use the below Go command to install minimp3.

``` bash
$ go get -u github.com/tosone/minimp3
```

2. Import it in your code:

``` bash
import "github.com/tosone/minimp3"
```

## Examples are here

<details>
  <summary>Example1: Decode the whole mp3 and play.</summary>

``` golang
package main

import (
	"io/ioutil"
	"log"
	"time"

	"github.com/hajimehoshi/oto"
	"github.com/tosone/minimp3"
)

func main() {
	var err error

	var file []byte
	if file, err = ioutil.ReadFile("test.mp3"); err != nil {
		log.Fatal(err)
	}

	var dec *minimp3.Decoder
	var data []byte
	if dec, data, err = minimp3.DecodeFull(file); err != nil {
		log.Fatal(err)
	}

	var context *oto.Context
	if context, err = oto.NewContext(dec.SampleRate, dec.Channels, 2, 1024); err != nil {
		log.Fatal(err)
	}

	var player = context.NewPlayer()
	player.Write(data)

	<-time.After(time.Second)

	dec.Close()
	if err = player.Close(); err != nil {
		log.Fatal(err)
	}
}
```

</details>

<details>
  <summary>Example2: Decode and play.</summary>

``` go
package main

import (
	"io"
	"log"
	"os"
	"sync"
	"time"

	"github.com/hajimehoshi/oto"
	"github.com/tosone/minimp3"
)

func main() {
	var err error

	var file *os.File
	if file, err = os.Open("../test.mp3"); err != nil {
		log.Fatal(err)
	}

	var dec *minimp3.Decoder
	if dec, err = minimp3.NewDecoder(file); err != nil {
		log.Fatal(err)
	}
	started := dec.Started()
	<-started

	log.Printf("Convert audio sample rate: %d, channels: %d\n", dec.SampleRate, dec.Channels)

	var context *oto.Context
	if context, err = oto.NewContext(dec.SampleRate, dec.Channels, 2, 1024); err != nil {
		log.Fatal(err)
	}

	var waitForPlayOver = new(sync.WaitGroup)
	waitForPlayOver.Add(1)

	var player = context.NewPlayer()

	go func() {
		for {
			var data = make([]byte, 1024)
			_, err := dec.Read(data)
			if err == io.EOF {
				break
			}
			if err != nil {
				break
			}
			player.Write(data)
		}
		log.Println("over play.")
		waitForPlayOver.Done()
	}()
	waitForPlayOver.Wait()

	<-time.After(time.Second)
	dec.Close()
	if err = player.Close(); err != nil {
		log.Fatal(err)
	}
}
```

</details>

<details>
  <summary>Example3: Play the network audio.</summary>

``` go
package main

import (
	"io"
	"log"
	"net/http"
	"os"
	"sync"
	"time"

	"github.com/hajimehoshi/oto"
	"github.com/tosone/minimp3"
)

func main() {
	var err error

	var args = os.Args
	if len(args) != 2 {
		log.Fatal("Run test like this:\n\n\t./networkAudio.test [mp3url]\n\n")
	}

	var response *http.Response
	if response, err = http.Get(args[1]); err != nil {
		log.Fatal(err)
	}

	var dec *minimp3.Decoder
	if dec, err = minimp3.NewDecoder(response.Body); err != nil {
		log.Fatal(err)
	}
	<-dec.Started()

	log.Printf("Convert audio sample rate: %d, channels: %d\n", dec.SampleRate, dec.Channels)

	var context *oto.Context
	if context, err = oto.NewContext(dec.SampleRate, dec.Channels, 2, 4096); err != nil {
		log.Fatal(err)
	}

	var waitForPlayOver = new(sync.WaitGroup)
	waitForPlayOver.Add(1)

	var player = context.NewPlayer()

	go func() {
		defer response.Body.Close()
		for {
			var data = make([]byte, 512)
			_, err = dec.Read(data)
			if err == io.EOF {
				break
			}
			if err != nil {
				log.Fatal(err)
				break
			}
			player.Write(data)
		}
		log.Println("over play.")
		waitForPlayOver.Done()
	}()

	waitForPlayOver.Wait()

	<-time.After(time.Second)
	dec.Close()
	player.Close()
}
```

</details>


minimp3

# go-mpris

[![Go](https://github.com/leberKleber/go-mpris/workflows/go/badge.svg)](https://github.com/leberKleber/go-mpris/actions?query=workflow%3Ago)
[![GoDoc](https://godoc.org/github.com/leberKleber/go-mpris?status.png)](https://godoc.org/github.com/leberKleber/go-mpris)
[![Go Report Card](https://goreportcard.com/badge/github.com/leberKleber/go-mpris)](https://goreportcard.com/report/github.com/leberKleber/go-mpris)
[![codecov](https://codecov.io/gh/leberKleber/go-mpris/branch/main/graph/badge.svg)](https://codecov.io/gh/leberKleber/go-mpris)

go-mpris is an implementation of the mpris dbus interface written in go (golang).
Implemented and tested against version 2.2. See: https://specifications.freedesktop.org/mpris-spec/2.2.

* [Example](#example)
* [Features](#features)
  * [Player](#player)
    * [Methods](#methods)
    * [Properties](#properties)
    * [Signals](#signals)
  * [TrackList](#tracklist)
    * [Methods](#methods-1)
    * [Properties](#properties-1)
    * [Signals](#signals-1)
* [Development](#development)
  * [Versioning](#versioning)
  * [Commits](#commits)
  * [Mocks](#mocks)
  * [Go Docs](#go-docs)

## Example

Example cli has been implemented.

```shell
git clone git@github.com:leberKleber/go-mpris.git

go build examples/cli.go

./cli-client
```

## Features

### Player

https://specifications.freedesktop.org/mpris-spec/2.2/Player_Interface.html

#### Methods

| method      | library path                                                            | implemented        |
|-------------|-------------------------------------------------------------------------|--------------------|
| Next        | `mpris.Player.Next()`                                                   | :heavy_check_mark: |
| Previous    | `mpris.Player.Previous()`                                               | :heavy_check_mark: |
| Pause       | `mpris.Player.Pause()`                                                  | :heavy_check_mark: |
| PlayPause   | `mpris.Player.PlayPause()`                                              | :heavy_check_mark: |
| Stop        | `mpris.Player.Stop()`                                                   | :heavy_check_mark: |
| Seek        | `mpris.Player.SeekTo(<offset> int64)`¹                                  | :heavy_check_mark: |
| SetPosition | `mpris.Player.SetPosition(<trackID> dbus.ObjectPath, <position> int64)` | :heavy_check_mark: |
| OpenUri     | `mpris.Player.OpenUri(<uri> string)`                                    | :heavy_check_mark: |

¹ Could not be named Seek, it's a reserved function name.

#### Properties

| property       | library path                                                            | implemented        |
|----------------|-------------------------------------------------------------------------|--------------------|
| PlaybackStatus | `mpris.Player.PlaybackStatus() (mpris.PlaybackStatus, error)`           | :heavy_check_mark: |
| LoopStatus     | `mpris.Player.LoopStatus() (mpris.LoopStatus, error)`                   | :heavy_check_mark: |
| LoopStatus     | `mpris.Player.SetLoopStatus(<loopStatus> mpris.LoopStatus) error`       | :heavy_check_mark: |
| Rate           | `mpris.Player.Rate() (float64, error)`                                  | :heavy_check_mark: |
| Rate           | `mpris.Player.SetRate(<rate> float64) error`                            | :heavy_check_mark: |
| Shuffle        | `mpris.Player.Shuffle() (bool, error)`                                  | :heavy_check_mark: |
| Shuffle        | `mpris.Player.SetShuffle(<shuffle> bool) error`                         | :heavy_check_mark: |
| Metadata       | `mpris.Player.Metadata() (mpris.Metadata, error)`                       | :heavy_check_mark: |
| Volume         | `mpris.Player.Volume() (float64, error)`                                | :heavy_check_mark: |
| Volume         | `mpris.Player.SetVolume(<volume> float64) (error)`                      | :heavy_check_mark: |
| Position       | `mpris.Player.Position() (int64, error)`                                | :heavy_check_mark: |
| Position       | `mpris.Player.SetPosition(<trackID> dbus.ObjectPath, <position> int64)` | :heavy_check_mark: |
| MinimumRate    | `mpris.Player.MinimumRate() (float64, error)`                           | :heavy_check_mark: |
| MaximumRate    | `mpris.Player.MaximumRate() (float64, error)`                           | :heavy_check_mark: |
| CanGoNext      | `mpris.Player.CanGoNext() (bool, error)`                                | :heavy_check_mark: |
| CanGoPrevious  | `mpris.Player.CanGoPrevious() (bool, error)`                            | :heavy_check_mark: |
| CanPlay        | `mpris.Player.CanPlay() (bool, error)`                                  | :heavy_check_mark: |
| CanPause       | `mpris.Player.CanPause() (bool, error)`                                 | :heavy_check_mark: |
| CanSeek        | `mpris.Player.CanSeek() (bool, error)`                                  | :heavy_check_mark: |
| CanControl     | `mpris.Player.CanControl() (bool, error)`                               | :heavy_check_mark: |

#### Signals

| signal | library path                                                      | implemented        |
|--------|-------------------------------------------------------------------|--------------------|
| Seeked | `mpris.Player.Seeked(<ctx> context.Context) (<-chan int, error) ` | :heavy_check_mark: |

### TrackList

https://specifications.freedesktop.org/mpris-spec/2.2/Track_List_Interface.html

#### Methods

| method            | library path        | implemented              |
|-------------------|---------------------|--------------------------|
| GetTracksMetadata | Not implemented yet | :heavy_multiplication_x: |
| AddTrack          | Not implemented yet | :heavy_multiplication_x: |
| RemoveTrack       | Not implemented yet | :heavy_multiplication_x: |
| GoTo              | Not implemented yet | :heavy_multiplication_x: |

#### Properties

| property       | library path        | implemented              |
|----------------|---------------------|--------------------------|
| Tracks         | Not implemented yet | :heavy_multiplication_x: |
| CanEditTracks  | Not implemented yet | :heavy_multiplication_x: |


#### Signals

| signal               | library path        | implemented              |
|----------------------|---------------------|--------------------------|
| TrackListReplaced    | Not implemented yet | :heavy_multiplication_x: |
| TrackAdded           | Not implemented yet | :heavy_multiplication_x: |
| TrackRemoved         | Not implemented yet | :heavy_multiplication_x: |
| TrackMetadataChanged | Not implemented yet | :heavy_multiplication_x: |

## Development

### Versioning

This library follows the semantic versioning concept.

### Commits

Commits should follow the conventional commit rules.  
See: https://conventionalcommits.org.

### Mocks

Mocks will be generated with `github.com/matryer/moq`. It can be installed with
`go install github.com/matryer/moq@latest`. Generation can be triggered with `go generate ./...`.

### Go Docs

Read the docs at https://pkg.go.dev/github.com/leberKleber/go-mpris

go-mpris

[![CI](https://github.com/go-music-theory/music-theory/actions/workflows/ci.yml/badge.svg)](https://github.com/go-music-theory/music-theory/actions/workflows/ci.yml) 
[![GoDoc](https://godoc.org/gopkg.in/music-theory.v0?status.svg)](https://godoc.org/gopkg.in/music-theory.v0) 
[![Go Report Card](https://goreportcard.com/badge/gopkg.in/music-theory.v0)](https://goreportcard.com/report/gopkg.in/music-theory.v0) 
[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

[Forge link](https://github.com/go-music-theory/music-theory) |
[pkg.go.dev](https://pkg.go.dev/github.com/go-music-theory/music-theory) |
[goreportcard.com](https://goreportcard.com/report/github.com/go-music-theory/music-theory) |
[Coverage](https://app.codecov.io/github/go-music-theory/music-theory)

## Music theory models in Go

There's an example command-line utility `music-theory.go` to demo the libraries, with a `bin/` wrapper.

To build and install `music-theory` to your machine:

    make install

Then, to calculate the note pitch classes for a specified **Chord**:

    $ music-theory chord "Cm nondominant -5 679"
    
    root: C
    tones:
      3: D#
      6: A
      7: A#
      9: D

To list the names of all the known chord-building rules:

    $ music-theory chords
    
    - Basic
    - Nondominant
    - Major Triad
    - Minor Triad
    - Augmented Triad
    - Diminished Triad
    - Suspended Triad
    - Omit Fifth
    - Flat Fifth
    - Add Sixth
    - Augmented Sixth
    - Omit Sixth
    - Add Seventh
    - Dominant Seventh
    - Major Seventh
    - Minor Seventh
    - Diminished Seventh
    - Half Diminished Seventh
    - Diminished Major Seventh
    - Augmented Major Seventh
    - Augmented Minor Seventh
    - Harmonic Seventh
    - Omit Seventh
    - Add Ninth
    - Dominant Ninth
    - Major Ninth
    - Minor Ninth
    - Sharp Ninth
    - Omit Ninth
    - Add Eleventh
    - Dominant Eleventh
    - Major Eleventh
    - Minor Eleventh
    - Omit Eleventh
    - Add Thirteenth
    - Dominant Thirteenth
    - Major Thirteenth
    - Minor Thirteenth

To calculate the note pitch classes for a specified **Scale**:

    $ music-theory scale "C aug"
    
    root: C
    tones:
      1: C
      2: D#
      3: E
      4: G
      5: G#
      6: B

To list the names of all the known scale-building rules:

    $ music-theory scales
    
    - Default (Major)
    - Minor
    - Major
    - Natural Minor
    - Diminished
    - Augmented
    - Melodic Minor Ascend
    - Melodic Minor Descend
    - Harmonic Minor
    - Ionian
    - Dorian
    - Phrygian
    - Lydian
    - Mixolydian
    - Aeolian
    - Locrian

To determine a key:

    $ music-theory key Db
    
    root: Db
    mode: Major
    relative:
      root: Bb
      mode: Minor

##### Credit

[Nick Charney Kaye](https://charneykaye.com)

[XJ Music](https://xj.io)

## [Note](note/)

A Note is used to represent the relative duration and pitch of a sound.

[![GoDoc](https://godoc.org/gopkg.in/music-theory.v0/note?status.svg)](https://godoc.org/gopkg.in/music-theory.v0/note) [![Coverage](https://raw.githubusercontent.com/wiki/go-music-theory/music-theory/coverage.svg)](https://raw.githack.com/wiki/go-music-theory/music-theory/coverage.html)

## [Key](key/)

The key of a piece is a group of pitches, or scale upon which a music composition is created in classical, Western art, and Western pop music.

[![GoDoc](https://godoc.org/gopkg.in/music-theory.v0/key?status.svg)](https://godoc.org/gopkg.in/music-theory.v0/key) [![Coverage](https://raw.githubusercontent.com/wiki/go-music-theory/music-theory/coverage.svg)](https://raw.githack.com/wiki/go-music-theory/music-theory/coverage.html)

## [Chord](chord/)

In music theory, a chord is any harmonic set of three or more notes that is heard as if sounding simultaneously.

[![GoDoc](https://godoc.org/gopkg.in/music-theory.v0/chord?status.svg)](https://godoc.org/gopkg.in/music-theory.v0/chord) [![Coverage](https://raw.githubusercontent.com/wiki/go-music-theory/music-theory/coverage.svg)](https://raw.githack.com/wiki/go-music-theory/music-theory/coverage.html)

## [Scale](scale/)

In music theory, a scale is any set of musical notes ordered by fundamental frequency or pitch.

[![GoDoc](https://godoc.org/gopkg.in/music-theory.v0/scale?status.svg)](https://godoc.org/gopkg.in/music-theory.v0/scale) [![Coverage](https://raw.githubusercontent.com/wiki/go-music-theory/music-theory/coverage.svg)](https://raw.githack.com/wiki/go-music-theory/music-theory/coverage.html)


music-theory

A simple library for playback and audio manipulation

# Beep

[![Go Reference](https://pkg.go.dev/badge/github.com/gopxl/beep/v2.svg)](https://pkg.go.dev/github.com/gopxl/beep/v2)
[![Go build status](https://github.com/gopxl/beep/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/gopxl/beep/actions/workflows/go.yml?query=branch%3Amain)
[![Coverage Status](https://coveralls.io/repos/github/gopxl/beep/badge.svg?branch=main)](https://coveralls.io/github/gopxl/beep?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/gopxl/beep/v2)](https://goreportcard.com/report/github.com/gopxl/beep/v2)
[![Discord Chat](https://img.shields.io/discord/1158461233121468496)](https://discord.gg/hPBTTXGDU3)


A little package that brings sound to any Go application. Suitable for playback and audio-processing.

```
go get -u github.com/gopxl/beep/v2
```

## Features

Beep is built on top of its [Streamer](https://godoc.org/github.com/gopxl/beep#Streamer) interface, which is like [io.Reader](https://golang.org/pkg/io/#Reader), but for audio. It was one of the best design decisions I've ever made and it enabled all the rest of the features to naturally come together with not much code.

- **Decode and play WAV, MP3, Ogg Vorbis, FLAC and MIDI.**
- **Encode and save WAV.**
- **Very simple API.** Limiting the support to stereo (two channel) audio made it possible to simplify the architecture and the API.
- **Rich library of compositors and effects.** Loop, pause/resume, change volume, mix, sequence, change playback speed, and more.
- **Easily create new effects.** With the `Streamer` interface, creating new effects is very easy.
- **Generate completely own artificial sounds.** Again, the `Streamer` interface enables easy sound generation.
- **Very small codebase.** The core is just ~1K LOC.

## Tutorial

The [Wiki](https://github.com/gopxl/beep/wiki) contains a handful of tutorials for you to get started. They teach the fundamentals and advanced topics alike. **Read them especially if you call `speaker.Init` every time you play something.**

- [Hello, Beep!](https://github.com/gopxl/beep/wiki/Hello,-Beep!)
- [Composing and controlling](https://github.com/gopxl/beep/wiki/Composing-and-controlling)
- [To buffer, or not to buffer, that is the question](https://github.com/gopxl/beep/wiki/To-buffer,-or-not-to-buffer,-that-is-the-question)
- [Making own streamers](https://github.com/gopxl/beep/wiki/Making-own-streamers)

## Examples

| [Speedy Player](https://github.com/gopxl/beep/tree/main/examples/speedy-player)                 | [Doppler Stereo Room](https://github.com/gopxl/beep/tree/main/examples/doppler-stereo-room)                 |
|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
| ![Speedy Player](https://github.com/gopxl/beep/blob/main/examples/speedy-player/screenshot.png) | ![Doppler Stereo Room](https://github.com/gopxl/beep/blob/main/examples/doppler-stereo-room/screenshot.png) |

## Dependencies

For playback, Beep uses [Oto](https://github.com/hajimehoshi/oto) under the hood. Check its requirements to see what you need to install for building your application.

Running an already built application should work with no extra dependencies.

## License

[MIT](https://github.com/gopxl/beep/blob/main/LICENSE)

## Related projects

- [Microphone support for Beep (a wrapper around PortAudio)](https://github.com/MarkKremer/microphone)

## Projects using Beep
- [retro](https://github.com/Malwarize/retro)
- [Mifasol music server](https://github.com/jypelle/mifasol)


beep

# libsamplerate binding for Golang
[![Go Report Card](https://goreportcard.com/badge/github.com/dh1tw/gosamplerate)](https://goreportcard.com/report/github.com/dh1tw/gosamplerate)
[![Cross Platform build](https://github.com/dh1tw/gosamplerate/actions/workflows/build.yml/badge.svg)](https://github.com/dh1tw/gosamplerate/actions/workflows/build.yml)
[![codecov](https://codecov.io/gh/dh1tw/gosamplerate/graph/badge.svg?token=5vIJOLA5hI)](https://codecov.io/gh/dh1tw/gosamplerate)

This is a [Golang](https://golang.org) binding for [libsamplerate](http://www.mega-nerd.com/SRC/index.html) (written in C), probably the best audio Sample Rate Converter available to today.

A classical use case is converting audio from a CD sample rate of 44.1kHz to the 48kHz sample rate used by DAT players.

libsamplerate is capable of arbitrary and time varying conversions (max sampling / upsampling by factor 256) and comes with 5 converters, allowing quality to be traded off against computation cost.

## API implementations
**gosamplerate** implements the following [libsamplerate](http://www.mega-nerd.com/SRC/index.html) API calls:

- [Simple API](http://www.mega-nerd.com/SRC/api_simple.html)
- [Full API](http://www.mega-nerd.com/SRC/api_full.html)
- [Most miscellaneous functions](http://www.mega-nerd.com/SRC/api_misc.html)

not (yet) implemented is:

- [Callback API](http://www.mega-nerd.com/SRC/api_callback.html)

## License
This library (**gosamplerate**) is published under the the permissive [BSD license](http://choosealicense.com/licenses/mit/). You can find a good comparison of Open Source Software licenses, including the BSD license at [choosealicense.com](http://choosealicense.com/licenses/)

libsamplerate has been [republished in 2016 under the 2-clause BSD license](http://www.mega-nerd.com/SRC/license.html).

## How to install samplerate

Make sure that you have [libsamplerate](http://www.mega-nerd.com/SRC/index.html) installed on your system.

On Mac or Linux it can be installed conveniently through your distro's packet manager.

### Linux:
using **apt** (Ubuntu), **yum** (Centos)...etc.
```bash
    $ sudo apt install libsamplerate0
```

### MacOS
using [Homebrew](http://brew.sh):
```bash
    $ brew install libsamplerate
```

### Install gosamplerate
```bash
    $ go get github.com/dh1tw/gosamplerate
```

## Documentation
The API of **gosamplerate** can be found at [godoc.org](https://godoc.org/github.com/dh1tw/gosamplerate).
The documentation of libsamplerate (necessary in order to fully understand the API) can be found
[here](http://www.mega-nerd.com/SRC/index.html).

## Tests & Examples
The test coverage is close to 100%. The tests contain various examples on how to use **gosamplerate**.

The Best Go Libraries For Audio and Music (12)