From 23bc58614cb64da0fd8935340629015b17146449 Mon Sep 17 00:00:00 2001
From: Gordon Klaus <gordon.klaus@gmail.com>
Date: Wed, 29 Mar 2017 10:45:46 +0200
Subject: [PATCH] Add support for sending and receiving audio, and all that
 entails.

---
 audiotrack.cc             |  88 +++++++++++++++++++++++
 audiotrack.go             | 142 ++++++++++++++++++++++++++++++++++++++
 audiotrack.h              |  30 ++++++++
 demo/beep/beep.go         | 138 ++++++++++++++++++++++++++++++++++++
 demo/beep/beep.html       |  11 +++
 demo/beep/beep.js         |  53 ++++++++++++++
 demo/echo/echo.go         | 124 +++++++++++++++++++++++++++++++++
 demo/echo/echo.html       |  11 +++
 demo/echo/echo.js         |  57 +++++++++++++++
 eventlistener.cc          |  35 ++++++++++
 eventlistener.go          |  34 +++++++++
 eventlistener.h           |  25 +++++++
 fauxaudiodevicemodule.cc  |  22 ++++++
 fauxaudiodevicemodule.hpp |  33 +++++++++
 mediastream.cc            |  17 +++++
 mediastream.go            |  50 ++++++++++++++
 mediastream.h             |  25 +++++++
 mediastreamtrack.cc       |  23 ++++++
 mediastreamtrack.go       |  64 +++++++++++++++++
 mediastreamtrack.h        |  27 ++++++++
 peerconnection.cc         |  48 ++++++++++---
 peerconnection.go         |  56 +++++++++++++++
 peerconnection.h          |  13 ++++
 refptr.cc                 |   7 ++
 refptr.go                 |  27 ++++++++
 refptr.h                  |  20 ++++++
 rtpreceiver.cc            |   9 +++
 rtpreceiver.go            |  29 ++++++++
 rtpreceiver.h             |  26 +++++++
 rtpsender.cc              |   9 +++
 rtpsender.go              |  29 ++++++++
 rtpsender.h               |  26 +++++++
 32 files changed, 1298 insertions(+), 10 deletions(-)
 create mode 100644 audiotrack.cc
 create mode 100644 audiotrack.go
 create mode 100644 audiotrack.h
 create mode 100644 demo/beep/beep.go
 create mode 100644 demo/beep/beep.html
 create mode 100644 demo/beep/beep.js
 create mode 100644 demo/echo/echo.go
 create mode 100644 demo/echo/echo.html
 create mode 100644 demo/echo/echo.js
 create mode 100644 eventlistener.cc
 create mode 100644 eventlistener.go
 create mode 100644 eventlistener.h
 create mode 100644 fauxaudiodevicemodule.cc
 create mode 100644 fauxaudiodevicemodule.hpp
 create mode 100644 mediastream.cc
 create mode 100644 mediastream.go
 create mode 100644 mediastream.h
 create mode 100644 mediastreamtrack.cc
 create mode 100644 mediastreamtrack.go
 create mode 100644 mediastreamtrack.h
 create mode 100644 refptr.cc
 create mode 100644 refptr.go
 create mode 100644 refptr.h
 create mode 100644 rtpreceiver.cc
 create mode 100644 rtpreceiver.go
 create mode 100644 rtpreceiver.h
 create mode 100644 rtpsender.cc
 create mode 100644 rtpsender.go
 create mode 100644 rtpsender.h

