It generates images (no spectogram logic yet)

Author: slacki

.gitignore

@@ -13,3 +13,7 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+waveforms
+*.png
+*.wav

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${workspaceFolder}",
+            "env": {},
+            "args": []
+        }
+    ]
+}

README.md

@@ -1 +1,6 @@
-# waveforms
+# waveforms
+
+# Credits
+
+- https://github.com/xigh/go-wavreader
+- https://github.com/xigh/spectrogram

go.mod

@@ -0,0 +1,3 @@
+module github.com/slacki/waveforms
+
+go 1.14

main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"image/color"
+
+	"github.com/slacki/waveforms/spectogram"
+)
+
+func main() {
+	fmt.Println("start")
+
+	s, err := spectogram.NewSpectogram(&spectogram.Config{
+		BG0:    color.RGBA{33, 41, 201, 255},
+		Width:  300,
+		Height: 50,
+	}, "test.wav")
+	if err != nil {
+		panic(err)
+	}
+
+	img, err := s.Generate()
+	if err != nil {
+		panic(err)
+	}
+
+	img.ToPNG("./test.png")
+}

spectogram/image.go

@@ -0,0 +1,124 @@
+package spectogram
+
+import (
+	"bufio"
+	"image"
+	"image/color"
+	"image/png"
+	"os"
+)
+
+// Image128 implements image.Image interface and represents spectogram image
+// TODO: rename to Image (then outside this package it'd be spectogram.Image HOW COOL IS THAT?!?!!)
+type Image128 struct {
+	set    int
+	at     int
+	pix    []color.Color
+	bounds image.Rectangle
+}
+
+func (img *Image128) ColorModel() color.Model {
+	return color.RGBA64Model
+}
+
+func (img *Image128) Bounds() image.Rectangle {
+	return img.bounds
+}
+
+func (img *Image128) offset(x, y int) int {
+	p := image.Point{x, y}
+	if !p.In(img.bounds) {
+		return -1
+	}
+	stride := img.bounds.Dx()
+	my := img.bounds.Min.Y
+	mx := img.bounds.Min.X
+	ny := y - my
+	nx := x - mx
+	return ny*stride + nx
+}
+
+func (img *Image128) At(x int, y int) color.Color {
+	o := img.offset(x, y)
+	if o < 0 {
+		return color.RGBA{}
+	}
+	img.at++
+	return img.pix[o]
+}
+
+func (img *Image128) Set(x int, y int, c color.Color) {
+	o := img.offset(x, y)
+	if o < 0 {
+		return
+	}
+	img.set++
+	img.pix[o] = c
+}
+
+func (img *Image128) Stats() (int, int) {
+	return img.at, img.set
+}
+
+// ToPNG writes image to specified path in .png format.
+func (img *Image128) ToPNG(file string) error {
+	f, err := os.Create(file)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	wr := bufio.NewWriter(f)
+
+	err = png.Encode(wr, img)
+	if err != nil {
+		return err
+	}
+
+	return wr.Flush()
+}
+
+func NewImage128(bounds image.Rectangle) *Image128 {
+	dx := bounds.Dx()
+	dy := bounds.Dy()
+	sz := dx * dy
+	return &Image128{
+		pix:    make([]color.Color, sz),
+		bounds: bounds,
+	}
+}
+
+type SubImage128 struct {
+	img    *Image128
+	bounds image.Rectangle
+}
+
+func (sub *SubImage128) ColorModel() color.Model {
+	return sub.ColorModel()
+}
+
+func (sub *SubImage128) Bounds() image.Rectangle {
+	return image.Rectangle{
+		Min: image.Pt(0, 0),
+		Max: image.Pt(sub.bounds.Dx(), sub.bounds.Dy()),
+	}
+}
+
+func (sub *SubImage128) At(x int, y int) color.Color {
+	mx := sub.bounds.Min.X
+	my := sub.bounds.Min.Y
+	return sub.img.At(x+mx, y+my)
+}
+
+func (sub *SubImage128) Set(x int, y int, c color.Color) {
+	mx := sub.bounds.Min.X
+	my := sub.bounds.Min.Y
+	sub.img.Set(x+mx, y+my, c)
+}
+
+func (img *Image128) Sub(bounds image.Rectangle) *SubImage128 {
+	return &SubImage128{
+		img:    img,
+		bounds: bounds,
+	}
+}

spectogram/spectogram.go

