def get_3d_attributes(self): """Retrieves the 3D attributes of a sample, stream, or MOD music channel with 3D functionality.""" answer = dict(mode=c_ulong(), min=c_float(), max=c_float(), iangle=c_ulong(), oangle=c_ulong(), outvol=c_float()) bass_call(BASS_ChannelGet3DAttributes, self.handle, pointer(answer['mode']), pointer(answer['min']), pointer(answer['max']), pointer(answer['iangle']), pointer(answer['oangle']), pointer(answer['outvol'])) for k in answer: answer[k] = answer[k].value() return answer
def get_attribute(self, attribute): """Retrieves the value of a channel's attribute.""" value = pointer(c_float()) if attribute in self.attribute_mapping: attribute = self.attribute_mapping[attribute] bass_call(BASS_ChannelGetAttribute, self.handle, attribute, value) return value.contents.value
def init_device(self,
device=None,
frequency=None,
flags=None,
window=None,
clsid=None):
if device is None:
device = self._device
self._device = device
if frequency is None:
frequency = self.frequency
self.frequency = frequency
if flags is None:
flags = self.flags
self.flags = flags
if window is None:
window = self.window
self.window = window
if clsid is None:
clsid = self.clsid
self.clsid = clsid
if platform.system(
) == 'Linux' and device == -1: #Bass wants default device set to 1 on linux
device = 1
bass_call(BASS_Init, device, frequency, flags, window, clsid)
def get_attribute(self, attribute):
"""Retrieves the value of a channel's attribute."""
value = pointer(c_float())
if attribute in self.attribute_mapping:
attribute = self.attribute_mapping[attribute]
bass_call(BASS_ChannelGetAttribute, self.handle, attribute, value)
return value.contents.value
def get_3d_factors(self):
res = {
'distance_factor': c_float(),
'rolloff': c_float(),
'doppler_factor': c_float()
}
bass_call(BASS_Get3DFactors, pointer(res['distance_factor']), pointer(res['rolloff']), pointer(res['doppler_factor']))
return {k: res[k].value for k in res}
def get_3d_position(self):
"""Retrieves the 3D position of a sample, stream, or MOD music channel with 3D functionality."""
answer = dict(position=BASS_3DVECTOR(),
orientation=BASS_3DVECTOR(),
velocity=BASS_3DVECTOR())
bass_call(BASS_ChannelGet3DPosition, self.handle,
pointer(answer['position']), pointer(answer['orientation']),
pointer(answer['velocity']))
return answer
def get_3d_position(self):
res = {
'position': BASS_3DVECTOR(),
'velocity': BASS_3DVECTOR(),
'front': BASS_3DVECTOR(),
'top': BASS_3DVECTOR()
}
bass_call(BASS_Get3DPosition, pointer(res['position']), pointer(res['velocity']), pointer(res['front']), pointer(res['top']))
return res
def get_3d_factors(self):
res = {
'distance_factor': c_float(),
'rolloff': c_float(),
'doppler_factor': c_float()
}
bass_call(BASS_Get3DFactors, pointer(res['distance_factor']),
pointer(res['rolloff']), pointer(res['doppler_factor']))
return {k: res[k].value for k in res}
def get_3d_position(self):
res = {
'position': BASS_3DVECTOR(),
'velocity': BASS_3DVECTOR(),
'front': BASS_3DVECTOR(),
'top': BASS_3DVECTOR()
}
bass_call(BASS_Get3DPosition, pointer(res['position']), pointer(res['velocity']), pointer(res['front']), pointer(res['top']))
return res
def set_eax_parameters(self, environment=None, volume=None, decay=None, damp=None):
def convert_arg(arg):
if arg is None:
arg = -1
return arg
environment = convert_arg(environment)
if isinstance(environment, basestring) and environment in EAX_ENVIRONMENTS:
environment = EAX_ENVIRONMENTS[environment]
volume = convert_arg(volume)
decay = convert_arg(decay)
damp = convert_arg(damp)
bass_call(BASS_SetEAXParameters, environment, volume, decay, damp)
def get_3d_attributes(self):
"""Retrieves the 3D attributes of a sample, stream, or MOD music channel with 3D functionality."""
answer = dict(mode=c_ulong(),
min=c_float(),
max=c_float(),
iangle=c_ulong(),
oangle=c_ulong(),
outvol=c_float())
bass_call(BASS_ChannelGet3DAttributes, self.handle,
pointer(answer['mode']), pointer(answer['min']),
pointer(answer['max']), pointer(answer['iangle']),
pointer(answer['oangle']), pointer(answer['outvol']))
for k in answer:
answer[k] = answer[k].value()
return answer
def set_3d_position(self, position=None, velocity=None, front=None, top=None):
"""Sets the position, velocity, and orientation of the listener (ie. the player)."""
old = self.get_3d_position()
if position is None:
position = old['position']
if velocity is None:
velocity = old['velocity']
if front is None:
front = old['front']
if top is None:
top = old['top']
position = pointer(position)
velocity = pointer(velocity)
front = pointer(front)
top = pointer(top)
bass_call(BASS_Set3DPosition, position, velocity, front, top)
def __init__(self,
source_encoder,
server,
password,
content,
name=None,
url=None,
genre=None,
description=None,
headers=None,
bitrate=0,
public=False):
contents = {
'mp3': pybassenc.BASS_ENCODE_TYPE_MP3,
'ogg': pybassenc.BASS_ENCODE_TYPE_OGG,
'aac': pybassenc.BASS_ENCODE_TYPE_AAC
}
if content in contents:
content = contents[content]
self.source_encoder = source_encoder
handle = source_encoder.handle
self.server = server
self.password = password
self.status = bass_call(pybassenc.BASS_Encode_CastInit, handle, server,
password, content, name, url, genre,
description, headers, bitrate, public)
def __init__(self,
mem=False,
file=None,
offset=0,
length=0,
flags=0,
three_d=False,
mono=False,
autofree=False,
decode=False,
unicode=True):
"""Creates a sample stream from an MP3, MP2, MP1, OGG, WAV, AIFF or plugin supported file."""
if platform.system() == 'Darwin':
unicode = False
file = file.encode(sys.getfilesystemencoding())
self.setup_flag_mapping()
flags = flags | self.flags_for(three_d=three_d,
autofree=autofree,
mono=mono,
decode=decode,
unicode=unicode)
if unicode and isinstance(file, str):
file = convert_to_unicode(file)
self.file = file
handle = bass_call(BASS_StreamCreateFile, mem, file, offset, length,
flags)
super(FileStream, self).__init__(handle)
def set_3d_position(self, position=None, velocity=None, front=None, top=None): """Sets the position, velocity, and orientation of the listener (ie. the player).""" old = self.get_3d_position() if position is None: position = old['position'] if velocity is None: velocity = old['velocity'] if front is None: front = old['front'] if top is None: top = old['top'] position = pointer(position) velocity = pointer(velocity) front = pointer(front) top = pointer(top) bass_call(BASS_Set3DPosition, position, velocity, front, top)
def __init__(self, url="", offset=0, flags=0, downloadproc=None, user=None, three_d=False, autofree=False, decode=False): self._downloadproc = downloadproc or self._callback #we *must hold on to this self.downloadproc = DOWNLOADPROC(self._downloadproc) self.url = url self.setup_flag_mapping() flags = flags | self.flags_for(three_d=three_d, autofree=autofree, decode=decode) handle = bass_call(BASS_StreamCreateURL, url, offset, flags, self.downloadproc, user) super(URLStream, self).__init__(handle)
def set_eax_parameters(self,
environment=None,
volume=None,
decay=None,
damp=None):
def convert_arg(arg):
if arg is None:
arg = -1
return arg
environment = convert_arg(environment)
if isinstance(environment,
basestring) and environment in EAX_ENVIRONMENTS:
environment = EAX_ENVIRONMENTS[environment]
volume = convert_arg(volume)
decay = convert_arg(decay)
damp = convert_arg(damp)
bass_call(BASS_SetEAXParameters, environment, volume, decay, damp)
def __init__(self, mem=False, file=None, offset=0, length=0, flags=0, three_d=False, mono=False, autofree=False, decode=False, unicode=True): """Creates a sample stream from an MP3, MP2, MP1, OGG, WAV, AIFF or plugin supported file.""" self.setup_flag_mapping() flags = flags | self.flags_for(three_d=three_d, autofree=autofree, mono=mono, decode=decode, unicode=unicode) if unicode and isinstance(file, str): file = convert_to_unicode(file) self.file = file handle = bass_call(BASS_StreamCreateFile, mem, file, offset, length, flags) super(FileStream, self).__init__(handle)
def set_3d_factors(self, distance_factor=-1, rolloff=-1, doppler_factor=-1):
conversions = {
'meters': 1.0,
'yards': 0.9144,
'feet': 0.3048
}
if distance_factor in conversions:
distance_factor = conversions[distance_factor]
return bass_call(BASS_Set3DFactors, distance_factor, rolloff, doppler_factor)
def __init__(self, frequency=44100, channels=2, flags=BASS_RECORD_PAUSE, proc=None, user=None): if not proc: proc = lambda: True self.callback = RECORDPROC(proc) self._frequency = frequency self._channels = channels self._flags = flags handle = bass_call(BASS_RecordStart, frequency, channels, flags, self.callback, user) super(Recording, self).__init__(handle)
def set_3d_position(self, position=None, orientation=None, velocity=None): """Sets the 3D position of a sample, stream, or MOD music channel with 3D functionality.""" if position: position = pointer(position) if orientation: orientation = pointer(orientation) if velocity: velocity = pointer(velocity) return bass_call(BASS_ChannelSet3DPosition, self.handle, position, orientation, velocity)
def set_3d_factors(self,
distance_factor=-1,
rolloff=-1,
doppler_factor=-1):
conversions = {'meters': 1.0, 'yards': 0.9144, 'feet': 0.3048}
if distance_factor in conversions:
distance_factor = conversions[distance_factor]
return bass_call(BASS_Set3DFactors, distance_factor, rolloff,
doppler_factor)
def set_3d_attributes(self,
mode=-1,
min=0.0,
max=0.0,
iangle=-1,
oangle=-1,
outvol=-1):
"""Sets the 3D attributes of a sample, stream, or MOD music channel with 3D functionality."""
return bass_call(BASS_ChannelSet3DAttributes, self.handle, mode, min,
max, iangle, oangle, outvol)
def set_3d_position(self, position=None, orientation=None, velocity=None):
"""Sets the 3D position of a sample, stream, or MOD music channel with 3D functionality."""
if position:
position = pointer(position)
if orientation:
orientation = pointer(orientation)
if velocity:
velocity = pointer(velocity)
return bass_call(BASS_ChannelSet3DPosition, self.handle, position,
orientation, velocity)
def __init__(self, source, command_line, pcm=False, no_header=False, rf64=False, big_endian=False, fp_8bit=False, fp_16bit=False, fp_24bit=False, fp_32bit=False, queue=False, limit=False, no_limit=False, pause=True, autofree=False, callback=None, user=None): self.setup_flag_mapping() flags = self.flags_for(pcm=pcm, no_header=no_header, rf64=rf64, big_endian=big_endian, fp_8bit=fp_8bit, fp_16bit=fp_16bit, fp_24bit=fp_24bit, fp_32bit=fp_32bit, queue=queue, limit=limit, no_limit=no_limit, pause=pause, autofree=autofree) #fwiw! self.source = source source_handle = source.handle if callback is None: callback = lambda *a: None callback = pybassenc.ENCODEPROC(callback) self.callback = callback self.handle = bass_call(pybassenc.BASS_Encode_Start, source_handle, command_line, flags, callback, user)
def init_device(self, device=None, frequency=None, flags=None, window=None, clsid=None): if device is None: device = self._device self._device = device if frequency is None: frequency = self.frequency self.frequency = frequency if flags is None: flags = self.flags self.flags = flags if window is None: window = self.window self.window = window if clsid is None: clsid = self.clsid self.clsid = clsid if platform.system() == 'Linux' and device == -1: #Bass wants default device set to 1 on linux device = 1 bass_call(BASS_Init, device, frequency, flags, window, clsid)
def get_stats(self, type, password=None):
types = {
'shoutcast': pybassenc.BASS_ENCODE_STATS_SHOUT,
'icecast': pybassenc.BASS_ENCODE_STATS_ICE,
'icecast_server': pybassenc.BASS_ENCODE_STATS_ICESERV,
}
if type in types:
type = types[type]
if password is None:
password = self.password
return bass_call(pybassenc.BASS_Encode_CastGetStats, self.handle, type, password)
def __init__(self, source_encoder, server, password, content, name=None, url=None, genre=None, description=None, headers=None, bitrate=0, public=False):
contents = {
'mp3': pybassenc.BASS_ENCODE_TYPE_MP3,
'ogg': pybassenc.BASS_ENCODE_TYPE_OGG,
'aac': pybassenc.BASS_ENCODE_TYPE_AAC
}
if content in contents:
content = contents[content]
self.source_encoder = source_encoder
handle = source_encoder.handle
self.server = server
self.password = password
self.status = bass_call(pybassenc.BASS_Encode_CastInit, handle, server, password, content, name, url, genre, description, headers, bitrate, public)
def __init__(self,
frequency=44100,
channels=2,
flags=BASS_RECORD_PAUSE,
proc=None,
user=None):
if not proc:
proc = lambda: True
self.callback = RECORDPROC(proc)
self._frequency = frequency
self._channels = channels
self._flags = flags
handle = bass_call(BASS_RecordStart, frequency, channels, flags,
self.callback, user)
super(Recording, self).__init__(handle)
def __init__(self,
freq=44100,
chans=2,
flags=0,
user=None,
three_d=False,
autofree=False,
decode=False):
self.proc = STREAMPROC_PUSH
self.setup_flag_mapping()
flags = flags | self.flags_for(
three_d=three_d, autofree=autofree, decode=decode)
handle = bass_call(BASS_StreamCreate, freq, chans, flags, self.proc,
user)
super(PushStream, self).__init__(handle)
def __init__(self,
url="",
offset=0,
flags=0,
downloadproc=None,
user=None,
three_d=False,
autofree=False,
decode=False):
self._downloadproc = downloadproc or self._callback #we *must hold on to this
self.downloadproc = DOWNLOADPROC(self._downloadproc)
self.url = url
self.setup_flag_mapping()
flags = flags | self.flags_for(
three_d=three_d, autofree=autofree, decode=decode)
handle = bass_call(BASS_StreamCreateURL, url, offset, flags,
self.downloadproc, user)
super(URLStream, self).__init__(handle)
def pause(self): return bass_call(BASS_Pause)
def stop(self): return bass_call(BASS_Stop)
def free(self): return bass_call(BASS_StreamFree, self.handle)
def start(self):
return bass_call(BASS_Start)
def set_proxy(self, proxy): self.proxy = c_char_p(proxy) return bass_call(BASS_SetConfigPtr, BASS_CONFIG_NET_PROXY, self.proxy)
def free(self): """Frees all resources used by the recording device.""" return bass_call(BASS_RecordFree)
def get_proxy(self):
ptr = bass_call(BASS_GetConfigPtr, BASS_CONFIG_NET_PROXY)
return string_at(ptr)
def free(): return bass_call(BASS_Free)
def set_volume(self, volume):
#Pass in a float 0.0 to 100.0 and watch the volume magically change
return bass_call(BASS_SetConfig, BASS_CONFIG_GVOL_STREAM,
int(round(volume * 100, 2)))
def free():
return bass_call(BASS_Free)
def set_device(self, device):
if device == self._device:
return
self.free()
self.init_device(device=device)
return bass_call(BASS_SetDevice, device)
def stop(self):
return bass_call(BASS_Stop)
def pause(self):
return bass_call(BASS_Pause)
def set_device(self, device): if device == self._device: return self.free() self.init_device(device=device) return bass_call(BASS_SetDevice, device)
def set_title(self, title=None, url=None):
return bass_call(pybassenc.BASS_Encode_CastSetTitle,
self.source_encoder.handle, title, url)
def set_volume (self, volume): #Pass in a float 0.0 to 100.0 and watch the volume magically change return bass_call(BASS_SetConfig, BASS_CONFIG_GVOL_STREAM, int(round(volume*100, 2)))
def stop(self):
return bass_call(pybassenc.BASS_Encode_Stop, self.handle)
def get_proxy(self): ptr = bass_call(BASS_GetConfigPtr, BASS_CONFIG_NET_PROXY) return string_at(ptr)
def set_proxy(self, proxy):
self.proxy = c_char_p(proxy)
return bass_call(BASS_SetConfigPtr, BASS_CONFIG_NET_PROXY, self.proxy)
def use_default_device(self, use=True): return bass_call(BASS_SetConfig, BASS_CONFIG_DEV_DEFAULT, use)
def use_default_device(self, use=True):
return bass_call(BASS_SetConfig, BASS_CONFIG_DEV_DEFAULT, use)
def __init__ (self, device=-1): bass_call(BASS_RecordInit, device) self._device = device self.config = config.BassConfig()
def start(self): return bass_call(BASS_Start)
def __init__(self, freq=44100, chans=2, flags=0, proc=None, user=None, three_d=False, autofree=False, decode=False): self.proc = STREAMPROC(proc) self.setup_flag_mapping() flags = flags | self.flags_for(three_d=three_d, autofree=autofree, decode=decode) handle = bass_call(BASS_StreamCreate, freq, chans, flags, self.proc, user) super(Stream, self).__init__(handle)
def paused(self, paused):
return bass_call(pybassenc.BASS_Encode_SetPaused, self.handle, paused)
def __init__(self, url="", offset=0, flags=0, downloadproc=None, user=None): self._downloadproc = downloadproc or self._callback #we *must hold on to this self.downloadproc = DOWNLOADPROC(self._downloadproc) self.url = url handle = bass_call(BASS_StreamCreateURL, url, offset, flags, self.downloadproc, user) super(URLStream, self).__init__(handle)
def set_fx(self, type, priority=0): """Sets an effect on a stream, MOD music, or recording channel.""" return SoundEffect(bass_call(BASS_ChannelSetFX, type, priority))
