def obs_osc_receive(unused_addr, args, command, value):
global obs_connected
if (obs_connected == False):
obs_connect()
time.sleep(1)
if (obs_connected):
if (command == OBS_COMMAND_SWITCH_SCENE):
print("Setting scene index : " + str(value))
ws.call(requests.SetCurrentScene(ScenesNames[value]))
else:
print("Warning: OBS not connected. Skipping OBS OSC command")
print("\n[{0}] ~ {1} {2}".format(args[0], command, value))
def switch_obs_scene(self):
current_scene = self.last_set_scene
target_scene = self.get_target_scene_name()
# If scene name is assigned to a scene and is not the same scene name as current active scene
if target_scene not in {"", current_scene}:
# print(f"Changing scene to {target_scene}")
self.last_set_scene = target_scene
if self.connected:
try:
self.ws.call(obsrequest.SetCurrentScene(target_scene))
except ConnectionResetError:
# OBS was closed
self.connected = False
async def event_raw_data(data):
if DEBUG:
print("[RAW]", data)
# Raid Detection
if not "PRIVMSG" in data:
if "USERNOTICE" in data and "msg-id=raid" in data:
mname = re.search('msg-param-displayName\=(.+?);', data)
mvcnt = re.search('msg-param-viewerCount\=([0-9]+?);', data)
mid = re.search('msg-param-login\=(.+?);', data)
print("[RAID]", mname.group(1), "raiding with", mvcnt.group(1),
"viewers!!")
if dat.obsConnected:
dat.ws.call(
obsrequests.SetCurrentScene("raid")) # OBS scene change
if dat.raid_autoso:
print("[RAID] " + mname.group(1) + "(" + mid.group(1) +
") raiding with " + mvcnt.group(1) + " viewers!!")
if dat.channel != None:
if SO_SELF:
if USE_TAPI:
ci = dat.getChannelInfo(
dat.getUIDfromName(mid.group(1)))
if ci == None:
await dat.channel.send("[shoutout] 不明なユーザー名です")
else:
if ci['broadcaster_name'] != mname.group(1):
name = ci[
'broadcaster_name'] + "(" + mname.group(
1) + ")"
else:
name = mname.group(1)
await dat.channel.send(
f"§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§ - - - - - Please check this awesome streamer!! - - - - - - - この素晴らしい配信者もチェックしてください！ - - {name} : https://twitch.tv/{mid.group(1)} 最近の配信 Recent stream : {ci['game_name']} - {ci['title']} §=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§"
)
else:
if mname.group(1) != mid.group(1):
name = mname.group(1) + "(" + mid.group(
1) + ")"
else:
name = mid.group(1)
await dat.channel.send(
f"§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§ - - - - - Please check this awesome streamer!! - - - - - - - この素晴らしい配信者もチェックしてください！ - - {name} : https://twitch.tv/{mid.group(1)} §=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§=§"
)
else:
await dat.channel.send("!so " + mid.group(1))
else:
print("dat.channel is None.")
if SOUND and dat.raid_beep:
simpleaudio.stop_all()
gBeep.play()
def TransitionToProgram():
#Here we check whether StudioMode is on
StudioState = CheckStudioState()
#Here we make the transition
if StudioState == True:
try:
CurrentsceneObject = ws.call(requests.GetPreviewScene())
Currentscene = CurrentsceneObject.getName()
ws.call(requests.SetCurrentScene(Currentscene))
print("Sent preview to program")
except:
print("Couldn't send preview to program")
else:
print("StudioMode not enabled")
async def end(self, ctx: Context):
if not self.bot.check_sender(ctx, 'iarspider'):
return
api = self.bot.get_cog("SLCog")
if not api:
return
self.ws.call(obsws_requests.SetCurrentScene('End'))
try:
api.roll_credits(self.streamlabs_oauth)
except requests.HTTPError as exc:
self.logger.error("Can't roll credits! " + str(exc))
pass
def CambiarEscena(self, opciones):
"""Enviá solicitud de cambiar de Escena."""
if "escena" in opciones:
Escena = opciones["escena"]
else:
logger.info(f"OBS[Escena no definida]")
return
if self.Conectado:
self.OBS.call(requests.SetCurrentScene(Escena))
logger.info(f"OBS[Cambiando] {Escena}")
else:
logger.warning("OBS[No conectado]")
self.Notificar("OBS-No-Encontrado")
def execute_tick(screen_capture, monitor_to_capture, image_mask,
image_descriptors, feature_detector, feature_matcher,
num_good_matches_required, obs, default_scene_name,
target_scene_name, show_debug_window):
global currently_in_default_scene
try:
start_time = time.time()
frame = numpy.array(
screen_capture.grab(screen_capture.monitors[monitor_to_capture]))
masked_frame = cv2.bitwise_and(frame, frame, mask=image_mask)
image_is_in_frame, matches = frame_contains_one_or_more_matching_images(
masked_frame, image_mask, image_descriptors, feature_detector,
feature_matcher, num_good_matches_required, show_debug_window)
tick_time = None
if image_is_in_frame:
if currently_in_default_scene:
obs.call(requests.SetCurrentScene(target_scene_name))
tick_time = round(time.time() - start_time, 2)
currently_in_default_scene = False
elif not currently_in_default_scene:
assumed_render_delay_sec = 0.1
# Compensates for the render delay, otherwise the scene changes too fast
time.sleep(assumed_render_delay_sec)
obs.call(requests.SetCurrentScene(default_scene_name))
tick_time = round(
(time.time() - start_time) - assumed_render_delay_sec, 2)
currently_in_default_scene = True
return (tick_time, matches)
except Exception as e:
print(e)
return (None, -1)
def switch(bh, msg, scene):
"""Switch OBS scenes"""
print(scene)
# Help text
help = '\n'.join([
'available scenes: ' + ' '.join('`' + x + '`'
for x in sorted(SCENES.keys())),
'switch with `switch $NAME`',
])
if not scene or scene not in SCENES:
return help
ws.connect()
# Set the scene
ws.call(requests.SetCurrentScene(SCENES[scene]))
# Get current scene and verify it is as expected
ret = ws.call(requests.GetCurrentScene())
ws.disconnect()
# React if it works
if ret.getName() == SCENES[scene]:
bh.react(msg, 'check_mark')
def SwitchScene(BUTTONCONF):
#Here we check whether StudioMode is on
StudioState = CheckStudioState()
if StudioState == True:
#Here we set the preview scene
try:
ws.call(requests.SetPreviewScene(BUTTONCONF["DestinationScene"]))
print("Set Target to preview")
except:
print("Couldn't set Target to preview")
#These lines are here to change the transition mode when pressing scene button. They produce lag and are commented out
# if "Transition" in BUTTONCONF:
# if "TransitionDuration" in BUTTONCONF:
# SetTransitionMode(BUTTONCONF["Transition"], BUTTONCONF["TransitionDuration"])
# else:
# SetTransitionMode(BUTTONCONF["Transition"], None)
#
# if "Transition" not in BUTTONCONF:
# SetTransitionMode(DefaultTransition, DefaultTransitionDuration)
else:
#Here we set the transition specified in config
if "Transition" in BUTTONCONF:
if "TransitionDuration" in BUTTONCONF:
SetTransitionMode(BUTTONCONF["Transition"],
BUTTONCONF["TransitionDuration"])
else:
SetTransitionMode(BUTTONCONF["Transition"], None)
#Here we set the scene being viewed
try:
ws.call(requests.SetCurrentScene(BUTTONCONF["DestinationScene"]))
print("Set " + BUTTONCONF["DestinationScene"] + " to program")
except:
print("Couldn't set " + BUTTONCONF["DestinationScene"] +
" to program")
#Here we set back the transition to the defaults
if "Transition" in BUTTONCONF:
time.sleep(BUTTONCONF["TransitionDuration"] / 1000 + 0.1)
SetTransitionMode(DefaultTransition, DefaultTransitionDuration)
def switch_obs_scene(self, target_scene: str):
# Return on empty string
if not target_scene:
return
if target_scene == self.last_set_scene:
# Last set scene is identical to the current target scene, don't attempt to switch scene
return
self.last_set_scene = target_scene
if not self.connected:
self.connect()
if self.connected:
logger.info(f"Scene switcher connected to OBS websocket")
if self.connected:
logger.info(f"Switching scene to '{target_scene}'")
try:
self.ws.call(obsrequest.SetCurrentScene(target_scene))
except (WebSocketConnectionClosedException,
ConnectionFailure) as e:
# OBS was closed
# logger.exception(f"Error in scene switcher script: {e}")
pass
def SwitchScene(Action):
#Here we check whether StudioMode is on
StudioState = CheckStudioState()
if StudioState == True:
#Here we set the preview scene
try:
ws.call(requests.SetPreviewScene(Action["DestinationScene"]))
except:
PrintError("Couldn't set " + Action["DestinationScene"] +
" to program")
else:
PrintWithTime("Set " + Action["DestinationScene"] + " to program")
else:
#Here we set the configured transition mode
if "Transition" in Action:
Transition_old = GetTransition()
SetTransition(Action)
#Here we set the scene being viewed
try:
ws.call(requests.SetCurrentScene(Action["DestinationScene"]))
except:
PrintError("Couldn't set " + Action["DestinationScene"] +
" to program")
else:
PrintWithTime("Set " + Action["DestinationScene"] + " to program")
#Here we set the transition mode back
if "Transition" in Action:
try:
Duration = ws.call(requests.GetTransitionDuration())
Duration = Duration.getTransitionDuration()
except:
PrintError("Couldn't get transition duration")
else:
time.sleep(Duration / 1000 + 0.1)
finally:
SetTransition(Transition_old)
def press_button(Button):
if Button == 8:
try:
print("Connecting to Camera1")
ws.call(requests.SetPreviewScene("Camera1"))
except:
print("Exception happened")
elif Button == 9:
try:
print("Connecting to Camera2")
ws.call(requests.SetPreviewScene("Camera2"))
except:
print("Exception happened")
elif Button == 15:
try:
print("Send to stream")
CurrentsceneObject = ws.call(requests.GetPreviewScene())
# print(CurrentsceneObject)
Currentscene = CurrentsceneObject.getName()
# print(Currentscene)
ws.call(requests.SetCurrentTransition("Fade"))
ws.call(requests.SetCurrentScene(Currentscene))
except:
print("Exception happened")
def ChooseScene(client, Action):
Scene = Action["Scene"]
client.call(requests.SetCurrentScene(Scene))
def handle(socket, scene: beatoraja.Scene):
name = config.OBS_SCENES.get(scene, None)
if name is None or socket.call(obsrequests.GetCurrentScene()).getName() == name:
return
socket.call(obsrequests.SetCurrentScene(name))
duration_min = 5 # Minimum duration we show a scene for before switching
scene_prefix = '_' # Only auto switch scenes with this prefix
obs_pass = '******' # Password/secret for OBS-WebSocket
obs_host = 'localhost' # Hostname of OBS-websocket server, usually localhost
obs_port = 4444 # TCP port that OBS-Webocket server is listening on
logging.basicConfig(level=logging.INFO)
ws = obsws(obs_host, obs_port, obs_pass)
ws.connect()
scenes_all = ws.call(requests.GetSceneList())
scenes_auto = []
last_scene = ''
scene = ''
for s in scenes_all.getScenes():
if s['name'][0] == scene_prefix:
print('Added:', s['name'])
scenes_auto.append(s['name'])
while True:
while scene == last_scene:
scene = random.choice(scenes_auto)
last_scene = scene
duration = random.randint(duration_min, duration_max)
print('Switching to [%s] for %ssec...' % (scene, duration))
ws.call(requests.SetCurrentScene(scene))
time.sleep(duration)
ws.disconnect()
def setScene(self, name):
self.ws.call(requests.SetCurrentScene(name))
def ChangeScenes(scene):
ws.call(requests.SetCurrentScene(scene))
def scene1(lp, mode):
ws = obsws("localhost", 4444, "secret")
ws.connect()
ws.call(requests.SetCurrentScene("Streamdeck"))
ws.disconnect()
import sys
import time
import logging
logging.basicConfig(level=logging.INFO)
sys.path.append('../')
from obswebsocket import obsws, requests # noqa: E402
host = "localhost"
port = 4444
password = "******"
ws = obsws(host, port, password)
ws.connect()
try:
scenes = ws.call(requests.GetSceneList())
for s in scenes.getScenes():
name = s['name']
print(u"Switching to {}".format(name))
ws.call(requests.SetCurrentScene(name))
time.sleep(2)
print("End of list")
except KeyboardInterrupt:
pass
ws.disconnect()
def scene3(lp, mode):
ws = obsws("localhost", 4444, "secret")
ws.connect()
ws.call(requests.SetCurrentScene("Display 2"))
ws.disconnect()
def change_scene(name):
ws.call(requests.SetCurrentScene(name))
elif "blue" == command:
b.set_light(['left', 'right'], colors['blue'])
elif "blue" == command:
b.set_light(['left', 'right'], colors['red'])
elif "connect" == command:
try:
ws.connect()
bot.send_message('Successfully connected to OBS!')
except BaseException:
bot.send_message('Unable to connect to OBS.')
continue
#OBS commands
#Requires mod permission. (specified in cfg.py)
try:
ws.call(requests.SetCurrentScene(command))
except BaseException:
print("No scene with that name.")
#continue
except KeyboardInterrupt:
print('Terminated by user.')
#ws.call(requests.GetSceneList())
#ws.call(requests.SetCurrentScene(name))
def change_scene(self):
try:
sel = self.scenes.curselection()[0]
except IndexError:
return
res = self.ws.call(requests.SetCurrentScene(self.scenes.get(sel)))
def get(self, scene_name):
scene = ws.call(requests.GetCurrentScene())
name = scene.getName()
if name != scene_name:
ws.call(requests.SetCurrentScene(scene_name))
async def countdown(self, ctx: Context):
def write_countdown_html():
args = ctx.message.content.split()[1:]
parts = tuple(int(x) for x in args[0].split(':'))
if len(parts) == 2:
m, s = parts
m, s = parts
# noinspection PyShadowingNames
delta = datetime.timedelta(minutes=m, seconds=s)
dt = datetime.datetime.now() + delta
elif len(parts) == 3:
h, m, s = parts
dt = datetime.datetime.now().replace(hour=h,
minute=m,
second=s)
else:
self.botlogger.error("Invalid call to countdown: {0}".format(
args[0]))
return
self.bot.countdown_to = dt
with codecs.open(self.htmlfile.replace('html', 'template'),
encoding='UTF-8') as f:
lines = f.read()
lines = lines.replace('@@date@@', dt.isoformat())
with codecs.open(self.htmlfile, 'w', encoding='UTF-8') as f:
f.write(lines)
if not self.bot.check_sender(ctx, 'iarspider'):
return
if not self.ws:
return
res: obsws_requests.GetStreamingStatus = self.ws.call(
obsws_requests.GetStreamingStatus())
if res.getStreaming():
self.logger.error('Already streaming!')
return
write_countdown_html()
self.ws.call(obsws_requests.DisableStudioMode())
# Refresh countdown
self.ws.call(obsws_requests.SetCurrentScene('Starting'))
try:
self.ws.call(
obsws_requests.SetMute(self.aud_sources.getMic2(), True))
except KeyError:
self.logger.warning("[WARN] Can't mute mic-2, please check!")
self.ws.call(obsws_requests.SetMute(self.aud_sources.getMic1(), True))
self.ws.call(obsws_requests.EnableStudioMode())
self.ws.call(obsws_requests.StartStopStreaming())
time.sleep(1)
self.ws.call(obsws_requests.PauseRecording())
# self.get_player()
# self.player_play_pause()
self.ws.call(obsws_requests.SetMute(False, 'Радио'))
asyncio.ensure_future(
ctx.send('Начат обратный отсчёт до {0}!'.format(
self.bot.countdown_to.strftime('%X'))))
asyncio.ensure_future(self.bot.my_run_commercial(self.bot.user_id))
self.logger.info("Getting Discord cog...")
discord_bot = self.bot.get_cog('DiscordCog')
if discord_bot:
self.logger.info("Got it, requesting announce...")
asyncio.ensure_future(discord_bot.announce())
else:
self.logger.warning("Discord cog not found")
def go_brb(self):
logging.info("OBS command: switch to BRB scene.")
# self.media_source_toggle()
return self.ws_call(requests.SetCurrentScene(self.brb_scene))
def switch_sequence(self, s):
# TODO
self.ws.call(requests.SetCurrentScene(s.scene_name))
def go_normal(self):
logging.info("OBS command: switch to normal scene.")
self.media_source_toggle()
return self.ws_call(requests.SetCurrentScene(self.normal_scene))
def set_scene(self, scene_name):
return self.client.call(R.SetCurrentScene(scene_name))
try:
#scenes = ws.call(requests.GetSceneList())
#for s in scenes.getScenes():
# name = s['name']
# print(u"Switching to {}".format(name))
# ws.call(requests.SetCurrentScene(name))
# time.sleep(2)
print("Started Command Processing")
if command == "Start Streaming Bool":
if getStreamStatus == False:
if currentScene == destinationScene:
print("Already running on the correct scene: Starting Stream")
ws.call(requests.StartStreaming())
else:
print("Setting scene to destination and starting stream")
ws.call(requests.SetCurrentScene(destinationScene))
time.sleep(2)
ws.call(requests.StartStreaming())
else:
print("Stream already running. Command halted.")
elif command == "Stop Stream":
ws.call(requests.StopStreaming())
elif command == "Start Stream":
ws.call(requests.StartStreaming())
elif command == "Switch Scene":
if enableOverride == "True" or getStreamStatus == False:
ws.call(requests.SetCurrentScene(destinationScene))
elif enableOverride == "False":
print("Override is not enabled.")
print("End of list")
