Hi all,

I want to make a randomised playlist of audio files using Pd - the plan is to have a USB stick full of wav files that can just be plugged in and have an a randomised, looping playlist made from them when Pd boots. This way I can change the tracks just by loading new files onto the USB stick, without having to alter the patch each time. What's the best solution for this?

[readsf~] or maybe [readanysf~] as the latter reads mp3 files too plus gives you more info, like length of file etc. so it's easier to automate a process where a track will start only when the current one finishes...

What platform? I have a python script (py/ext) that pick a file randomly from a specified folder and spit it out to [readanysf~]. You could also use the mtl abstractions / [fileBrowser] and send a random index to it.

It's on a pi, though my python knowledge is almost non existent! That sounds like an interesting solution though...

search.py script is very straightforward:

import sys, os

try:
    import pyext
except:
    print "ERROR: This script must be loaded by the PD pyext external"
    sys.exit()

savepath = os.getcwd()
extension = 'wav'

def Walk( root, recurse=1, pattern='*', return_folders=0 ):
    import fnmatch, os, string
    
    # initialize
    result = []

    # must have at least root folder
    try:
        names = os.listdir(root)
    except os.error:
        return result

    # expand pattern
    pattern = pattern or '*'
    pat_list = string.splitfields( pattern , ';' )
    
    # check each file
    for name in names:
        fullname = os.path.normpath(os.path.join(root, name))

        # grab if it matches our pattern and entry type
        for pat in pat_list:
            if fnmatch.fnmatch(name, pat):
                if os.path.isfile(fullname) or (return_folders and os.path.isdir(fullname)):
                    result.append(fullname)
                continue
                
        # recursively scan other folders, appending results
        if recurse:
            if os.path.isdir(fullname) and not os.path.islink(fullname):
                result = result + Walk( fullname, recurse, pattern, return_folders )
            
    return result

class file(pyext._class):
    """A simple script to fetch wav in folders (recursive)"""

    # number of inlets and outlets
    _inlets=1
    _outlets=2
    
    def __init__(self,*args):
        pass
    
    def set_1(self,a):
            global savepath
            savepath = a
            
    def ext_1(self,a):
            global extension
            extension = a           
        
    def fetch_1(self,*a):
        files = Walk(str(savepath), 1, '*.'+str(extension))
        for file in files:
            self._outlet(1, str(file))
        filescap = Walk(str(savepath), 1, '*.'+str(extension).upper())
        for filecap in filescap:
            self._outlet(1, str(filecap))
        self._outlet(2, 'bang')

@royal_orchestra precompiled py/ext for the rpi (tested).
all you need (search.py, py.pd_linux, randomPlay~.pd) not tested:
randomPlay.zip

let me know if it works for you!
cheers~

hi @youcloudsofdoom, I use bb_filebrowser (Ben Baker 2010) to do exactly what you need.
bb_filebrowser.pd
cheers

@EEight I am waiting on a new SD card so haven't had the chance to run your solution on the Pi yet, but thank you so much for posting it.

@alistair_blunt this also looks very interesting - how can you randomise the list order? If it randomised the order every time the folder was loaded, I could just bang out from sfplay~ at end of file and have it generate another random track for me...that would be exactly what I need!

yes, sfplay~ should give a bang in the right outlet when the file is played so just send a new bang (file) from there.

Ah, got it, didn't realise the inlet on the browser accepted messages instead of bangs. Excellent, just going to put a [random] in front of it which receives the bang from sfplay~. Perfect, thanks!

yes, you just have to know how many files are in there then set a [random] or [urn] to avoid repetitions of the same file.

generative_playlist.pd

Hmm so I built a system around what we discussed here, but something's still going wrong. When I launch this on my Mac, it runs correctly - the list populates, starts playing a random track from it, and then at the end sfplay bangs out and another random track is selected and played (repetitions are fine).

However, when I run this on my Pi, it always plays the playlist in the same order (though that order appears to have been randomly generated) when it loads, and continues playing through it in the same order after the first track finishes. Very odd. Any thoughts?

give random a different seed every time you use it, possibly with date & time from zexy. random should also give the same sequence every time on any other system as well if the seed doesn't change every time.
just fyi the reason for this is because random works by taking a number, multiplying a very large constant, adding a large constant, performing modulo, and ranging appropriately. specifically:

randval = randval * 472940017 + 832416023;
    nval = ((double)range) * ((double)randval) * (1./4294967296.);```
(modulo comes from the definition of unsigned int overflow, which randval is)
the ranging is done by division by 2^32, the highest value of unsigned 32-bit int - 1
so every instance of [random] in a patch will have the same seed (starting value) every time (unless you send it a "seed" message) and so the same sequence will occur (unless you delete a [random] you created earlier, then the seeds of all randoms created after that one will shift 1 step backwards)

the sizes of usigned int and double are the same for mac and pi so it shouldn't behave differently...

if you want a "less deterministic" random number generator you can try a wrapper I made to urandom using [shell], it's on the github in the signature and called "urandom.pd". urandom is supposed to use hardware sampling of noisy environmental signals and should be different every time.
you also need list-dripdex, list-abs, and moocow/any2bytes to make it work