diff --git a/Dockerfile b/Dockerfile
index 3d80231..81d39d1 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -34,8 +34,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
          libavutil-dev \
          libswresample-dev \
          libfftw3-dev \
-         libmad0 \
-         libmad0-dev \
          python-gst-1.0 \
          python3-gst-1.0 \
          libsndfile1 &&\
@@ -47,7 +45,4 @@ WORKDIR /app
 
 # install requirements, starting with pycairo because it fails in a different order
 RUN pip install pycairo
-RUN pip install --requirement /app/requirements.txt
-
-# install torchaudio from source
-RUN git clone https://github.com/pytorch/audio.git pytorchaudio && cd pytorchaudio && python setup.py install
+RUN pip install --requirement /app/requirements.txt
\ No newline at end of file
diff --git a/README.md b/README.md
index 84ba28b..9e4a33a 100644
--- a/README.md
+++ b/README.md
@@ -4,28 +4,28 @@ The aim of his repository is to evaluate the loading performance of various audi
 
 This is relevant for machine learning models that today often process raw (time domain) audio and assembling a batch on the fly. It is therefore important to load the audio as fast as possible. At the same time a library should ideally support a variety of uncompressed and compressed audio formats and also is capable of loading only chunks of audio (seeking). The latter is especially important for models that cannot easily work with samples of variable length (convnets).
 
-## Tested Libraries 
+## Tested Libraries
 
 | Library                 | Version | Short-Name/Code       | Out Type          | Supported codecs  | Excerpts/Seeking |
 |-------------------------|---------|-----------------------|-------------------|-------------------| -----------------|