diff --git a/audiotrack.cc b/audiotrack.cc
new file mode 100644
index 0000000..021220f
--- /dev/null
+++ b/audiotrack.cc
@@ -0,0 +1,88 @@
+#include <_cgo_export.h>  // Allow calling certain Go functions.
+
+#include "audiotrack.h"
+
+#include "webrtc/api/mediastreaminterface.h"
+#include "webrtc/pc/mediastreamtrack.h"
+
+using namespace webrtc;
+
+class AudioTrack : public MediaStreamTrack<AudioTrackInterface> {
+ public:
+  explicit AudioTrack(std::string label, CGO_GoAudioSource source)
+    : MediaStreamTrack<AudioTrackInterface>(label)
+    , source(source) {}
+
+  virtual std::string kind() const override {
+    return kAudioKind;
+  }
+
+  virtual AudioSourceInterface* GetSource() const override {
+    return nullptr;
+  }
+
+  virtual void AddSink(AudioTrackSinkInterface* sink) override {
+    cgoAudioSourceAddSink(source, (CGO_AudioSink)sink);
+  }
+  virtual void RemoveSink(AudioTrackSinkInterface* sink) override {
+    cgoAudioSourceRemoveSink(source, (CGO_AudioSink)sink);
+  }
+
+  virtual bool GetSignalLevel(int* level) override { return false; }
+
+  virtual rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
+    return nullptr;
+  }
+
+protected:
+  ~AudioTrack() {
+    cgoAudioSourceDestruct(source);
+  }
+
+private:
+  CGO_GoAudioSource source;
+};
+
+CGO_AudioTrack CGO_NewAudioTrack(const char* label, CGO_GoAudioSource source) {
+  return new rtc::RefCountedObject<AudioTrack>(label, source);
+}
+
+class AudioSink : public AudioTrackSinkInterface {
+public:
+	explicit AudioSink(CGO_GoAudioSink s) : s(s) {}
+
+	virtual void OnData(const void* audio_data,
+		                int bits_per_sample,
+		                int sample_rate,
+		                size_t number_of_channels,
+		                size_t number_of_frames) {
+		cgoAudioSinkOnData(
+			s,
+			(void*)audio_data,
+			bits_per_sample,
+			sample_rate,
+			(int)number_of_channels,
+			(int)number_of_frames
+		);
+	}
+
+	CGO_GoAudioSink s;
+};
+
+void CGO_AudioSinkOnData(CGO_AudioSink s, void* data, int bitsPerSample, int sampleRate, int numberOfChannels, int numberOfFrames) {
+	((AudioTrackSinkInterface*)s)->OnData(data, bitsPerSample, sampleRate, (size_t)numberOfChannels, (size_t)numberOfFrames);
+}
+
+CGO_AudioSink CGO_AudioTrack_AddSink(CGO_AudioTrack t, CGO_GoAudioSink gs) {
+  auto s = new AudioSink(gs);
+  ((AudioTrackInterface*)t)->AddSink(s);
+  return s;
+}
+
+CGO_GoAudioSink CGO_AudioTrack_RemoveSink(CGO_AudioTrack t, CGO_AudioSink cs) {
+  auto s = (AudioSink*)cs;
+  ((AudioTrackInterface*)t)->RemoveSink(s);
+  auto gs = s->s;
+  delete s;
+  return gs;
+}
diff --git a/audiotrack.go b/audiotrack.go
new file mode 100644
index 0000000..f85afd8
--- /dev/null
+++ b/audiotrack.go
@@ -0,0 +1,142 @@
+package webrtc
+
+/*
+#include "mediastreamtrack.h"
+#include "audiotrack.h"
+*/
+import "C"
+import (
+	"math"
+	"reflect"
+	"sync"
+	"unsafe"
+)
+
+/*
+An AudioTrack can be obtained via NewAudioTrack (a local track) or via
+PeerConnection.OnAddTrack (a remote track).  Audio samples are provided or
+retrieved, respectively, via an AudioSource or AudioSink.
+*/
+type AudioTrack struct {
+	*mediaStreamTrack
+	t C.CGO_AudioTrack
+}
+
+func newAudioTrack(t C.CGO_AudioTrack) *AudioTrack {
+	return &AudioTrack{
+		mediaStreamTrack: newMediaStreamTrack(C.CGO_MediaStreamTrack(t)),
+		t:                t,
+	}
+}
+
+// NewAudioTrack creates a local audio track.
+func NewAudioTrack(label string, source AudioSource) *AudioTrack {
+	t := C.CGO_NewAudioTrack(C.CString(label), C.CGO_GoAudioSource(audioSources.Set(source)))
+	return newAudioTrack(t)
+}
+
+func (t *AudioTrack) AddSink(s AudioSink) {
+	cAudioSinksMu.Lock()
+	defer cAudioSinksMu.Unlock()
+
+	if _, ok := cAudioSinks[s]; ok {
+		panic("AudioSink already added")
+	}
+	csink := C.CGO_AudioTrack_AddSink(t.t, C.CGO_GoAudioSink(audioSinks.Set(s)))
+	cAudioSinks[s] = csink
+}
+
+func (t *AudioTrack) RemoveSink(s AudioSink) {
+	cAudioSinksMu.Lock()
+	defer cAudioSinksMu.Unlock()
+
+	if csink, ok := cAudioSinks[s]; ok {
+		audioSinks.Delete(int(C.CGO_AudioTrack_RemoveSink(t.t, csink)))
+		delete(cAudioSinks, s)
+	}
+}
+
+var (
+	audioSources = NewCGOMap()
+	audioSinks   = NewCGOMap()
+
+	cAudioSinksMu sync.Mutex
+	cAudioSinks   = map[AudioSink]C.CGO_AudioSink{}
+)
+
+// An AudioSource pushes audio to the AudioSinks that are added to it.
+type AudioSource interface {
+	AddAudioSink(AudioSink)
+	RemoveAudioSink(AudioSink)
+}
+
+// An AudioSink receives audio, typically from an AudioSource.
+type AudioSink interface {
+	/*
+		OnAudioData is called when new audio data is available.
+		len(data) == numberOfChannels; len(data[i]) is the same for all i.
+	*/
+	OnAudioData(data [][]float64, sampleRate float64)
+}
+
+//export cgoAudioSourceAddSink
+func cgoAudioSourceAddSink(source C.CGO_GoAudioSource, sink C.CGO_AudioSink) {
+	audioSources.Get(int(source)).(AudioSource).AddAudioSink(cAudioSink{sink})
+}
+
+//export cgoAudioSourceRemoveSink
+func cgoAudioSourceRemoveSink(source C.CGO_GoAudioSource, sink C.CGO_AudioSink) {
+	audioSources.Get(int(source)).(AudioSource).RemoveAudioSink(cAudioSink{sink})
+}
+
+//export cgoAudioSourceDestruct
+func cgoAudioSourceDestruct(source C.CGO_GoAudioSource) {
+	audioSources.Delete(int(source))
+}
+
+type cAudioSink struct {
+	s C.CGO_AudioSink
+}
+
+func (s cAudioSink) OnAudioData(data [][]float64, sampleRate float64) {
+	bitsPerSample := 16
+	numberOfChannels := len(data)
+	numberOfFrames := len(data[0])
+	buf := make([]int16, numberOfChannels*numberOfFrames*bitsPerSample/2)
+	i := 0
+	for j := range data[0] {
+		for _, ch := range data {
+			buf[i] = int16(ch[j] * float64(math.MaxInt16))
+			i++
+		}
+	}
+	C.CGO_AudioSinkOnData(s.s, unsafe.Pointer(&buf[0]), C.int(bitsPerSample), C.int(sampleRate), C.int(numberOfChannels), C.int(numberOfFrames))
+}
+
+//export cgoAudioSinkOnData
+func cgoAudioSinkOnData(s C.CGO_GoAudioSink, audioData unsafe.Pointer, bitsPerSample, sampleRate, numberOfChannels, numberOfFrames int) {
+	if bitsPerSample != 16 {
+		panic("expected 16 bits per sample")
+	}
+
+	var buf []int16
+	sh := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	sh.Data = uintptr(audioData)
+	sh.Len = numberOfChannels * numberOfFrames
+	sh.Cap = sh.Len
+
+	data := make([][]float64, numberOfChannels)
+	for i := range data {
+		data[i] = make([]float64, numberOfFrames)
+	}
+
+	i := 0
+	for j := range data[0] {
+		for _, ch := range data {
+			ch[j] = float64(buf[i]) / float64(math.MaxInt16)
+			i++
+		}
+	}
+
+	audioSinks.Get(int(s)).(AudioSink).OnAudioData(data, float64(sampleRate))
+}
diff --git a/audiotrack.h b/audiotrack.h
new file mode 100644
index 0000000..050fa33
--- /dev/null
+++ b/audiotrack.h
@@ -0,0 +1,30 @@
+#ifndef _C_AUDIOTRACK_H
+#define _C_AUDIOTRACK_H
+
+#define WEBRTC_POSIX 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_AudioTrack; // webrtc::AudioTrackInterface*
+  typedef int CGO_GoAudioSource; // key into Go audioSourceMap
+  typedef int CGO_GoAudioSink; // key into Go audioSinkMap
+  typedef void* CGO_AudioSink; // webrtc::AudioTrackSinkInterface
+
+  CGO_AudioTrack CGO_NewAudioTrack(const char* label, CGO_GoAudioSource source);
+
+  void CGO_AudioSinkOnData(CGO_AudioSink s, void* data, int bitsPerSample, int sampleRate, int numberOfChannels, int numberOfFrames);
+
+  CGO_AudioSink CGO_AudioTrack_AddSink(CGO_AudioTrack, CGO_GoAudioSink);
+  CGO_GoAudioSink CGO_AudioTrack_RemoveSink(CGO_AudioTrack, CGO_AudioSink);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_AUDIOTRACK_H
diff --git a/demo/beep/beep.go b/demo/beep/beep.go
new file mode 100644
index 0000000..95b6cec
--- /dev/null
+++ b/demo/beep/beep.go
@@ -0,0 +1,138 @@
+/*
+WebRTC audio bee demo server.
+See beep.html for the client.
+
+To use, `go run beep.go`, then open beep.html in a browser.
+This server will send a tone to the browser, which will play it.
+*/
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/keroserene/go-webrtc"
+	"golang.org/x/net/websocket"
+)
+
+func main() {
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	webrtc.SetLoggingVerbosity(1)
+
+	http.Handle("/ws", websocket.Handler(handleWebSocket))
+	log.Fatal(http.ListenAndServe(":49372", nil))
+}
+
+func handleWebSocket(ws *websocket.Conn) {
+	pc, err := webrtc.NewPeerConnection(webrtc.NewConfiguration())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	beep := &beep{}
+	pc.AddTrack(webrtc.NewAudioTrack("beep-audio", beep), nil)
+	go beep.run()
+
+	pc.OnIceCandidate = func(c webrtc.IceCandidate) {
+		if err := websocket.JSON.Send(ws, c); err != nil {
+			log.Println(err)
+			return
+		}
+	}
+
+	for {
+		var msg struct {
+			Type string
+			Body json.RawMessage
+		}
+		if err := websocket.JSON.Receive(ws, &msg); err != nil {
+			if err != io.EOF {
+				log.Println(err)
+			}
+			return
+		}
+
+		switch msg.Type {
+		case "offer":
+			offer := webrtc.DeserializeSessionDescription(string(msg.Body))
+			if err := pc.SetRemoteDescription(offer); err != nil {
+				log.Println(err)
+				return
+			}
+			answer, err := pc.CreateAnswer()
+			if err != nil {
+				log.Println(err)
+				return
+			}
+			if err := pc.SetLocalDescription(answer); err != nil {
+				log.Println(err)
+				return
+			}
+			if err := websocket.JSON.Send(ws, answer); err != nil {
+				log.Println(err)
+				return
+			}
+		case "icecandidate":
+			c := webrtc.DeserializeIceCandidate(string(msg.Body))
+			if err := pc.AddIceCandidate(*c); err != nil {
+				log.Println(err)
+			}
+		default:
+			log.Println("unexpected message type:", msg.Type)
+		}
+	}
+}
+
+type beep struct {
+	sync.Mutex
+	sinks []webrtc.AudioSink
+}
+
+func (b *beep) AddAudioSink(s webrtc.AudioSink) {
+	b.Lock()
+	b.sinks = append(b.sinks, s)
+	b.Unlock()
+}
+
+func (b *beep) RemoveAudioSink(s webrtc.AudioSink) {
+	b.Lock()
+	defer b.Unlock()
+	for i, s2 := range b.sinks {
+		if s2 == s {
+			b.sinks = append(b.sinks[:i], b.sinks[i+1:]...)
+		}
+	}
+}
+
+func (b *beep) run() {
+	const (
+		sampleRate     = 48000
+		chunkRate      = 100
+		numberOfFrames = sampleRate / chunkRate
+		toneFrequency  = 256
+	)
+	data := [][]float64{make([]float64, numberOfFrames)}
+	count := 0
+	x := 0.04
+	for next := time.Now(); ; next = next.Add(time.Second / chunkRate) {
+		time.Sleep(next.Sub(time.Now()))
+
+		for i := range data[0] {
+			if count%(sampleRate/toneFrequency/2) == 0 {
+				x = -x
+			}
+			data[0][i] = x
+			count++
+		}
+
+		b.Lock()
+		for _, sink := range b.sinks {
+			sink.OnAudioData(data, sampleRate)
+		}
+		b.Unlock()
+	}
+}
diff --git a/demo/beep/beep.html b/demo/beep/beep.html
new file mode 100644
index 0000000..11d1540
--- /dev/null
+++ b/demo/beep/beep.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html>
+<head>
+  <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+  <script src="beep.js"></script>
+</head>
+<body>
+  <h1>go-webrtc audio beep demo</h1>
+  <audio id="audio" autoplay />
+</body>
+</html>
diff --git a/demo/beep/beep.js b/demo/beep/beep.js
new file mode 100644
index 0000000..75a3b7a
--- /dev/null
+++ b/demo/beep/beep.js
@@ -0,0 +1,53 @@
+// WebRTC audio echo client
+// See echo.go for the server.
+
+// Chrome / Firefox compatibility
+window.RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
+
+var ws;
+var pc;
+
+window.onload = () => {
+	openWebSocket()
+	.then(() => {
+		pc = new window.RTCPeerConnection();
+		pc.onaddstream = evt => {
+			console.info("onaddstream", evt.stream);
+			document.getElementById('audio').srcObject = evt.stream;
+		};
+		pc.onicecandidate = evt => {
+			if (evt.candidate) {
+				ws.send(JSON.stringify({type: "icecandidate", body: evt.candidate}));
+			}
+		};
+		return pc.createOffer({offerToReceiveAudio: true})
+		.then(offer => {
+			ws.send(JSON.stringify({type: "offer", body: offer}));
+			return pc.setLocalDescription(offer);
+		});
+	})
+	.catch(err => console.error('unhandled error:', err));
+}
+
+function openWebSocket() {
+	return new Promise((resolve, reject) => {
+		ws = new WebSocket('ws://localhost:49372/ws');
+		ws.onopen = () => {
+			console.info("WS OPENED");
+			resolve();
+		};
+		ws.onerror = err => {
+			console.error('websocket error:', err);
+			reject();
+		};
+		ws.onmessage = evt => {
+			let msg = JSON.parse(evt.data);
+			if (msg.sdp) {
+				pc.setRemoteDescription(msg);
+			} else {
+				pc.addIceCandidate(msg);
+			}
+		};
+		ws.onclose = () => console.info("WS CLOSED");
+	});
+}
diff --git a/demo/echo/echo.go b/demo/echo/echo.go
new file mode 100644
index 0000000..b2d28da
--- /dev/null
+++ b/demo/echo/echo.go
@@ -0,0 +1,124 @@
+/*
+WebRTC audio echo demo server.
+See echo.html for the client.
+
+To use, `go run echo.go`, then open echo.html in a browser.
+You may want to wear headphones or turn your volume low,
+because there will be some audio feedback (much of which should
+be removed by echo cancellation).
+*/
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"sync"
+
+	"github.com/keroserene/go-webrtc"
+	"golang.org/x/net/websocket"
+)
+
+func main() {
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	webrtc.SetLoggingVerbosity(1)
+
+	http.Handle("/ws", websocket.Handler(handleWebSocket))
+	log.Fatal(http.ListenAndServe(":49372", nil))
+}
+
+func handleWebSocket(ws *websocket.Conn) {
+	pc, err := webrtc.NewPeerConnection(webrtc.NewConfiguration())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	pc.OnIceCandidate = func(c webrtc.IceCandidate) {
+		if err := websocket.JSON.Send(ws, c); err != nil {
+			log.Println(err)
+			return
+		}
+	}
+
+	pc.OnAddTrack = func(r *webrtc.RtpReceiver, s []*webrtc.MediaStream) {
+		echo := &echo{}
+		r.Track().(*webrtc.AudioTrack).AddSink(echo)
+		pc.AddTrack(webrtc.NewAudioTrack("audio-echo", echo), nil)
+
+		// A much simpler way to echo audio (but less useful
+		// for demonstrative purposes) is to just:
+		// pc.AddTrack(r.Track(), s)
+	}
+
+	for {
+		var msg struct {
+			Type string
+			Body json.RawMessage
+		}
+		if err := websocket.JSON.Receive(ws, &msg); err != nil {
+			if err != io.EOF {
+				log.Println(err)
+			}
+			return
+		}
+
+		switch msg.Type {
+		case "offer":
+			offer := webrtc.DeserializeSessionDescription(string(msg.Body))
+			if err := pc.SetRemoteDescription(offer); err != nil {
+				log.Println(err)
+				return
+			}
+			answer, err := pc.CreateAnswer()
+			if err != nil {
+				log.Println(err)
+				return
+			}
+			if err := pc.SetLocalDescription(answer); err != nil {
+				log.Println(err)
+				return
+			}
+			if err := websocket.JSON.Send(ws, answer); err != nil {
+				log.Println(err)
+				return
+			}
+		case "icecandidate":
+			c := webrtc.DeserializeIceCandidate(string(msg.Body))
+			if err := pc.AddIceCandidate(*c); err != nil {
+				log.Println(err)
+			}
+		default:
+			log.Println("unexpected message type:", msg.Type)
+		}
+	}
+}
+
+type echo struct {
+	sync.Mutex
+	sinks []webrtc.AudioSink
+}
+
+func (e *echo) AddAudioSink(s webrtc.AudioSink) {
+	e.Lock()
+	defer e.Unlock()
+	e.sinks = append(e.sinks, s)
+}
+
+func (e *echo) RemoveAudioSink(s webrtc.AudioSink) {
+	e.Lock()
+	defer e.Unlock()
+	for i, s2 := range e.sinks {
+		if s2 == s {
+			e.sinks = append(e.sinks[:i], e.sinks[i+1:]...)
+		}
+	}
+}
+
+func (e *echo) OnAudioData(data [][]float64, sampleRate float64) {
+	e.Lock()
+	defer e.Unlock()
+	for _, s := range e.sinks {
+		s.OnAudioData(data, sampleRate)
+	}
+}
diff --git a/demo/echo/echo.html b/demo/echo/echo.html
new file mode 100644
index 0000000..62921bb
--- /dev/null
+++ b/demo/echo/echo.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html>
+<head>
+  <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+  <script src="echo.js"></script>
+</head>
+<body>
+  <h1>go-webrtc audio echo demo</h1>
+  <audio id="audio" autoplay />
+</body>
+</html>
diff --git a/demo/echo/echo.js b/demo/echo/echo.js
new file mode 100644
index 0000000..871f7d9
--- /dev/null
+++ b/demo/echo/echo.js
@@ -0,0 +1,57 @@
+// WebRTC audio echo client
+// See echo.go for the server.
+
+// Chrome / Firefox compatibility
+window.RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
+
+var ws;
+var stream;
+var pc;
+
+window.onload = () => {
+	navigator.mediaDevices.getUserMedia({audio: true})
+	.then(s => stream = s)
+	.then(() => openWebSocket())
+	.then(() => {
+		pc = new window.RTCPeerConnection();
+		pc.addStream(stream);
+		pc.onaddstream = evt => {
+			console.info("onaddstream", evt.stream);
+			document.getElementById('audio').srcObject = evt.stream;
+		};
+		pc.onicecandidate = evt => {
+			if (evt.candidate) {
+				ws.send(JSON.stringify({type: "icecandidate", body: evt.candidate}));
+			}
+		};
+		return pc.createOffer()
+		.then(offer => {
+			ws.send(JSON.stringify({type: "offer", body: offer}));
+			return pc.setLocalDescription(offer);
+		});
+	})
+	.catch(err => console.error('unhandled error:', err));
+}
+
+function openWebSocket() {
+	return new Promise((resolve, reject) => {
+		ws = new WebSocket('ws://localhost:49372/ws');
+		ws.onopen = () => {
+			console.info("WS OPENED");
+			resolve();
+		};
+		ws.onerror = err => {
+			console.error('websocket error:', err);
+			reject();
+		};
+		ws.onmessage = evt => {
+			let msg = JSON.parse(evt.data);
+			if (msg.sdp) {
+				pc.setRemoteDescription(msg);
+			} else {
+				pc.addIceCandidate(msg);
+			}
+		};
+		ws.onclose = () => console.info("WS CLOSED");
+	});
+}
diff --git a/eventlistener.cc b/eventlistener.cc
new file mode 100644
index 0000000..3d3109c
--- /dev/null
+++ b/eventlistener.cc
@@ -0,0 +1,35 @@
+#include <_cgo_export.h>  // Allow calling certain Go functions.
+
+#include "eventlistener.h"
+
+#include "webrtc/api/mediastreaminterface.h"
+
+using namespace webrtc;
+
+class Observer : public ObserverInterface {
+public:
+  Observer(NotifierInterface* n, CGO_EventCallback c)
+    : n(n), c(c) {
+    n->RegisterObserver(this);
+  }
+
+  ~Observer() {
+    n->UnregisterObserver(this);
+  }
+
+  void OnChanged() override {
+    cgoObserverOnChanged(c);
+  }
+
+private:
+  NotifierInterface* n;
+  CGO_EventCallback c;
+};
+
+CGO_Observer CGO_NewObserver(CGO_Notifier n, CGO_EventCallback c) {
+  return new Observer((NotifierInterface*)n, c);
+}
+
+void CGO_DeleteObserver(CGO_Observer o) {
+  delete (Observer*)o;
+}
diff --git a/eventlistener.go b/eventlistener.go
new file mode 100644
index 0000000..7ae1eae
--- /dev/null
+++ b/eventlistener.go
@@ -0,0 +1,34 @@
+package webrtc
+
+/*
+#include "eventlistener.h"
+*/
+import "C"
+
+type EventListener struct {
+	o C.CGO_Observer
+	c int
+}
+
+func newEventListener(n C.CGO_Notifier, f func()) *EventListener {
+	c := eventCallbacks.Set(f)
+	return &EventListener{
+		o: C.CGO_NewObserver(n, C.CGO_EventCallback(c)),
+		c: c,
+	}
+}
+
+var eventCallbacks = NewCGOMap()
+
+func (e *EventListener) Cancel() {
+	if e.o != nil {
+		C.CGO_DeleteObserver(e.o)
+		e.o = nil
+		eventCallbacks.Delete(e.c)
+	}
+}
+
+//export cgoObserverOnChanged
+func cgoObserverOnChanged(l C.CGO_EventCallback) {
+	eventCallbacks.Get(int(l)).(func())()
+}
diff --git a/eventlistener.h b/eventlistener.h
new file mode 100644
index 0000000..1f96190
--- /dev/null
+++ b/eventlistener.h
@@ -0,0 +1,25 @@
+#ifndef _C_EVENTLISTENER_H
+#define _C_EVENTLISTENER_H
+
+#define WEBRTC_POSIX 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_Notifier; // webrtc::NotifierInterface*
+  typedef void* CGO_Observer; // webrtc::ObserverInterface*
+  typedef int CGO_EventCallback; // key into Go eventCallbacks
+
+  CGO_Observer CGO_NewObserver(CGO_Notifier, CGO_EventCallback);
+  void CGO_DeleteObserver(CGO_Observer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_EVENTLISTENER_H
diff --git a/fauxaudiodevicemodule.cc b/fauxaudiodevicemodule.cc
new file mode 100644
index 0000000..80da87b
--- /dev/null
+++ b/fauxaudiodevicemodule.cc
@@ -0,0 +1,22 @@
+#include "fauxaudiodevicemodule.hpp"
+
+#include "webrtc/base/refcount.h"
+
+int32_t FauxAudioDeviceModule::RegisterAudioCallback(webrtc::AudioTransport* audio_callback) {
+  rtc::CritScope cs(&crit_);
+  audio_callback_ = audio_callback;
+  return 0;
+}
+
+void FauxAudioDeviceModule::Pull(uint16_t* audioSamples, size_t nSamples, uint32_t samplesPerSec) {
+  rtc::CritScope cs(&crit_);
+  if (!audio_callback_) {
+    return;
+  }
+  size_t nSamplesOut = 0;
+  int64_t elapsed_time_ms = 0;
+  int64_t ntp_time_ms = 0;
+  audio_callback_->NeedMorePlayData(nSamples, 2, 1, samplesPerSec,
+                                    audioSamples, nSamplesOut,
+                                    &elapsed_time_ms, &ntp_time_ms);
+}
diff --git a/fauxaudiodevicemodule.hpp b/fauxaudiodevicemodule.hpp
new file mode 100644
index 0000000..5fc3a35
--- /dev/null
+++ b/fauxaudiodevicemodule.hpp
@@ -0,0 +1,33 @@
+#ifndef FAUXAUDIODEVICEMODULE_H_
+#define FAUXAUDIODEVICEMODULE_H_
+
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/modules/audio_device/include/fake_audio_device.h"
+
+/*
+FauxAudioDeviceModule drives the mechanism for receiving remote audio tracks by
+having its Pull method called periodically (from Go, because I couldn't get
+threading to compile in C++).  It does not do the other thing that an
+AudioDeviceModule is intended to do, which is to push recorded audio, because,
+strangely, pushing any such audio causes it to be interleaved with audio data
+from other sent tracks, corrupting it on the receiving end.
+
+This feels hackish.  Maybe there is a better way to do it.
+*/
+class FauxAudioDeviceModule : public webrtc::FakeAudioDeviceModule {
+ public:
+  explicit FauxAudioDeviceModule() : audio_callback_(nullptr) {}
+
+  int32_t RegisterAudioCallback(webrtc::AudioTransport* audio_callback) override;
+
+  void Pull(uint16_t* audioSamples, size_t nSamples, uint32_t samplesPerSec);
+
+ protected:
+  virtual ~FauxAudioDeviceModule() {}
+
+ private:
+  webrtc::AudioTransport* audio_callback_;
+  rtc::CriticalSection crit_;
+};
+
+#endif  // FAUXAUDIODEVICEMODULE_H_
diff --git a/mediastream.cc b/mediastream.cc
new file mode 100644
index 0000000..74f6158
--- /dev/null
+++ b/mediastream.cc
@@ -0,0 +1,17 @@
+#include "mediastream.h"
+
+#include "webrtc/api/mediastreaminterface.h"
+
+CGO_AudioTrack* CGO_MediaStream_GetAudioTracks(CGO_MediaStream s, int* n) {
+	auto tracks = ((webrtc::MediaStreamInterface*)s)->GetAudioTracks();
+	*n = tracks.size();
+	auto ctracks = (CGO_AudioTrack*)malloc(*n * sizeof(CGO_AudioTrack*));
+	for (int i = 0; i < *n; ++i) {
+		ctracks[i] = tracks[i].release();
+	}
+	return ctracks;
+}
+
+void CGO_MediaStream_AddAudioTrack(CGO_MediaStream s, CGO_AudioTrack t) {
+	((webrtc::MediaStreamInterface*)s)->AddTrack((webrtc::AudioTrackInterface*)t);
+}
diff --git a/mediastream.go b/mediastream.go
new file mode 100644
index 0000000..1344433
--- /dev/null
+++ b/mediastream.go
@@ -0,0 +1,50 @@
+package webrtc
+
+/*
+#include "refptr.h"
+#include "mediastream.h"
+#include "peerconnection.h"
+
+#include <stdlib.h>
+*/
+import "C"
+import "unsafe"
+
+type MediaStream struct {
+	p *refptr
+	s C.CGO_MediaStream
+}
+
+func newMediaStream(s C.CGO_MediaStream) *MediaStream {
+	return &MediaStream{
+		p: newRefPtr(C.CGO_RefPtr(s)),
+		s: s,
+	}
+}
+
+// TODO: Factor pc_factory out of Peer (and make it a single global instance?)
+func (pc *PeerConnection) NewMediaStream(label string) *MediaStream {
+	s := C.CGO_NewMediaStream(pc.cgoPeer, C.CString(label))
+	return newMediaStream(s)
+}
+
+func (s *MediaStream) GetAudioTracks() []*AudioTrack {
+	var n C.int
+	ctracks := uintptr(unsafe.Pointer(C.CGO_MediaStream_GetAudioTracks(s.s, &n)))
+	tracks := make([]*AudioTrack, n)
+	for i := range tracks {
+		t := *(*C.CGO_AudioTrack)(unsafe.Pointer(ctracks + uintptr(i)))
+		tracks[i] = newAudioTrack(t)
+	}
+	C.free(unsafe.Pointer(ctracks))
+	return tracks
+}
+
+func (s *MediaStream) AddTrack(t MediaStreamTrack) {
+	switch t := t.(type) {
+	case *AudioTrack:
+		C.CGO_MediaStream_AddAudioTrack(s.s, t.t)
+	default:
+		panic("unknown track type")
+	}
+}
diff --git a/mediastream.h b/mediastream.h
new file mode 100644
index 0000000..93df72d
--- /dev/null
+++ b/mediastream.h
@@ -0,0 +1,25 @@
+#ifndef _C_MEDIASTREAM_H_
+#define _C_MEDIASTREAM_H_
+
+#define WEBRTC_POSIX 1
+
+#include "audiotrack.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_MediaStream; // webrtc::MediaStreamInterface*
+
+  CGO_AudioTrack* CGO_MediaStream_GetAudioTracks(CGO_MediaStream, int*);
+  void CGO_MediaStream_AddAudioTrack(CGO_MediaStream, CGO_AudioTrack);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_MEDIASTREAM_H_
diff --git a/mediastreamtrack.cc b/mediastreamtrack.cc
new file mode 100644
index 0000000..a44d08b
--- /dev/null
+++ b/mediastreamtrack.cc
@@ -0,0 +1,23 @@
+#include <_cgo_export.h>  // Allow calling certain Go functions.
+
+#include "mediastreamtrack.h"
+
+#include "webrtc/api/mediastreaminterface.h"
+
+using namespace webrtc;
+
+const char* CGO_MediaStreamTrack_ID(CGO_MediaStreamTrack t) {
+	return ((MediaStreamTrackInterface*)t)->id().c_str();
+}
+
+bool CGO_MediaStreamTrack_Enabled(CGO_MediaStreamTrack t) {
+	return ((MediaStreamTrackInterface*)t)->enabled();
+}
+
+void CGO_MediaStreamTrack_SetEnabled(CGO_MediaStreamTrack t, bool x) {
+	((MediaStreamTrackInterface*)t)->set_enabled(x);
+}
+
+bool CGO_MediaStreamTrack_Ended(CGO_MediaStreamTrack t) {
+	return ((MediaStreamTrackInterface*)t)->state() == MediaStreamTrackInterface::TrackState::kEnded;
+}
diff --git a/mediastreamtrack.go b/mediastreamtrack.go
new file mode 100644
index 0000000..1bea482
--- /dev/null
+++ b/mediastreamtrack.go
@@ -0,0 +1,64 @@
+package webrtc
+
+/*
+#include "eventlistener.h"
+#include "refptr.h"
+#include "mediastreamtrack.h"
+*/
+import "C"
+
+// A MediaStreamTrack is either an *AudioTrack or a *VideoTrack.
+type MediaStreamTrack interface {
+	ID() string
+	Enabled() bool
+	SetEnabled(bool)
+	Ended() bool
+	OnEnded(func()) *EventListener
+
+	cgo_MediaStreamTrack() C.CGO_MediaStreamTrack
+}
+
+// A mediaStreamTrack is the common implementation shared by AudioTrack and VideoTrack.
+type mediaStreamTrack struct {
+	p *refptr
+	t C.CGO_MediaStreamTrack
+}
+
+func newMediaStreamTrack(t C.CGO_MediaStreamTrack) *mediaStreamTrack {
+	return &mediaStreamTrack{
+		p: newRefPtr(C.CGO_RefPtr(t)),
+		t: t,
+	}
+}
+
+func (t *mediaStreamTrack) cgo_MediaStreamTrack() C.CGO_MediaStreamTrack {
+	return t.t
+}
+
+func (t *mediaStreamTrack) ID() string {
+	return C.GoString(C.CGO_MediaStreamTrack_ID(t.t))
+}
+
+func (t *mediaStreamTrack) Enabled() bool {
+	return bool(C.CGO_MediaStreamTrack_Enabled(t.t))
+}
+
+func (t *mediaStreamTrack) SetEnabled(x bool) {
+	C.CGO_MediaStreamTrack_SetEnabled(t.t, C.bool(x))
+}
+
+func (t *mediaStreamTrack) Ended() bool {
+	return bool(C.CGO_MediaStreamTrack_Ended(t.t))
+}
+
+func (t *mediaStreamTrack) OnEnded(f func()) *EventListener {
+	var e *EventListener
+	e = newEventListener(C.CGO_Notifier(t.t), func() {
+		if t.Ended() {
+			f()
+			// Once a track has ended, it will never become live again.
+			e.Cancel()
+		}
+	})
+	return e
+}
diff --git a/mediastreamtrack.h b/mediastreamtrack.h
new file mode 100644
index 0000000..64f24f7
--- /dev/null
+++ b/mediastreamtrack.h
@@ -0,0 +1,27 @@
+#ifndef _C_MEDIASTREAMTRACK_H_
+#define _C_MEDIASTREAMTRACK_H_
+
+#define WEBRTC_POSIX 1
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_MediaStreamTrack; // webrtc::MediaStreamTrackInterface*
+
+  const char* CGO_MediaStreamTrack_ID(CGO_MediaStreamTrack);
+  bool CGO_MediaStreamTrack_Enabled(CGO_MediaStreamTrack);
+  void CGO_MediaStreamTrack_SetEnabled(CGO_MediaStreamTrack, bool);
+  bool CGO_MediaStreamTrack_Ended(CGO_MediaStreamTrack);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_MEDIASTREAMTRACK_H_
diff --git a/peerconnection.cc b/peerconnection.cc
index 275007a..e9a19cb 100644
--- a/peerconnection.cc
+++ b/peerconnection.cc
@@ -3,14 +3,17 @@
  * allows compatibility with CGO's requirements so that everything may
  * ultimately be exposed in Go.
  */
+#include <_cgo_export.h>  // Allow calling certain Go functions.
+
 #include "peerconnection.h"
+#include "fauxaudiodevicemodule.hpp"
 #include "datachannel.hpp"
+#include "mediastream.h"
 
 #include <iostream>
 #include <future>
 
 #include "webrtc/api/test/fakeconstraints.h"
-#include "webrtc/pc/test/fakeaudiocapturemodule.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/pc/webrtcsdp.h"
 
@@ -56,11 +59,11 @@ class Peer
     signalling_thread_->Start();  // Must start before being passed to
     worker_thread_->Start();      // PeerConnectionFactory.
 
-    this->fake_audio_ = FakeAudioCaptureModule::Create();
+    this->faux_audio_ = new rtc::RefCountedObject<FauxAudioDeviceModule>;
     pc_factory = CreatePeerConnectionFactory(
       worker_thread_,
       signalling_thread_,
-      this->fake_audio_, NULL, NULL);
+      this->faux_audio_, NULL, NULL);
     if (!pc_factory.get()) {
       CGO_DBG("Could not create PeerConnectionFactory");
       return false;
@@ -75,6 +78,10 @@ class Peer
     return true;
   }
 
