curveset = Curveset(sliders=opts.sliders)

    subterms = []

    curveset.load(basename=os.path.join(

        showconfig.curvesDir(),

        showconfig.songFilenameFromURI(song)),

                  skipMusic=opts.skip_music)

    subtermPath = graphPathForSubterms(song)

    try:

        graph.parse(subtermPath, format='n3')

            raise

        log.info("%s not found, starting with empty graph" % subtermPath)

    log.debug("startup: output %s", time.time() - startTime)

    out = Output(subterms, music)

    musicfilename = showconfig.songOnDisk(song)

    maxtime = wavelength(musicfilename)

    dispatcher.connect(lambda: maxtime, "get max time", weak=False)

    start = Main(graph, opts, song, curveset, subterms, music)

"""for completion, print the available song uris on stdout

in .zshrc:

function _songs { local expl;  _description files expl 'songs';  compadd "$expl[@]" - `${LIGHT9_SHOW}/../../bin/listsongs` }

compdef _songs curvecalc

"""

import run_local

from light9 import showconfig

from light9.namespaces import L9

"""

rewrite all the songs with silence at the start and end

"""

import sys, wave, logging, os

sys.path.append(".")

from light9 import showconfig

from light9.namespaces import L9

from light9.ascoltami.playlist import Playlist

logging.basicConfig(level=logging.INFO)

log = logging.getLogger()

introPad = 4

postPad = 9 # 5 + autostop + 4

playlist = Playlist.fromShow(showconfig.getGraph(), showconfig.showUri())

for p in playlist.allSongPaths():

    log.info("read %s", p)

    inputWave = wave.open(p, 'r')

    outputDir = os.path.join(os.path.dirname(p), "pad")

    try:

        os.makedirs(outputDir)

    except OSError:

        pass # exists

    outputPath = os.path.join(outputDir, os.path.basename(p))

    outputWave = wave.open(outputPath, 'w')

    outputWave.setparams(inputWave.getparams())

import optparse

import run_local

from light9.wavepoints import simp

def createCurve(inpath, outpath, t):

    print "reading %s, writing %s" % (inpath, outpath)

    points = simp(inpath.replace('.ogg', '.wav'), seconds_per_average=t)

    f = file(outpath, 'w')

    for time_val in points:

        print >>f, "%s %s" % time_val

                  help="make standard curves for all songs")

options,args = parser.parse_args()

if options.all:

    from light9 import showconfig

    from light9.namespaces import L9

    from rdflib import RDF

    from light9.ascoltami.playlist import Playlist

    graph = showconfig.getGraph()

    playlist = Playlist.fromShow(showconfig.getGraph(), showconfig.showUri())

    for song in playlist.allSongs():

        for curveName, t in [('music', .01),

                             ('smooth_music', .07)]:

            outpath = showconfig.curvesDir() + "/%s-%s" % (

                showconfig.songFilenameFromURI(song), curveName)

            createCurve(inpath, outpath, t)

else:

    inpath, outpath = args

    createCurve(inpath, outpath, options.t)

        self.autoStopTime = 0

        self.onEOS = onEOS

        # before playbin2:

        #self.pipeline = gst.parse_launch("filesrc name=file location=%s ! wavparse name=src ! audioconvert ! alsasink name=out" % songFile)

        gobject.timeout_add(50, self.watchTime)

        bus = self.pipeline.get_bus()

        bus.add_signal_watch()

        def on_any(bus, msg):

            if msg.type == gst.MESSAGE_EOS:

                if self.onEOS is not None:

                    self.onEOS(self.getSong())

        bus.connect('message', on_any)

        def onStreamStatus(bus, message):

            print "streamstatus", bus, message

            (statusType, _elem) = message.parse_stream_status()

            if statusType == gst.STREAM_STATUS_TYPE_ENTER:

                self.setupAutostop()

        bus.connect('message::stream-status', onStreamStatus)

from light9.namespaces import L9

class NoSuchSong(ValueError):

    """Raised when a song is requested that doesn't exist (e.g. one

    after the last song in the playlist)."""

class Playlist(object):

    def __init__(self, graph, playlistUri):

        self.graph = graph

        self.songs = list(graph.items(playlistUri))

    def nextSong(self, currentSong):

        """Returns the next song in the playlist or raises NoSuchSong if 

            currentIndex = self.songs.index(currentSong)

        except IndexError:

            raise ValueError("%r is not in the current playlist (%r)." % \

                (currentSong, self.playlistUri))

        try:

            nextSong = self.songs[currentIndex + 1]

        except IndexError:

            raise NoSuchSong("%r is the last item in the playlist." % \

                             currentSong)

        return nextSong

    def allSongs(self):

        """Returns a list of all song URIs in order."""

        return self.songs

    def allSongPaths(self):

        """Returns a list of the filesystem paths to all songs in order."""

        paths = []

        for song in self.songs:

        return paths

    def songPath(self, uri):

        """filesystem path to a song"""

    @classmethod

    def fromShow(playlistClass, graph, show):

        playlistUri = graph.value(show, L9['playList'])

        if not playlistUri:

            raise ValueError("%r has no l9:playList" % show)

        return playlistClass(graph, playlistUri)

def songOnDisk(song):

    """given a song URI, where's the on-disk file that mpd would read?"""

    graph = getGraph()

    root = graph.value(showUri(), L9['musicRoot'])

    if not root:

        raise ValueError("%s has no :musicRoot" % showUri())

    name = graph.value(song, L9['songFilename'])

    if not name:

        raise ValueError("Song %r has no :songFilename" % song)

def songFilenameFromURI(uri):

    """

    'http://light9.bigasterisk.com/show/dance2007/song8' -> 'song8'

    everything that uses this should be deprecated for real URIs

    everywhere"""

    assert isinstance(uri, URIRef)

    return uri.split('/')[-1]

def getSongsFromShow(graph, show):

    playList = graph.value(show, L9['playList'])