dejavu

For macOS (tested on OS X Mavericks), it is recommended to use Homebrew to install portaudio and ffmpeg. Follow the steps below to install the necessary Python dependencies and link the MySQL client library.

brew install portaudio
brew install ffmpeg

sudo easy_install pyaudio
sudo easy_install pydub
sudo easy_install numpy
sudo easy_install scipy
sudo easy_install matplotlib
sudo easy_install pip

sudo pip install MySQL-python

sudo ln -s /usr/local/mysql/lib/libmysqlclient.18.dylib /usr/lib/libmysqlclient.18.dylib

To memorize an audio collection, instantiate a Dejavu object with a configuration dictionary and use the fingerprint_directory method. Dejavu is robust; if interrupted, it will skip already fingerprinted songs upon restart.

fingerprint_directory arguments:

• input_directory: Path to the directory containing audio files.
• extensions: A list of audio extensions to look for (e.g., ['.mp3']).
• num_processes (optional): Number of processes to use for fingerprinting.

from dejavu import Dejavu

config = {
    "database": {
        "host": "127.0.0.1",
        "user": "root",
        "password": "your_password", 
        "database": "your_database",
    }
}

djv = Dejavu(config)

# Fingerprint all mp3s in the directory using 3 processes
djv.fingerprint_directory("va_us_top_40/mp3", [".mp3"], 3)

There is a direct trade-off between the required recording time, fingerprint accuracy, and database storage usage. You can adjust the following parameters to balance these needs:

• Amplitude threshold for peaks: Adjusting this affects how many peaks are stored.
• Fan value for fingerprinting: Adjusting this affects the density of fingerprints.

Increasing these values will result in more fingerprints, which bolsters accuracy but increases the storage footprint in the database.

To install Dejavu on Fedora 20+, you must first install system dependencies via yum, set up a virtual environment with system site packages enabled to access those dependencies, and then install the PyDejavu package via PyPI or GitHub.

# Install system dependencies
sudo yum install numpy scipy python-matplotlib ffmpeg portaudio-devel
pip install PyAudio
pip install pydub

# Setup virtualenv with system site packages
pip install virtualenv
virtualenv --system-site-packages env_with_system

# Install from PyPI
source env_with_system/bin/activate
pip install PyDejavu

# OR install latest code from GitHub
source env_with_system/bin/activate
pip install https://github.com/worldveil/dejavu/zipball/master

Dejavu is configured via a Python dictionary passed to the Dejavu constructor.

Mandatory Keys:

• database: A dictionary containing connection parameters required by your database driver (e.g., host, user, password, database).

Optional Keys:

• database_type: Supports mysql (default) and postgres.
• fingerprint_limit: Controls how many seconds of each audio file to fingerprint. Use -1 or None to fingerprint the entire file.

from dejavu import Dejavu

config = {
    "database": {
        "host": "127.0.0.1",
        "user": "root",
        "password": "Password123", 
        "database": "dejavu_db",
    },
    "database_type" : "mysql",
    "fingerprint_limit" : 10
}

djv = Dejavu(config)

You can deploy the Dejavu stack (PostgreSQL database and Python environment) using the provided docker-compose.yaml file. This setup creates a private network db_network to allow the python service to communicate with the db service.

To start the services, run:

docker-compose up

You can recognize live audio through a microphone using the CLI or the Python API.

Via CLI: Specify the number of seconds to listen after the mic keyword.

python dejavu.py --recognize mic <seconds>

Via Python API: Use the MicrophoneRecognizer class with the djv.recognize method.

from dejavu.logic.recognizer.microphone_recognizer import MicrophoneRecognizer
song = djv.recognize(MicrophoneRecognizer, seconds=10)

# CLI
$ python dejavu.py --recognize mic 10

# Python
from dejavu.logic.recognizer.microphone_recognizer import MicrophoneRecognizer
song = djv.recognize(MicrophoneRecognizer, seconds=10)

You can recognize audio files using either the CLI or the Python API.

Via CLI:

python dejavu.py --recognize file <path_to_file>

Via Python API: Use the FileRecognizer class with the djv.recognize method.

from dejavu.logic.recognizer.file_recognizer import FileRecognizer
song = djv.recognize(FileRecognizer, "path/to/audio.wav")

# CLI
$ python dejavu.py --recognize file sometrack.wav 

# Python
from dejavu.logic.recognizer.file_recognizer import FileRecognizer
song = djv.recognize(FileRecognizer, "va_us_top_40/wav/Mirrors - Justin Timberlake.wav")

The python service is built from ./docker/python and depends on the db service being available. It mounts the current working directory to /code inside the container, allowing for live development or access to local files.

services:
  python:
    build:
      context: ./docker/python
    volumes:
      - .:/code
    depends_on:
      - db

The db service uses a PostgreSQL image built from ./docker/postgres. You can configure the database credentials and name using the following environment variables:

• POSTGRES_DB: The name of the database (defaults to dejavu).
• POSTGRES_USER: The database user (defaults to postgres).
• POSTGRES_PASSWORD: The password for the database user (defaults to password).

services:
  db:
    environment:
      - POSTGRES_DB=dejavu
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password