+  void pullAudio(uint16_t* audioSamples, size_t nSamples, uint32_t samplesPerSec) {
+    faux_audio_->Pull(audioSamples, nSamples, samplesPerSec);
+  }
+
   void resetPromise() {
     promiseSDP = promise<SDP>();
   }
@@ -104,12 +111,13 @@ class Peer
     cgoOnSignalingStateChange(goPeerConnection, state);
   }
 
-  // This is required for the Media API.
-  void OnAddStream(webrtc::MediaStreamInterface* stream) {
-    CGO_DBG("unimplemented OnAddStream");
-  }
-  void OnRemoveStream(webrtc::MediaStreamInterface* stream) {
-    CGO_DBG("unimplemented OnRemoveStream");
+  void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
+      const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
+    vector<MediaStreamInterface*> ss;
+    for(auto s : streams) {
+      ss.push_back(s.release());
+    }
+    cgoOnAddTrack(goPeerConnection, receiver.release(), (CGO_MediaStream*)ss.data(), ss.size());
   }
 
   void OnRenegotiationNeeded() {
@@ -191,7 +199,7 @@ class Peer
  private:
   rtc::Thread *signalling_thread_;
   rtc::Thread *worker_thread_;
-  rtc::scoped_refptr<AudioDeviceModule> fake_audio_;
+  rtc::scoped_refptr<FauxAudioDeviceModule> faux_audio_;
 };  // class Peer
 
 // Keep track of Peers in global scope to prevent deallocation, due to the
