diff --git a/app/build.gradle b/app/build.gradle
index fab637d..1e683b3 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -13,7 +13,7 @@ android {
         targetSdkVersion 30
         versionCode 1
         versionName "1.0"
-
+        multiDexEnabled true
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -34,6 +34,11 @@ android {
 
 dependencies {
 
+    api project(':exorecord')
+    implementation 'com.google.android.exoplayer:exoplayer:2.13.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.8'
+
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation 'androidx.core:core-ktx:1.3.2'
     implementation 'androidx.appcompat:appcompat:1.2.0'
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index d59d79c..a4e3f4c 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -2,17 +2,20 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="dev.brookmg.exorecord">
 
+    <uses-permission android:name="android.permission.INTERNET" />
     <application
+        android:name=".App"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.ExoRecord">
+        android:theme="@style/Theme.ExoRecord"
+        android:fullBackupContent="true">
+
         <activity android:name=".MainActivity">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
-
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
diff --git a/app/src/main/java/dev/brookmg/exorecord/App.kt b/app/src/main/java/dev/brookmg/exorecord/App.kt
new file mode 100644
index 0000000..0ca204e
--- /dev/null
+++ b/app/src/main/java/dev/brookmg/exorecord/App.kt
@@ -0,0 +1,17 @@
+package dev.brookmg.exorecord
+
+import android.app.Application
+import dev.brookmg.exorecord.lib.ExoRecord
+
+class App : Application() {
+
+    companion object {
+        lateinit var instance: App
+        val exoRecordInstance: ExoRecord by lazy { ExoRecord(instance) }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        instance = this
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/dev/brookmg/exorecord/MainActivity.kt b/app/src/main/java/dev/brookmg/exorecord/MainActivity.kt
index 3523128..c590c76 100644
--- a/app/src/main/java/dev/brookmg/exorecord/MainActivity.kt
+++ b/app/src/main/java/dev/brookmg/exorecord/MainActivity.kt
@@ -1,11 +1,108 @@
 package dev.brookmg.exorecord
 
-import androidx.appcompat.app.AppCompatActivity
+import android.content.Context
+import android.net.Uri
 import android.os.Bundle
+import android.util.Log
+import android.widget.Button
+import androidx.appcompat.app.AppCompatActivity
+import com.google.android.exoplayer2.DefaultRenderersFactory
+import com.google.android.exoplayer2.MediaItem
+import com.google.android.exoplayer2.SimpleExoPlayer
+import com.google.android.exoplayer2.audio.*
+import com.google.android.exoplayer2.extractor.DefaultExtractorsFactory
+import com.google.android.exoplayer2.source.MediaSource
+import com.google.android.exoplayer2.source.ProgressiveMediaSource
+import com.google.android.exoplayer2.source.hls.HlsExtractorFactory
+import com.google.android.exoplayer2.source.hls.HlsMediaSource
+import com.google.android.exoplayer2.trackselection.AdaptiveTrackSelection
+import com.google.android.exoplayer2.trackselection.DefaultTrackSelector
+import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter
+import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 
 class MainActivity : AppCompatActivity() {
+
+    companion object {
+        const val FORMAT_MP3 = "mp3"
+        const val FORMAT_MP4 = "mp4"
+        const val FORMAT_M3U = "m3u"
+        const val FORMAT_M3U8 = "m3u8"
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+        val streamUrl = "https://stream.live.vc.bbcmedia.co.uk/bbc_radio_one?s=1619514803&e=1619529203&h=f378f4ca18759ebfa5fd1d674c794cfc"
+
+        val mainMediaSource: MediaSource
+        val uri = Uri.parse(streamUrl)
+        val lastPath = uri.lastPathSegment
+
+        val bandwidthMeter = DefaultBandwidthMeter.Builder(applicationContext).build()
+        val trackSelectionFactory = AdaptiveTrackSelection.Factory()
+        val httpDataSourceFactory = DefaultHttpDataSourceFactory(
+            "-- Audio Test --",
+            bandwidthMeter,
+            DefaultHttpDataSource.DEFAULT_CONNECT_TIMEOUT_MILLIS,
+            DefaultHttpDataSource.DEFAULT_READ_TIMEOUT_MILLIS,
+            true
+        )
+
+        val dataSourceFactory = DefaultDataSourceFactory(this, bandwidthMeter, httpDataSourceFactory)
+
+        if (lastPath == null || lastPath.isEmpty()) return
+        mainMediaSource = if (lastPath.contains(FORMAT_M3U8) ||
+            lastPath.contains(FORMAT_M3U)) {
+            HlsMediaSource.Factory(dataSourceFactory)
+                .setAllowChunklessPreparation(true)
+                .setExtractorFactory(HlsExtractorFactory.DEFAULT)
+                .createMediaSource(MediaItem.fromUri(uri))
+        } else {
+            ProgressiveMediaSource.Factory(dataSourceFactory, DefaultExtractorsFactory()).createMediaSource(
+                MediaItem.fromUri(uri)
+            )
+        }
+
+        val renderersFactory = object : DefaultRenderersFactory(this) {
+            override fun buildAudioSink(
+                context: Context, enableFloatOutput: Boolean,
+                enableAudioTrackPlaybackParams: Boolean, enableOffload: Boolean
+            ): AudioSink {
+                return DefaultAudioSink(
+                    AudioCapabilities.DEFAULT_AUDIO_CAPABILITIES,
+                    DefaultAudioSink.DefaultAudioProcessorChain(App.exoRecordInstance.exoRecordProcessor),
+                    enableFloatOutput, enableAudioTrackPlaybackParams, enableOffload
+                )
+            }
+        }
+
+        val trackSelector = DefaultTrackSelector(applicationContext, trackSelectionFactory)
+        val exoPlayer = SimpleExoPlayer.Builder(applicationContext, renderersFactory)
+            .setTrackSelector(trackSelector)
+            .setBandwidthMeter(bandwidthMeter)
+            .build()
+
+        exoPlayer.setMediaSource(mainMediaSource)
+        exoPlayer.prepare()
+
+        findViewById<Button>(R.id.button).setOnClickListener { exoPlayer.playWhenReady = true }
+        findViewById<Button>(R.id.button2).setOnClickListener { exoPlayer.stop() }
+
+        findViewById<Button>(R.id.button_rec).setOnClickListener {
+            CoroutineScope(Dispatchers.Main).launch {
+                App.exoRecordInstance.startRecording()
+            }
+        }
+
+        findViewById<Button>(R.id.button_rec_stop).setOnClickListener {
+            CoroutineScope(Dispatchers.Main).launch {
+                Log.e("CONVERSION", App.exoRecordInstance.stopRecording(true).toString())
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 4fc2444..0ee6d9b 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
@@ -7,12 +8,64 @@
     tools:context=".MainActivity">
 
     <TextView
+        android:id="@+id/tview"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:text="Hello World!"
+        android:text="@string/exorecord_nothing"
+        android:padding="16dp"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintLeft_toLeftOf="parent"
         app:layout_constraintRight_toRightOf="parent"
         app:layout_constraintTop_toTopOf="parent" />
 
+    <Button
+        android:id="@+id/button"
+        android:layout_marginTop="16dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toBottomOf="@+id/tview"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toStartOf="@+id/button2"
+        android:text="@string/start"
+        tools:layout_editor_absoluteX="203dp"
+        tools:layout_editor_absoluteY="412dp" />
+
+    <Button
+        android:id="@+id/button2"
+        android:layout_marginTop="16dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toBottomOf="@+id/tview"
+        app:layout_constraintStart_toEndOf="@+id/button"
+        app:layout_constraintEnd_toEndOf="parent"
+        android:text="@string/stop"
+        tools:layout_editor_absoluteX="169dp"
+        tools:layout_editor_absoluteY="509dp" />
+
+    <Button
+        android:id="@+id/button_rec"
+        android:layout_marginTop="16dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:backgroundTint="#a00000"
+        app:layout_constraintTop_toBottomOf="@+id/button"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toStartOf="@+id/button2"
+        android:text="@string/start_recording"
+        tools:layout_editor_absoluteX="203dp"
+        tools:layout_editor_absoluteY="412dp" />
+
+    <Button
+        android:id="@+id/button_rec_stop"
+        android:layout_marginTop="16dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:backgroundTint="#a00000"
+        app:layout_constraintTop_toBottomOf="@+id/button"
+        app:layout_constraintStart_toEndOf="@+id/button"
+        app:layout_constraintEnd_toEndOf="parent"
+        android:text="@string/stop_recording"
+        tools:layout_editor_absoluteX="169dp"
+        tools:layout_editor_absoluteY="509dp" />
+
 </androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 11bc6e0..9f3637e 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1,3 +1,8 @@
 <resources>
     <string name="app_name">ExoRecord</string>
+    <string name="exorecord_nothing">ExoRecord --- --- --- NOTHING!</string>
+    <string name="start">Start</string>
+    <string name="stop">Stop</string>
+    <string name="start_recording">Start Recording</string>
+    <string name="stop_recording">Stop Recording</string>
 </resources>
\ No newline at end of file
diff --git a/exorecord/build.gradle b/exorecord/build.gradle
index cf94223..90778c6 100644
--- a/exorecord/build.gradle
+++ b/exorecord/build.gradle
@@ -36,6 +36,10 @@ dependencies {
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation 'com.google.android.exoplayer:exoplayer:2.13.3'
+    implementation 'androidx.core:core-ktx:1.3.2'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.8'
+
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.2'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
diff --git a/exorecord/src/androidTest/java/dev/brookmg/exoplayer/ExampleInstrumentedTest.kt b/exorecord/src/androidTest/java/dev/brookmg/exorecord/lib/ExampleInstrumentedTest.kt
similarity index 83%
rename from exorecord/src/androidTest/java/dev/brookmg/exoplayer/ExampleInstrumentedTest.kt
rename to exorecord/src/androidTest/java/dev/brookmg/exorecord/lib/ExampleInstrumentedTest.kt
index 067456a..9f7bf75 100644
--- a/exorecord/src/androidTest/java/dev/brookmg/exoplayer/ExampleInstrumentedTest.kt
+++ b/exorecord/src/androidTest/java/dev/brookmg/exorecord/lib/ExampleInstrumentedTest.kt
@@ -1,4 +1,4 @@
-package dev.brookmg.exoplayer
+package dev.brookmg.exorecord.lib
 
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -19,6 +19,6 @@ class ExampleInstrumentedTest {
     fun useAppContext() {
         // Context of the app under test.
         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("dev.brookmg.exoplayer.test", appContext.packageName)
+        assertEquals("dev.brookmg.exorecord.lib.test", appContext.packageName)
     }
 }
\ No newline at end of file
diff --git a/exorecord/src/main/AndroidManifest.xml b/exorecord/src/main/AndroidManifest.xml
index abd632e..c827513 100644
--- a/exorecord/src/main/AndroidManifest.xml
+++ b/exorecord/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="dev.brookmg.exoplayer">
+    package="dev.brookmg.exorecord.lib">
 
 </manifest>
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecord.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecord.kt
new file mode 100644
index 0000000..4699a18
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecord.kt
@@ -0,0 +1,16 @@
+package dev.brookmg.exorecord.lib
+
+import android.app.Application
+
+/**
+ * It's wise to pass the application context here
+ */
+class ExoRecord(private val application: Application) : IExoRecord{
+
+    val exoRecordProcessor: ExoRecordProcessor by lazy { ExoRecordProcessor(applicationContext = application) }
+
+    override suspend fun startRecording() = exoRecordProcessor.startRecording()
+
+    override suspend fun stopRecording(saveAsAAC: Boolean): IExoRecord.Record = exoRecordProcessor.stopRecording(saveAsAAC)
+
+}
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecordProcessor.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecordProcessor.kt
new file mode 100644
index 0000000..4878dad
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/ExoRecordProcessor.kt
@@ -0,0 +1,132 @@
+package dev.brookmg.exorecord.lib
+
+import android.content.Context
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.Format
+import com.google.android.exoplayer2.audio.AudioProcessor
+import kotlinx.coroutines.*
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+@Suppress("unused")
+class ExoRecordProcessor internal constructor(private val applicationContext: Context) : AudioProcessor, IExoRecord {
+
+    private var sampleRateHz: Int = 0
+    private var channelCount: Int = 0
+    private var bytePerFrame: Int = 0
+
+    @C.Encoding private var encoding: Int = 0
+    private var isActive: Boolean = false
+
+    private var processBuffer: ByteBuffer = AudioProcessor.EMPTY_BUFFER
+    private var outputBuffer: ByteBuffer? = null
+
+    private var inputEnded: Boolean = false
+    private var wavFile: WavFile? = null
+    private var filePath: String = ""
+
+    init {
+        outputBuffer = AudioProcessor.EMPTY_BUFFER
+        channelCount = Format.NO_VALUE
+        sampleRateHz = Format.NO_VALUE
+    }
+
+    override fun configure(inputAudioFormat: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
+        if (inputAudioFormat.encoding != C.ENCODING_PCM_16BIT) {
+            throw AudioProcessor.UnhandledAudioFormatException(AudioProcessor.AudioFormat(inputAudioFormat.sampleRate, inputAudioFormat.channelCount, inputAudioFormat.encoding))
+        }
+
+        this.sampleRateHz = inputAudioFormat.sampleRate
+        this.channelCount = inputAudioFormat.channelCount
+        this.encoding = inputAudioFormat.encoding
+        this.bytePerFrame = inputAudioFormat.bytesPerFrame
+
+        isActive = true
+
+        return inputAudioFormat
+    }
+
+    override fun isActive() = isActive
+
+    private fun recordBuffer(inputBuffer: ByteBuffer) {
+        val byteArray = ByteArray(inputBuffer.remaining())
+        inputBuffer.get(byteArray)
+        if (isActive) wavFile?.appendBytes(byteArray)
+    }
+
+    override fun queueInput(inputBuffer: ByteBuffer) {
+        var position = inputBuffer.position()
+        val limit = inputBuffer.limit()
+        val frameCount = (limit - position) / (2 * channelCount)
+        val outputSize = frameCount * channelCount * 2
+
+        recordBuffer(inputBuffer)
+
+        if (processBuffer.capacity() < outputSize) {
+            processBuffer = ByteBuffer.allocateDirect(outputSize).order(ByteOrder.nativeOrder())
+        } else {
+            processBuffer.clear()
+        }
+
+        while (position < limit) {
+            var summedUp = 0
+            for (channelIndex in 0 until channelCount) {
+                val current = inputBuffer.getShort(position + 2 * channelIndex)
+                processBuffer.putShort(current)
+                summedUp += current
+            }
+            position += channelCount * 2
+        }
+
+        inputBuffer.position(limit)
+
+        processBuffer.flip()
+        outputBuffer = this.processBuffer
+    }
+
+    override fun queueEndOfStream() {
+        inputEnded = true
+    }
+
+    override fun getOutput(): ByteBuffer {
+        val outputBuffer = this.outputBuffer
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER
+        return outputBuffer ?: ByteBuffer.allocate(0)
+    }
+
+    override fun isEnded(): Boolean = inputEnded && processBuffer === AudioProcessor.EMPTY_BUFFER
+
+    override fun flush() {
+        outputBuffer = AudioProcessor.EMPTY_BUFFER
+        inputEnded = false
+    }
+
+    override fun reset() {
+        CoroutineScope(Dispatchers.IO).launch {
+            stopRecording()
+            withContext(Dispatchers.Main) {
+                flush()
+                processBuffer = AudioProcessor.EMPTY_BUFFER
+                sampleRateHz = Format.NO_VALUE
+                channelCount = Format.NO_VALUE
+                encoding = Format.NO_VALUE
+            }
+        }
+    }
+
+    override suspend fun startRecording() {
+        stopRecording()
+        filePath = "radio-${System.nanoTime()}.wav"
+        wavFile = WavFile(applicationContext = applicationContext, filePath)
+        wavFile?.writeHeaders(sampleRateHz, bytePerFrame, channelCount)
+        isActive = true
+    }
+
+    override suspend fun stopRecording(saveAsAAC: Boolean): IExoRecord.Record {
+        isActive = false
+        val aac = wavFile?.save(saveAsAAC = saveAsAAC)
+        wavFile = null
+        return IExoRecord.Record(filePath, sampleRateHz, bytePerFrame, channelCount, aacFilePath = aac)
+    }
+
+}
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/IExoRecord.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/IExoRecord.kt
new file mode 100644
index 0000000..d1a19a6
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/IExoRecord.kt
@@ -0,0 +1,11 @@
+package dev.brookmg.exorecord.lib
+
+interface IExoRecord {
+
+    data class Record(val filePath: String, val sampleBitRate: Int, val bytePerFrame: Int,
+                      val channelCount: Int, val aacFilePath: String? = null)
+
+    suspend fun startRecording()
+    suspend fun stopRecording(saveAsAAC: Boolean = false) : Record
+
+}
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/Util.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/Util.kt
new file mode 100644
index 0000000..84631dd
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/Util.kt
@@ -0,0 +1,19 @@
+package dev.brookmg.exorecord.lib
+
+import java.nio.ByteBuffer
+
+object Util {
+
+    fun Int.toByteArray(capacity: Int) : ByteArray {
+        val byteBuffer: ByteBuffer = ByteBuffer.allocate(capacity)
+        byteBuffer.putInt(this)
+        return byteBuffer.array().reversedArray()
+    }
+
+    fun Short.toByteArray(capacity: Int) : ByteArray {
+        val byteBuffer: ByteBuffer = ByteBuffer.allocate(capacity)
+        byteBuffer.putShort(this)
+        return byteBuffer.array().reversedArray()
+    }
+
+}
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavFile.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavFile.kt
new file mode 100644
index 0000000..baa0f77
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavFile.kt
@@ -0,0 +1,96 @@
+package dev.brookmg.exorecord.lib
+
+import android.content.Context
+import android.util.Log
+import com.google.android.exoplayer2.Format.NO_VALUE
+import dev.brookmg.exorecord.lib.Util.toByteArray
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.DataOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.RandomAccessFile
+
+class WavFile(
+    private val applicationContext: Context, private val fileName: String,
+) {
+
+    private var currentSampleRateHZ = NO_VALUE
+    private var currentBytePerFrame = NO_VALUE
+    private var currentChannelCount = NO_VALUE
+
+    private val fileOutputStream = DataOutputStream(
+        FileOutputStream(
+            applicationContext.filesDir.absolutePath + File.separator + fileName
+        )
+    )
+    
+    private var audioArray: MutableList<Byte> = mutableListOf()
+
+    fun appendBytes(byteArray: ByteArray) {
+        byteArray.forEach { audioArray.add(it) }
+        if (audioArray.size > 10) {
+            fileOutputStream.write(audioArray.toByteArray())
+            audioArray.clear()
+        }
+    }
+    
+    fun writeHeaders(sampleRateHz: Int, bytePerFrame: Int, channelCount: Int) {
+        currentSampleRateHZ = sampleRateHz
+        currentBytePerFrame = bytePerFrame
+        currentChannelCount = channelCount
+
+        // write the wav file per the wav file format
+        fileOutputStream.write("RIFF".toByteArray()) // 00 - 04 - RIFF
+        fileOutputStream.writeInt(Integer.reverseBytes(audioArray.size + 44 - 8)) // 04 - 08 - how big is the rest of this file?
+        fileOutputStream.write("WAVE".toByteArray()) // 08 - 12 - WAVE
+        fileOutputStream.write("fmt ".toByteArray()) // 12 - 16 - fmt
+
+        fileOutputStream.writeInt(Integer.reverseBytes(16)) // 16 - 20 - size of this chunk
+        fileOutputStream.write(1.toShort().toByteArray(2), 0, 2) // 20 - 22 - what is the audio format? 1 for PCM = Pulse Code Modulation
+        fileOutputStream.write(2.toShort().toByteArray(2), 0, 2) // 22 - 24 - mono or stereo? 1 or 2?  (or 5 or ???)
+
+        // THE CHAOS
+        fileOutputStream.writeInt(Integer.reverseBytes(sampleRateHz / 2)) // 24 - 28 - samples per second (numbers per second)
+        fileOutputStream.writeInt(Integer.reverseBytes(((sampleRateHz / 2) * bytePerFrame * channelCount))) // 28 - 32 - bytes per second
+        fileOutputStream.write((bytePerFrame * channelCount).toShort().toByteArray(2), 0, 2) // 32 - 34 - # of bytes in one sample, for all channels
+        fileOutputStream.write((bytePerFrame * 8).toShort().toByteArray(2), 0, 2) // 34 - 36 // - how many bits in a sample(number)?  usually 16 or 24
+
+        fileOutputStream.write("data".toByteArray()) // 36 40 - data
+        fileOutputStream.writeInt(Integer.reverseBytes(audioArray.size))
+    }
+
+    suspend fun save(saveAsAAC: Boolean = false) : String? = withContext(Dispatchers.IO){
+        try {
+
+            // Change the wav content size
+            fileOutputStream.write(audioArray.toByteArray())
+            fileOutputStream.close()
+
+            val randomAccessFile = RandomAccessFile(applicationContext.filesDir.absolutePath + File.separator + fileName, "rw")
+            randomAccessFile.seek(40)
+            randomAccessFile.write(Integer.reverseBytes(fileOutputStream.size() - 40).toByteArray(4), 0, 4)
+            randomAccessFile.seek(4)
+            randomAccessFile.write(Integer.reverseBytes(fileOutputStream.size() - 8).toByteArray(4), 0, 4)
+
+            audioArray.clear()
+
+            if (saveAsAAC && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
+                return@withContext WavToAAC().convertWavToAAC(applicationContext, fileName,
+                        samplingRate = currentSampleRateHZ,
+                        audioBitRate = (currentSampleRateHZ) * currentBytePerFrame * currentChannelCount,
+                        channelCount = currentChannelCount) { progress ->
+                    Log.v("WaveToAAC" , "Working @ $progress%")
+                }
+            }
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return@withContext null
+    }
+
+
+}
\ No newline at end of file
diff --git a/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavToAAC.kt b/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavToAAC.kt
new file mode 100644
index 0000000..a09c420
--- /dev/null
+++ b/exorecord/src/main/java/dev/brookmg/exorecord/lib/WavToAAC.kt
@@ -0,0 +1,118 @@
+package dev.brookmg.exorecord.lib
+
+import android.content.Context
+import android.media.MediaCodec
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import android.media.MediaMuxer
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import java.io.File
+import java.io.FileInputStream
+import java.nio.ByteBuffer
+import kotlin.math.roundToInt
+
+
+class WavToAAC {
+
+    companion object {
+        const val COMPRESSED_AUDIO_FILE_MIME_TYPE = "audio/mp4a-latm"
+        const val CODEC_TIMEOUT_IN_MS = 1000
+        const val LOGTAG = "WavToAAC"
+    }
+
+    @RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
+    fun convertWavToAAC(context: Context, fileToConvert: String, samplingRate: Int,
+                        audioBitRate: Int, channelCount: Int, progress: (Int) -> Unit = {} ) : String {
+        val filePath: String = context.filesDir.absolutePath + File.separator + fileToConvert
+        val aacFilePath: String = context.filesDir.absolutePath.toString() + "/" + fileToConvert.split('.')[0] + ".aac"
+
+        val inputFile = File(filePath)
+        val fis = FileInputStream(inputFile)
+
+        val outputFile = File(aacFilePath)
+        if (outputFile.exists()) outputFile.delete()
+
+        val mux = MediaMuxer(outputFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
+
+        var outputFormat = MediaFormat.createAudioFormat(COMPRESSED_AUDIO_FILE_MIME_TYPE, samplingRate, channelCount)
+        outputFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)
+        outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, audioBitRate)
+
+        val codec = MediaCodec.createEncoderByType(COMPRESSED_AUDIO_FILE_MIME_TYPE)
+        codec.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+        codec.start()
+
+        val codecInputBuffers: Array<ByteBuffer> = codec.inputBuffers // Note: Array of buffers
+        val codecOutputBuffers: Array<ByteBuffer> = codec.outputBuffers
+
+        val outBuffInfo = MediaCodec.BufferInfo()
+        val tempBuffer = ByteArray(samplingRate)
+        var hasMoreData = true
+        var presentationTimeUs = 0.0
+        var audioTrackIdx = 0
+        var totalBytesRead = 0
+        var percentComplete = 0
+
+        while (outBuffInfo.flags != MediaCodec.BUFFER_FLAG_END_OF_STREAM) {
+            var inputBufIndex = 0
+
+            while (inputBufIndex != -1 && hasMoreData) {
+                inputBufIndex = codec.dequeueInputBuffer(CODEC_TIMEOUT_IN_MS.toLong())
+                if (inputBufIndex >= 0) {
+                    val dstBuf: ByteBuffer = codecInputBuffers[inputBufIndex]
+                    dstBuf.clear()
+                    val bytesRead: Int = fis.read(tempBuffer, 0, dstBuf.limit())
+                    if (bytesRead == -1) { // -1 implies EOS
+                        hasMoreData = false
+                        codec.queueInputBuffer(inputBufIndex, 0, 0, presentationTimeUs.toLong(), MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                    } else {
+                        totalBytesRead += bytesRead
+                        dstBuf.put(tempBuffer, 0, bytesRead)
+                        codec.queueInputBuffer(inputBufIndex, 0, bytesRead, presentationTimeUs.toLong(), 0)
+                        presentationTimeUs = (1000000L * (totalBytesRead / 2) / samplingRate).toDouble()
+                    }
+                }
+            }
+
+            var outputBufIndex = 0
+            while (outputBufIndex != MediaCodec.INFO_TRY_AGAIN_LATER) {
+                outputBufIndex = codec.dequeueOutputBuffer(outBuffInfo, CODEC_TIMEOUT_IN_MS.toLong())
+
+                if (outputBufIndex >= 0) {
+                    val encodedData: ByteBuffer = codecOutputBuffers[outputBufIndex]
+                    encodedData.position(outBuffInfo.offset)
+                    encodedData.limit(outBuffInfo.offset + outBuffInfo.size)
+                    if (outBuffInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0 && outBuffInfo.size != 0) {
+                        codec.releaseOutputBuffer(outputBufIndex, false)
+                    } else {
+                        mux.writeSampleData(audioTrackIdx, codecOutputBuffers[outputBufIndex], outBuffInfo)
+                        codec.releaseOutputBuffer(outputBufIndex, false)
+                    }
+                } else if (outputBufIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+                    outputFormat = codec.outputFormat
+                    audioTrackIdx = mux.addTrack(outputFormat)
+                    mux.start()
+                } else if (outputBufIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+
+                } else if (outputBufIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
+                    // NO OP
+                } else {
+                    Log.e(LOGTAG, "Unknown return code from dequeueOutputBuffer - $outputBufIndex")
+                }
+            }
+
+            percentComplete = (totalBytesRead.toFloat() / inputFile.length() * 100.0).roundToInt()
+            progress.invoke(percentComplete)
+
+        }
+
+        fis.close()
+        mux.stop()
+        mux.release()
+        Log.v(LOGTAG, "Compression done ...")
+        return aacFilePath
+    }
+
+}
\ No newline at end of file
diff --git a/exorecord/src/test/java/dev/brookmg/exoplayer/ExampleUnitTest.kt b/exorecord/src/test/java/dev/brookmg/exorecord/lib/ExampleUnitTest.kt
similarity index 90%
rename from exorecord/src/test/java/dev/brookmg/exoplayer/ExampleUnitTest.kt
rename to exorecord/src/test/java/dev/brookmg/exorecord/lib/ExampleUnitTest.kt
index f6dbc3c..0eda3f2 100644
--- a/exorecord/src/test/java/dev/brookmg/exoplayer/ExampleUnitTest.kt
+++ b/exorecord/src/test/java/dev/brookmg/exorecord/lib/ExampleUnitTest.kt
@@ -1,4 +1,4 @@
-package dev.brookmg.exoplayer
+package dev.brookmg.exorecord.lib
 
 import org.junit.Test