Audio Streaming from OS

I would like to interface with the output of my computer's audio and generate a visualization of that audio with fft's.

My question is "Where do I get the audio output stream of my computer? Are there any useful libraries for this purpose?" All the examples I've looked at stream from files, which isn't very useful to me.

I'm hoping to work in golang and linux.

Have a look at the "Graphics and Audio" and "Audio" sections of http://go-lang.cat-v.org/library-bindings.

Especially the bindings to PortAudio (http://code.google.com/p/portaudio-go/) and PulseAudio (https://github.com/moriyoshi/pulsego/) could be of use to you, being a linux guy.

For playing back sound with golang you can use beep: http://github.com/faiface/beep , see the tutorial:

package main

import (
	"log"
	"os"
	"time"

	"github.com/faiface/beep"
	"github.com/faiface/beep/mp3"
	"github.com/faiface/beep/speaker"
)

func main() {
	f, err := os.Open("../Lame_Drivers_-_01_-_Frozen_Egg.mp3")
	if err != nil {
		log.Fatal(err)
	}

	streamer, format, err := mp3.Decode(f)
	if err != nil {
		log.Fatal(err)
	}
	defer streamer.Close()

	speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10))

	done := make(chan bool)
	speaker.Play(beep.Seq(streamer, beep.Callback(func() {
		done <- true
	})))

	<-done
}

For recording your computers audio (microphone), you could try this tutorial: https://medium.com/@valentijnnieman_79984/how-to-build-an-audio-streaming-server-in-go-part-1-1676eed93021 that uses the PortAudio bindings:

package main
import (
 "encoding/binary"
 "github.com/gordonklaus/portaudio"
 "net/http"
)

const sampleRate = 44100
const seconds = 1

func main() {
 portaudio.Initialize()
 defer portaudio.Terminate()
 buffer := make([]float32, sampleRate * seconds)
 stream, err := portaudio.OpenDefaultStream(1, 0, sampleRate,   len(buffer), func(in []float32) {
  for i := range buffer {
   buffer[i] = in[i]
  }
 })

 if err != nil {
   panic(err)
 }

 stream.Start()
 defer stream.Close()
}

I know this is from a while ago, but if anyone else is wondering the same, I've been working on: https://github.com/padster/go-sound

Sounds are modelled as channels of float samples (44.1khz, each sample in the range [-1, 1]), and you can process them, or e.g. play to speakers (currently via pulsego), write them to file or display on screen using openGL.

There's also some experimental FFT code (Constant Q, which is similar)