https://github.com/phyks/blissify
Bind Bliss to MPD.
https://github.com/phyks/blissify
Last synced: about 2 months ago
JSON representation
Bind Bliss to MPD.
- Host: GitHub
- URL: https://github.com/phyks/blissify
- Owner: Phyks
- License: mit
- Created: 2016-04-05T22:36:04.000Z (about 9 years ago)
- Default Branch: master
- Last Pushed: 2017-04-13T14:43:27.000Z (about 8 years ago)
- Last Synced: 2025-03-24T12:08:10.847Z (2 months ago)
- Language: Python
- Size: 71.3 KB
- Stars: 14
- Watchers: 4
- Forks: 1
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
Blissify
========
Blissify is a wrapper around
[Bliss](https://github.com/Polochon-street/bliss) to compute and store values
in an SQLite database.
It is done in an attempt to bind Bliss to MPD to be able to play
smooth mixes with MPD, _à la_ Grooveshark radio.
## Dependencies
To build it you will need `sqlite3`, plus the required
dependencies from `bliss` (see
[https://github.com/Polochon-street/bliss](https://github.com/Polochon-street/bliss)).
## Build
```
git clone --recursive https://github.com/phyks/blissify
cd blissify; mkdir build; cd build
cmake ..
make
```
This will build a `blissify` executable.
## Usage
This repo contains several codes and scripts.
## The main `blissify` executable
The main `blissify` executable can be used to compute the values necessary to
use Bliss for various song files and store them in a SQLite database.
This executable takes a first argument being the basepath and a list of
filenames relative to this basepath as argument. It will compute values using
Bliss and store them in a SQLite database located in
`$XDG_DATA_HOME/blissify/db.sqlite3` (defaults to
`~/.local/share/blissify/db.sqlite3`).
You can do whatever you want with this db afterwards.
## The MPD server-side script
In the `mpd/` folder of this repo, you will find a `server.py` script. This is
a simple Python script to easily build the database from your MPD music
library. It calls `blissify` under the hood, so note that the `blissify`
executable **SHOULD** be in your `$PATH`.
It takes a `mpd_root` argument to set the top path of your MPD music library.
You can use either
* `--full-rescan` to purge the db and perform a full scan of your MPD music
library.
* `--rescan-errored` to scan failed files stored in database (from a previous
run). This option is usable even if you do not use MPD.
* `--update` to perform an update based on new additions to the library.
* `--listen` to listen to MPD IDLE signals on database update and update the
database accordingly in realtime.
Connection to your MPD server is handled by `$MPD_HOST` and `$MPD_PORT`
(defaulting to `localhost` and `6600`), as described in `mpc` man page.
_Note_: This step can be quite long. It took me around 50 hours to build the
database for a library with 50k songs.
## The MPD client-side script
Once you have built the database, you may want to play a continuous mix with
MPD. This is the purpose of the `client.py` script in `mpd/×` folder.
This script also uses the same environment variables as `mpc` does to connect to your MPD server.
_Note_: This script needs to have access to the database you built previously.
Then, you should either copy the database on the client (in the same
`$XDG_DATA_HOME/blissify` folder) or run it on the server.
It takes a single (optional) argument which is the number of songs to add to the playlist. Default is 20.
It builds a continuous mix starting from the latest song in your playlist. If your playlist is empty, it will start from a random song.
_Note_: If random mode is enabled in MPD, the script will warn you about it. Indeed, in this case, the mix is no longer continuous.
## The cache building script
Finally, in `scripts` folder, you will find a Python script `build_cache.py` to
build the distances cache.
Whenever you want to create a continuous mix, the client script will iterate
through your music library, compute pairwise distances and take a close enough
song. These computed distances are stored in the database as a cache, to
generate a playlist faster the next time.
This `build_cache.py` script can be used to precompute the pairwise distances
and build the cache, if you are willing to make some extra computation to
generate mixes faster.
## License
This code is distributed under an MIT license.
Feel free to contribute and reuse. For more details, see `LICENSE` file.