diff --git a/3rd_party/pypo/config.cfg b/3rd_party/pypo/config.cfg new file mode 100644 index 000000000..c3353b71d --- /dev/null +++ b/3rd_party/pypo/config.cfg @@ -0,0 +1,47 @@ +############################################ +# pypo - configuration # +############################################ + +############################################ +# Directories / Hosts # +# _include_ trailing slash !! # +############################################ +cache_dir = '/storage/pypo/cache/' +file_dir = '/storage/pypo/files/' +tmp_dir = '/var/tmp/obp/' + +############################################ +# API path & co # +############################################ +base_url = 'http://vdeb.openbroadcast.ch/' +obp_api_key = 'AAA-BBB-CCC-EEE' + +# stage config +#base_url = 'http://stage.openbroadcast.ch/' +#obp_api_key = 'EMMKM-PMXWV-NIGOA-KHGWPP + +# prod config +#base_url = 'http://openbroadcast.ch/' +#obp_api_key = 'XWQWP-XIHJU-ZHENT-NGSAW' + +export_path = 'api/pypo/export_range/' # YYYY-MM-DD-hh-mm will be added in script, exports json + +############################################ +# Liquidsoap settings # +############################################ +ls_host = '127.0.0.1' +ls_port = '1234' + +############################################ +# pypo preferences # +############################################ +prepare_ahead = 24 #in hours +cache_for = 24 #how long to hold the cache, in hours + +poll_interval = 10 # in seconds +push_interval = 1 # in seconds + +# 'pre' or 'otf'. 'pre' cues while pplaylist preparation +# while 'otf' (on the fly) cues while loading into ls +# (needs the post_processor patch) +cue_style = 'pre' diff --git a/3rd_party/pypo/config.cfg.dist b/3rd_party/pypo/config.cfg.dist new file mode 100755 index 000000000..65b2e8733 --- /dev/null +++ b/3rd_party/pypo/config.cfg.dist @@ -0,0 +1,40 @@ +############################################ +# pypo - configuration # +############################################ + +############################################ +# Directories / Hosts # +# _include_ trailing slash !! # +############################################ +cache_dir = '/storage/pypo/cache/' +file_dir = '/storage/pypo/files/' +tmp_dir = '/var/tmp/obp/' + +############################################ +# API path & co # +############################################ +base_url = 'http://test.local.obp.ch/' +obp_api_key = 'AAA-BBB-CCC-EEE' + +export_path = 'api/pypo/export_range/' # YYYY-MM-DD-hh-mm will be added in script, exports json +export_source = 'scheduler' # choose "dayparts" or "scheduler" + +############################################ +# Liquidsoap settings # +############################################ +ls_host = '127.0.0.1' +ls_port = '1234' + +############################################ +# pypo preferences # +############################################ +prepare_ahead = 12 #in hours +cache_for = 12 #how long to hold the cache, in hours + +poll_interval = 10 # in seconds +push_interval = 1 # in seconds + +# 'pre' or 'otf'. 'pre' cues while pplaylist preparation +# while 'otf' (on the fly) cues while loading into ls +# (needs the post_processor patch) +cue_style = 'pre' diff --git a/3rd_party/pypo/dls/__init__.py b/3rd_party/pypo/dls/__init__.py new file mode 100644 index 000000000..7957e7dad --- /dev/null +++ b/3rd_party/pypo/dls/__init__.py @@ -0,0 +1,3 @@ +# -*- coding: utf-8 -*- + +from dls_client import * \ No newline at end of file diff --git a/3rd_party/pypo/dls/dls_client.py b/3rd_party/pypo/dls/dls_client.py new file mode 100755 index 000000000..2b09a75b5 --- /dev/null +++ b/3rd_party/pypo/dls/dls_client.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +import sys +import time + +import logging + +from util import json + +import os +import socket + + + +class DlsClient(): + + def __init__(self, dls_host, dls_port, dls_user, dls_pass): + self.dls_host = dls_host + self.dls_port = dls_port + self.dls_user = dls_user + self.dls_pass = dls_pass + + def set_txt(self, txt): + + logger = logging.getLogger("DlsClient.set_txt") + + try: + + print 'trying to update dls' + + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.connect((self.dls_host, self.dls_port)) + + s.send('client_zzzz') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('RS_DLS_VERSION' + ' ' + '1') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('SERVICE' + ' ' + self.dls_user) + s.send("\r\n") + + s.send('PASSWORD' + ' ' + self.dls_pass) + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('SET_DLS_CHARSET' + ' ' + '4') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('CLEAR_DLS') + s.send("\r\n") + + s.send('SET_DLS' + ' ' + txt) + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('CLOSE_DLS') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.close() + + + print 'OK' + + except Exception, e: + #print e + print 'did not work out.' + dls_status = False + logger.info("Unable to connect to the update metadata - %s", e) + + + return + + + + + \ No newline at end of file diff --git a/3rd_party/pypo/logging.cfg b/3rd_party/pypo/logging.cfg new file mode 100644 index 000000000..54a958296 --- /dev/null +++ b/3rd_party/pypo/logging.cfg @@ -0,0 +1,63 @@ +[loggers] +keys=root + +[handlers] +keys=consoleHandler,fileHandlerERROR,fileHandlerDEBUG,nullHandler + +[formatters] +keys=simpleFormatter + +[logger_root] +level=DEBUG +handlers=consoleHandler,fileHandlerERROR,fileHandlerDEBUG + +[logger_libs] +handlers=nullHandler +level=DEBUG +qualname="process" +propagate=0 + + + +[handler_consoleHandler] +class=StreamHandler +level=ERROR +formatter=simpleFormatter +args=(sys.stdout,) + +[handler_fileHandlerERROR] +class=FileHandler +level=WARNING +formatter=simpleFormatter +args=("/var/log/obp/pypo/error.log",) + +[handler_fileHandlerDEBUG] +class=FileHandler +level=DEBUG +formatter=simpleFormatter +args=("/var/log/obp/pypo/debug.log",) + +[handler_nullHandler] +class=FileHandler +level=DEBUG +formatter=simpleFormatter +args=("/tmp/sessionlog_null.log",) + + + + +[formatter_simpleFormatter] +format=%(asctime)s %(levelname)s - [%(name)s] - %(message)s +datefmt= + + +## multitail color sheme +## pyml / python +# colorscheme:pyml:www.obp.net +# cs_re:blue:\[[^ ]*\] +# cs_re:red:CRITICAL:* +# cs_re:red,black,blink:ERROR:* +# cs_re:blue:NOTICE:* +# cs_re:cyan:INFO:* +# cs_re:green:DEBUG:* + diff --git a/3rd_party/pypo/obp/__init__.py b/3rd_party/pypo/obp/__init__.py new file mode 100644 index 000000000..61a986ccd --- /dev/null +++ b/3rd_party/pypo/obp/__init__.py @@ -0,0 +1,3 @@ +# -*- coding: utf-8 -*- + +from api_client import * \ No newline at end of file diff --git a/3rd_party/pypo/obp/api_client.py b/3rd_party/pypo/obp/api_client.py new file mode 100755 index 000000000..9bb5dc6b4 --- /dev/null +++ b/3rd_party/pypo/obp/api_client.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +import sys +import time +import urllib + +import logging + +from util import json + +import os + + + +class ApiClient(): + + def __init__(self, api_url, api_auth): + self.api_url = api_url + self.api_auth = api_auth + + def get_obp_version(self): + logger = logging.getLogger("ApiClient.get_obp_version") + # lookup OBP version + + url = self.api_url + 'api/pypo/status/json' + + try: + + logger.debug("Trying to contact %s", url) + + response = urllib.urlopen(url, self.api_auth) + response_json = json.read(response.read()) + obp_version = int(response_json['version']) + logger.debug("OBP Version %s detected", obp_version) + + + except Exception, e: + try: + if e[1] == 401: + print '#####################################' + print '# YOUR API KEY SEEMS TO BE INVALID' + print '# ' + self.api_auth + print '#####################################' + sys.exit() + + except Exception, e: + pass + + try: + if e[1] == 404: + print '#####################################' + print '# Unable to contact the OBP-API' + print '# ' + url + print '#####################################' + sys.exit() + + except Exception, e: + pass + + obp_version = 0 + logger.error("Unable to detect OBP Version - %s", e) + + + return obp_version + + + def update_shedueled_item(self, item_id, value): + logger = logging.getLogger("ApiClient.update_shedueled_item") + # lookup OBP version + + url = self.api_url + 'api/pypo/update_shedueled_item/' + str(item_id) + '?played=' + str(value) + + try: + response = urllib.urlopen(url, self.api_auth) + response = json.read(response.read()) + logger.info("API-Status %s", response['status']) + logger.info("API-Message %s", response['message']) + + except Exception, e: + print e + api_status = False + logger.critical("Unable to connect to the OBP API - %s", e) + + + return response + + + def update_start_playing(self, playlist_type, export_source, media_id, playlist_id, transmission_id): + + logger = logging.getLogger("ApiClient.update_shedueled_item") + + url = self.api_url + 'api/pypo/update_start_playing/' \ + + '?playlist_type=' + str(playlist_type) \ + + '&export_source=' + str(export_source) \ + + '&export_source=' + str(export_source) \ + + '&media_id=' + str(media_id) \ + + '&playlist_id=' + str(playlist_id) \ + + '&transmission_id=' + str(transmission_id) + + print url + + try: + response = urllib.urlopen(url, self.api_auth) + response = json.read(response.read()) + logger.info("API-Status %s", response['status']) + logger.info("API-Message %s", response['message']) + logger.info("TXT %s", response['str_dls']) + + except Exception, e: + print e + api_status = False + logger.critical("Unable to connect to the OBP API - %s", e) + + + return response + + + def generate_range_dp(self): + logger = logging.getLogger("ApiClient.generate_range_dp") + + url = self.api_url + 'api/pypo/generate_range_dp/' + + try: + response = urllib.urlopen(url, self.api_auth) + response = json.read(response.read()) + logger.debug("Trying to contact %s", url) + logger.info("API-Status %s", response['status']) + logger.info("API-Message %s", response['message']) + + except Exception, e: + print e + api_status = False + logger.critical("Unable to handle the OBP API request - %s", e) + + + return response + + + + + \ No newline at end of file diff --git a/3rd_party/pypo/push.py b/3rd_party/pypo/push.py new file mode 100755 index 000000000..e222b6c0d --- /dev/null +++ b/3rd_party/pypo/push.py @@ -0,0 +1,307 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +""" +Python part of radio playout (pypo) + +The main functionas are "fetch" (./pypo_cli.py -f) and "push" (./pypo_cli.py -p) + +Also check out the php counterpart that handles the api requests: +https://lab.digris.ch/svn/elgg/trunk/unstable/mod/medialibrary/application/controllers/api/pypo.php + +Attention & ToDos +- liquidsoap does not like mono files! So we have to make sure that only files with + 2 channels are fed to LS + (solved: current = audio_to_stereo(current) - maybe not with ultimate performance) + + +made for python version 2.5!! +should work with 2.6 as well with a bit of adaption. for +sure the json parsing has to be changed +(2.6 has an parser, pypo brigs it's own -> util/json.py) +""" + +# python defaults (debian default) +import time +import os +import traceback +from optparse import * +import sys +import time +import datetime +import logging +import logging.config +import shutil +import urllib +import urllib2 +import pickle +import telnetlib +import random +import string +import operator + +# additional modules (should be checked) +from configobj import ConfigObj + +# custom imports +from util import * +from obp import * + + + +PYPO_VERSION = '0.1' +OBP_MIN_VERSION = 2010100101 # required obp version + + +#set up command-line options +parser = OptionParser() + +# help screeen / info +usage = "%prog [options]" + " - python playout system" +parser = OptionParser(usage=usage) + +#options +parser.add_option("-f", "--fetch", help="Fetch Schedule (loop, interval in config file)", default=False, action="store_true", dest="fetch") +parser.add_option("-p", "--push", help="Push pl to Liquidsoap (loop, interval in config file)", default=False, action="store_true", dest="push") +parser.add_option("-b", "--cleanup", help="Faeili Butzae aka cleanup", default=False, action="store_true", dest="cleanup") +parser.add_option("-j", "--jingles", help="Get new jungles from obp, comma separated list if jingle-id's as argument", metavar="LIST") +parser.add_option("-c", "--check", help="Check the cached schedule and exit", default=False, action="store_true", dest="check") + +parser.add_option("-P", "--pushpkey", help="Push PKEY", metavar="LIST") + +# parse options +(options, args) = parser.parse_args() + +# configure logging +logging.config.fileConfig("logging.cfg") + +# loading config file +try: + config = ConfigObj('config.cfg') + CACHE_DIR = config['cache_dir'] + FILE_DIR = config['file_dir'] + TMP_DIR = config['tmp_dir'] + BASE_URL = config['base_url'] + OBP_API_BASE = BASE_URL + 'mod/medialibrary/' + EXPORT_URL = OBP_API_BASE + config['export_path'] + EXPORT_SOURCE = config['export_source'] + + OBP_STATUS_URL = OBP_API_BASE + 'status/version/json' + OBP_API_KEY = config['obp_api_key'] + + POLL_INTERVAL = float(config['poll_interval']) + PUSH_INTERVAL = float(config['push_interval']) + LS_HOST = config['ls_host'] + LS_PORT = config['ls_port'] + PREPARE_AHEAD = config['prepare_ahead'] + CACHE_FOR = config['cache_for'] + CUE_STYLE = config['cue_style'] + +except Exception, e: + print 'error: ', e + sys.exit() + +#TIME = time.localtime(time.time()) +TIME = (2010, 6, 26, 15, 33, 23, 2, 322, 0) + + + + + +class Global: + def __init__(self): + #print '# global initialisation' + print + + def selfcheck(self): + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + obp_version = self.api_client.get_obp_version() + + + if obp_version == 0: + print '#################################################' + print 'Unable to get OBP version. Is OBP up and running?' + print '#################################################' + print + sys.exit() + + elif obp_version < OBP_MIN_VERSION: + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo not compatible with this version of OBP' + print + sys.exit() + + else: + print 'OBP API: ' + str(OBP_API_BASE) + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo is compatible with this version of OBP' + print + + + """ + Uncomment the following lines to let pypo check if + liquidsoap is running. (checks for a telnet server) + """ +# while self.status.check_ls(LS_HOST, LS_PORT) == 0: +# print 'Unable to connect to liquidsoap. Is it up and running?' +# time.sleep(2) + + + +""" + +""" +class Playout: + def __init__(self): + #print '# init fallback' + + self.cache_dir = CACHE_DIR + self.file_dir = FILE_DIR + self.tmp_dir = TMP_DIR + self.export_url = EXPORT_URL + self.export_source = EXPORT_SOURCE + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + self.cue_file = CueFile() + + self.schedule_file = CACHE_DIR + 'schedule' + + # set initial state + self.range_updated = False + + + + + def push_liquidsoap(self,options): + logger = logging.getLogger("push_liquidsoap") + + print options + + #pkey = '2010-10-26-21-00-00' + + pkey = options + + src = self.cache_dir + str(pkey) + '/list.lsp' + + print src + + + if True == os.access(src, os.R_OK): + print 'OK - Can read' + + pl_file = open(src, "r") + + + + """ + i know this could be wrapped, maybe later.. + """ + tn = telnetlib.Telnet(LS_HOST, 1234) + #tn.write("\n") + + for line in pl_file.readlines(): + print line.strip() + + #tn.write('q.push ' + pl_entry) + #tn.write("\n") + + tn.write('scheduler.push %s' % (line.strip())) + tn.write("\n") + + + + tn.write("scheduler_q0.queue \n") + + tn.write("scheduler_q1.queue \n") + #time.sleep(2) + + + #print tn.read_all() + + print 'sending "flip"' + + tn.write('scheduler.flip') + tn.write("\n") + + + + + #tn.write("live_in.stop\n") + #tn.write("stream_disable\n") + #time.sleep(0.2) + #tn.write("\n") + #tn.write("reload_current\n") + #tn.write("current.reload\n") + #time.sleep(0.2) + #tn.write("skip_current\n") + +# if(int(ptype) == 6): +# """ +# Couchcaster / Recast comming. Stop/Start live input to have ls re-read it's playlist +# """ +# print 'Couchcaster - switching to stream' +# tn.write("live_in.start\n") +# time.sleep(0.2) +# tn.write("stream_enable\n") +# +# +# +# """ +# Pass some extra information to liquidsoap +# """ +# tn.write("pl.pl_id '%s'\n" % p_id) +# tn.write("pl.user_id '%s'\n" % user_id) + + + + tn.write("exit\n") + + print tn.read_all() + + status = 1 + sys.exit() + +# except Exception, e: +# logger.error('%s', e) +# status = 0 + + + + +if __name__ == '__main__': + + print + print '#########################################' + print '# *** pypo *** #' + print '# obp python playout #' + print '#########################################' + print + + # initialize + g = Global() + g.selfcheck() + po = Playout() + + +run = True +while run == True: + + logger = logging.getLogger("pypo") + + while options.pushpkey: + try: po.push_liquidsoap(options.pushpkey) + except Exception, e: + print e + sys.exit() + + while options.push: + po.push_liquidsoap() + sys.exit() diff --git a/3rd_party/pypo/pypo_cli.py b/3rd_party/pypo/pypo_cli.py new file mode 100755 index 000000000..19b2dd95a --- /dev/null +++ b/3rd_party/pypo/pypo_cli.py @@ -0,0 +1,1145 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +""" +Python part of radio playout (pypo) + +The main functionas are "fetch" (./pypo_cli.py -f) and "push" (./pypo_cli.py -p) + +Also check out the php counterpart that handles the api requests: +https://lab.digris.ch/svn/elgg/trunk/unstable/mod/medialibrary/application/controllers/api/pypo.php + +Attention & ToDos +- liquidsoap does not like mono files! So we have to make sure that only files with + 2 channels are fed to LS + (solved: current = audio_to_stereo(current) - maybe not with ultimate performance) + + +made for python version 2.5!! +should work with 2.6 as well with a bit of adaption. for +sure the json parsing has to be changed +(2.6 has an parser, pypo brigs it's own -> util/json.py) +""" + +# python defaults (debian default) +import time +import os +import traceback +from optparse import * +import sys +import time +import datetime +import logging +import logging.config +import shutil +import urllib +import urllib2 +import pickle +import telnetlib +import random +import string +import operator + +# additional modules (should be checked) +from configobj import ConfigObj + +# custom imports +from util import * +from obp import * + + + +PYPO_VERSION = '0.1' +OBP_MIN_VERSION = 2010100101 # required obp version + + +#set up command-line options +parser = OptionParser() + +# help screeen / info +usage = "%prog [options]" + " - python playout system" +parser = OptionParser(usage=usage) + +#options +parser.add_option("-f", "--fetch-scheduler", help="Fetch from scheduler - scheduler (loop, interval in config file)", default=False, action="store_true", dest="fetch_scheduler") +parser.add_option("-p", "--push-scheduler", help="Push scheduler to Liquidsoap (loop, interval in config file)", default=False, action="store_true", dest="push_scheduler") + +parser.add_option("-F", "--fetch-daypart", help="Fetch from daypart - scheduler (loop, interval in config file)", default=False, action="store_true", dest="fetch_daypart") +parser.add_option("-P", "--push-daypart", help="Push daypart to Liquidsoap (loop, interval in config file)", default=False, action="store_true", dest="push_daypart") + +parser.add_option("-b", "--cleanup", help="Faeili Butzae aka cleanup", default=False, action="store_true", dest="cleanup") +parser.add_option("-j", "--jingles", help="Get new jungles from obp, comma separated list if jingle-id's as argument", metavar="LIST") +parser.add_option("-c", "--check", help="Check the cached schedule and exit", default=False, action="store_true", dest="check") + +# parse options +(options, args) = parser.parse_args() + +# configure logging +logging.config.fileConfig("logging.cfg") + +# loading config file +try: + config = ConfigObj('config.cfg') + CACHE_DIR = config['cache_dir'] + FILE_DIR = config['file_dir'] + TMP_DIR = config['tmp_dir'] + BASE_URL = config['base_url'] + OBP_API_BASE = BASE_URL + 'mod/medialibrary/' + EXPORT_URL = OBP_API_BASE + config['export_path'] + + OBP_STATUS_URL = OBP_API_BASE + 'status/version/json' + OBP_API_KEY = config['obp_api_key'] + + POLL_INTERVAL = float(config['poll_interval']) + PUSH_INTERVAL = float(config['push_interval']) + LS_HOST = config['ls_host'] + LS_PORT = config['ls_port'] + PREPARE_AHEAD = config['prepare_ahead'] + CACHE_FOR = config['cache_for'] + CUE_STYLE = config['cue_style'] + +except Exception, e: + print 'error: ', e + sys.exit() + +#TIME = time.localtime(time.time()) +TIME = (2010, 6, 26, 15, 33, 23, 2, 322, 0) + + + + + +class Global: + def __init__(self): + #print '# global initialisation' + print + + def selfcheck(self): + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + obp_version = self.api_client.get_obp_version() + + + if obp_version == 0: + print '#################################################' + print 'Unable to get OBP version. Is OBP up and running?' + print '#################################################' + print + sys.exit() + + elif obp_version < OBP_MIN_VERSION: + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo not compatible with this version of OBP' + print + sys.exit() + + else: + print 'OBP API: ' + str(OBP_API_BASE) + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo is compatible with this version of OBP' + print + + + """ + Uncomment the following lines to let pypo check if + liquidsoap is running. (checks for a telnet server) + """ +# while self.status.check_ls(LS_HOST, LS_PORT) == 0: +# print 'Unable to connect to liquidsoap. Is it up and running?' +# time.sleep(2) + + + +""" + +""" +class Playout: + def __init__(self): + #print '# init fallback' + + + self.file_dir = FILE_DIR + self.tmp_dir = TMP_DIR + self.export_url = EXPORT_URL + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + self.cue_file = CueFile() + + + + # set initial state + self.range_updated = False + + + + + """ + Fetching part of pypo + - Reads the scheduled entries of a given range (actual time +/- "prepare_ahead" / "cache_for") + - Saves a serialized file of the schedule + - playlists are prepared. (brought to ls format) and, if not mounted via nsf, files are copied + to the cache dir (Folder-structure: cache/YYYY-MM-DD-hh-mm-ss) + - runs the cleanup routine, to get rid of unused cashed files + """ + def fetch(self, export_source): + """ + wrapper script for fetchin whole shedule (in json) + """ + logger = logging.getLogger("fetch") + + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + try: os.mkdir(self.cache_dir) + except Exception, e: pass + + + """ + Trigger daypart range-generation. (Only if daypart-instance) + """ + if self.export_source == 'daypart': + + print '******************************' + print '*** TRIGGER DAYPART UPDATE ***' + print '******************************' + + try: + self.generate_range_dp() + except Exception, e: + logger.error("%s", e) + + + # get shedule + try: + while self.get_schedule(self.export_source) != 1: + logger.warning("failed to read from export url") + time.sleep(1) + + except Exception, e: logger.error("%s", e) + + # prepare the playlists + if CUE_STYLE == 'pre': + try: self.prepare_playlists_cue(self.export_source) + except Exception, e: logger.error("%s", e) + elif CUE_STYLE == 'otf': + try: self.prepare_playlists(self.export_source) + except Exception, e: logger.error("%s", e) + + # cleanup + try: self.cleanup(self.export_source) + except Exception, e: logger.error("%s", e) + + logger.info("fetch loop completed") + + + + + + """ + This is actually a bit ugly (again feel free to improve!!) + The generate_range_dp function should be called once a day, + we do this at 18h. The hour before the state is set back to 'False' + """ + def generate_range_dp(self): + + logger = logging.getLogger("generate_range_dp") + + logger.debug("trying to trigger daypart update") + + tnow = time.localtime(time.time()) + + if(tnow[3] == 16): + self.range_updated = False + + if(tnow[3] == 17 and self.range_updated == False): + + try: + print self.api_client.generate_range_dp() + logger.info("daypart updated") + self.range_updated = True + + except Exception, e: + print e + + + + def get_schedule(self, export_source): + + logger = logging.getLogger("fetch.get_schedule") + + """ + calculate start/end time range (format: YYYY-DD-MM-hh-mm-ss,YYYY-DD-MM-hh-mm-ss) + (seconds are ignored, just here for consistency) + """ + + + self.export_source = export_source + + tnow = time.localtime(time.time()) + tstart = time.localtime(time.time() - 3600 * int(CACHE_FOR)) + tend = time.localtime(time.time() + 3600 * int(PREPARE_AHEAD)) + + range = {} + range['start'] = "%04d-%02d-%02d-%02d-%02d" % (tstart[0], tstart[1], tstart[2], tstart[3], tstart[4]) + range['end'] = "%04d-%02d-%02d-%02d-%02d" % (tend[0], tend[1], tend[2], tend[3], tend[4]) + + + export_url = self.export_url + range['start'] + ',' + range['end'] + '/' + self.export_source + logger.info("export from %s", export_url) + + try: + response_json = urllib.urlopen(export_url, self.api_auth).read() + response = json.read(response_json) + logger.info("export status %s", response['check']) + status = response['check'] + schedule = response['playlists'] + + except Exception, e: + print e + status = 0 + + if status == 1: + + logger.info("dump serialized shedule to %s", self.schedule_file) + + try: + schedule_file = open(self.schedule_file, "w") + pickle.dump(schedule, schedule_file) + schedule_file.close() + + except Exception, e: + print e + status = 0 + + return status + + + + + + """ + Alternative version of playout preparation. Every playlist entry is + pre-cued if neccessary (cue_in/cue_out != 0) and stored in the + playlist folder. + file is eg 2010-06-23-15-00-00/17_cue_10.132-123.321.mp3 + """ + def prepare_playlists_cue(self, export_source): + logger = logging.getLogger("fetch.prepare_playlists") + + self.export_source = export_source + + try: + schedule_file = open(self.schedule_file, "r") + schedule = pickle.load(schedule_file) + schedule_file.close() + + except Exception, e: + logger.error("%s", e) + schedule = None + + #for pkey in schedule: + try: + for pkey in sorted(schedule.iterkeys()): + logger.info("found playlist at %s", pkey) + #print pkey + playlist = schedule[pkey] + + # create playlist directory + try: os.mkdir(self.cache_dir + str(pkey)) + except Exception, e: pass + + ls_playlist = ''; + + print '*****************************************' + print 'pkey: ' + str(pkey) + print 'cached at : ' + self.cache_dir + str(pkey) + print 'subtype: ' + str(playlist['subtype']) + print 'played: ' + str(playlist['played']) + print 'schedule id: ' + str(playlist['schedule_id']) + print 'duration: ' + str(playlist['duration']) + print 'source id: ' + str(playlist['x_ident']) + print '*****************************************' + + # TODO: maybe a bit more modular.. + silence_file = self.file_dir + 'basic/silence.mp3' + + + if int(playlist['played']) == 1: + logger.info("playlist %s already played / sent to liquidsoap, so will ignore it", pkey) + + elif int(playlist['subtype']) == 5: + """ + This is a live session, so silence is scheduled + Maybe not the most elegant solution :) + It adds 20 time 30min silence to the playlist + Silence file has to be in /basic/silence.mp3 + """ + logger.debug("found %s seconds of live/studio session at %s", pkey, playlist['duration']) + + if os.path.isfile(silence_file): + logger.debug('file stored at: %s' + silence_file) + + for i in range (0, 19): + ls_playlist += silence_file + "\n" + + else: + print 'Could not find silence file!' + print 'file is excpected to be at: ' + silence_file + logger.critical('file is excpected to be at: %s', silence_file) + sys.exit() + + elif int(playlist['subtype']) == 6: + """ + This is a live-cast session + create a silence list. (could eg also be a falback list..) + """ + logger.debug("found %s seconds of live-cast session at %s", pkey, playlist['duration']) + + if os.path.isfile(silence_file): + logger.debug('file stored at: %s' + silence_file) + + for i in range (0, 19): + ls_playlist += silence_file + "\n" + + else: + print 'Could not find silence file!' + print 'file is excpected to be at: ' + silence_file + logger.critical('file is excpected to be at: %s', silence_file) + sys.exit() + + + elif int(playlist['subtype']) > 0 and int(playlist['subtype']) < 5: + + for media in playlist['medias']: + logger.debug("found track at %s", media['uri']) + + try: + src = media['uri'] + + if str(media['cue_in']) == '0' and str(media['cue_out']) == '0': + dst = "%s%s/%s.mp3" % (self.cache_dir, str(pkey), str(media['id'])) + do_cue = False + else: + dst = "%s%s/%s_cue_%s-%s.mp3" % \ + (self.cache_dir, str(pkey), str(media['id']), str(float(media['cue_in']) / 1000), str(float(media['cue_out']) / 1000)) + do_cue = True + + #print "dst_cue: " + dst + + # check if it is a remote file, if yes download + if src[0:4] == 'http' and do_cue == False: + + if os.path.isfile(dst): + logger.debug("file already in cache: %s", dst) + + else: + logger.debug("try to download %s", src) + try: + print '** urllib auth with: ', + print self.api_auth + urllib.urlretrieve (src, dst, False, self.api_auth) + logger.info("downloaded %s to %s", src, dst) + except Exception, e: + logger.error("%s", e) + + elif src[0:4] == 'http' and do_cue == True: + + + + if os.path.isfile(dst): + logger.debug("file already in cache: %s", dst) + print 'cached' + + else: + logger.debug("try to download and cue %s", src) + + print '***' + dst_tmp = self.tmp_dir + "".join([random.choice(string.letters) for i in xrange(10)]) + '.mp3' + print dst_tmp + print '***' + + try: + print '** urllib auth with: ', + print self.api_auth + urllib.urlretrieve (src, dst_tmp, False, self.api_auth) + logger.info("downloaded %s to %s", src, dst_tmp) + except Exception, e: + logger.error("%s", e) + + + # cue + print "STARTIONG CUE" + print self.cue_file.cue(dst_tmp, dst, float(media['cue_in']) / 1000, float(media['cue_out']) / 1000) + print "END CUE" + + if True == os.access(dst, os.R_OK): + + try: fsize = os.path.getsize(dst) + except Exception, e: + logger.error("%s", e) + fsize = 0 + + if fsize > 0: + logger.debug('try to remove temporary file: %s' + dst_tmp) + try: os.remove(dst_tmp) + except Exception, e: + logger.error("%s", e) + + else: + logger.warning('something went wrong cueing: %s - using uncued file' + dst) + try: os.rename(dst_tmp, dst) + except Exception, e: + logger.error("%s", e) + + + else: + """ + Handle files on nas. Pre-cueing not implemented at the moment. + (not needed by openbroadcast, feel free to add this) + """ + # assume the file is local + # logger.info("local file assumed for : %s", src) + # dst = src + + + """ + Here an implementation for localy stored files. + Works the same as with remote files, just replaced API-download with + file copy. + """ + if do_cue == False: + + if os.path.isfile(dst): + logger.debug("file already in cache: %s", dst) + + else: + logger.debug("try to copy file to cache %s", src) + try: + shutil.copy(src, dst) + logger.info("copied %s to %s", src, dst) + except Exception, e: + logger.error("%s", e) + + + + + if do_cue == True: + + if os.path.isfile(dst): + logger.debug("file already in cache: %s", dst) + + else: + logger.debug("try to copy and cue %s", src) + + print '***' + dst_tmp = self.tmp_dir + "".join([random.choice(string.letters) for i in xrange(10)]) + print dst_tmp + print '***' + + try: + shutil.copy(src, dst_tmp) + logger.info("copied %s to %s", src, dst_tmp) + except Exception, e: + logger.error("%s", e) + + + # cue + print "STARTIONG CUE" + print self.cue_file.cue(dst_tmp, dst, float(media['cue_in']) / 1000, float(media['cue_out']) / 1000) + print "END CUE" + + if True == os.access(dst, os.R_OK): + + try: fsize = os.path.getsize(dst) + except Exception, e: + logger.error("%s", e) + fsize = 0 + + if fsize > 0: + logger.debug('try to remove temporary file: %s' + dst_tmp) + try: os.remove(dst_tmp) + except Exception, e: + logger.error("%s", e) + + else: + logger.warning('something went wrong cueing: %s - using uncued file' + dst) + try: os.rename(dst_tmp, dst) + except Exception, e: + logger.error("%s", e) + + + + + if True == os.access(dst, os.R_OK): + # check filesize (avoid zero-byte files) + #print 'waiting: ' + dst + + try: fsize = os.path.getsize(dst) + except Exception, e: + logger.error("%s", e) + fsize = 0 + + if fsize > 0: + + pl_entry = 'annotate:export_source="%s",media_id="%s",liq_start_next="%s",liq_fade_in="%s",liq_fade_out="%s":%s' % \ + (str(media['export_source']), media['id'], 0, str(float(media['fade_in']) / 1000), str(float(media['fade_out']) / 1000), dst) + + print pl_entry + + + """ + Tracks are only added to the playlist if they are accessible + on the file system and larger than 0 bytes. + So this can lead to playlists shorter than expectet. + (there is a hardware silence detector for this cases...) + """ + ls_playlist += pl_entry + "\n" + + logger.debug("everything ok, adding %s to playlist", pl_entry) + + else: + print 'zero-file: ' + dst + ' from ' + src + logger.warning("zero-size file - skiping %s. will not add it to playlist", dst) + + else: + logger.warning("something went wrong. file %s not available. will not add it to playlist", dst) + + + + except Exception, e: logger.info("%s", e) + + + """ + This is kind of hackish. We add a bunch of "silence" tracks to the end of each playlist. + So we can make sure the list does not get repeated just before a new one is called. + (or in case nothing is in the scheduler afterwards) + 20 x silence = 10 hours + """ + for i in range (0, 1): + ls_playlist += silence_file + "\n" + print '', + + # write playlist file + plfile = open(self.cache_dir + str(pkey) + '/list.lsp', "w") + plfile.write(ls_playlist) + plfile.close() + logger.info('ls playlist file written to %s', self.cache_dir + str(pkey) + '/list.lsp') + + except Exception, e: + logger.info("%s", e) + + + def cleanup(self, export_source): + logger = logging.getLogger("cleanup") + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + """ + Cleans up folders in cache_dir. Look for modification date older than "now - CACHE_FOR" + and deletes them. + """ + + offset = 3600 * int(CACHE_FOR) + now = time.time() + + for r, d, f in os.walk(CACHE_DIR): + for dir in d: + timestamp = os.path.getmtime(os.path.join(r, dir)) + + logger.debug('Folder "Age": %s - %s', round((((now - offset) - timestamp) / 60), 2), os.path.join(r, dir)) + + if now - offset > timestamp: + try: + logger.debug('trying to remove %s - timestamp: %s', os.path.join(r, dir), timestamp) + shutil.rmtree(os.path.join(r, dir)) + except Exception, e: + logger.error("%s", e) + pass + else: + logger.info('sucessfully removed %s', os.path.join(r, dir)) + + + + + """ + The counterpart - the push loop periodically (minimal 1/2 of the playlist-grid) + checks if there is a playlist that should be sheduled at the current time. + If yes, the temporary liquidsoap playlist gets replaced with the corresponding one, + then liquid is asked (via telnet) to reload and immediately play it + """ + def push(self, export_source): + logger = logging.getLogger("push") + + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + self.push_ahead = 15 + + try: + dummy = self.schedule + logger.debug('schedule already loaded') + except Exception, e: + self.schedule = self.push_init(self.export_source) + + self.schedule = self.push_init(self.export_source) + + + """ + I'm quite sure that this could be achieved in a much more elegant way in python... + """ + + tcomming = time.localtime(time.time() + self.push_ahead) + tnow = time.localtime(time.time()) + + str_tnow = "%04d-%02d-%02d-%02d-%02d" % (tnow[0], tnow[1], tnow[2], tnow[3], tnow[4]) + str_tnow_s = "%04d-%02d-%02d-%02d-%02d-%02d" % (tnow[0], tnow[1], tnow[2], tnow[3], tnow[4], tnow[5]) + + str_tcomming = "%04d-%02d-%02d-%02d-%02d" % (tcomming[0], tcomming[1], tcomming[2], tcomming[3], tcomming[4]) + str_tcomming_s = "%04d-%02d-%02d-%02d-%02d-%02d" % (tcomming[0], tcomming[1], tcomming[2], tcomming[3], tcomming[4], tcomming[5]) + + + print '--' + print str_tnow_s + ' now' + print str_tcomming_s + ' comming' + + + playnow = None + + if self.schedule == None: + print 'unable to loop schedule - maybe write in progress' + print 'will try in next loop' + + else: + for pkey in self.schedule: + logger.debug('found playlist schedulet at: %s', pkey) + + #if pkey[0:16] == str_tnow: + if pkey[0:16] == str_tcomming: + playlist = self.schedule[pkey] + + if int(playlist['played']) != 1: + + print '!!!!!!!!!!!!!!!!!!!' + print 'MATCH' + + + """ + ok we have a match, replace the current playlist and + force liquidsoap to refresh + Add a 'played' state to the list in schedule, so it is not called again + in the next push loop + """ + + + ptype = playlist['subtype'] + + try: + user_id = playlist['user_id'] + playlist_id = playlist['id'] + transmission_id = playlist['schedule_id'] + + except Exception, e: + playlist_id = 0 + user_id = 0 + transmission_id = 0 + print e + + + print 'Playlist id:', + + + if(self.push_liquidsoap(pkey, ptype, user_id, playlist_id, transmission_id, self.push_ahead) == 1): + self.schedule[pkey]['played'] = 1 + """ + Call api to update schedule states and + write changes back to cache file + """ + self.api_client.update_shedueled_item(int(playlist['schedule_id']), 1) + schedule_file = open(self.schedule_file, "w") + pickle.dump(self.schedule, schedule_file) + schedule_file.close() + + #else: + # print 'Nothing to do...' + + + + + def push_init(self, export_source): + + logger = logging.getLogger("push_init") + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + # load the shedule from cache + logger.debug('load shedule from cache') + try: + schedule_file = open(self.schedule_file, "r") + schedule = pickle.load(schedule_file) + schedule_file.close() + + except Exception, e: + logger.error('%s', e) + schedule = None + + return schedule + + + + def push_liquidsoap(self, pkey, ptype, user_id, playlist_id, transmission_id, push_ahead): + logger = logging.getLogger("push_liquidsoap") + + #self.export_source = export_source + + self.push_ahead = push_ahead + + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + src = self.cache_dir + str(pkey) + '/list.lsp' + + print src + + try: + if True == os.access(src, os.R_OK): + print 'OK - Can read' + + pl_file = open(src, "r") + + """ + i know this could be wrapped, maybe later.. + """ + tn = telnetlib.Telnet(LS_HOST, 1234) + + + if(int(ptype) == 6): + tn.write("live_in.start") + tn.write("\n") + + + if(int(ptype) < 5): + for line in pl_file.readlines(): + print line.strip() + tn.write(self.export_source + '.push %s' % (line.strip())) + tn.write("\n") + #time.sleep(0.1) + + tn.write("exit\n") + print tn.read_all() + + + + + + + + print 'sleeping for %s s' % (self.push_ahead) + time.sleep(self.push_ahead) + + + print 'sending "flip"' + tn = telnetlib.Telnet(LS_HOST, 1234) + + """ + Pass some extra information to liquidsoap + """ + print 'user_id: %s' % user_id + print 'playlist_id: %s' % playlist_id + print 'transmission_id: %s' % transmission_id + print 'ptype: %s' % ptype + + tn.write("vars.user_id %s\n" % user_id) + tn.write("vars.playlist_id %s\n" % playlist_id) + tn.write("vars.transmission_id %s\n" % transmission_id) + tn.write("vars.playlist_type %s\n" % ptype) + + +# if(int(ptype) < 5): +# tn.write(self.export_source + '.flip') +# tn.write("\n") + + tn.write(self.export_source + '.flip') + tn.write("\n") + + if(int(ptype) == 6): + tn.write("live.active 1") + tn.write("\n") + else: + tn.write("live.active 0") + tn.write("\n") + tn.write("live_in.stop") + tn.write("\n") + + + tn.write("exit\n") + + print tn.read_all() + status = 1 + except Exception, e: + logger.error('%s', e) + status = 0 + + return status + + + def push_liquidsoap_legacy(self, pkey, ptype, p_id, user_id): + logger = logging.getLogger("push_liquidsoap") + + logger.debug('trying to push %s to liquidsoap', pkey) + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + src = self.cache_dir + str(pkey) + '/list.lsp' + dst = self.cache_dir + 'current.lsp' + + print src + print dst + + print '*************' + print ptype + print '*************' + + if True == os.access(src, os.R_OK): + try: + shutil.copy2(src, dst) + logger.debug('copy %s to %s', src, dst) + """ + i know this could be wrapped, maybe later.. + """ + tn = telnetlib.Telnet(LS_HOST, 1234) + tn.write("\n") + tn.write("live_in.stop\n") + tn.write("stream_disable\n") + time.sleep(0.2) + tn.write("\n") + #tn.write("reload_current\n") + tn.write("current.reload\n") + time.sleep(0.2) + tn.write("skip_current\n") + + if(int(ptype) == 6): + """ + Couchcaster comming. Stop/Start live input to have ls re-read it's playlist + """ + print 'Couchcaster - switching to stream' + tn.write("live_in.start\n") + time.sleep(0.2) + tn.write("stream_enable\n") + + if(int(ptype) == 7): + """ + Recast comming. Start the live input + """ + print 'Recast - switching to stream' + tn.write("live_in.start\n") + time.sleep(0.2) + tn.write("stream_enable\n") + + """ + Pass some extra information to liquidsoap + """ + tn.write("pl.pl_id '%s'\n" % p_id) + tn.write("pl.user_id '%s'\n" % user_id) + + + + tn.write("exit\n") + + print tn.read_all() + + status = 1 + + except Exception, e: + logger.error('%s', e) + status = 0 + else: + status = 0 + + return status + + + """ + Updates the jinles. Give comma separated list of jingle tracks + """ + def update_jingles(self, options): + print 'jingles' + + jingle_list = string.split(options, ',') + print jingle_list + for media_id in jingle_list: + # api path maybe should not be hard-coded + src = OBP_API_BASE + 'api/pypo/get_media/' + str(media_id) + print src + # include the hourly jungles for the moment + dst = "%s%s/%s.mp3" % (self.file_dir, 'jingles/hourly', str(media_id)) + print dst + + try: + print '** urllib auth with: ', + print self.api_auth + opener = urllib.URLopener() + opener.retrieve (src, dst, False, self.api_auth) + logger.info("downloaded %s to %s", src, dst) + except Exception, e: + print e + logger.error("%s", e) + + + + + + def check_schedule(self, export_source): + logger = logging.getLogger("check_schedule") + + self.export_source = export_source + self.cache_dir = CACHE_DIR + self.export_source + '/' + self.schedule_file = self.cache_dir + 'schedule' + + try: + schedule_file = open(self.schedule_file, "r") + schedule = pickle.load(schedule_file) + schedule_file.close() + + except Exception, e: + logger.error("%s", e) + schedule = None + + + + #for pkey in schedule: + for pkey in sorted(schedule.iterkeys()): + + playlist = schedule[pkey] + + print '*****************************************' + print '\033[0;32m%s %s\033[m' % ('scheduled at:', str(pkey)) + print 'cached at : ' + self.cache_dir + str(pkey) + print 'subtype: ' + str(playlist['subtype']) + print 'played: ' + str(playlist['played']) + print 'schedule id: ' + str(playlist['schedule_id']) + print 'duration: ' + str(playlist['duration']) + print 'source id: ' + str(playlist['x_ident']) + + print '-----------------------------------------' + + for media in playlist['medias']: + print media + + + print + + + +if __name__ == '__main__': + + print + print '#########################################' + print '# *** pypo *** #' + print '# obp python playout #' + print '#########################################' + print + + # initialize + g = Global() + g.selfcheck() + po = Playout() + + +run = True +while run == True: + + logger = logging.getLogger("pypo") + + loops = 0 + + while options.fetch_scheduler: + try: po.fetch('scheduler') + except Exception, e: + print e + sys.exit() + + print 'ZZzZzZzzzzZZZz.... sleeping for ' + str(POLL_INTERVAL) + ' seconds' + logger.info('fetch loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, POLL_INTERVAL) + loops += 1 + time.sleep(POLL_INTERVAL) + + while options.fetch_daypart: + try: po.fetch('daypart') + except Exception, e: + print e + sys.exit() + + print 'ZZzZzZzzzzZZZz.... sleeping for ' + str(POLL_INTERVAL) + ' seconds' + logger.info('fetch loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, POLL_INTERVAL) + loops += 1 + time.sleep(POLL_INTERVAL) + + + while options.push_scheduler: + + po.push('scheduler') + + try: po.push('scheduler') + except Exception, e: + print 'PUSH ERROR!! WILL EXIT NOW:(' + print e + sys.exit() + + logger.info('push loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, PUSH_INTERVAL) + loops += 1 + time.sleep(PUSH_INTERVAL) + + + while options.push_daypart: + + po.push('daypart') + + try: po.push('daypart') + except Exception, e: + print 'PUSH ERROR!! WILL EXIT NOW:(' + print e + sys.exit() + + logger.info('push loop %s - ZZzZzZzzzzZZZz.... sleeping for %s seconds', loops, PUSH_INTERVAL) + loops += 1 + time.sleep(PUSH_INTERVAL) + + + while options.jingles: + try: po.update_jingles(options.jingles) + except Exception, e: + print e + sys.exit() + + + while options.check: + try: po.check_schedule() + except Exception, e: + print e + sys.exit() + + while options.cleanup: + try: po.cleanup() + except Exception, e: + print e + sys.exit() + + + sys.exit() diff --git a/3rd_party/pypo/pypo_dls.py b/3rd_party/pypo/pypo_dls.py new file mode 100755 index 000000000..8e200d24b --- /dev/null +++ b/3rd_party/pypo/pypo_dls.py @@ -0,0 +1,243 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +""" +Python part of radio playout (pypo) + +This function acts as a gateway between liquidsoap and the obp-api. +Mainliy used to tell the plattform what pypo/LS does. + +Main case: + - whenever LS starts playing a new track, its on_metadata callback calls + a function in ls (notify(m)) which then calls the pythin script here + with the currently starting filename as parameter + - this python script takes this parameter, tries to extract the actual + media id from it, and then calls back to obp via api to tell about + + +""" + +# python defaults (debian default) +import time +import os +import traceback +from optparse import * +import sys +import time +import datetime +import logging +import logging.config +import urllib +import urllib2 +import string + +import socket + +# additional modules (should be checked) +from configobj import ConfigObj + +# custom imports +from util import * +from obp import * + + + +PYPO_VERSION = '0.9' +OBP_MIN_VERSION = 2010040501 # required obp version + + +#set up command-line options +parser = OptionParser() + +# help screeen / info +usage = "%prog [options]" + " - notification gateway" +parser = OptionParser(usage=usage) + +#options +parser.add_option("-p", "--playing", help="Tell daddy what is playing right now", metavar="path") + +# parse options +(options, args) = parser.parse_args() + +# configure logging +logging.config.fileConfig("logging.cfg") + +# loading config file +try: + config = ConfigObj('config.cfg') + TMP_DIR = config['tmp_dir'] + BASE_URL = config['base_url'] + OBP_API_BASE = BASE_URL + 'mod/medialibrary/' + EXPORT_SOURCE = config['export_source'] + + OBP_STATUS_URL = OBP_API_BASE + 'status/version/json' + OBP_API_KEY = config['obp_api_key'] + +except Exception, e: + print 'error: ', e + sys.exit() + + +class Global: + def __init__(self): + print + + def selfcheck(self): + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + obp_version = self.api_client.get_obp_version() + + if obp_version == 0: + print '#################################################' + print 'Unable to get OBP version. Is OBP up and running?' + print '#################################################' + print + sys.exit() + + elif obp_version < OBP_MIN_VERSION: + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo not compatible with this version of OBP' + print + sys.exit() + + else: + print 'OBP API: ' + str(OBP_API_BASE) + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo is compatible with this version of OBP' + print + +class Notify: + def __init__(self): + + self.tmp_dir = TMP_DIR + self.export_source = EXPORT_SOURCE + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + + def start_playing(self, options): + logger = logging.getLogger("start_playing") + + tnow = time.localtime(time.time()) + + + path = options + + try: + file = path.split("/")[-1:][0] + if file.find('_cue_') > 0: + id = file.split("_cue_")[0] + else: + id = file.split(".")[-2:][0] + + except Exception, e: + #print e + id = False + + try: + id = int(id) + except Exception, e: + #print e + id = False + + print + print "Media ID: ", + print id + + + + # self.api_client.update_start_playing(id, self.export_source, path) + + txt = "test this update" + + + + # Echo client program + + + HOST = '172.16.16.128' # The remote host + PORT = 50008 # The same port as used by the server + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.connect((HOST, PORT)) + + s.send('client_zzzz') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('RS_DLS_VERSION' + ' ' + '1') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('SERVICE' + ' ' + 'OPENBRO+') + s.send("\r\n") + + s.send('PASSWORD' + ' ' + 'OPENBRO+') + s.send("\r\n") + data = s.recv(1024) + print data; + + s.send('CLEAR_DLS') + s.send("\r\n") + + s.send('SET_DLS' + ' ' + txt) + s.send("\r\n") + data = s.recv(1024) + print data; + + s.close() + + print data + + if data == "session": + print 'KKK' + + + time.sleep(0.1) + + + + + print 'DONE' + + + + +if __name__ == '__main__': + + print + print '#########################################' + print '# *** pypo *** #' + print '# pypo notification gateway #' + print '#########################################' + print + + # initialize + g = Global() + g.selfcheck() + n = Notify() + + +run = True +while run == True: + + logger = logging.getLogger("pypo notify") + + while options.playing: + try: n.start_playing(options.playing) + except Exception, e: + print e + sys.exit() + + + + + sys.exit() diff --git a/3rd_party/pypo/pypo_notify.py b/3rd_party/pypo/pypo_notify.py new file mode 100755 index 000000000..70f1aeae9 --- /dev/null +++ b/3rd_party/pypo/pypo_notify.py @@ -0,0 +1,285 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + +""" +Python part of radio playout (pypo) + +This function acts as a gateway between liquidsoap and the obp-api. +Mainliy used to tell the plattform what pypo/LS does. + +Main case: + - whenever LS starts playing a new track, its on_metadata callback calls + a function in ls (notify(m)) which then calls the pythin script here + with the currently starting filename as parameter + - this python script takes this parameter, tries to extract the actual + media id from it, and then calls back to obp via api to tell about + + +""" + +# python defaults (debian default) +import time +import os +import traceback +from optparse import * +import sys +import time +import datetime +import logging +import logging.config +import urllib +import urllib2 +import string + +# additional modules (should be checked) +from configobj import ConfigObj + +# custom imports +from util import * +from obp import * +from dls import * + + + +PYPO_VERSION = '0.9' +OBP_MIN_VERSION = 2010040501 # required obp version + + +#set up command-line options +parser = OptionParser() + +# help screeen / info +usage = "%prog [options]" + " - notification gateway" +parser = OptionParser(usage=usage) + +#options +#parser.add_option("-p", "--playing", help="Tell daddy what is playing right now", dest="playing", default=False, metavar=False) + +parser.add_option("-p", "--playing", help="Tell daddy what is playing right now", default=False, action="store_true", dest="playing") + + +parser.add_option("-t", "--playlist-type", help="Tell daddy what is playing right now", metavar="playlist_type") + +parser.add_option("-M", "--media-id", help="Tell daddy what is playing right now", metavar="media_id") +parser.add_option("-U", "--user-id", help="Tell daddy what is playing right now", metavar="user_id") +parser.add_option("-P", "--playlist-id", help="Tell daddy what is playing right now", metavar="playlist_id") +parser.add_option("-T", "--transmission-id", help="Tell daddy what is playing right now", metavar="transmission_id") +parser.add_option("-E", "--export-source", help="Tell daddy what is playing right now", metavar="export_source") + +# parse options +(options, args) = parser.parse_args() + +# configure logging +logging.config.fileConfig("logging.cfg") + +# loading config file +try: + config = ConfigObj('config.cfg') + TMP_DIR = config['tmp_dir'] + BASE_URL = config['base_url'] + OBP_API_BASE = BASE_URL + 'mod/medialibrary/' + + OBP_STATUS_URL = OBP_API_BASE + 'status/version/json' + OBP_API_KEY = config['obp_api_key'] + +except Exception, e: + print 'error: ', e + sys.exit() + + +class Global: + def __init__(self): + print + + def selfcheck(self): + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + obp_version = self.api_client.get_obp_version() + + if obp_version == 0: + print '#################################################' + print 'Unable to get OBP version. Is OBP up and running?' + print '#################################################' + print + sys.exit() + + elif obp_version < OBP_MIN_VERSION: + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo not compatible with this version of OBP' + print + sys.exit() + + else: + print 'OBP API: ' + str(OBP_API_BASE) + print 'OBP version: ' + str(obp_version) + print 'OBP min-version: ' + str(OBP_MIN_VERSION) + print 'pypo is compatible with this version of OBP' + print + +class Notify: + def __init__(self): + + self.tmp_dir = TMP_DIR + + self.api_auth = urllib.urlencode({'api_key': OBP_API_KEY}) + self.api_client = ApiClient(OBP_API_BASE, self.api_auth) + + self.dls_client = DlsClient('127.0.0.128', 50008, 'myusername', 'mypass') + + + + + def start_playing(self, options): + logger = logging.getLogger("start_playing") + + tnow = time.localtime(time.time()) + + #print options + + + + print '#################################################' + print '# calling obp to tell about what\'s playing #' + print '#################################################' + + if int(options.playlist_type) < 5: + print 'seems to be a playlist' + + try: + media_id = int(options.media_id) + except Exception, e: + media_id = 0 + + response = self.api_client.update_start_playing(options.playlist_type, options.export_source, media_id, options.playlist_id, options.transmission_id) + + print response + + if int(options.playlist_type) == 6: + print 'seems to be a couchcast' + + try: + media_id = int(options.media_id) + except Exception, e: + media_id = 0 + + response = self.api_client.update_start_playing(options.playlist_type, options.export_source, media_id, options.playlist_id, options.transmission_id) + + print response + + + + + + + sys.exit() + + + + + + def start_playing_legacy(self, options): + logger = logging.getLogger("start_playing") + + tnow = time.localtime(time.time()) + + + print '#################################################' + print '# calling obp to tell about what\'s playing #' + print '#################################################' + + path = options + + print + print path + print + + if 'pl_id' in path: + print 'seems to be a playlist' + type = 'playlist' + id = path[5:] + + elif 'text' in path: + print 'seems to be a playlist' + type = 'text' + id = path[4:] + print id + + else: + print 'seems to be a single track (media)' + type = 'media' + try: + file = path.split("/")[-1:][0] + if file.find('_cue_') > 0: + id = file.split("_cue_")[0] + else: + id = file.split(".")[-2:][0] + + except Exception, e: + #print e + id = False + + try: + id = id + except Exception, e: + #print e + id = False + + print + print type + " id: ", + print id + + + response = self.api_client.update_start_playing(type, id, self.export_source, path) + + print 'DONE' + + try: + txt = response['txt'] + print '#######################################' + print txt + print '#######################################' + #self.dls_client.set_txt(txt) + + except Exception, e: + print e + + + + + + +if __name__ == '__main__': + + print + print '#########################################' + print '# *** pypo *** #' + print '# pypo notification gateway #' + print '#########################################' + print + + # initialize + g = Global() + g.selfcheck() + n = Notify() + + +run = True +while run == True: + + logger = logging.getLogger("pypo notify") + + if options.playing: + try: n.start_playing(options) + except Exception, e: + print e + sys.exit() + + + + + sys.exit() diff --git a/3rd_party/pypo/scripts/README b/3rd_party/pypo/scripts/README new file mode 100644 index 000000000..5e79bd7e3 --- /dev/null +++ b/3rd_party/pypo/scripts/README @@ -0,0 +1,23 @@ +This directory contains scripts not directly related to pypo +These mainly are things related to liquidsoap & playout + +I added those scripts here to have them at hand for +development and also to update/share them via svn + + +scripts here: + +- ls_run.sh + wrapper to run liquid soap. makes sure that the "current" playlist is + filled with silence + +- ls_script.liq (called by ls_run.sh) + the main liquidsoap control-script + +- ls_cue.liq (included by ls_script.liq) + contains a custom protocol that registers the cue-in/out values from the playlist script + +- cue_file.py (called by ls_cue.liq) + a wrapper that does the actual cutting. + it is called with: path_to_file[path] cue_in[ss.ms] cue_out[ss.ms] and does the mp3 cutting (with mp3cut) + returns a temporary file that can be used by ls (make sure to set "TEMP_DIR" in script) \ No newline at end of file diff --git a/3rd_party/pypo/scripts/cue_file.py b/3rd_party/pypo/scripts/cue_file.py new file mode 100755 index 000000000..c52dd7a58 --- /dev/null +++ b/3rd_party/pypo/scripts/cue_file.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# author Jonas Ohrstrom + + +""" +cue script that gets called by liquidsoap if a file in the playlist +gives orders to cue (in/out). eg: +cue_file:cue_in=120.0,cue_out=110.0:annotate:*** + +params: path_to_file, cue_in [float, seconds], cue_out [float, sseconds] +returns: path to the cued temp-file + +examples: +calling: ./cue_file.py /storage/pypo/cache/2010-06-25-15-05-00/35.mp3 10 120.095 +returns: /tmp/lstf_UwDKcEngvF + +One thing to mention here: +The way pypo (ab)uses liquidsoap can bring in some unwanted effects. liquidsoap +is built in a way that it tries to collect the needed files to playout in advance. +we 'force' liquidsoap to immediately start playing a newly loaded list, so ls has +no time to prepare the files. If a file is played without cues, this does not afect +the playout too much. My testing on a lame VM added a delay of +/- 10ms. + +If the first file in a playlist is cued, the "mp3cut" command takes time to execute. +On the same VM this takes an additional 200ms for an average size mp3-file. +So the playout will start a bit delayed. This should not be a too big issue, but +think about this behaviour if you eg access the files via network (nas) as the reading +of files could take some time as well. + +So maybe we should think about a different implementation. One way would be to do the +cueing during playlist preparation, so all the files would be pre-cut when they are +passed to liquidsoap. +Additionally this would allow to run an unpathed version of ls. + +""" + +import sys +import shutil +import random +import string +import time +from datetime import timedelta +import os + +from mutagen.mp3 import MP3 +import mad + +TEMP_DIR = '/tmp/'; + + +sys.stderr.write('\n** starting mp3 cutter **\n\n') + +try: src = sys.argv[1] +except Exception, e: + sys.stderr.write('No file givien. sorry.\n') + sys.exit() + +try: cue_in = float(sys.argv[2]) +except Exception, e: + cue_in = float(0) + pass + +try: cue_out = float(sys.argv[3]) +except Exception, e: + cue_out = float(0) + pass + +sys.stderr.write('in: %s - out: %s file: %s \n' % (cue_in, cue_out, src)) +dst = TEMP_DIR + 'lstf_' + "".join( [random.choice(string.letters) for i in xrange(10)] ) + +# get length of track +""" +madlib is not accurate enough to get the duration. (only goes to seconds, no ms) +so it is not suitable for relative offsets (eg "play until 10s before the end") +it anyway wuld be better to provide this script with absolute times, like +play from 23.234 to 323.321 +""" +# madlib +#mf = mad.MadFile(src) +#dur = float(float(mf.total_time())/1000) + +# mutagen +audio = MP3(src) +dur = round(audio.info.length, 3) + + +sys.stderr.write('duration: ' + str(dur) + '\n') + +cue_out = round(float(dur) - cue_out, 3) + +str_cue_in = str(timedelta(seconds=cue_in)).replace(".", "+") # hh:mm:ss+mss, eg 00:00:20+000 +str_cue_out = str(timedelta(seconds=cue_out)).replace(".", "+") # + +""" +now a bit a hackish part, don't know how to do this better... +need to cut the digits after the "+" + +""" +ts = str_cue_in.split("+") +try: + if len(ts[1]) == 6: + ts[1] = ts[1][0:3] + str_cue_in = "%s+%s" % (ts[0], ts[1]) +except Exception, e: + pass + +ts = str_cue_out.split("+") +try: + if len(ts[1]) == 6: + ts[1] = ts[1][0:3] + str_cue_out = "%s+%s" % (ts[0], ts[1]) +except Exception, e: + pass + +#sys.stderr.write(str(timedelta(seconds=cue_in)).replace(".", "+") + '\n\n') +sys.stderr.write('in: ' + str_cue_in + '\n') +sys.stderr.write('abs: ' + str(str_cue_out) + '\n\n') + +command = 'mp3cut -o %s -t %s-%s %s' % (dst, str_cue_in, str_cue_out, src); + +sys.stderr.write(command + '\n\n\n') +os.system(command + ' >/dev/null') +#shutil.copy2(src, dst) + +print dst + "\n"; diff --git a/3rd_party/pypo/scripts/include_daypart.liq b/3rd_party/pypo/scripts/include_daypart.liq new file mode 100644 index 000000000..e43c29e41 --- /dev/null +++ b/3rd_party/pypo/scripts/include_daypart.liq @@ -0,0 +1,70 @@ + +######################################### +# A/B queue-setup daypart +######################################### + +# a/b queue setup +daypart_q0 = request.queue(conservative=true,length=600.,id="daypart_q0") +daypart_q1 = request.queue(conservative=true,length=600.,id="daypart_q1") + +daypart_q0 = audio_to_stereo(daypart_q0) +daypart_q1 = audio_to_stereo(daypart_q1) + +daypart_active = ref 0 +daypart_queue = ref 1 +daypart_q0_enabled = ref false +daypart_q1_enabled = ref false + +# push function, enqueues file in inactive queue (does not start automatically) +def daypart_push(s) + list.hd(server.execute("daypart_q#{!daypart_queue}.push #{s}")) + print('push to #{!daypart_queue} - #{s}') + "Done" +end + + +# flips the queues +def daypart_flip() + + # set a/b-queue corresponding to active, see fallback below + if !daypart_active==1 then daypart_q0_enabled:=true else daypart_q0_enabled:=false end + if !daypart_active==0 then daypart_q1_enabled:=true else daypart_q1_enabled:=false end + + # get playing (active) queue and flush it + l = list.hd(server.execute("daypart_q#{!daypart_active}.queue")) + l = string.split(separator=" ",l) + list.iter(fun (rid) -> ignore(server.execute("daypart_q#{!daypart_active}.ignore #{rid}")), l) + + # skip the playing item + # source.skip(if !daypart_active==0 then daypart_q0 else daypart_q1 end) + + # flip variables + daypart_active := 1-!daypart_active + daypart_queue := 1-!daypart_active + + "Done" +end + + +# print status +def daypart_status() + print('daypart_active: #{!daypart_active}') + print('daypart_queue : #{!daypart_queue}') + "Done" +end + +# register for telnet access +server.register(namespace="daypart","push", daypart_push) +server.register(namespace="daypart","flip", fun (_) -> daypart_flip()) +server.register(namespace="daypart","status", fun (_) -> daypart_status()) + + +# activate / deactivate queues, needed for fallback to work +daypart_q0 = switch(track_sensitive=true, [({!daypart_q0_enabled},daypart_q0)]) +daypart_q1 = switch(track_sensitive=true, [({!daypart_q1_enabled},daypart_q1)]) +daypart_q_holder = fallback(track_sensitive=true, [daypart_q0, daypart_q1]) + + +# finally the resulting daypart source +daypart = fallback(track_sensitive=false, [daypart_q_holder, default]) + diff --git a/3rd_party/pypo/scripts/include_dynamic_vars.liq b/3rd_party/pypo/scripts/include_dynamic_vars.liq new file mode 100644 index 000000000..c62c868a0 --- /dev/null +++ b/3rd_party/pypo/scripts/include_dynamic_vars.liq @@ -0,0 +1,32 @@ +####################################################################### +# Dynamic variables +####################################################################### + +playlist_id = ref '0' +user_id = ref '0' +transmission_id = ref '0' +playlist_type = ref '0' + + +def set_user_id(s) + user_id := s +end + + +def set_playlist_id(s) + playlist_id := s +end + + +def set_transmission_id(s) + transmission_id := s +end + +def set_playlist_type(s) + playlist_type := s +end + +server.register(namespace="vars", "user_id", fun (s) -> begin set_user_id(s) "Done!" end) +server.register(namespace="vars", "playlist_id", fun (s) -> begin set_playlist_id(s) "Done!" end) +server.register(namespace="vars", "transmission_id", fun (s) -> begin set_transmission_id(s) "Done!" end) +server.register(namespace="vars", "playlist_type", fun (s) -> begin set_playlist_type(s) "Done!" end) \ No newline at end of file diff --git a/3rd_party/pypo/scripts/include_live_in.liq b/3rd_party/pypo/scripts/include_live_in.liq new file mode 100644 index 000000000..c20bf876a --- /dev/null +++ b/3rd_party/pypo/scripts/include_live_in.liq @@ -0,0 +1,24 @@ +####################################################################### +# Live input - From external icecast server +####################################################################### + + +live_in = input.http(id="live_in",autostart=false,buffer=.1, max=12.,couchcaster_list) +live_in = buffer(id="buffer_live_in",buffer=.1,fallible=true,live_in) +live_in = mksafe(live_in) + + + +live_active = ref false +def live_switch(i) + print(i) + if i=='1' then live_active:=true else live_active:=false end + print(live_active) + "Done" +end +server.register(namespace="live","active", live_switch) + +live = switch(track_sensitive=false, [({!live_active},live_in)]) + +to_live_s = to_live(jingles_cc) +to_scheduler_s = to_scheduler() diff --git a/3rd_party/pypo/scripts/include_notify.liq b/3rd_party/pypo/scripts/include_notify.liq new file mode 100644 index 000000000..8dc125907 --- /dev/null +++ b/3rd_party/pypo/scripts/include_notify.liq @@ -0,0 +1,27 @@ +######################################## +# call pypo api gateway +######################################## + +def notify(m) + + print('user_id: #{!user_id}') + print('playlist_id: #{!playlist_id}') + print('transmission_id: #{!transmission_id}') + print('playlist_type: #{!playlist_type}') + + if !playlist_type=='5' then + print('livesession') + system("./notify.sh --playing --playlist-type=#{!playlist_type} --transmission-id=#{!transmission_id} --export-source=scheduler") + end + + if !playlist_type=='6' then + print('couchcaster') + system("./notify.sh --playing --playlist-type=#{!playlist_type} --transmission-id=#{!transmission_id} --export-source=scheduler") + end + + if !playlist_type=='0' or !playlist_type=='1' or !playlist_type=='2' or !playlist_type=='3' or !playlist_type=='4' then + print('playlist') + system("./notify.sh --playing --playlist-type=#{!playlist_type} --media-id=#{m['media_id']} --export-source=#{m['export_source']}") + end + +end \ No newline at end of file diff --git a/3rd_party/pypo/scripts/include_scheduler.liq b/3rd_party/pypo/scripts/include_scheduler.liq new file mode 100644 index 000000000..e60e1435b --- /dev/null +++ b/3rd_party/pypo/scripts/include_scheduler.liq @@ -0,0 +1,77 @@ + +######################################### +# A/B queue-setup Scheduler +######################################### + +# a/b queue setup +scheduler_q0 = request.queue(conservative=true,length=600.,id="scheduler_q0") +scheduler_q1 = request.queue(conservative=true,length=600.,id="scheduler_q1") + +scheduler_q0 = audio_to_stereo(scheduler_q0) +scheduler_q1 = audio_to_stereo(scheduler_q1) + +scheduler_active = ref 0 +scheduler_queue = ref 1 +scheduler_q0_enabled = ref false +scheduler_q1_enabled = ref false + +# push function, enqueues file in inactive queue (does not start automatically) +def scheduler_push(s) + list.hd(server.execute("scheduler_q#{!scheduler_queue}.push #{s}")) + print('push to #{!scheduler_queue} - #{s}') + "Done" +end + + +# flips the queues +def scheduler_flip() + + # set a/b-queue corresponding to active, see fallback below + if !scheduler_active==1 then scheduler_q0_enabled:=true else scheduler_q0_enabled:=false end + if !scheduler_active==0 then scheduler_q1_enabled:=true else scheduler_q1_enabled:=false end + + # get playing (active) queue and flush it + l = list.hd(server.execute("scheduler_q#{!scheduler_active}.queue")) + l = string.split(separator=" ",l) + list.iter(fun (rid) -> ignore(server.execute("scheduler_q#{!scheduler_active}.ignore #{rid}")), l) + + # skip the playing item + source.skip(if !scheduler_active==0 then scheduler_q0 else scheduler_q1 end) + + # flip variables + scheduler_active := 1-!scheduler_active + scheduler_queue := 1-!scheduler_active + + + "Done" +end + + +# print status +def scheduler_status() + print('scheduler_active: #{!scheduler_active}') + print('scheduler_queue : #{!scheduler_queue}') + + print('user_id: #{!user_id}') + print('playlist_id: #{!playlist_id}') + print('transmission_id: #{!transmission_id}') + print('playlist_type: #{!playlist_type}') + + "Done" +end + +# register for telnet access +server.register(namespace="scheduler","push", scheduler_push) +server.register(namespace="scheduler","flip", fun (_) -> scheduler_flip()) +server.register(namespace="scheduler","status", fun (_) -> scheduler_status()) + + +# activate / deactivate queues, needed for fallback to work +scheduler_q0 = switch(track_sensitive=true, [({!scheduler_q0_enabled},scheduler_q0)]) +scheduler_q1 = switch(track_sensitive=true, [({!scheduler_q1_enabled},scheduler_q1)]) +scheduler_q_holder = fallback(track_sensitive=true, [scheduler_q0, scheduler_q1]) + + +# finally the resulting scheduler source +scheduler = fallback(track_sensitive=false, [scheduler_q_holder, default]) + diff --git a/3rd_party/pypo/scripts/library.liq b/3rd_party/pypo/scripts/library.liq new file mode 100644 index 000000000..5b93ac8ff --- /dev/null +++ b/3rd_party/pypo/scripts/library.liq @@ -0,0 +1,37 @@ +# Define a transition that fades out the +# old source, adds a single, and then +# plays the new source +def to_live(jingle,old,new) = + # Fade out old source + old = fade.final(old) + # Supperpose the jingle + s = add([jingle,old]) + # Compose this in sequence with + # the new source + sequence([s,new]) +end + +def to_scheduler(old,new) = + # We skip the file + # currently in new + # in order to being with + # a fresh file + # source.skip(new) + sequence([old,new]) +end + +# A transition when switching back to files: +def to_file(old,new) = + # We skip the file + # currently in new + # in order to being with + # a fresh file + # source.skip(new) + sequence([old,new]) +end + + +def dp_to_scheduler(old,new) = + old = fade.final(type='log',duration=2.1,old) + sequence([old,new]) +end \ No newline at end of file diff --git a/3rd_party/pypo/scripts/library/externals.liq b/3rd_party/pypo/scripts/library/externals.liq new file mode 100644 index 000000000..9a3ed28eb --- /dev/null +++ b/3rd_party/pypo/scripts/library/externals.liq @@ -0,0 +1,149 @@ +# Decoders, enabled when the binary is detected and the os is not Win32. + +# Get_mime is not always defined +# so we define a default in this case.. +my_get_mime = fun (_) -> "" +%ifdef get_mime +my_get_mime = get_mime +%endif +get_mime = my_get_mime + +%ifdef add_decoder +if test_process("which flac") then + log(level=3,"Found flac binary: enabling flac external decoder.") + flac_p = "flac -d -c - 2>/dev/null" + def test_flac(file) = + if test_process("which metaflac") then + channels = list.hd(get_process_lines("metaflac \ + --show-channels #{quote(file)} \ + 2>/dev/null")) + # If the value is not an int, this returns 0 and we are ok :) + int_of_string(channels) + else + # Try to detect using mime test.. + mime = get_mime(file) + if string.match(pattern="flac",file) then + # We do not know the number of audio channels + # so setting to -1 + (-1) + else + # All tests failed: no audio decodable using flac.. + 0 + end + end + end + add_decoder(name="FLAC",description="Decode files using the flac \ + decoder binary.", test=test_flac,flac_p) +else + log(level=3,"flac binary not found: flac decoder disabled.") +end +%endif + +if os.type != "Win32" then + if test_process("which metaflac") then + log(level=3,"Found metaflac binary: enabling flac external metadata \ + resolver.") + def flac_meta(file) + ret = get_process_lines("metaflac --export-tags-to=- \ + #{quote(file)} 2>/dev/null") + ret = list.map(string.split(separator="="),ret) + # Could be made better.. + def f(l',l)= + if list.length(l) >= 2 then + list.append([(list.hd(l),list.nth(l,1))],l') + else + if list.length(l) >= 1 then + list.append([(list.hd(l),"")],l') + else + l' + end + end + end + list.fold(f,[],ret) + end + add_metadata_resolver("FLAC",flac_meta) + else + log(level=3,"metaflac binary not found: flac metadata resolver disabled.") + end +end + +# A list of know extensions and content-type for AAC. +# Values from http://en.wikipedia.org/wiki/Advanced_Audio_Coding +# TODO: can we register a setting for that ?? +aac_mimes = ["audio/aac", "audio/aacp", "audio/3gpp", "audio/3gpp2", "audio/mp4", + "audio/MP4A-LATM", "audio/mpeg4-generic", "audio/x-hx-aac-adts"] +aac_filexts = ["m4a", "m4b", "m4p", "m4v", + "m4r", "3gp", "mp4", "aac"] + +# Faad is not very selective so +# We are checking only file that +# end with a known extension or mime type +def faad_test(file) = + # Get the file's mime + mime = get_mime(file) + # Test mime + if list.mem(mime,aac_mimes) then + true + else + # Otherwise test file extension + ret = string.extract(pattern='\.(.+)$',file) + if list.length(ret) != 0 then + ext = ret["1"] + list.mem(ext,aac_filexts) + else + false + end + end +end + +if os.type != "Win32" then + if test_process("which faad") then + log(level=3,"Found faad binary: enabling external faad decoder and \ + metadata resolver.") + faad_p = (fun (f) -> "faad -w #{quote(f)} 2>/dev/null") + def test_faad(file) = + if faad_test(file) then + channels = list.hd(get_process_lines("faad -i #{quote(file)} 2>&1 | \ + grep 'ch,'")) + ret = string.extract(pattern=", (\d) ch,",channels) + ret = + if list.length(ret) == 0 then + # If we pass the faad_test, chances are + # high that the file will contain aac audio data.. + "-1" + else + ret["1"] + end + int_of_string(default=(-1),ret) + else + 0 + end + end +%ifdef add_oblivious_decoder + add_oblivious_decoder(name="FAAD",description="Decode files using \ + the faad binary.", test=test_faad, faad_p) +%endif + def faad_meta(file) = + if faad_test(file) then + ret = get_process_lines("faad -i \ + #{quote(file)} 2>&1") + # Yea, this is tuff programming (again) ! + def get_meta(l,s)= + ret = string.extract(pattern="^(\w+):\s(.+)$",s) + if list.length(ret) > 0 then + list.append([(ret["1"],ret["2"])],l) + else + l + end + end + list.fold(get_meta,[],ret) + else + [] + end + end + add_metadata_resolver("FAAD",faad_meta) + else + log(level=3,"faad binary not found: faad decoder disabled.") + end +end + diff --git a/3rd_party/pypo/scripts/library/extract-replaygain b/3rd_party/pypo/scripts/library/extract-replaygain new file mode 100755 index 000000000..726fa5928 --- /dev/null +++ b/3rd_party/pypo/scripts/library/extract-replaygain @@ -0,0 +1,73 @@ +#!/usr/bin/perl -w + +use strict ; + +my $file = $ARGV[0] || die ; + +sub test_mime { + my $file = shift ; + if (`which file`) { + return `file -b --mime-type "$file"`; + } +} + +if (($file =~ /\.mp3$/i) || (test_mime($file) =~ /audio\/mpeg/)) { + + if (`which mp3gain`) { + + my $out = `nice -n 20 mp3gain -q "$file" 2> /dev/null` ; + $out =~ /Recommended "Track" dB change: (.*)$/m || die ; + print "$1 dB\n" ; + + } else { + + print STDERR "Cannot find mp3gain binary!\n"; + + } + +} elsif (($file =~ /\.ogg$/i) || (test_mime($file) =~ /application\/ogg/)) { + + if ((`which vorbisgain`) && (`which ogginfo`)) { + + system("nice -n 20 vorbisgain -q -f \"$file\" 2>/dev/null >/dev/null") ; + my $info = `ogginfo "$file"` ; + $info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/ || die ; + print "$1 dB\n" ; + + } else { + + print STDERR "Cannot find vorbisgain or ogginfo!\n"; + + } + +} elsif (($file =~ /\.flac$/i) || (test_mime($file) =~ /audio\/x-flac/)) { + + if (`which metaflac`) { + + my $info = `metaflac --show-tag=REPLAYGAIN_TRACK_GAIN "$file"` ; + $info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/; + if (defined($1)) { + + print "$1 dB\n" ; + + } else { + + system("nice -n 20 metaflac --add-replay-gain \"$file\" \ + 2>/dev/null >/dev/null") ; + $info = `metaflac --show-tag=REPLAYGAIN_TRACK_GAIN "$file"` ; + $info =~ /REPLAYGAIN_TRACK_GAIN=(.*) dB/ || die "Error in $file" ; + print "$1 dB\n" ; + + } + + } else { + + print STDERR "Cannot find metaflac!\n"; + + } + +} else { + + print STDERR "File format not supported...\n"; + +} diff --git a/3rd_party/pypo/scripts/library/lastfm.liq b/3rd_party/pypo/scripts/library/lastfm.liq new file mode 100644 index 000000000..0886bf0a2 --- /dev/null +++ b/3rd_party/pypo/scripts/library/lastfm.liq @@ -0,0 +1,133 @@ + +dummy = fun () -> log("Lastfm/audioscrobbler support was not compiled.") + +%ifdef input.lastfm +dummy = fun () -> () + +# Utility to compose last.fm URIs. +# @category String +# @param ~user Lastfm user +# @param ~password Lastfm password +# @param ~discovery Allow lastfm suggestions +# @param radio URI, e.g. user/toots5446/playlist, globaltags/rocksteady. +def lastfm.uri(~user="",~password="",~discovery=false, + radio="globaltags/creative-commons") + auth = if user == "" then "" else "#{user}:#{password}@" end + discovery = if discovery == true then "1" else "0" end + "lastfm://#{auth}#{radio}?discovery=#{discovery}" +end + +# Submit metadata to libre.fm using the audioscrobbler protocol. +# @category Interaction +# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set. +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +def librefm.submit(~user,~password,~source="broadcast",~length=false,m) = + audioscrobbler.submit(user=user,password=password, + source=source,length=length, + host="turtle.libre.fm",port=80, + m) +end + +# Submit metadata to lastfm.fm using the audioscrobbler protocol. +# @category Interaction +# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set. +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +def lastfm.submit(~user,~password,~source="broadcast",~length=false,m) = + audioscrobbler.submit(user=user,password=password, + source=source,length=length, + host="post.audioscrobbler.com",port=80, + m) +end + +# Submit metadata to libre.fm using the audioscrobbler protocol (nowplaying mode). +# @category Interaction +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +def librefm.nowplaying(~user,~password,~length=false,m) = + audioscrobbler.nowplaying(user=user,password=password,length=length, + host="turtle.libre.fm",port=80, + m) +end + +# Submit metadata to lastfm.fm using the audioscrobbler protocol (nowplaying mode). +# @category Interaction +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +def lastfm.nowplaying(~user,~password,~length=false,m) = + audioscrobbler.nowplaying(user=user,password=password,length=length, + host="post.audioscrobbler.com",port=80, + m) +end + +# Submit songs using audioscrobbler, respecting the full protocol: +# First signal song as now playing when starting, and +# then submit song when it ends. +# @category Interaction +# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set. +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +# @param ~delay Submit song when there is only this delay left, in seconds. +# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour. +def audioscrobbler.submit.full( + ~user,~password, + ~host="post.audioscrobbler.com",~port=80, + ~source="broadcast",~length=false, + ~delay=10.,~force=false,s) = + f = audioscrobbler.nowplaying( + user=user,password=password, + host=host,port=port,length=length) + s = on_metadata(f,s) + f = fun (rem,m) -> + # Avoid skipped songs + if rem > 0. or force then + audioscrobbler.submit( + user=user,password=password, + host=host,port=port,length=length, + source=source,m) + else + log(label="audioscrobbler.submit.full", + level=4,"Remaining time null: \ + will not submit song (song skipped ?)") + end + on_end(delay=delay,f,s) +end + +# Submit songs to librefm using audioscrobbler, respecting the full protocol: +# First signal song as now playing when starting, and +# then submit song when it ends. +# @category Interaction +# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set. +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +# @param ~delay Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour. +# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour. +def librefm.submit.full( + ~user,~password, + ~source="broadcast",~length=false, + ~delay=10.,~force=false,s) = + audioscrobbler.submit.full( + user=user,password=password, + source=source,length=length, + host="turtle.libre.fm",port=80, + delay=delay,force=force,s) +end + +# Submit songs to lastfm using audioscrobbler, respecting the full protocol: +# First signal song as now playing when starting, and +# then submit song when it ends. +# @category Interaction +# @param ~source Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intented for radio broadcasting, this is the default. Sources other than user don't need duration to be set. +# @param ~length Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type. +# @param ~delay Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour. +# @param ~force If remaining time is null, the song will be assumed to be skipped or cuted, and not submitted. Set to zero to disable this behaviour. +def lastfm.submit.full( + ~user,~password, + ~source="broadcast",~length=false, + ~delay=10.,~force=false,s) = + audioscrobbler.submit.full( + user=user,password=password, + source=source,length=length, + host="post.audioscrobbler.com",port=80, + delay=delay,force=force,s) +end + +%endif + +dummy () + diff --git a/3rd_party/pypo/scripts/library/liquidtts b/3rd_party/pypo/scripts/library/liquidtts new file mode 100755 index 000000000..ad17a248c --- /dev/null +++ b/3rd_party/pypo/scripts/library/liquidtts @@ -0,0 +1,11 @@ +#!/bin/sh + +# This script is called from liquidsoap for generating a file +# for "say:voice/text" URIs. +# Usage: liquidtts text output_file voice + +echo $1 | /usr/bin/text2wave -f 44100 > $2.tmp.wav && /usr/bin/sox $2.tmp.wav -t wav -c 2 -r 44100 $2 2> /dev/null > /dev/null +return=$? +/bin/rm $2.tmp.wav +false $2 2> /dev/null > /dev/null +exit $return diff --git a/3rd_party/pypo/scripts/library/pervasives.liq b/3rd_party/pypo/scripts/library/pervasives.liq new file mode 100644 index 000000000..eecf31e23 --- /dev/null +++ b/3rd_party/pypo/scripts/library/pervasives.liq @@ -0,0 +1,4 @@ +%include "utils.liq" +%include "externals.liq" +%include "shoutcast.liq" +%include "lastfm.liq" diff --git a/3rd_party/pypo/scripts/library/shoutcast.liq b/3rd_party/pypo/scripts/library/shoutcast.liq new file mode 100644 index 000000000..eacd7b7a9 --- /dev/null +++ b/3rd_party/pypo/scripts/library/shoutcast.liq @@ -0,0 +1,49 @@ + +%ifdef output.icecast +# Output to shoutcast. +# @category Source / Output +# @param ~id Output's ID +# @param ~start Start output threads on operator initialization. +# @param ~restart Restart output after a failure. By default, liquidsoap will stop if the output failed. +# @param ~restart_delay Delay, in seconds, before attempting new connection, if restart is enabled. +# @param ~user User for shout source connection. Useful only in special cases, like with per-mountpoint users. +# @param ~icy_reset Reset shoutcast source buffer upon connecting (necessary for NSV). +# @param ~dumpfile Dump stream to file, for debugging purpose. Disabled if empty. +# @param ~fallible Allow the child source to fail, in which case the output will be (temporarily) stopped. +# @param ~on_start Callback executed when outputting starts. +# @param ~on_stop Callback executed when outputting stops. +# @param ~on_connect Callback executed when connection starts. +# @param ~on_disconnect Callback executed when connection stops. +# @param ~icy_metadata Send new metadata using the ICY protocol. One of: "guess", "true", "false" +# @param ~format Format, e.g. "audio/ogg". When empty, the encoder is used to guess. +# @param e Endoding format. For shoutcast, should be mp3 or AAC(+). +# @param s The source to output +def output.shoutcast( + ~id="output.shoutcast",~start=true, + ~restart=false,~restart_delay=3, + ~host="localhost",~port=8000, + ~user="source",~password="hackme", + ~genre="Misc",~url="http://savonet.sf.net/", + ~name="OCaml Radio!",~public=true, ~format="", + ~dumpfile="", ~icy_metadata="guess", + ~on_connect={()}, ~on_disconnect={()}, + ~aim="",~icq="",~irc="",~icy_reset=true, + ~fallible=false,~on_start={()},~on_stop={()}, + e,s) = + icy_reset = if icy_reset then "1" else "0" end + headers = [("icy-aim",aim),("icy-irc",irc), + ("icy-icq",icq),("icy-reset",icy_reset)] + output.icecast( + e, format=format, + id=id, headers=headers, + start=start,icy_metadata=icy_metadata, + on_connect=on_connect, on_disconnect=on_disconnect, + restart=restart, restart_delay=restart_delay, + host=host, port=port, user=user, password=password, + genre=genre, url=url, description="UNUSED", + public=public, dumpfile=dumpfile, + name=name, mount="/", protocol="icy", + fallible=fallible,on_start=on_start,on_stop=on_stop, + s) +end +%endif diff --git a/3rd_party/pypo/scripts/library/utils.liq b/3rd_party/pypo/scripts/library/utils.liq new file mode 100644 index 000000000..fba616846 --- /dev/null +++ b/3rd_party/pypo/scripts/library/utils.liq @@ -0,0 +1,578 @@ + +# Turn a source into an infaillible source. +# by adding blank when the source is not available. +# @param s the source to turn infaillible +# @category Source / Input +def mksafe(s) + fallback(id="mksafe",track_sensitive=false,[s,blank(id="safe_blank")]) +end + +# Alias for the l[k] notation. +# @category List +# @param a Key to look for +# @param l List of pairs (key,value) +def list.assoc(a,l) + l[a] +end + +# list.mem_assoc(key,l) returns true if l contains a pair +# (key,value) +# @category List +# @param a Key to look for +# @param l List of pairs (key,value) +def list.mem_assoc(a,l) + v = list.assoc(a,l) + # We check for existence, since "" may indicate + # either a binding (a,"") or no binding.. + list.mem((a,v),l) +end + +# Remove a pair from an associative list +# @category List +# @param a Key of pair to be removed +# @param l List of pairs (key,value) +def list.remove_assoc(a,l) + list.remove((a,list.assoc(a,l)),l) +end + +# Rewrite metadata on the fly using a list of (target,rules). +# @category Source / Track Processing +# @param l \ +# List of (target,value) rewriting rules. +# @param ~insert_missing \ +# Treat track beginnings without metadata as having empty ones. \ +# The operational order is: \ +# create empty if needed, map and strip if enabled. +# @param ~update \ +# Only update metadata. \ +# If false, only returned values will be set as metadata. +# @param ~strip \ +# Completly remove empty metadata. \ +# Operates on both empty values and empty metadata chunk. +def rewrite_metadata(l,~insert_missing=true, + ~update=true,~strip=false, + s) + # We don't need to return all values, since + # map_metadata only update returned values. + # So, we simply apply all rewrite rules ! + def map(m) + def apply(x) + label = fst(x) + value = snd(x) + (label,value % m) + end + list.map(apply,l) + end + map_metadata(map,insert_missing=insert_missing, + update=update,strip=strip,s) +end + +# Add a skip function to a source +# when it does not have one +# by default +# @category Interaction +# @param s The source to attach the command to. +def add_skip_command(s) = + # A command to skip + def skip(_) = + source.skip(s) + "Done!" + end + # Register the command: + server.register(namespace="#{source.id(s)}", + usage="skip", + description="Skip the current song.", + "skip",skip) +end + +# Removes all metadata coming from a source +# @category Source / Track Processing +def clear_metadata(s) + def map(m) + [] + end + map_metadata(map,update=false,strip=true,s) +end + +output.prefered=output.dummy +%ifdef output.oss + output.prefered=output.oss +%endif +%ifdef output.alsa + output.prefered=output.alsa +%endif +%ifdef output.pulseaudio + output.prefered=output.pulseaudio +%endif +%ifdef output.ao + output.prefered=output.ao +%endif +# Output to local audio card using the first available driver in this list: +# ao, pulseaudio, alsa, oss, dummy +# @category Source / Output +def output.prefered(~id="",s) + output.prefered(id=id,s) +end + +in = fun () -> blank() +%ifdef input.oss + in = fun () -> input.oss(id="oss_mic") +%endif +%ifdef input.alsa + in = fun () -> input.alsa(id="alsa_mic") +%endif +%ifdef input.portaudio + in = fun () -> input.portaudio(id="pa_mic") +%endif +# Create a source from the first available input driver in this list: +# portaudio, alsa, oss, blank +# @category Source / Input +def in() + in() +end + +# Output a stream using the 'output.prefered' operator. The input source does +# not need to be infallible, blank will just be played during failures. +# @param s the source to output +# @category Source / Output +def out(s) + output.prefered(mksafe(s)) +end + +# Special track insensitive fallback that +# always skip current song before switching. +# @category Source / Track Processing +# @param ~input The input source +# @param f The fallback source +def fallback.skip(~input,f) + def transition(a,b) = + source.skip(a) + # This eats the last remaining frame from a + sequence([a,b]) + end + fallback(track_sensitive=false,transitions=[transition,transition],[input,f]) +end + +# Compress and normalize, producing a more uniform and "full" sound. +# @category Source / Sound Processing +# @param s The input source. +def nrj(s) + compress(threshold=-15.,ratio=3.,gain=3.,normalize(s)) +end + +# Multiband-compression. +# @category Source / Sound Processing +# @param s The input source. +def sky(s) + # 3-band crossover + low = filter.iir.eq.low(frequency = 168.) + mh = filter.iir.eq.high(frequency = 100.) + mid = filter.iir.eq.low(frequency = 1800.) + high = filter.iir.eq.high(frequency = 1366.) + + # Add back + add(normalize = false, + [ compress(attack = 100., release = 200., threshold = -20., + ratio = 6., gain = 6.7, knee = 0.3, + low(s)), + compress(attack = 100., release = 200., threshold = -20., + ratio = 6., gain = 6.7, knee = 0.3, + mid(mh(s))), + compress(attack = 100., release = 200., threshold = -20., + ratio = 6., gain = 6.7, knee = 0.3, + high(s)) + ]) +end + +# Simple crossfade. +# @category Source / Track Processing +# @param ~start_next Duration in seconds of the crossed end of track. +# @param ~fade_in Duration of the fade in for next track +# @param ~fade_out Duration of the fade out for previous track +# @param s The source to use +def crossfade(~id="",~start_next,~fade_in,~fade_out,s) + s = fade.in(duration=fade_in,s) + s = fade.out(duration=fade_out,s) + fader = fun (a,b) -> add(normalize=false,[b,a]) + cross(id=id,conservative=true,duration=start_next,fader,s) +end + +# Append speech-synthesized tracks reading the metadata. +# @category Source / Track Processing +# @param ~pattern Pattern to use +# @param s The source to use +def say_metadata + p = 'say:$(if $(artist),"It was $(artist)$(if $(title),\", $(title)\").")' + fun (s,~pattern=p) -> + append(s,fun (m) -> request.queue(queue=[request.create(pattern % m)], + interactive=false)) +end + +# Relay the audio stream of Dolebraï, a libre music netradio running liquidsoap. +# @category Source / Input +def dolebrai () + input.http(id="dolebrai","http://dolebrai.net:8000/dolebrai.ogg") +end + +%ifdef soundtouch +# Increases the pitch, making voices sound like on helium. +# @category Source / Sound Processing +# @param s The input source. +def helium(s) + soundtouch(pitch=1.5,s) +end +%endif + +# Return true if process exited with 0 code. +# Command should return quickly. +# @category System +# @param command Command to test +def test_process(command) + lines = + get_process_lines("(" ^ command ^ " >/dev/null 2>&1 && echo 0) || echo 1") + if list.length(lines) == 0 then + false + else + "0" == list.hd(lines) + end +end + +# Get the base name of a path. +# Implemented using the corresponding shell command. +# @category System +# @param s Path +def basename(s) + lines = get_process_lines("basename #{quote(s)}") + if list.length(lines) > 0 then + list.hd(lines) + else + # Don't know what to do.. output s + s + end +end + +# Get the directory name of a path. +# Implemented using the corresponding shell command. +# @category System +# @param s Path +# @param ~default Value returned in case of error. +def dirname(~default="/nonexistent",s) + lines = get_process_lines("dirname #{quote(s)}") + if list.length(lines) > 0 then + list.hd(lines) + else + default + end +end + +# Read some value from standard input (console). +# @category System +# @param ~hide Hide typed characters (for passwords). +def read(~hide=false) + if hide then + system("stty -echo") + end + s = list.hd(get_process_lines("read BLA && echo $BLA")) + if hide then + system("stty echo") + end + print("") + s +end + +# Generic mime test. First try to use file.mime if it exist. +# Otherwise try to get the value using the file binary. +# Returns "" (empty string) if no value can be find. +# @category System +# @param file The file to test +def get_mime(file) = + def file_method(file) = + if test_process("which file") then + list.hd(get_process_lines("file -b --mime-type \ + #{quote(file)}")) + else + "" + end + end + def mime_method(file) = + ret = "" + %ifdef file.mime + ret = file.mime(file) + %endif + ret + end + # First try mime method + ret = mime_method(file) + if ret != "" then + ret + else + # Now try file method + file_method(file) + end +end + + +# Remove low frequencies often produced by microphones. +# @category Source / Sound Processing +# @param s The input source. +def mic_filter(s) + filter(freq=200.,q=1.,mode="high",s) +end + +# Creates a source that fails to produce anything. +# @category Source / Input +def fail() + fallback([]) +end + +# Creates a source that plays only one track of the input source. +# @category Source / Track Processing +# @param s The input source. +def once(s) + sequence([s,fail()]) +end + +# Crossfade between tracks, taking the respective volume levels into account in +# the choice of the transition. +# @category Source / Track Processing +# @param ~start_next Crossing duration, if any. +# @param ~fade_in Fade-in duration, if any. +# @param ~fade_out Fade-out duration, if any. +# @param ~width Width of the volume analysis window. +# @param ~conservative Always prepare for a premature end-of-track. +# @param ~default Transition used when no rule applies \ +# (default: sequence). +# @param ~high Value, in dB, for loud sound level +# @param ~medium Value, in dB, for medium sound level +# @param ~margin Margin to detect sources that have too different \ +# sound level for crossing. +# @param s The input source. +def smart_crossfade (~start_next=5.,~fade_in=3.,~fade_out=3., + ~default=(fun (a,b) -> sequence([a, b])), + ~high=-15., ~medium=-32., ~margin=4., + ~width=2.,~conservative=false,s) + fade.out = fade.out(type="sin",duration=fade_out) + fade.in = fade.in(type="sin",duration=fade_in) + add = fun (a,b) -> add(normalize=false,[b, a]) + log = log(label="smart_crossfade") + + def transition(a,b,ma,mb,sa,sb) + + list.iter(fun(x)-> log(level=4,"Before: #{x}"),ma) + list.iter(fun(x)-> log(level=4,"After : #{x}"),mb) + + if + # If A and B are not too loud and close, fully cross-fade them. + a <= medium and b <= medium and abs(a - b) <= margin + then + log("Old <= medium, new <= medium and |old-new| <= margin.") + log("Old and new source are not too loud and close.") + log("Transition: crossed, fade-in, fade-out.") + add(fade.out(sa),fade.in(sb)) + + elsif + # If B is significantly louder than A, only fade-out A. + # We don't want to fade almost silent things, ask for >medium. + b >= a + margin and a >= medium and b <= high + then + log("new >= old + margin, old >= medium and new <= high.") + log("New source is significantly louder than old one.") + log("Transition: crossed, fade-out.") + add(fade.out(sa),sb) + + elsif + # Opposite as the previous one. + a >= b + margin and b >= medium and a <= high + then + log("old >= new + margin, new >= medium and old <= high") + log("Old source is significantly louder than new one.") + log("Transition: crossed, fade-in.") + add(sa,fade.in(sb)) + + elsif + # Do not fade if it's already very low. + b >= a + margin and a <= medium and b <= high + then + log("new >= old + margin, old <= medium and new <= high.") + log("Do not fade if it's already very low.") + log("Transition: crossed, no fade.") + add(sa,sb) + + # What to do with a loud end and a quiet beginning ? + # A good idea is to use a jingle to separate the two tracks, + # but that's another story. + + else + # Otherwise, A and B are just too loud to overlap nicely, + # or the difference between them is too large and overlapping would + # completely mask one of them. + log("No transition: using default.") + default(sa, sb) + end + end + + smart_cross(width=width, duration=start_next, conservative=conservative, + transition,s) +end + +# Custom playlist source written using the script language. +# Will read directory or playlist, play all files and stop +# @category Source / Input +# @param ~random Randomize playlist content +# @param ~on_done Function to execute when the playlist is finished +# @param uri Playlist URI +def playlist.once(~random=false,~on_done={()},uri) + x = ref 0 + def playlist.custom(files) + length = list.length(files) + if length == 0 then + log("Empty playlist..") + fail () + else + files = + if random then + list.sort(fun (x,y) -> int_of_float(random.float()), files) + else + files + end + def next () = + state = !x + file = + if state < length then + x := state + 1 + list.nth(files,state) + else + # Playlist finished + on_done () + "" + end + request.create(file) + end + request.dynamic(next) + end + end + if test_process("test -d #{quote(uri)}") then + files = get_process_lines("find #{quote(uri)} -type f | sort") + playlist.custom(files) + else + playlist = request.create.raw(uri) + result = + if request.resolve(playlist) then + playlist = request.filename(playlist) + files = playlist.parse(playlist) + files = list.map(snd,files) + playlist.custom(files) + else + log("Couldn't read playlist: request resolution failed.") + fail () + end + request.destroy(playlist) + result + end +end + +# Mixes two streams, with faded transitions between the state when only the +# normal stream is available and when the special stream gets added on top of +# it. +# @category Source / Track Processing +# @param ~delay Delay before starting the special source. +# @param ~p Portion of amplitude of the normal source in the mix. +# @param ~normal The normal source, which could be called the carrier too. +# @param ~special The special source. +def smooth_add(~delay=0.5,~p=0.2,~normal,~special) + d = delay + fade.final = fade.final(duration=d*2.) + fade.initial = fade.initial(duration=d*2.) + q = 1. - p + c = amplify + fallback(track_sensitive=false, + [special,normal], + transitions=[ + fun(normal,special)-> + add(normalize=false, + [c(p,normal), + c(q,fade.final(type="sin",normal)), + sequence([blank(duration=d),c(q,special)])]), + fun(special,normal)-> + add(normalize=false, + [c(p,normal), + c(q,fade.initial(type="sin",normal))]) + ]) +end + +# Restrict a source to play only when a predicate is true. +# @category Source / Track Processing +# @param pred The predicate, typically a time interval such as \ +# {10h-10h30}. +def at(pred,s) + switch([(pred,s)]) +end + +# Execute a given action when a predicate is true. +# This will be run in background. +# @category System +# @param ~freq Frequency for checking the predicate, in seconds. +# @param ~pred Predicate indicating when to execute the function, \ +# typically a time interval such as {10h-10h30}. +# @param f Function to execute when the predicate is true. +def exec_at(~freq=1.,~pred,f) + def check() + if pred() then + f() + end + freq + end + add_timeout(freq,check) +end + +# Register the replaygain protocol +def replaygain_protocol(arg,delay) + # The extraction program + extract_replaygain = "#{configure.libdir}/extract-replaygain" + x = get_process_lines("#{extract_replaygain} #{quote(arg)}") + if list.hd(x) != "" then + ["annotate:replay_gain=\"#{list.hd(x)}\":#{arg}"] + else + [arg] + end +end +add_protocol("replay_gain", replaygain_protocol) + +# Enable replay gain metadata resolver. This resolver will +# process any file decoded by liquidsoap and add a @replay_gain@ +# metadata when this value could be computed. For a finer-grained +# replay gain processing, use the @replay_gain@ protocol. +# @category Liquidsoap +# @param ~extract_replaygain The extraction program +def enable_replaygain_metadata( + ~extract_replaygain="#{configure.libdir}/extract-replaygain") + def replaygain_metadata(file) + x = get_process_lines("#{extract_replaygain} \ + #{quote(file)}") + if list.hd(x) != "" then + [("replay_gain",list.hd(x))] + else + [] + end + end + add_metadata_resolver("replay_gain", replaygain_metadata) +end + +# Create a log of clock times for all the clocks initially present. +# The log is in simple format, which you can notably directly use with gnuplot. +# @category Liquidsoap +# @param ~interval Polling interval. +def log_clocks(~interval=1.,logfile) + # Get the current clocks + clocks = list.map(fst,get_clock_status()) + # Column headers + system("echo \# #{string.concat(separator=' ',clocks)} > #{logfile}") + def report() + status = get_clock_status() + status = list.map(fun (x) -> (fst(x),string_of(snd(x))), status) + status = list.map(fun (c) -> status[c], clocks) + system("echo #{string.concat(separator=' ',status)} >> #{logfile}") + interval + end + add_timeout(interval,report) +end diff --git a/3rd_party/pypo/scripts/log_run.sh b/3rd_party/pypo/scripts/log_run.sh new file mode 100755 index 000000000..d373cac25 --- /dev/null +++ b/3rd_party/pypo/scripts/log_run.sh @@ -0,0 +1,18 @@ +#!/bin/sh + +DATE=$(date '+%Y-%m-%d') +CI_LOG=/var/log/obp/ci/log-$DATE.php + +clear +echo +echo "##############################" +echo "# STARTING PYPO MULTI-LOG #" +echo "##############################" +sleep 1 +clear + +# split +multitail -s 2 -cS pyml /var/log/obp/pypo/debug.log \ +-cS pyml /var/log/obp/pypo/error.log \ +-l "tail -f -n 50 $CI_LOG | grep API" \ +/var/log/obp/ls/ls_script.log diff --git a/3rd_party/pypo/scripts/ls_config.liq b/3rd_party/pypo/scripts/ls_config.liq new file mode 100644 index 000000000..50b8f89a7 --- /dev/null +++ b/3rd_party/pypo/scripts/ls_config.liq @@ -0,0 +1,49 @@ +########################################### +# liquidsoap config file # +########################################### + +# author Jonas Ohrstrom + + +# this file is specific to the obp +# installation. eg it assumes that there are +# two instances of LS running +# the "scheduler" & the "fallback" instance + + +########################################### +# general settings # +########################################### + +log_file = "/var/log/obp/ls/