-| [scipy.io.wavfile](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read) | 0.14.0 | [`scipy`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L55)       | Numpy      | PCM (only 16 bit)   | ❌        |
-| [scipy.io.wavfile memmap](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read) | 0.14.0 | [`scipy_mmap`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L61)  | Numpy      | PCM (only 16 bit)   | ✅        |
-| [soundfile](https://pysoundfile.readthedocs.io/en/0.9.0/) ([libsndfile](http://www.mega-nerd.com/libsndfile/)) | 0.9.0 | [`soundfile`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L50)   | Numpy   | PCM, Ogg, Flac | ✅             |
+| [scipy.io.wavfile](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read) | 1.4.1 | [`scipy`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L55)       | Numpy      | PCM (only 16 bit)   | ❌        |
+| [scipy.io.wavfile memmap](https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read) | 1.4.1 | [`scipy_mmap`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L61)  | Numpy      | PCM (only 16 bit)   | ✅        |
+| [soundfile](https://pysoundfile.readthedocs.io/en/0.9.0/) ([libsndfile](http://www.mega-nerd.com/libsndfile/)) | 0.9.0 | [`soundfile`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L50)   | Numpy | PCM, Ogg, Flac | ✅             |
 | [pydub](https://github.com/jiaaro/pydub) | 0.23.1 | [`pydub`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L97) | Python Array |  PCM, MP3, OGG or other FFMPEG/libav supported codec | ❌ |
 | [aubio](https://github.com/aubio/aubio) | 0.4.9 | [`aubio`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L32) | Numpy Array | PCM, MP3, OGG or other avconv supported code |  ✅ |
-| [audioread](https://github.com/beetbox/audioread) ([libmad](https://www.underbit.com/products/mad/))  | 2.1.6 | [`ar_mad`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L77) | Numpy Array | FFMPEG | ❌ |
-| [audioread](https://github.com/beetbox/audioread) ([gstreamer](https://gstreamer.freedesktop.org/)) |2.1.6 | [`ar_gstreamer`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L67) |2.1.6 | Numpy Array | all of FFMPEG | ❌ |
-| [audioread](https://github.com/beetbox/audioread) ([FFMPEG](https://www.ffmpeg.org/)) | 2.1.6 | [`ar_ffmpeg`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L87) | Numpy Array | all of FFMPEG | ❌ |
-| [librosa](https://librosa.github.io/)  | 0.6.2 | [`librosa`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L104) | Numpy Array | relies on audioread |  ✅ |
-| [tensorflow 1.13 `contrib.ffmpeg`](https://www.tensorflow.org/api_docs/python/tf/contrib/ffmpeg/decode_audio) | 1.13 | [`tf_decode`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L21) | Tensorflow Tensor | All codecs supported by FFMPEG |  ❌ |
-| [torchaudio](https://github.com/pytorch/audio) | 0.3.0 | [`torchaudio`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L45) | PyTorch Tensor | all codecs supported by Sox |  ✅ |
-
-### Not tested
+| [audioread](https://github.com/beetbox/audioread) ([gstreamer](https://gstreamer.freedesktop.org/)) | 2.1.8 | [`ar_gstreamer`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L67) | Numpy Array | all of FFMPEG | ❌ |
+| [audioread](https://github.com/beetbox/audioread) ([FFMPEG](https://www.ffmpeg.org/)) | 2.1.8 | [`ar_ffmpeg`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L87) | Numpy Array | all of FFMPEG | ❌ |
+| [librosa](https://librosa.github.io/)  | 0.7.2 | [`librosa`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L104) | Numpy Array | relies on audioread |  ✅ |
+| [tensorflow `tf.io.audio.decode_wav`](https://www.tensorflow.org/api_docs/python/tf/contrib/ffmpeg/decode_audio) | 2.1.0 | [`tf_decode_wav`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L22) | Tensorflow Tensor | PCM (only 16 bit) |  ❌ |
+| [tensorflow-io `from_audio`](https://www.tensorflow.org/io/api_docs/python/tfio/v0/IOTensor#from_audio) | 0.11.0 | [`tfio_fromaudio`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L22) | Tensorflow Tensor | PCM, Ogg, Flac |  ✅ |
+| [torchaudio](https://github.com/pytorch/audio) (sox) | 0.4.0 | [`torchaudio`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L45) | PyTorch Tensor | all codecs supported by Sox |  ✅ |
+| [torchaudio](https://github.com/pytorch/audio) (soundfile) | 0.4.0| [`torchaudio`](https://github.com/faroit/python_audio_loading_benchmark/blob/master/loaders.py#L45) | PyTorch Tensor | all codecs supported by Sox |  ✅ |
+### Not included
 
 * __[audioread (coreaudio)](https://github.com/beetbox/audioread/blob/master/audioread/macca.py)__: only available on macOS.
-* __[madmom](https://github.com/CPJKU/madmom):__ same ffmpeg interface as `ar_ffmpeg`.
-* __[tensorflow 2 `decode_wav`](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/audio/decode_wav):__ Not released yet.
-* __[python builtin `wave`](https://docs.python.org/3.7/library/wave.html)__: TODO
+* __[madmom](https://github.com/CPJKU/madmom)__: same ffmpeg interface as `ar_ffmpeg`.
+* __[pymad](https://github.com/jaqx0r/pymad)__: only support for MP3, also very slow.
+* __[python builtin `wave`](https://docs.python.org/3.7/library/wave.html)__: TODO (open for PR)
 
 ## Results
 
@@ -73,7 +73,13 @@ Build the docker container using
 docker build -t audio_benchmark .
 ```
 It installs all the package requirements for all audio libraries.
-Afterwards, mount the data directory into the docker container.
+Afterwards, mount the data directory into the docker container and run `run.sh` inside the
+container, e.g.:
+
+```bash
+docker run -v /home/user/repos/python_audio_loading_benchmark/:/app \
+    -it audio_benchmark:latest /bin/bash run.sh
+```
 
 ### Setting up in a virtual environment
 
@@ -105,4 +111,4 @@ The data is generated by using a shell script. To generate the data in the folde
 
 ## Contribution
 
-We encourage interested users to contribute to this repository in the issue section and via pull requests. Particularly interesting are notifications of new tools and new versions of existing packages. Since benchmarks are subjective, I (@faroit) will reran the benchmark on our server again.
\ No newline at end of file
+We encourage interested users to contribute to this repository in the issue section and via pull requests. Particularly interesting are notifications of new tools and new versions of existing packages. Since benchmarks are subjective, I (@faroit) will reran the benchmark on our server again.
diff --git a/benchmark_metadata.py b/benchmark_metadata.py
index 7b43f6d..c42c1c7 100644
--- a/benchmark_metadata.py
+++ b/benchmark_metadata.py
@@ -61,7 +61,6 @@ def __len__(self):
         'soundfile',
         'sox',
         'audioread',
-        # 'pydub',  # too slow
     ]
 
     for lib in libs:
diff --git a/benchmark_np.py b/benchmark_np.py
index 53a2ff5..287ef50 100644
--- a/benchmark_np.py
+++ b/benchmark_np.py
@@ -1,13 +1,11 @@
-import matplotlib
-matplotlib.use('Agg')
 import os
 import os.path
-import random
-import time
+import timeit
 import argparse
 import utils
-import loaders
 import numpy as np
+import functools
+import loaders
 
 
 def get_files(dir, extension):
@@ -26,24 +24,30 @@ class AudioFolder(object):
     def __init__(
         self,
         root,
-        download=True,
-        extension='wav',
-        lib="librosa",
+        extension='wav'
     ):
         self.root = os.path.expanduser(root)
         self.data = []
         self.audio_files = get_files(dir=self.root, extension=extension)
-        self.loader_function = getattr(loaders, lib)
 
     def __getitem__(self, index):
-        return self.loader_function(self.audio_files[index])
+        return self.audio_files[index]
 
     def __len__(self):
         return len(self.audio_files)
 
 
+def test_np_loading(fp, lib):
+    load_function = getattr(loaders, 'load_' + lib)
+    audio = load_function(fp)
+    if np.max(audio) > 0:
+        return True
+    else:
+        return False
+
+
 if __name__ == "__main__":
-    
+
     parser = argparse.ArgumentParser(description='Process some integers.')
     parser.add_argument('--ext', type=str, default="wav")
     args = parser.parse_args()
@@ -60,14 +64,14 @@ def __len__(self):
     # audio formats to be bench
     # libraries to be benchmarked
     libs = [
-        'ar_gstreamer',
+        'scipy',
+        'stempeg',
+        'soxbindings',
         'ar_ffmpeg',
-        'ar_mad',
         'aubio',
         'pydub',
-        'soundfile', 
-        'librosa', 
-        'scipy',
+        'soundfile',
+        'librosa',
         'scipy_mmap'
     ]
 
@@ -75,29 +79,25 @@ def __len__(self):
         print("Testing: %s" % lib)
         for root, dirs, fnames in sorted(os.walk('AUDIO')):
             for audio_dir in dirs:
-                try:
-                    duration = int(audio_dir)
-                    dataset = AudioFolder(
-                            os.path.join(root, audio_dir), 
-                            lib='load_' + lib,
-                            extension=args.ext
-                    )
-                    
-                    
-                    start = time.time()
-
-                    for fp in dataset.audio_files:
-                        audio = dataset.loader_function(fp)
-                        np.max(audio)
-
-                    end = time.time()
-                    store.append(
-                        ext=args.ext,
-                        lib=lib,
-                        duration=duration,
-                        time=float(end-start) / len(dataset),
-                    )
-                except:
-                    continue
+                duration = int(audio_dir)
+                dataset = AudioFolder(
+                    os.path.join(root, audio_dir),
+                    extension=args.ext
+                )
+
+                # for fp in dataset.audio_files:
+                for fp in dataset.audio_files:
+                    time = min(timeit.repeat(
+                        functools.partial(test_np_loading, fp, lib),
+                        number=3,
+                        repeat=3
+                    ))
+
+                store.append(
+                    ext=args.ext,
+                    lib=lib,
+                    duration=duration,
+                    time=time,
+                )
 
     store.df.to_pickle("results/benchmark_%s_%s.pickle" % ("np", args.ext))
\ No newline at end of file
diff --git a/benchmark_pytorch.py b/benchmark_pytorch.py
index 23f8fd1..1e8aff2 100644
--- a/benchmark_pytorch.py
+++ b/benchmark_pytorch.py
@@ -28,7 +28,6 @@ class AudioFolder(torch.utils.data.Dataset):
     def __init__(
         self,
         root,
-        download=True,
         extension='wav',
         lib="librosa",
     ):
@@ -39,18 +38,19 @@ def __init__(
 
     def __getitem__(self, index):
         audio = self.loader_function(self.audio_files[index])
-        return torch.FloatTensor(audio).view(1, 1, -1)
+        return torch.as_tensor(audio).view(1, 1, -1)
 
     def __len__(self):
         return len(self.audio_files)
 
 
 if __name__ == "__main__":
-    
+
     parser = argparse.ArgumentParser(description='Process some integers.')
     parser.add_argument('--ext', type=str, default="wav")
     args = parser.parse_args()
 
+    repeat = 3
     columns = [
         'ext',
         'lib',
@@ -63,30 +63,39 @@ def __len__(self):
     # audio formats to be bench
     # libraries to be benchmarked
     libs = [
-        'ar_gstreamer',
+        'stempeg',
+        'soxbindings',
         'ar_ffmpeg',
-        'ar_mad',
         'aubio',
         'pydub',
-        'soundfile', 
-        'librosa', 
+        'soundfile',
+        'librosa',
         'scipy',
         'scipy_mmap',
     ]
 
     if args.ext != "mp4":
-        libs.append('torchaudio')
+        libs.append('torchaudio-sox_io')
+        libs.append('torchaudio-soundfile')
 
     for lib in libs:
         print("Testing: %s" % lib)
+        if "torchaudio" in lib:
+            backend = lib.split("torchaudio-")[-1]
+            import torchaudio
+            torchaudio.set_audio_backend(backend)
+            call_fun = "load_torchaudio"
+        else:
+            call_fun = 'load_' + lib
+
         for root, dirs, fnames in sorted(os.walk('AUDIO')):
             for audio_dir in dirs:
                 try:
                     duration = int(audio_dir)
                     data = torch.utils.data.DataLoader(
                         AudioFolder(
-                            os.path.join(root, audio_dir), 
-                            lib='load_' + lib,
+                            os.path.join(root, audio_dir),
+                            lib=call_fun,
                             extension=args.ext
                         ),
                         batch_size=1,
@@ -95,18 +104,19 @@ def __len__(self):
                     )
                     start = time.time()
 
-                    for X in data:
-                        X.max()
+                    for i in range(repeat):
+                        for X in data:
+                            X.max()
 
                     end = time.time()
                     store.append(
                         ext=args.ext,
                         lib=lib,
                         duration=duration,
-                        time=float(end-start) / len(data),
+                        time=float(end-start) / (len(data) * repeat),
                     )
                 except:
+                    "Error but continue"
                     continue
 
-
-    store.df.to_pickle("results/benchmark_%s_%s.pickle" % ("pytorch", args.ext))
\ No newline at end of file
+    store.df.to_pickle("results/benchmark_%s_%s.pickle" % ("pytorch", args.ext))
diff --git a/benchmark_tf.py b/benchmark_tf.py
index c942e2e..6fd5b6e 100644
--- a/benchmark_tf.py
+++ b/benchmark_tf.py
@@ -26,16 +26,18 @@ def get_files(dir, extension):
 
 def _make_py_loader_function(func):
     def _py_loader_function(fp):
-        return func(fp.decode())
+        return func(fp.numpy().decode())
     return _py_loader_function
 
 
 if __name__ == "__main__":
 
-    parser = argparse.ArgumentParser(description='Benchmark audio loading in tensorflow')
+    parser = argparse.ArgumentParser(
+        description='Benchmark audio loading in tensorflow'
+    )
     parser.add_argument('--ext', type=str, default="wav")
     args = parser.parse_args()
-
+    repeat = 3
     columns = [
         'ext',
         'lib',
@@ -46,60 +48,75 @@ def _py_loader_function(fp):
     store = utils.DF_writer(columns)
 
     libs = [
-        'ar_gstreamer',
+        'tfio_fromaudio',
+        'stempeg',
+        'soxbindings',
         'ar_ffmpeg',
-        'ar_mad',
         'aubio',
         'pydub',
         'soundfile',
         'librosa',
         'scipy',
         'scipy_mmap',
-        'tf_decode'
+        'tf_decode_wav',
     ]
 
     for lib in libs:
         print("Testing: %s" % lib)
         for root, dirs, fnames in sorted(os.walk('AUDIO')):
             for audio_dir in dirs:
-                try:
-                    duration = int(audio_dir)
-                    audio_files = get_files(dir=os.path.join(root, audio_dir), extension=args.ext)
-
-                    dataset = tf.data.Dataset.from_tensor_slices(audio_files)
-                    if lib == "tf_decode":
-                        dataset = dataset.map(lambda x: loaders.load_tf_decode(x, args.ext))
-                    else:
-                        loader_function = getattr(loaders, 'load_' + lib)
-                        dataset = dataset.map(
-                            lambda filename: tf.py_func(
-                                _make_py_loader_function(loader_function), 
-                                [filename], 
-                                [tf.float32]
-                            )
-                        )
-
-                    dataset = dataset.batch(1)
-                    start = time.time()
-                    iterator = dataset.make_one_shot_iterator()
-                    next_audio = iterator.get_next()
-                    with tf.Session() as sess:
-                        for i in range(len(audio_files)):
-                            try:
-                                value = sess.run(tf.reduce_max(next_audio))
-                            except tf.errors.OutOfRangeError:
-                                break
-
-                    end = time.time()
-                    
+                append = False
+                duration = int(audio_dir)
+                audio_files = get_files(
+                    dir=os.path.join(root, audio_dir),
+                    extension=args.ext
+                )
+
+                dataset = tf.data.Dataset.from_tensor_slices(audio_files)
+                if lib in ["tf_decode_wav"]:
+                    dataset = dataset.map(
+                        lambda x: loaders.load_tf_decode_wav(x),
+                        num_parallel_calls=1
+                    )
+                elif lib in ["tfio_fromaudio"]:
+                    dataset = dataset.map(
+                        lambda x: loaders.load_tfio_fromaudio(x, args.ext),
+                        num_parallel_calls=1
+                    )
+                elif lib in ["tfio_fromffmpeg"]:
+                    dataset = dataset.map(
+                        lambda x: loaders.load_tfio_fromffmpeg(x),
+                        num_parallel_calls=1
+                    )
+                else:
+                    loader_function = getattr(loaders, 'load_' + lib)
+                    dataset = dataset.map(
+                        lambda filename: tf.py_function(
+                            _make_py_loader_function(loader_function),
+                            [filename],
+                            [tf.float32]
+                        ),
+                        num_parallel_calls=1
+                    )
+
+                dataset = dataset.apply(tf.data.experimental.ignore_errors())
+
+                start = time.time()
+
+                for i in range(repeat):
+                    for audio in dataset:
+                        value = tf.reduce_max(audio)
+                        if value:
+                            append = True
+
+                end = time.time()
+                
+                if append:
                     store.append(
                         ext=args.ext,
                         lib=lib,
                         duration=duration,
-                        time=float(end-start) / len(audio_files),
+                        time=float(end-start) / (len(audio_files) * repeat),
                     )
-                except:
-                    continue
 
     store.df.to_pickle("results/benchmark_%s_%s.pickle" % ("tf", args.ext))
-
diff --git a/generate_audio.sh b/generate_audio.sh
index a745dc2..a7b2aa4 100644
--- a/generate_audio.sh
+++ b/generate_audio.sh
@@ -7,7 +7,7 @@ DIR=AUDIO
 for k in $(seq -f "%02g" 1 10 151); do
     mkdir $DIR/$k
     for i in $(seq 1 $NBFILES); do
-        sox -n -r 44100 $DIR/$k/$i.wav synth "0:$k" whitenoise vol 0.5 fade q 1 "0:$k" 1
+        sox -n -r 44100 -b 16 $DIR/$k/$i.wav synth "0:$k" whitenoise vol 0.5 fade q 1 "0:$k" 1
         ffmpeg -i $DIR/$k/$i.wav -strict -2 $DIR/$k/$i.mp4
         ffmpeg -i $DIR/$k/$i.wav $DIR/$k/$i.mp3
         ffmpeg -i $DIR/$k/$i.wav $DIR/$k/$i.flac
diff --git a/loaders.py b/loaders.py
index cf54fb6..29b65fc 100644
--- a/loaders.py
+++ b/loaders.py
@@ -1,7 +1,5 @@
 from scipy.io import wavfile
 import audioread.rawread
-import audioread.gstdec
-import audioread.maddec
 import audioread.ffdec
 import matplotlib.pyplot as plt
 import soundfile as sf
@@ -10,8 +8,11 @@
 import torchaudio
 import numpy as np
 import tensorflow as tf
+import tensorflow_io as tfio
 import librosa
-import sox
+import soxbindings as sox
+import stempeg
+
 
 """
 Some of the code taken from: 
@@ -19,15 +20,26 @@
 """
 
 
-def load_tf_decode(fp, ext="wav", rate=44100):
-    audio_binary = tf.read_file(fp)
-    audio_decoded = tf.contrib.ffmpeg.decode_audio(
-        audio_binary, 
-        file_format=ext, 
-        samples_per_second=rate, 
-        channel_count=1
-    )
-    return tf.cast(audio_decoded, tf.float32)
+@tf.function
+def load_tfio_fromffmpeg(fp):
+    # not supported yet
+    audio = tfio.IOTensor.graph(tf.int16).from_ffmpeg(fp)
+    return tf.cast(audio.to_tensor(), tf.float32) / 32767.0
+
+
+@tf.function
+def load_tfio_fromaudio(fp, ext="wav"):
+    if ext in ["wav", "flac", "mp4"]:
+        audio = tfio.IOTensor.graph(tf.float16).from_audio(fp)
+        return tf.cast(audio.to_tensor(), tf.float16)
+    else:
+        return tfio.IOTensor.graph(tf.float32).from_audio(fp).to_tensor()
+
+
+@tf.function
+def load_tf_decode_wav(fp, ext="wav", rate=44100):
+    audio, rate = tf.audio.decode_wav(tf.io.read_file(fp))
+    return tf.cast(audio, tf.float32)
 
 
 def load_aubio(fp):
@@ -48,6 +60,20 @@ def load_torchaudio(fp):
     return sig
 
 
+def load_stempeg(fp):
+    sig = stempeg.read._read_ffmpeg(
+        fp,
+        sample_rate=44100,
+        channels=1,
+        start=None,
+        duration=None,
+        dtype=np.float32,
+        ffmpeg_format='f32le',
+        stem_idx=0
+    )
+    return sig
+
+
 def load_soundfile(fp):
     sig, rate = sf.read(fp)
     return sig
@@ -65,26 +91,6 @@ def load_scipy_mmap(fp):
     return sig
 
 
-def load_ar_gstreamer(fp):
-    with audioread.gstdec.GstAudioFile(fp) as f:
-        total_frames = 0
-        for buf in f:
-            sig = _convert_buffer_to_float(buf)
-            sig = sig.reshape(f.channels, -1)
-            total_frames += sig.shape[1]
-        return sig
-
-
-def load_ar_mad(fp):
-    with audioread.maddec.MadAudioFile(fp) as f:
-        total_frames = 0
-        for buf in f:
-            sig = _convert_buffer_to_float(buf)
-            sig = sig.reshape(f.channels, -1)
-            total_frames += sig.shape[1]
-        return sig
-
-
 def load_ar_ffmpeg(fp):
     with audioread.ffdec.FFmpegAudioFile(fp) as f:
         total_frames = 0
@@ -95,6 +101,12 @@ def load_ar_ffmpeg(fp):
         return sig
 
 
+def load_soxbindings(fp):
+    tfm = sox.Transformer()
+    array_out = tfm.build_array(input_filepath=fp)
+    return array_out
+
+
 def load_pydub(fp):
     song = AudioSegment.from_file(fp)
     sig = np.asarray(song.get_array_of_samples(), dtype='float32')
@@ -103,8 +115,6 @@ def load_pydub(fp):
 
 
 def load_librosa(fp):
-    """Librosa audio loading is using 
-    """
     # loading with `sr=None` is disabling the internal resampling
     sig, rate = librosa.load(fp, sr=None)
     return sig
diff --git a/plot.py b/plot.py
index 02e1418..5872f61 100644
--- a/plot.py
+++ b/plot.py
@@ -3,33 +3,37 @@
 import matplotlib.pyplot as plt
 
 
-for package in ['pytorch', 'tf', 'np', 'metadata']:
+for package in ['np', 'pytorch', 'tf']:
     dfs = []
     for ext in ["wav", "mp3", "mp4", "ogg", "flac"]:
-        dfs.append(pd.read_pickle("results/benchmark_%s_%s.pickle" % (package, ext)))
+        try:
+            dfs.append(
+                pd.read_pickle("results/benchmark_%s_%s.pickle" % (package, ext))
+            )
+        except FileNotFoundError:
+            continue
 
     df = pd.concat(dfs, ignore_index=True)
 
     sns.set_style("whitegrid")
 
-    ordered_libs = df.time.groupby(
-        df.lib
+    ordered_exts = df.time.groupby(
+        df.ext
     ).mean().sort_values().index.tolist()
 
     fig = plt.figure()
 
     g = sns.catplot(
-        x="time", 
-        y="lib", 
+        x="time",
+        y="ext",
         kind='bar',
-        hue='ext', 
-        order=ordered_libs,
+        hue='lib',
+        order=ordered_exts,
         data=df,
-        height=6.6, 
+        height=6.6,
         aspect=1,
         legend=False
     )
     g.despine(left=True)
     plt.legend(loc='upper right')
     g.savefig("results/benchmark_%s.png" % package)
-
diff --git a/requirements.txt b/requirements.txt
index e9ce5cc..9d607e7 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,16 +1,17 @@
-scipy==1.2.0
-tensorflow==1.15.2
-audioread==2.1.6
-librosa==0.6.2
-SoundFile==0.10.2
-torch==1.0.1
-pydub==0.23.1
-sox==1.3.7
-PyGObject==3.30.4
+scipy==1.7.1
+tensorflow==2.6.0
+audioread==2.1.9
+librosa==0.8.1
+SoundFile==0.10.3.post1
+torch==1.9.0
+pydub==0.25.1
+sox==1.4.1
+soxbindings
+torchaudio==0.9.0
+aubio==0.4.9
+tensorflow_io==0.20.0
+stempeg==0.2.3
 seaborn
 pandas
 ipython
-torchvision
-pymad
 cffi
-aubio==0.4.9
\ No newline at end of file
diff --git a/results/benchmark_metadata.png b/results/benchmark_metadata.png
deleted file mode 100644
index 0be9d38..0000000
Binary files a/results/benchmark_metadata.png and /dev/null differ
diff --git a/results/benchmark_metadata_flac.pickle b/results/benchmark_metadata_flac.pickle
index 75d36a8..71a37b6 100644
Binary files a/results/benchmark_metadata_flac.pickle and b/results/benchmark_metadata_flac.pickle differ
diff --git a/results/benchmark_metadata_mp3.pickle b/results/benchmark_metadata_mp3.pickle
index a412e0b..7c24003 100644
Binary files a/results/benchmark_metadata_mp3.pickle and b/results/benchmark_metadata_mp3.pickle differ
diff --git a/results/benchmark_metadata_mp4.pickle b/results/benchmark_metadata_mp4.pickle
index ca3a8c8..c90542c 100644
Binary files a/results/benchmark_metadata_mp4.pickle and b/results/benchmark_metadata_mp4.pickle differ
diff --git a/results/benchmark_metadata_ogg.pickle b/results/benchmark_metadata_ogg.pickle
index 0651c59..d0b1559 100644
Binary files a/results/benchmark_metadata_ogg.pickle and b/results/benchmark_metadata_ogg.pickle differ
diff --git a/results/benchmark_metadata_wav.pickle b/results/benchmark_metadata_wav.pickle
index ce6ee71..1c5a9e1 100644
Binary files a/results/benchmark_metadata_wav.pickle and b/results/benchmark_metadata_wav.pickle differ
diff --git a/results/benchmark_np.png b/results/benchmark_np.png
index 6450e2d..c84c533 100644
Binary files a/results/benchmark_np.png and b/results/benchmark_np.png differ
diff --git a/results/benchmark_np_flac.pickle b/results/benchmark_np_flac.pickle
index 3a759d4..32397ff 100644
Binary files a/results/benchmark_np_flac.pickle and b/results/benchmark_np_flac.pickle differ
diff --git a/results/benchmark_np_mp3.pickle b/results/benchmark_np_mp3.pickle
index e37baf7..c44efdf 100644
Binary files a/results/benchmark_np_mp3.pickle and b/results/benchmark_np_mp3.pickle differ
diff --git a/results/benchmark_np_mp4.pickle b/results/benchmark_np_mp4.pickle
index cea5970..44cd50f 100644
Binary files a/results/benchmark_np_mp4.pickle and b/results/benchmark_np_mp4.pickle differ
diff --git a/results/benchmark_np_ogg.pickle b/results/benchmark_np_ogg.pickle
index 68f8b4d..3962254 100644
Binary files a/results/benchmark_np_ogg.pickle and b/results/benchmark_np_ogg.pickle differ
diff --git a/results/benchmark_np_wav.pickle b/results/benchmark_np_wav.pickle
index 407a5b0..fde7f5a 100644
Binary files a/results/benchmark_np_wav.pickle and b/results/benchmark_np_wav.pickle differ
diff --git a/results/benchmark_pytorch.png b/results/benchmark_pytorch.png
index 5f25826..34a810a 100644
Binary files a/results/benchmark_pytorch.png and b/results/benchmark_pytorch.png differ
diff --git a/results/benchmark_pytorch_flac.pickle b/results/benchmark_pytorch_flac.pickle
index fea1880..ab58240 100644
Binary files a/results/benchmark_pytorch_flac.pickle and b/results/benchmark_pytorch_flac.pickle differ
diff --git a/results/benchmark_pytorch_mp3.pickle b/results/benchmark_pytorch_mp3.pickle
index ebd97ff..553adf9 100644
Binary files a/results/benchmark_pytorch_mp3.pickle and b/results/benchmark_pytorch_mp3.pickle differ
diff --git a/results/benchmark_pytorch_mp4.pickle b/results/benchmark_pytorch_mp4.pickle
index f580c5c..9fc7a1c 100644
Binary files a/results/benchmark_pytorch_mp4.pickle and b/results/benchmark_pytorch_mp4.pickle differ
diff --git a/results/benchmark_pytorch_ogg.pickle b/results/benchmark_pytorch_ogg.pickle
index 2fc054f..7372d7c 100644
Binary files a/results/benchmark_pytorch_ogg.pickle and b/results/benchmark_pytorch_ogg.pickle differ
diff --git a/results/benchmark_pytorch_wav.pickle b/results/benchmark_pytorch_wav.pickle
index d2f7107..66f8011 100644
Binary files a/results/benchmark_pytorch_wav.pickle and b/results/benchmark_pytorch_wav.pickle differ
diff --git a/results/benchmark_tf.png b/results/benchmark_tf.png
index 75d84ae..ebfa25f 100644
Binary files a/results/benchmark_tf.png and b/results/benchmark_tf.png differ
diff --git a/results/benchmark_tf_flac.pickle b/results/benchmark_tf_flac.pickle
index e8a7804..3d62efc 100644
Binary files a/results/benchmark_tf_flac.pickle and b/results/benchmark_tf_flac.pickle differ
diff --git a/results/benchmark_tf_mp3.pickle b/results/benchmark_tf_mp3.pickle
index 6f17ee2..3e6e74b 100644
Binary files a/results/benchmark_tf_mp3.pickle and b/results/benchmark_tf_mp3.pickle differ
diff --git a/results/benchmark_tf_mp4.pickle b/results/benchmark_tf_mp4.pickle
index 14074e7..a3daf39 100644
Binary files a/results/benchmark_tf_mp4.pickle and b/results/benchmark_tf_mp4.pickle differ
diff --git a/results/benchmark_tf_ogg.pickle b/results/benchmark_tf_ogg.pickle
index 3762417..5790e7a 100644
Binary files a/results/benchmark_tf_ogg.pickle and b/results/benchmark_tf_ogg.pickle differ
diff --git a/results/benchmark_tf_wav.pickle b/results/benchmark_tf_wav.pickle
index c9008cc..05ddba8 100644
Binary files a/results/benchmark_tf_wav.pickle and b/results/benchmark_tf_wav.pickle differ