@@ -283,6 +291,10 @@ int CGO_CreatePeerConnection(CGO_Peer cgoPeer, CGO_Configuration *cgoConfig) {
   return SUCCESS;
 }
 
+void CGO_PullAudio(CGO_Peer cgoPeer, uint16_t* audioSamples, int nSamples, uint32_t samplesPerSec) {
+  ((Peer*)cgoPeer)->pullAudio(audioSamples, nSamples, samplesPerSec);
+}
+
 bool SDPtimeout(future<SDP> *f, int seconds) {
   auto status = f->wait_for(chrono::seconds(TIMEOUT_SECS));
   return future_status::ready != status;
@@ -426,6 +438,16 @@ int CGO_SetConfiguration(CGO_Peer cgoPeer, CGO_Configuration* cgoConfig) {
   return (int) error->type();
 }
 
+CGO_RtpSender CGO_PeerConnection_AddTrack(CGO_Peer cgoPeer, CGO_MediaStreamTrack track, CGO_MediaStream* streams, int numStreams) {
+  auto s = (webrtc::MediaStreamInterface**)streams;
+  std::vector<webrtc::MediaStreamInterface*> ss(s, s+numStreams);
+  return ((Peer*)cgoPeer)->pc_->AddTrack((webrtc::MediaStreamTrackInterface*)track, ss);
+}
+
+void CGO_PeerConnection_RemoveTrack(CGO_Peer cgoPeer, CGO_RtpSender sender) {
+  ((Peer*)cgoPeer)->pc_->RemoveTrack((webrtc::RtpSenderInterface*)sender);
+}
+
 // PeerConnection::CreateDataChannel
 void* CGO_CreateDataChannel(CGO_Peer cgoPeer, char *label, void *dict) {
   auto cPeer = (Peer*)cgoPeer;
@@ -445,6 +467,12 @@ void* CGO_CreateDataChannel(CGO_Peer cgoPeer, char *label, void *dict) {
   return (void *)o;
 }
 
+// TODO: Move to mediastream.cc (when pc_factory is factored out of Peer).
+CGO_MediaStream CGO_NewMediaStream(CGO_Peer cgoPeer, const char* label) {
+  Peer *peer = (Peer*)cgoPeer;
+  return peer->pc_factory->CreateLocalMediaStream(label).release();
+}
+
 // PeerConnection::Close
 void CGO_Close(CGO_Peer peer) {
   auto cPeer = (Peer*)peer;
diff --git a/peerconnection.go b/peerconnection.go
index 9c91a4d..db524f8 100644
--- a/peerconnection.go
+++ b/peerconnection.go
@@ -38,12 +38,14 @@ package webrtc
 #cgo darwin,amd64 pkg-config: webrtc-darwin-amd64.pc
 #include <stdlib.h>  // Needed for C.free
 #include "peerconnection.h"
+#include "rtpreceiver.h"
 #include "ctestenums.h"
 */
 import "C"
 import (
 	"errors"
 	"fmt"
+	"time"
 	"unsafe"
 )
 
@@ -127,6 +129,7 @@ type PeerConnection struct {
 
 	// Event handlers
 	OnNegotiationNeeded        func()
+	OnAddTrack                 func(*RtpReceiver, []*MediaStream)
 	OnIceCandidate             func(IceCandidate)
 	OnIceCandidateError        func()
 	OnIceComplete              func() // Possibly to be removed.
@@ -165,9 +168,30 @@ func NewPeerConnection(config *Configuration) (*PeerConnection, error) {
 		return nil, errors.New("PeerConnection: could not create from config.")
 	}
 	INFO.Println("Created PeerConnection: ", pc, pc.cgoPeer)
+	go pc.pullAudio()
 	return pc, nil
 }
 
+/*
+The webrtc.org mechanism for decoding audio data and passing it to audio tracks
+is driven by an audio device periodically requesting audio for playout.
+Instead of requiring a real audio device, we implement this mechanism here.
+*/
+func (pc *PeerConnection) pullAudio() {
+	const (
+		samplesPerSec = 48000
+		pullsPerSec   = 100
+	)
+	audioSamples := [samplesPerSec / pullsPerSec]uint16{}
+
+	next := time.Now()
+	for {
+		C.CGO_PullAudio(pc.cgoPeer, (*C.uint16_t)(&audioSamples[0]), C.int(len(audioSamples)), samplesPerSec)
+		next = next.Add(time.Second / pullsPerSec)
+		time.Sleep(next.Sub(time.Now()))
+	}
+}
+
 //
 // === Session Description Protocol ===
 //
@@ -323,6 +347,22 @@ func (pc *PeerConnection) SetConfiguration(config Configuration) error {
 	return nil
 }
 
+func (pc *PeerConnection) AddTrack(t MediaStreamTrack, s []*MediaStream) *RtpSender {
+	var sp *C.CGO_MediaStream
+	if len(s) > 0 {
+		ss := make([]C.CGO_MediaStream, len(s))
+		for i, s := range s {
+			ss[i] = s.s
+		}
+		sp = &ss[0]
+	}
+	return newRtpSender(C.CGO_PeerConnection_AddTrack(pc.cgoPeer, t.cgo_MediaStreamTrack(), sp, C.int(len(s))))
+}
+
+func (pc *PeerConnection) RemoveTrack(s *RtpSender) {
+	C.CGO_PeerConnection_RemoveTrack(pc.cgoPeer, s.s)
+}
+
 /*
 Create and return a DataChannel.
 
@@ -371,6 +411,22 @@ func cgoOnSignalingStateChange(p int, s SignalingState) {
 	}
 }
 
+//export cgoOnAddTrack
+func cgoOnAddTrack(p int, r C.CGO_RtpReceiver, s *C.CGO_MediaStream, ns int) {
+	INFO.Println("fired OnAddTrack: ", p, r, s, ns)
+	pc := PCMap.Get(p).(*PeerConnection)
+	receiver := newRtpReceiver(r)
+	streams := make([]*MediaStream, ns)
+	sp := uintptr(unsafe.Pointer(s))
+	for i := range streams {
+		s := *(*C.CGO_MediaStream)(unsafe.Pointer(sp + uintptr(i)))
+		streams[i] = newMediaStream(s)
+	}
+	if nil != pc.OnAddTrack {
+		pc.OnAddTrack(receiver, streams)
+	}
+}
+
 //export cgoOnNegotiationNeeded
 func cgoOnNegotiationNeeded(p int) {
 	INFO.Println("fired OnNegotiationNeeded: ", p)
diff --git a/peerconnection.h b/peerconnection.h
index 29a84a0..6e520a0 100644
--- a/peerconnection.h
+++ b/peerconnection.h
@@ -3,6 +3,12 @@
 
 #define WEBRTC_POSIX 1
 
+#include <stdint.h>
+
+#include "mediastreamtrack.h"
+#include "mediastream.h"
+#include "rtpsender.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -49,6 +55,8 @@ extern "C" {
 
   int CGO_CreatePeerConnection(CGO_Peer, CGO_Configuration*);
 
+  void CGO_PullAudio(CGO_Peer, uint16_t*, int, uint32_t);
+
   CGO_sdpString CGO_CreateOffer(CGO_Peer);
   CGO_sdpString CGO_CreateAnswer(CGO_Peer);
 
@@ -66,8 +74,13 @@ extern "C" {
   int CGO_IceGatheringState(CGO_Peer);
   int CGO_SetConfiguration(CGO_Peer, CGO_Configuration*);
 
+  CGO_RtpSender CGO_PeerConnection_AddTrack(CGO_Peer, CGO_MediaStreamTrack, CGO_MediaStream*, int);
+  void CGO_PeerConnection_RemoveTrack(CGO_Peer, CGO_RtpSender);
   void* CGO_CreateDataChannel(CGO_Peer, char*, void*);
 
+  // TODO: Move to mediastream.cc (when pc_factory is factored out of Peer).
+  CGO_MediaStream CGO_NewMediaStream(CGO_Peer cgoPeer, const char* label);
+
   void CGO_Close(CGO_Peer);
 
   // Test helpers
diff --git a/refptr.cc b/refptr.cc
new file mode 100644
index 0000000..320e628
--- /dev/null
+++ b/refptr.cc
@@ -0,0 +1,7 @@
+#include "refptr.h"
+
+#include "webrtc/base/refcount.h"
+
+void CGO_RefPtr_Release(CGO_RefPtr p) {
+	((rtc::RefCountInterface*)p)->Release();
+}
diff --git a/refptr.go b/refptr.go
new file mode 100644
index 0000000..7b245bd
--- /dev/null
+++ b/refptr.go
@@ -0,0 +1,27 @@
+package webrtc
+
+/*
+#include "refptr.h"
+*/
+import "C"
+import "runtime"
+
+/*
+refptr holds a reference counted pointer and decrements its reference count
+when the refptr is garbage collected.  It is roughly the equivalent of
+rtc::scoped_refptr, except it doesn't increment the reference count.
+*/
+type refptr struct{}
+
+/*
+newRefPtr returns a refptr that, upon being garbage collected, decrements p's
+reference count.  p must already have its reference count incremented before
+being passed to newRefPtr, for example by calling scoped_refptr::release().
+*/
+func newRefPtr(p C.CGO_RefPtr) *refptr {
+	rp := &refptr{}
+	runtime.SetFinalizer(rp, func(*refptr) {
+		C.CGO_RefPtr_Release(p)
+	})
+	return rp
+}
diff --git a/refptr.h b/refptr.h
new file mode 100644
index 0000000..19fbfa6
--- /dev/null
+++ b/refptr.h
@@ -0,0 +1,20 @@
+#ifndef _C_REFPTR_H_
+#define _C_REFPTR_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_RefPtr; // rtc::RefCountInterface*
+
+  void CGO_RefPtr_Release(CGO_RefPtr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_REFPTR_H_
diff --git a/rtpreceiver.cc b/rtpreceiver.cc
new file mode 100644
index 0000000..d984fd1
--- /dev/null
+++ b/rtpreceiver.cc
@@ -0,0 +1,9 @@
+#include "rtpreceiver.h"
+
+#include "webrtc/api/rtpreceiverinterface.h"
+
+CGO_MediaStreamTrack CGO_RtpReceiver_Track(CGO_RtpReceiver r, bool* isAudio) {
+	auto t = ((webrtc::RtpReceiverInterface*)r)->track().release();
+	*isAudio = t->kind() == "audio";
+	return t;
+}
diff --git a/rtpreceiver.go b/rtpreceiver.go
new file mode 100644
index 0000000..8fc44cd
--- /dev/null
+++ b/rtpreceiver.go
@@ -0,0 +1,29 @@
+package webrtc
+
+/*
+#include "refptr.h"
+#include "rtpreceiver.h"
+#include "audiotrack.h"
+*/
+import "C"
+
+type RtpReceiver struct {
+	p *refptr
+	r C.CGO_RtpReceiver
+}
+
+func newRtpReceiver(r C.CGO_RtpReceiver) *RtpReceiver {
+	return &RtpReceiver{
+		p: newRefPtr(C.CGO_RefPtr(r)),
+		r: r,
+	}
+}
+
+func (r *RtpReceiver) Track() MediaStreamTrack {
+	isAudio := false
+	t := C.CGO_RtpReceiver_Track(r.r, (*C.bool)(&isAudio))
+	if isAudio {
+		return newAudioTrack(C.CGO_AudioTrack(t))
+	}
+	panic("VideoTrack not yet implemented")
+}
diff --git a/rtpreceiver.h b/rtpreceiver.h
new file mode 100644
index 0000000..3d89aff
--- /dev/null
+++ b/rtpreceiver.h
@@ -0,0 +1,26 @@
+#ifndef _C_RTPRECEIVER_H_
+#define _C_RTPRECEIVER_H_
+
+#define WEBRTC_POSIX 1
+
+#include <stdbool.h>
+
+#include "mediastreamtrack.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_RtpReceiver; // webrtc::RtpReceiverInterface*
+
+  CGO_MediaStreamTrack CGO_RtpReceiver_Track(CGO_RtpReceiver, bool*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_RTPRECEIVER_H_
diff --git a/rtpsender.cc b/rtpsender.cc
new file mode 100644
index 0000000..d54236a
--- /dev/null
+++ b/rtpsender.cc
@@ -0,0 +1,9 @@
+#include "rtpsender.h"
+
+#include "webrtc/api/rtpsenderinterface.h"
+
+CGO_MediaStreamTrack CGO_RtpSender_Track(CGO_RtpSender s, bool* isAudio) {
+	auto t = ((webrtc::RtpSenderInterface*)s)->track().release();
+	*isAudio = t->kind() == "audio";
+	return t;
+}
diff --git a/rtpsender.go b/rtpsender.go
new file mode 100644
index 0000000..2368d23
--- /dev/null
+++ b/rtpsender.go
@@ -0,0 +1,29 @@
+package webrtc
+
+/*
+#include "refptr.h"
+#include "rtpsender.h"
+#include "audiotrack.h"
+*/
+import "C"
+
+type RtpSender struct {
+	p *refptr
+	s C.CGO_RtpSender
+}
+
+func newRtpSender(s C.CGO_RtpSender) *RtpSender {
+	return &RtpSender{
+		p: newRefPtr(C.CGO_RefPtr(s)),
+		s: s,
+	}
+}
+
+func (s *RtpSender) Track() MediaStreamTrack {
+	isAudio := false
+	t := C.CGO_RtpSender_Track(s.s, (*C.bool)(&isAudio))
+	if isAudio {
+		return newAudioTrack(C.CGO_AudioTrack(t))
+	}
+	panic("VideoTrack not yet implemented")
+}
diff --git a/rtpsender.h b/rtpsender.h
new file mode 100644
index 0000000..0508604
--- /dev/null
+++ b/rtpsender.h
@@ -0,0 +1,26 @@
+#ifndef _C_RTPSENDER_H_
+#define _C_RTPSENDER_H_
+
+#define WEBRTC_POSIX 1
+
+#include <stdbool.h>
+
+#include "mediastreamtrack.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  // In order to present an interface cgo is happy with, nothing in this file
+  // can directly reference header files from libwebrtc / C++ world. All the
+  // casting must be hidden in the .cc file.
+
+  typedef void* CGO_RtpSender; // webrtc::RtpSenderInterface*
+
+  CGO_MediaStreamTrack CGO_RtpSender_Track(CGO_RtpSender, bool*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // _C_RTPSENDER_H_