@@ -0,0 +1,114 @@
+package spectogram
+
+import (
+	"image"
+	"image/color"
+	"image/draw"
+	"os"
+
+	"github.com/slacki/waveforms/wavreader"
+)
+
+// Config is a set of options for Spectogram
+type Config struct {
+	// TODO: ?
+	Ratio float64
+
+	Width  uint
+	Height uint
+	// TODO: ?
+	Bins uint
+	// TODO: wtf, even square is rectangle after all?
+	Rectangle bool
+
+	// TODO: no idea, but probably used when actually generating spect
+	HideAverage bool
+	// TODO: also tbd
+	HideRulers bool
+
+	// TODO: poke around with this setting and check out what does it mean
+	PreEmphasis float64
+
+	// TODO: the followint 3 options don't make any sense for me yet
+	DFT   bool
+	LOG10 bool
+	MAG   bool
+
+	BG0, BG1, FG0, FG1 color.Color
+	RulerColor         color.Color
+}
+
+// Spectogram represents a spectogram to be generated
+type Spectogram struct {
+	Config  *Config
+	samples []float64
+	File    string
+}
+
+// NewSpectogram creates new Spectogram instance and configures it with Config
+func NewSpectogram(c *Config, file string) (*Spectogram, error) {
+	if c.PreEmphasis == 0 {
+		c.PreEmphasis = 0.95
+	}
+
+	s := &Spectogram{
+		Config: c,
+		File:   file,
+	}
+
+	err := s.sampleWav()
+	if err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}
+
+func (s *Spectogram) sampleWav() error {
+	file, err := os.Open(s.File)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	wr, err := wavreader.New(file)
+	if err != nil {
+		return err
+	}
+
+	length := wr.Len()
+	s.samples = make([]float64, length)
+	for i := uint64(0); i < length; i++ {
+		samp, err := wr.At(0, i)
+		if err != nil {
+			return err
+		}
+		s.samples[i] = float64(samp)
+	}
+
+	return nil
+}
+
+func (s *Spectogram) preEmphasis() {
+	for i := len(s.samples) - 1; i > 0; i-- {
+		s.samples[i] = s.samples[i] - s.Config.PreEmphasis*s.samples[i-1]
+	}
+}
+
+func (s *Spectogram) imageBounds() image.Rectangle {
+	w := int(s.Config.Width)
+	h := int(s.Config.Height)
+	b := int(s.Config.Bins)
+
+	return image.Rect(-20, -20, w+20, h+40+b)
+}
+
+// Generate generates a spectogram
+func (s *Spectogram) Generate() (*Image128, error) {
+	s.preEmphasis()
+
+	img := NewImage128(s.imageBounds())
+	draw.Draw(img, img.Bounds(), image.NewUniform(s.Config.BG0), image.ZP, draw.Src)
+
+	return img, nil
+}

wavreader/binary.go

@@ -0,0 +1,81 @@
+package wavreader
+
+import (
+	"fmt"
+	"io"
+)
+
+func readU8(r io.ReaderAt, off int64) (uint8, error) {
+	b := make([]byte, 1)
+	n, err := r.ReadAt(b, off)
+	if err != nil {
+		return 0, err
+	}
+	if n != 1 {
+		return 0, fmt.Errorf("could not read byte at %v", err)
+	}
+	return b[0], nil
+}
+
+func readU16(r io.ReaderAt, off int64) (uint16, error) {
+	b := make([]byte, 2)
+	n, err := r.ReadAt(b, off)
+	if err != nil {
+		return 0, err
+	}
+	if n != 2 {
+		return 0, fmt.Errorf("could not read byte at %v", err)
+	}
+	return uint16(b[0]) | uint16(b[1])<<8, nil
+}
+
+func readS16(r io.ReaderAt, off int64) (int16, error) {
+	u16, err := readU16(r, off)
+	if err != nil {
+		return 0, err
+	}
+	return int16(u16), nil
+}
+
+func readU32(r io.ReaderAt, off int64) (uint32, error) {
+	b := make([]byte, 4)
+	n, err := r.ReadAt(b, off)
+	if err != nil {
+		return 0, err
+	}
+	if n != 4 {
+		return 0, fmt.Errorf("could not read byte at %v", err)
+	}
+	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, nil
+}
+
+func readS32(r io.ReaderAt, off int64) (int32, error) {
+	u32, err := readU32(r, off)
+	if err != nil {
+		return 0, err
+	}
+	return int32(u32), nil
+}
+
+func readU64(r io.ReaderAt, off int64) (uint64, error) {
+	b := make([]byte, 8)
+	n, err := r.ReadAt(b, off)
+	if err != nil {
+		return 0, err
+	}
+	if n != 8 {
+		return 0, fmt.Errorf("could not read byte at %v", err)
+	}
+	return uint64(b[0]) | uint64(b[1])<<8 |
+		uint64(b[2])<<16 | uint64(b[3])<<24 |
+		uint64(b[2])<<32 | uint64(b[3])<<40 |
+		uint64(b[2])<<48 | uint64(b[3])<<56, nil
+}
+
+func readS64(r io.ReaderAt, off int64) (int64, error) {
+	u64, err := readU64(r, off)
+	if err != nil {
+		return 0, err
+	}
+	return int64(u64), nil
+}