def __init__(self, *args, **kwds):
# begin wxGlade: MyFrame.__init__
kwds["style"] = kwds.get("style", 0) | wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
self.SetSize((812, 522))
self.Bind(wx.EVT_KEY_DOWN, self.KeyDown)
# Menu Bar
self.frame_menubar = wx.MenuBar()
wxglade_tmp_menu = wx.Menu()
item = wxglade_tmp_menu.Append(wx.ID_ANY, u"Configuración", "")
self.Bind(wx.EVT_MENU, self.configuraciónClick, id=item.GetId())
item = wxglade_tmp_menu.Append(wx.ID_ANY, "Acerca de...", "")
self.Bind(wx.EVT_MENU, self.acercaDeClick, id=item.GetId())
item = wxglade_tmp_menu.Append(wx.ID_ANY, "Salir", "")
self.Bind(wx.EVT_MENU, self.salirClick, id=item.GetId())
self.frame_menubar.Append(wxglade_tmp_menu, "Menu")
wxglade_tmp_menu = wx.Menu()
item = wxglade_tmp_menu.Append(wx.ID_ANY, "Start/Stop", "")
self.Bind(wx.EVT_MENU, self.cambiarEstadoCNN, id=item.GetId())
self.frame_menubar.Append(wxglade_tmp_menu, "CNN")
self.SetMenuBar(self.frame_menubar)
# Menu Bar end
self.label_1 = wx.StaticText(self, wx.ID_ANY, "Ubicaciones:")
self.cantUbicaciones = wx.StaticText(self, wx.ID_ANY, "0")
self.label_2 = wx.StaticText(self, wx.ID_ANY, "Ocupadas: ")
self.cantOcupadas = wx.StaticText(self, wx.ID_ANY, "0")
self.label_3 = wx.StaticText(self, wx.ID_ANY, "Libres:")
self.cantLibres = wx.StaticText(self, wx.ID_ANY, "0")
self.__set_properties()
self.__do_layout()
# end wxGlade
self.PATH_VIDEOS_TUTORIAL = 'videos/Tutorial/Tuto.mp4'
self.PATH_VIDEOS_ADULTOS = 'videos/Adultos'
self.listaAdultos = [
f for f in listdir(self.PATH_VIDEOS_ADULTOS)
if isfile(join(self.PATH_VIDEOS_ADULTOS, f)) and os.path.splitext(
join(self.PATH_VIDEOS_ADULTOS, f))[1] == ".mp4"
]
self.listaVideosAdultos = cycle(self.listaAdultos)
self.PATH_VIDEOS_MENORES = 'videos/Menores'
self.listaMenores = [
f for f in listdir(self.PATH_VIDEOS_MENORES)
if isfile(join(self.PATH_VIDEOS_MENORES, f)) and os.path.splitext(
join(self.PATH_VIDEOS_MENORES, f))[1] == ".mp4"
]
self.listaVideosMenores = cycle(self.listaMenores)
self.personas = 0
self.pause = False
self.forzarPausa = False
self.personasTotales = 0
self.Genero = "Adultos"
self.MostrarGenero = False
#Create objects
self.CaptureWidth = 640
self.CaptureHeight = 480
#Para Camara en vivo
self.Screen1Width = 550
self.Screen1Height = 300
self.Screen1 = wx.StaticBitmap(
self,
size=(self.Screen1Width,
self.Screen1Height)) # Static bitmaps for OpenCV images
img = wx.Image('imagenes/negro.png').Scale(self.Screen1Width,
self.Screen1Height,
wx.IMAGE_QUALITY_HIGH)
self.wxbmp = img.ConvertToBitmap()
self.num = -1
self.boxes = 0
self.scores = 0
self.classes = 0
self.sizer_2.Add(self.Screen1, 1, wx.FIXED_MINSIZE | wx.ALL, 5)
self.Screen1.Bind(wx.EVT_ERASE_BACKGROUND, self.onEraseBackground)
self.Screen1.Bind(wx.EVT_PAINT, self.onPaint)
# Add objects to sizer
#self.sizer_2.Add(self.Screen1, 0, wx.EXPAND | wx.ALL, 10)
#Para resultado del analisis
self.Screen2Width = 550
self.Screen2Height = 270
#Maximizo ventana para que ocupe todo el escritorio menos la barra de tareas
c_x, c_y, c_w, c_h = wx.ClientDisplayRect()
self.SetSize((c_w, c_h))
self.SetPosition((c_x, c_y))
#Ventana mitad de escritorio
self.SetSize((c_w / 2, c_h))
self.SetPosition((c_w / 2, c_y))
#Obtengo la posicion, dentro de la toma completa, de cada ubicacion
path_locations = 'configuracion'
self.images_location = self.xml_to_locations(path_locations)
self.cantUbicaciones.Label = str(len(self.images_location))
self.cantLibres.Label = str(len(self.images_location))
#Lista para guardar el estado de cada banca:
# [OK] = ocupada
# [ ] = libre
# [?] = indeterminado
self.locations_state = []
self.tiempo1 = time.now()
#ipcamUrl = 'http://*****:*****@192.168.43.1:8081'
ipcamUrl = 'http://*****:*****@192.168.43.93:8081'
ipcam = {}
ipcamDesc = 'Celular'
ipcam[ipcamDesc] = urlparse(ipcamUrl)
print(time.now())
try:
#self.capture = cv2.VideoCapture(ipcamUrl)
self.capture = cv2.VideoCapture(0)
self.capture.set(3, self.CaptureWidth) #1024 640 1280 800 384
self.capture.set(4, self.CaptureHeight) #600 480 960 600 288
global x2, y2
x2 = self.CaptureWidth
y2 = self.CaptureHeight
sys.path.append("..")
# Importación del módulo de detección de objetos.
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as vis_util
PATH_TO_CKPT = 'modelo_congelado/frozen_inference_graph.pb'
PATH_TO_LABELS = os.path.join('configuracion', 'label_map.pbtxt')
NUM_CLASSES = 90
self.detection_graph = tf.Graph()
with self.detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
self.category_index = label_map_util.create_category_index(
categories)
except IOError as e:
print(time.now(), "Error abriendo socket: ", ipcamUrl)
except KeyboardInterrupt as e:
print(time.now(), "Detenido por teclado.")
except BaseException as e:
print(time.now(), "Error desconocido: ", e)
# if e.number == -138:
# print("Compruebe la conexión con '" + ipcamUrl + "'")
# else:
# print("Error: " + e.message)
finally:
#self.capture.release()
cv2.destroyAllWindows()
with self.detection_graph.as_default():
with tf.Session(graph=self.detection_graph) as sess:
self.sess = tf.Session()
self.image_tensor = self.detection_graph.get_tensor_by_name(
'image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
self.detection_boxes = self.detection_graph.get_tensor_by_name(
'detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
self.detection_scores = self.detection_graph.get_tensor_by_name(
'detection_scores:0')
self.detection_classes = self.detection_graph.get_tensor_by_name(
'detection_classes:0')
self.num_detections = self.detection_graph.get_tensor_by_name(
'num_detections:0')
#Creo un timer para:
# 1) Actualizar la información en pantalla
# 2) Activar la CNN y obtener datos del analisis
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.OnTimer)
#Inicialmente la CNN está inactiva
self.analisis = False
self.Bind(wx.EVT_CLOSE, self.onClose)
self.Bind(wx.EVT_LEFT_UP, self.VentanaClick)
#Estado del programa
self.STATE_RUNNING = 1
self.STATE_CLOSING = 2
self.state = self.STATE_RUNNING
#Estado del reproductor
self.STATE_PORTADA = 1
self.STATE_TUTORIAL = 2
self.STATE_PELICULA = 3
self.statePlayer = self.STATE_PORTADA
#Cantidad de ciclos del timer que la CNN no trabaja
#Esto es para evitar lag
self.FREC = 20
self.FRECUENCIA_CNN = 0
#Seteo cada cuanto tiempo se activará el timer
self.fps = 40
self.timer.Start(1000. / self.fps) # timer interval
self.camara = "Camera"
cv2.namedWindow(self.camara, cv2.WINDOW_NORMAL)
cv2.setMouseCallback(self.camara, on_mouse, 0)
cv2.setWindowProperty(self.camara, cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
sleep(0.1)
cv2.resizeWindow(self.camara, 320, 180)
cv2.moveWindow(self.camara, 16, 16)
self.appPrincipal = "AppPrincipal"
#Para traer al frente la toma de la camara
top_windows = []
win32gui.EnumWindows(windowEnumerationHandler, top_windows)
for i in top_windows:
if self.camara in i[1]:
self.camaraPID = i[0]
win32gui.ShowWindow(i[0], 5)
win32gui.SetForegroundWindow(i[0])
break
#Para traer al frente la AppPrincipal para capturar eventos
top_windows = []
win32gui.EnumWindows(windowEnumerationHandler, top_windows)
for i in top_windows:
if self.appPrincipal in i[1]:
self.appPrincipalPID = i[0]
win32gui.ShowWindow(i[0], 5)
#win32gui.SetForegroundWindow(i[0])
break
rect = win32gui.GetWindowRect(self.camaraPID)
self.xCamara = rect[0]
self.yCamara = rect[1]
self.wCamara = rect[2] - self.xCamara
self.hCamara = rect[3] - self.yCamara
self.frequency = 1000 # Set Frequency
self.duration = 200 # Set Duration To 1000 ms == 1 second
self.widhtDesktop = GetSystemMetrics(0)
self.heightDesktop = GetSystemMetrics(1)
#Oculto la AppPrincipal del escritorio (X,Y,Width,Height)
sleep(0.1)
win32gui.ShowWindow(self.appPrincipalPID, win32con.SW_HIDE)
self.logostr = 'imagenes/usher 5 borde4.png'
self.xyLogo = 10
if self.statePlayer == self.STATE_PELICULA:
#VLC para las peliculas
self.instance = vlc.Instance()
self.player = self.instance.media_player_new(
"Reproductor Peliculas y Portadas")
self.player.set_fullscreen(True)
pathVideo = os.path.join(self.PATH_VIDEOS,
next(self.listaVideosAdultos))
self.media = self.instance.media_new(pathVideo)
self.player.set_media(self.media)
self.player.play()
sleep(0.1)
self.reproductorPID = win32gui.GetForegroundWindow()
self.player.pause()
self.pause = True
self.media = self.player.get_media()
else:
#VLC para las portadas
self.instance = vlc.Instance("--sub-source logo:marq")
self.player = self.instance.media_player_new()
self.player.set_fullscreen(True)
self.media = self.instance.media_new(
'imagenes/portada.jpg')
self.player.set_media(self.media)
self.player.play()
sleep(0.1)
self.reproductorPID = win32gui.GetForegroundWindow()
self.player.pause()
self.pause = True
self.player.set_time(8000)
self.media = self.player.get_media()
print("Reproductor inicial:", self.reproductorPID)
self.vlcName = "VLC (Direct3D output)"
self.vlcName2 = "VLC (VLC Video Output)"
self.reproductorPID = 0
#Obtengo el PID del vlc
top_windows = []
win32gui.EnumWindows(windowEnumerationHandler, top_windows)
for i in top_windows:
if self.vlcName in i[1]:
self.reproductorPID = i[0]
win32gui.ShowWindow(i[0], 5)
break
print("Reproductor inicial buscado:", self.reproductorPID)
win32gui.ShowWindow(self.reproductorPID, win32con.SW_MAXIMIZE)
def play_audio_file(self, fname):
Instance = vlc.Instance()
player = Instance.media_player_new()
player.set_mrl(fname)
player.play()
def do_play(self):
return False
def do_play_pause(self):
return False
VideoOverlay._backends['image/gif'] = GifOverlay
VideoOverlay._backend_versions.append(_('GtkImage gif player'))
try:
import vlc
vlc_opts = ['--no-video-title-show']
if IS_POSIX:
vlc_opts.append('--no-xlib')
elif IS_WINDOWS and vlc.plugin_path:
# let python find the DLLs
os.environ['PATH'] = vlc.plugin_path + ';' + os.environ['PATH']
VLCVideo._instance = vlc.Instance(vlc_opts)
# make VLCvideo the fallback
VideoOverlay._backends = defaultdict(lambda: VLCVideo,
VideoOverlay._backends)
VideoOverlay._backend_versions.append('VLC {}'.format(
vlc.libvlc_get_version().decode('ascii')))
except:
logger.exception(_("Video support using VLC is disabled."))
def start_video(self, canvas, video_path, angle, mute, invert):
self.canvas = canvas
if self.isMacOS:
from ctypes import c_void_p, cdll
# libtk = cdll.LoadLibrary(ctypes.util.find_library('tk'))
# returns the tk library /usr/lib/libtk.dylib from macOS,
# but we need the tkX.Y library bundled with Python 3+,
# to match the version number of tkinter, _tkinter, etc.
try:
libtk = 'libtk%s.dylib' % (Tk.TkVersion,)
prefix = getattr(sys, 'base_prefix', sys.prefix)
libtk = joined(prefix, 'lib', libtk)
dylib = cdll.LoadLibrary(libtk)
# getNSView = dylib.TkMacOSXDrawableView is the
# proper function to call, but that is non-public
# (in Tk source file macosx/TkMacOSXSubwindows.c)
# and dylib.TkMacOSXGetRootControl happens to call
# dylib.TkMacOSXDrawableView and return the NSView
self.getNSView = dylib.TkMacOSXGetRootControl
# C signature: void *_GetNSView(void *drawable) to get
# the Cocoa/Obj-C NSWindow.contentView attribute, the
# drawable NSView object of the (drawable) NSWindow
self.getNSView.restype = c_void_p
self.getNSView.argtypes = c_void_p,
del dylib
except (NameError, OSError): # image or symbol not found
def _GetNSView(unused):
return None
print(f'Starting VLC on Mac:{self.isMacOS} Windows:{self.isWindows} Linux:{self.isLinux}')
# VLC player options
if invert:
args = [f'--video-filter=transform{{type={angle}}}:invert']
else:
args = [f'--video-filter=transform{{type={angle}}}']
if mute:
args.append('--noaudio')
if self.isLinux:
args.append('--no-xlib')
self.instance = vlc.Instance(args)
self.player = self.Instance.media_player_new()
m = self.Instance.media_new(str(video_path)) # Path, unicode
self.player.set_media(m)
# set the window id where to render VLC's video output
w_id = self.canvas.winfo_id()
if self.isWindows:
self.player.set_hwnd(w_id)
elif self.isMacOS:
v = self.getNSView(w_id)
if v:
self.player.set_nsobject(v)
else:
self.player.set_xwindow(w_id) # plays audio, no video
else:
self.player.set_xwindow(w_id)
# set_mute will mute all VLC instance
# self.player.audio_set_mute(mute)
# it is better/more efficient to disable the audio track (see Instance constructor)
self.player.play()
def __init__(self, title):
wx.Frame.__init__(self,
None,
-1,
title,
pos=wx.DefaultPosition,
size=(550, 500))
# Menu Bar
# File Menu
self.frame_menubar = wx.MenuBar()
self.file_menu = wx.Menu()
self.file_menu.Append(1, "&Open", "Open from file..")
self.file_menu.AppendSeparator()
self.file_menu.Append(2, "&Close", "Quit")
self.Bind(wx.EVT_MENU, self.OnOpen, id=1)
self.Bind(wx.EVT_MENU, self.OnExit, id=2)
self.frame_menubar.Append(self.file_menu, "File")
self.SetMenuBar(self.frame_menubar)
# Panels
# The first panel holds the video and it's all black
self.videopanel = wx.Panel(self, -1)
self.videopanel.SetBackgroundColour(wx.BLACK)
# The second panel holds controls
ctrlpanel = wx.Panel(self, -1)
self.timeslider = wx.Slider(ctrlpanel, -1, 0, 0, 1000)
self.timeslider.SetRange(0, 1000)
pause = wx.Button(ctrlpanel, label="Pause")
play = wx.Button(ctrlpanel, label="Play")
stop = wx.Button(ctrlpanel, label="Stop")
volume = wx.Button(ctrlpanel, label="Volume")
self.volslider = wx.Slider(ctrlpanel, -1, 0, 0, 100, size=(100, -1))
# Bind controls to events
self.Bind(wx.EVT_BUTTON, self.OnPlay, play)
self.Bind(wx.EVT_BUTTON, self.OnPause, pause)
self.Bind(wx.EVT_BUTTON, self.OnStop, stop)
self.Bind(wx.EVT_BUTTON, self.OnToggleVolume, volume)
self.Bind(wx.EVT_SLIDER, self.OnSetVolume, self.volslider)
# Give a pretty layout to the controls
ctrlbox = wx.BoxSizer(wx.VERTICAL)
box1 = wx.BoxSizer(wx.HORIZONTAL)
box2 = wx.BoxSizer(wx.HORIZONTAL)
# box1 contains the timeslider
box1.Add(self.timeslider, 1)
# box2 contains some buttons and the volume controls
box2.Add(play, flag=wx.RIGHT, border=5)
box2.Add(pause)
box2.Add(stop)
box2.Add((-1, -1), 1)
box2.Add(volume)
box2.Add(self.volslider, flag=wx.TOP | wx.LEFT, border=5)
# Merge box1 and box2 to the ctrlsizer
ctrlbox.Add(box1, flag=wx.EXPAND | wx.BOTTOM, border=10)
ctrlbox.Add(box2, 1, wx.EXPAND)
ctrlpanel.SetSizer(ctrlbox)
# Put everything togheter
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.videopanel, 1, flag=wx.EXPAND)
sizer.Add(ctrlpanel, flag=wx.EXPAND | wx.BOTTOM | wx.TOP, border=10)
self.SetSizer(sizer)
self.SetMinSize((350, 300))
# finally create the timer, which updates the timeslider
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer)
# VLC player controls
self.Instance = vlc.Instance()
self.player = self.Instance.media_player_new('Africa.mp4')
def __init__(self):
super(VLC_Player, self).__init__()
self.i = vlc.Instance()
self.player = self.i.media_player_new()
self.player.audio_set_volume(100)
import random
from os import walk
from os.path import join
import sys
import vlc
import vidlist
from playlist import PlayList
# read settings
# setup xml
playlist = PlayList()
# fill xml with contents
x = vlc.Instance()
def handle(index, tpath, trackLength):
media = x.media_new(tpath)
media.parse()
duration = media.get_duration()-1
if duration < 0:
print("error: duration is 0 for file " + str(tpath))
print("media state: " + str(media.get_state()))
else:
playlist.addTrack(index, tpath, duration, trackLength, 0, duration)
def handleSegment(index, tpath, trackLength, segstart, segstop):
media = x.media_new(tpath)
media.parse()
duration = media.get_duration()-1
def __init__(self, parent, title=None, video=''):
Tk.Frame.__init__(self, parent)
self.compDataset = []
self.compComboOptions = ["Select Competition"]
self.teamComboOptions = []
self.teamComboOptionsI = []
self.roundComboOptions = []
self.videoWt = 120
self.framesFound = 0
self.isSplitting = 0
style = ttk.Style()
style.configure("TButton", padding=5, font=("Helvetica", "12"))
style.configure("Player.TButton",
pady=0,
padx=0,
font=("Helvetica", "12"))
style.configure("Split.TButton",
padx=5,
pady=20,
font=("Helvetica", "12"))
style.configure("TProgressbar", pady=5)
style.configure("SplitSelected.TButton",
padding=5,
background="green",
activebackground="yellow",
highlightbackground="yellow",
font=("Helvetica", "20"))
style.configure("Error.SplitSelected.TButton",
padding=5,
background="red",
activebackground="red",
highlightbackground="red",
font=("Helvetica", "20"))
self.parent = parent # == root
self.parent.title(title or "Skydive Or Bust Dubbing 1.0")
self.video = expanduser(video)
# first, top panel shows vide
self.vWrapper = ttk.Frame(self.parent)
self.videopanel = ttk.Frame(self.vWrapper)
self.canvas = Tk.Canvas(self.videopanel)
self.canvas.pack(fill=Tk.BOTH, expand=1)
self.videopanel.pack(fill=Tk.BOTH, expand=1)
self.vWrapper.pack(side=Tk.LEFT)
# panel to hold buttons
self.buttons_panel = Tk.Frame(self.vWrapper)
self.splitting_panel = Tk.Frame(self.parent)
compcombo = ttk.Frame(self.buttons_panel)
self.compCombo = ttk.Combobox(compcombo, width=25)
self.compCombo['values'] = self.compComboOptions
self.teamCombo = ttk.Combobox(compcombo, width=25)
self.roundCombo = ttk.Combobox(compcombo, width=25)
self.compCombo.pack(side=Tk.TOP)
self.teamCombo.pack(side=Tk.TOP)
self.roundCombo.pack(side=Tk.TOP)
compcombo.pack(side=Tk.BOTTOM, fill=Tk.X)
self.compCombo.bind('<<ComboboxSelected>>',
lambda event: self.change_comp())
buttons = ttk.Frame(self.buttons_panel)
self.openButton = ttk.Button(buttons,
text="Open",
command=self.OnOpen,
style="Player.TButton")
self.playButton = ttk.Button(buttons,
text="Play",
command=self.OnPlay,
style="Player.TButton")
stop = ttk.Button(buttons,
text="Stop",
command=self.OnStop,
style="Player.TButton")
eject = ttk.Button(buttons,
text="Eject",
command=self.OnEject,
style="Player.TButton")
self.slateButton = ttk.Button(self.splitting_panel,
text="Slate",
command=self.onMarkSlate,
style="Split.TButton")
self.exitButton = ttk.Button(self.splitting_panel,
text="Exit",
command=self.onMarkExit,
style="Split.TButton")
self.uploadButton = ttk.Button(self.splitting_panel,
text="Upload",
command=self.onUpload,
style="Split.TButton")
self.statusLabelH = ttk.Label(self.splitting_panel,
text="Video Status:")
self.progressBar = ttk.Progressbar(self.splitting_panel,
orient=Tk.HORIZONTAL,
length=200,
mode='determinate',
style="TProgressbar")
self.wtLabel = ttk.Label(self.splitting_panel,
text=str(self.videoWt) + "sec Working Time")
self.statusLabel = ttk.Label(self.splitting_panel, text="Open Video")
self.openButton.pack(side=Tk.LEFT)
self.playButton.pack(side=Tk.LEFT)
stop.pack(side=Tk.LEFT)
eject.pack(side=Tk.LEFT)
self.slateButton.pack(side=Tk.TOP)
self.exitButton.pack(side=Tk.TOP)
self.uploadButton.pack(side=Tk.TOP)
self.statusLabelH.pack(side=Tk.TOP)
self.progressBar.pack(side=Tk.TOP)
self.wtLabel.pack(side=Tk.TOP)
self.statusLabel.pack(side=Tk.TOP)
buttons.pack(side=Tk.BOTTOM, fill=Tk.X)
# panel to hold player time slider
timers = ttk.Frame(self.buttons_panel)
self.timeVar = Tk.DoubleVar()
self.timeSliderLast = 0
self.timeSlider = Tk.Scale(timers,
variable=self.timeVar,
command=self.OnTime,
from_=0,
to=1000,
orient=Tk.HORIZONTAL,
length=400,
showvalue=0) # label='Time',
self.timeSlider.pack(side=Tk.BOTTOM, fill=Tk.X, expand=1)
self.timeSliderUpdate = time.time()
timers.pack(side=Tk.BOTTOM, fill=Tk.X)
self.buttons_panel.pack(fill=Tk.BOTH, expand=1)
self.splitting_panel.pack(fill=Tk.BOTH, expand=1)
# VLC player
args = []
args.append('--no-xlib')
self.Instance = vlc.Instance(args)
self.player = self.Instance.media_player_new()
self.player.audio_set_volume(0)
self.parent.bind("<Configure>",
self.OnConfigure) # catch window resize, etc.
self.parent.update()
# After parent.update() otherwise panel is ignored.
# self.buttons_panel.overrideredirect(True)
# Estetic, to keep our video panel at least as wide as our buttons panel.
# self.parent.minsize(width=600, height=450)
self.is_buttons_panel_anchor_active = False
# Download API Data
self.get_comps()
self.list_comps()
self.OnTick() # set the timer up
if(inp == "play"):
player.play()
elif inp == "stop":
player.stop()
elif inp == "prev":
player.previous_chapter()
elif inp == "next":
player.previous_chapter()
else:
break
"""
#player = vlc.MediaPlayer()
#song1.play()
#time.sleep(10)
import time
inst = vlc.Instance()
sub_player = inst.media_player_new()
player = inst.media_list_player_new()
mediaList = inst.media_list_new(playlist)
player.set_media_list(mediaList)
volume = 150
sub_player.audio_set_volume(volume)
sub_player.play()
playing = set([1, 2, 3, 4])
player.play()
while player.get_state() in playing:
time.sleep(1)
import vlc
import cv2
import time
# vp = 'rtsp://localhost:8554/stream'
vp = 'rtsp://192.168.1.39:554/stream'
args = '--vout=dummy'
# player=vlc.MediaPlayer(vp)
inst = vlc.Instance(args)
player = inst.media_player_new()
player.set_mrl(vp)
# player=vlc.MediaPlayer('{} {}'.format(vp,args))
# player.video_set_callbacks(lock= True, unlock= None, display=False, opaque=None)
player.play()
while 1:
# time.sleep(0.1)
res = player.video_take_snapshot(0, 'vlc_test.png', 0, 0)
if res == 0:
img = cv2.imread('vlc_test.png')
# cv2.imshow('', img)
cv2.waitKey(1)
# # print(res)
#!/usr/bin/env python
import vlc, os, time
from tkinter import *
# Folder
effects_folder = "Input/Effects"
music_folder = "Input/Music"
# Constant instances
media_player_effects = vlc.MediaPlayer()
player_music = vlc.Instance("--input-repeat=999999")
media_player_music = player_music.media_list_player_new()
global_font = ('Arial', 14)
window = Tk()
# Window settings
window.title('EffectPlayer')
window.geometry("300x1000+10+20")
# Widgets
lb_effects = Listbox(window, font=global_font, exportselection=False)
lb_music = Listbox(window, font=global_font, exportselection=False)
# Effects
for filename in sorted(os.listdir(effects_folder)):
lb_effects.insert(END, filename)
# Music
for filename in sorted(os.listdir(music_folder)):
lb_music.insert(END, filename)
class MainMusicAlarm:
Config = configparser.ConfigParser()
VLCInstance = vlc.Instance()
VLCPlayer = VLCInstance.media_player_new()
ConfigFileName = 'config.ini'
def __init__(self):
self.Config.read(self.ConfigFileName)
logging.info(
termcolor.colored(
'Initializing the music Alarm checker at {}.'.format(
datetime.datetime.now().strftime("%H:%M")), 'green'))
self.initDB()
events = self.VLCPlayer.event_manager()
events.event_attach(vlc.EventType.MediaPlayerEndReached,
self.SongFinished)
def SongFinished(self, event):
logging.debug("Powering off the socket because the track ends...")
self.powerSocket(True)
self.stopAlarm()
def playFile(self, alarm):
self.VLCPlayer.set_media(self.VLCInstance.media_new(alarm.url))
self.VLCPlayer.play()
def playTTS(self, alarm):
tts = gtts.gTTS(text=alarm.url, lang='de')
tts.save("temp.mp3")
self.VLCPlayer.set_media(self.VLCInstance.media_new("temp.mp3"))
self.VLCPlayer.play()
def checkAlarms(self):
logging.warning(
termcolor.colored('SCHEDULER => Starting checking the alarms!',
'yellow'))
for alarm in Alarm.select():
# check if the current weekday is in the alarm ones and
# check if the alarm is a single one (without repeating)
logging.warning(
termcolor.colored(
'1 - Passing the weekday condition?. Today is {} and the alarm will trigger => {}'
.format(str(datetime.datetime.now().weekday() + 1),
alarm.repeatDays.strip().split(',')), 'green'))
if str(datetime.datetime.now().weekday() +
1) in alarm.repeatDays.strip().split(',') or (
alarm.lastAlarm == datetime.datetime.utcfromtimestamp(0)
and alarm.repeatDays == '0'):
# check if the alarm is over the current time
logging.warning(
termcolor.colored(
'2 - Passing the alarm time condition?. Today is {} and the alarm will trigger => {}'
.format(datetime.datetime.now().time(),
alarm.alarmTime), 'green'))
if alarm.alarmTime < datetime.datetime.now().time():
# check if the alarm is currently not playing
logging.warning(
termcolor.colored(
'3 - Passing the playing / active condition?. The alarm is active => {} and is playing => {}'
.format(alarm.active, alarm.playing), 'green'))
if alarm.playing == False and alarm.active == True:
# adds to the lastAlarm one day and sets the time to the normal alarm time
# this variable should be bigger as the
# datetime.datetime.now()
nextScheduledAlarm = alarm.lastAlarm.replace(
hour=alarm.alarmTime.hour,
minute=alarm.alarmTime.minute,
second=alarm.alarmTime.second,
microsecond=0) + datetime.timedelta(days=1)
if ((nextScheduledAlarm < datetime.datetime.now())
or (alarm.lastAlarm
== datetime.datetime.utcfromtimestamp(0))
and nextScheduledAlarm > alarm.created):
logging.info(
termcolor.colored(
'4 - Triggering the alarm {} at {} for {}.'
.format(alarm.name,
datetime.datetime.now(),
alarm.alarmTime), 'green'))
self.manageAlarmTargets(alarm)
threading.Timer(30.0, self.checkAlarms).start()
def manageAlarmTargets(self, alarm):
self.powerSocket(True)
if alarm.source == 'file' or alarm.source == 'stream':
self.playFile(alarm)
elif alarm.source == 'tts':
self.playTTS(alarm)
alarm.lastAlarm = datetime.datetime.now()
alarm.playing = True
alarm.save()
def stopAlarm(self):
for alarm in Alarm.select().where(Alarm.playing == 1):
alarm.playing = False
alarm.save()
if str(0) in alarm.repeatDays.strip().split(','):
alarm.delete_instance()
History.create(
triggerTime=alarm.alarmTime,
stopTime=datetime.datetime.now().time(),
duration=(datetime.datetime.now() - datetime.datetime.combine(
datetime.date.today(), alarm.alarmTime)).total_seconds())
self.powerSocket(False)
self.VLCPlayer.stop()
def initDB(self):
DB.connect()
Alarm.create_table(True)
History.create_table(True)
def powerSocket(self, state):
socketState = 0
if (state == True):
socketState = 1
os.system("sudo send433 {code} {id} {state}".format(
code=M.Config['SOCKETS']['code'],
id=M.Config['SOCKETS']['id'],
state=socketState))
def __init__(self):
try:
self.instance = vlc.Instance('--verbose=-1')
self.player = self.instance.media_player_new()
except Exception as e:
logging.critical(e)
def __init__(self,
id,
volume,
cacheFolder,
top=False,
title='',
resize=[],
textSetting=[True, 20, 2, 6, 0, '【 [ {', 10],
maxCacheSize=2048000,
startWithDanmu=True):
super(VideoWidget, self).__init__()
self.setAcceptDrops(True)
self.installEventFilter(self)
self.id = id
self.title = '未定义的直播间'
self.uname = '未定义'
self.hoverToken = False
self.roomID = '0' # 初始化直播间房号
self.liveStatus = 0 # 初始化直播状态为0
self.pauseToken = False
self.quality = 250
self.audioChannel = 0 # 0 原始音效 5 杜比音效
self.volume = volume
self.volumeAmplify = 1.0 # 音量加倍
self.muted = False
self.hardwareDecode = True
self.leftButtonPress = False
self.rightButtonPress = False
self.fullScreen = False
self.userPause = False # 用户暂停
self.cacheName = ''
self.maxCacheSize = maxCacheSize
self.startWithDanmu = startWithDanmu
# 容器设置
self.setFrameShape(QFrame.Box)
self.setObjectName('video')
self.top = top
self.name_str = f"悬浮窗{self.id}" if self.top else f"嵌入窗{self.id}"
if top:
self.setWindowFlags(Qt.Window)
else:
self.setStyleSheet(
'#video{border-width:1px;border-style:solid;border-color:gray}'
)
self.textSetting = textSetting
self.horiPercent = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
1.0][self.textSetting[2]]
self.vertPercent = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
1.0][self.textSetting[3]]
self.filters = textSetting[5].split(' ')
self.opacity = 100
if top:
self.setWindowFlag(Qt.WindowStaysOnTopHint)
if title:
if top:
self.setWindowTitle('%s %s' % (title, id + 1 - 9))
else:
self.setWindowTitle('%s %s' % (title, id + 1))
layout = QGridLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
# ---- 弹幕机 ----
self.textBrowser = TextBrowser(
self) # 必须赶在resizeEvent和moveEvent之前初始化textbrowser
self.setDanmuOpacity(self.textSetting[1]) # 设置弹幕透明度
self.textBrowser.optionWidget.opacitySlider.setValue(
self.textSetting[1]) # 设置选项页透明条
self.textBrowser.optionWidget.opacitySlider.value.connect(
self.setDanmuOpacity)
self.setHorizontalPercent(self.textSetting[2]) # 设置横向占比
self.textBrowser.optionWidget.horizontalCombobox.setCurrentIndex(
self.textSetting[2]) # 设置选项页占比框
self.textBrowser.optionWidget.horizontalCombobox.currentIndexChanged.connect(
self.setHorizontalPercent)
self.setVerticalPercent(self.textSetting[3]) # 设置横向占比
self.textBrowser.optionWidget.verticalCombobox.setCurrentIndex(
self.textSetting[3]) # 设置选项页占比框
self.textBrowser.optionWidget.verticalCombobox.currentIndexChanged.connect(
self.setVerticalPercent)
self.setTranslateBrowser(self.textSetting[4])
self.textBrowser.optionWidget.translateCombobox.setCurrentIndex(
self.textSetting[4]) # 设置同传窗口
self.textBrowser.optionWidget.translateCombobox.currentIndexChanged.connect(
self.setTranslateBrowser)
self.setTranslateFilter(self.textSetting[5]) # 同传过滤字符
self.textBrowser.optionWidget.translateFitler.setText(
self.textSetting[5])
self.textBrowser.optionWidget.translateFitler.textChanged.connect(
self.setTranslateFilter)
self.setFontSize(self.textSetting[6]) # 设置弹幕字体大小
self.textBrowser.optionWidget.fontSizeCombox.setCurrentIndex(
self.textSetting[6])
self.textBrowser.optionWidget.fontSizeCombox.currentIndexChanged.connect(
self.setFontSize)
self.textBrowser.closeSignal.connect(self.closeDanmu)
self.textBrowser.moveSignal.connect(self.moveTextBrowser)
if not self.startWithDanmu: # 如果启动隐藏被设置，隐藏弹幕机
self.textSetting[0] = False
self.textBrowser.hide()
self.textPosDelta = QPoint(0, 0) # 弹幕框和窗口之间的坐标差
self.deltaX = 0
self.deltaY = 0
# ---- 播放器布局设置 ----
# 播放器
self.videoFrame = VideoFrame() # 新版本vlc内核播放器
self.videoFrame.rightClicked.connect(self.rightMouseClicked)
self.videoFrame.leftClicked.connect(self.leftMouseClicked)
self.videoFrame.doubleClicked.connect(self.doubleClick)
layout.addWidget(self.videoFrame, 0, 0, 12, 12)
# vlc 实例
self.instance = vlc.Instance()
self.newPlayer() # 实例化 player
# 直播间标题
self.topLabel = QLabel()
self.topLabel.setFixedHeight(30)
# self.topLabel.setAlignment(Qt.AlignCenter)
self.topLabel.setObjectName('frame')
self.topLabel.setStyleSheet("background-color:#293038")
# self.topLabel.setFixedHeight(32)
self.topLabel.setFont(QFont('微软雅黑', 15, QFont.Bold))
layout.addWidget(self.topLabel, 0, 0, 1, 12)
self.topLabel.hide()
# 控制栏容器
self.frame = QWidget()
self.frame.setObjectName('frame')
self.frame.setStyleSheet("background-color:#293038")
self.frame.setFixedHeight(50)
frameLayout = QHBoxLayout(self.frame)
frameLayout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.frame, 11, 0, 1, 12)
self.frame.hide()
# ---- 嵌入式播放器 控制栏 ----
# 主播名
self.titleLabel = QLabel()
self.titleLabel.setMaximumWidth(150)
self.titleLabel.setStyleSheet('background-color:#00000000')
self.setTitle()
frameLayout.addWidget(self.titleLabel)
# 播放/暂停
self.play = PushButton(self.style().standardIcon(QStyle.SP_MediaPause))
self.play.clicked.connect(self.mediaPlay)
frameLayout.addWidget(self.play)
# 刷新
self.reload = PushButton(self.style().standardIcon(
QStyle.SP_BrowserReload))
self.reload.clicked.connect(self.mediaReload)
frameLayout.addWidget(self.reload)
# 音量开关
self.volumeButton = PushButton(self.style().standardIcon(
QStyle.SP_MediaVolume))
self.volumeButton.clicked.connect(self.mediaMute)
frameLayout.addWidget(self.volumeButton)
# 音量滑条
self.slider = Slider()
self.slider.setStyleSheet('background-color:#00000000')
self.slider.value.connect(self.setVolume)
frameLayout.addWidget(self.slider)
# 弹幕开关
self.danmuButton = PushButton(text='弹')
self.danmuButton.clicked.connect(self.showDanmu)
frameLayout.addWidget(self.danmuButton)
# 关闭窗口
self.stop = PushButton(self.style().standardIcon(
QStyle.SP_DialogCancelButton))
self.stop.clicked.connect(self.mediaStop)
frameLayout.addWidget(self.stop)
# ---- IO 交互设置 ----
# 单开线程获取视频流
self.getMediaURL = GetMediaURL(self.id, cacheFolder, maxCacheSize)
self.getMediaURL.cacheName.connect(self.setMedia)
self.getMediaURL.downloadError.connect(self.mediaReload)
self.danmu = remoteThread(self.roomID)
# 导出配置
self.exportCache = ExportCache()
self.exportCache.finish.connect(self.exportFinish)
self.exportTip = ExportTip()
# ---- 定时器 ----
# 弹幕机位置匹配
self.moveTimer = QTimer()
self.moveTimer.timeout.connect(self.initTextPos)
self.moveTimer.start(50)
# 检查播放卡住的定时器
self.checkPlaying = QTimer()
self.checkPlaying.timeout.connect(self.checkPlayStatus)
# 最后再 resize 避免有变量尚未初始化
if resize:
self.resize(resize[0], resize[1])
logging.info(
f"{self.name_str} VLC 播放器构造完毕, 缓存大小: %dkb , 置顶?: %s, 启用弹幕?: %s" %
(self.maxCacheSize, self.top, self.startWithDanmu))
self.audioTimer = QTimer()
self.audioTimer.timeout.connect(self.checkAudio)
self.audioTimer.setInterval(100)
def __init__(self):
# Constants
self.storagePath = "/raccourci_video_robot/"
self.speakingVideoPath = "video_parle.mp4"
self.idleVideoPath = "video_tait.mp4"
self.tiredVideoPath = "video_fatigue.mp4"
self.baillementSoundPath = "son_fatigue.wav"
# Init variables
self.laptopChargeLow = False
self.turtlebotChargeLow = False
self.isPlaying = False
self.videoOn = False
self.playbackVolume = 1
# Parse arguments
options, _ = argument_parser().parse_args()
self.video = options.video
self.playbackVolume = options.audio
zoom = options.zoom
self.id = options.id
self.number = options.number
rospy.init_node('sound_player', anonymous=True)
rospy.Subscriber("/turtleshow/text_to_say", String, self.callback)
rospy.Subscriber("/turtleshow/sound_to_play", String,
self.callbackSound)
if self.video:
rospy.Subscriber("/turtleshow/video_on", Bool,
self.callbackSwitchVideo)
rospy.Subscriber("/turtleshow/robot_charge_level", Point,
self.BatteryChargeCallback)
rospy.Subscriber("/turtleshow/synchro", Int8, self.callbackSynchro)
# Handle synchro
self.syncMsg = Int8(self.id)
self.pubSynchro = rospy.Publisher("/turtleshow/synchro",
Int8,
queue_size=10)
self.syncArray = zeroes(self.number)
if zoom == 1:
self.interface = vlc.Instance('--no-audio', '--input-repeat=100',
'--no-video-title-show',
'--fullscreen',
'--mouse-hide-timeout=0')
self.player = self.interface.media_player_new()
self.player.toggle_fullscreen()
else:
self.interface = vlc.Instance('--no-audio', '--input-repeat=100',
'--video-title-show',
'--mouse-hide-timeout=0',
'--video-title= ', '--zoom',
str(zoom))
self.player = self.interface.media_player_new()
self.mediaSpeaking = self.interface.media_new(self.storagePath +
self.speakingVideoPath)
self.mediaIdle = self.interface.media_new(self.storagePath +
self.idleVideoPath)
self.mediaTired = self.interface.media_new(self.storagePath +
self.tiredVideoPath)
self.player.set_media(self.mediaIdle)
if self.videoOn:
self.player.play()
rospy.loginfo("Sound self.player launched")
rospy.spin()
def __init__(self, parent, title=None):
Tk.Frame.__init__(self, parent)
self.parent = parent
if title == None:
title = "tk_vlc"
self.parent.title(title)
# Menu Bar
# File Menu
menubar = Tk.Menu(self.parent)
self.parent.config(menu=menubar)
folder_icon = ImageTk.PhotoImage(Image.open('./Icon/folder-icon.png'))
play_icon = ImageTk.PhotoImage(
Image.open('./Icon/control-play-icon.png'))
stop_icon = ImageTk.PhotoImage(
Image.open('./Icon/control-stop-icon.png'))
pause_icon = ImageTk.PhotoImage(
Image.open('./Icon/control-pause-icon.png'))
volume_icon = ImageTk.PhotoImage(Image.open('./Icon/volume-icon.png'))
fileMenu = Tk.Menu(menubar)
fileMenu.add_command(label="Open", underline=0, command=self.OnOpen)
fileMenu.add_command(label="Detect",
underline=1,
command=self.OnDetect)
fileMenu.add_separator()
fileMenu.add_command(label="Exit", underline=2, command=_quit)
menubar.add_cascade(label="File", menu=fileMenu)
# The second panel holds controls
self.player = None
self.videopanel = ttk.Frame(self.parent)
self.canvas = Tk.Canvas(self.videopanel).pack(fill=Tk.BOTH, expand=1)
self.videopanel.pack(fill=Tk.BOTH, expand=1)
#self.controller = controller
ctrlpanel = ttk.Frame(self.parent)
pause = ttk.Button(ctrlpanel, image=pause_icon, command=self.OnPause)
play = ttk.Button(ctrlpanel, image=play_icon, command=self.OnPlay)
stop = ttk.Button(ctrlpanel, image=stop_icon, command=self.OnStop)
volume = ttk.Button(ctrlpanel,
image=volume_icon,
command=self.OnSetVolume)
self.progress = ttk.Progressbar(ctrlpanel,
orient="horizontal",
length=200,
mode="determinate")
#self.progress.bind('<Map>',self.OnDetect)
self.bytes = 0
self.maxbytes = 0
pause.image = pause_icon
play.image = play_icon
stop.image = stop_icon
volume.image = volume_icon
self.progress.pack(side=Tk.LEFT)
pause.pack(side=Tk.LEFT)
play.pack(side=Tk.LEFT)
stop.pack(side=Tk.LEFT)
volume.pack(side=Tk.LEFT)
self.volume_var = Tk.IntVar()
self.volslider = Tk.Scale(ctrlpanel,
variable=self.volume_var,
command=self.volume_sel,
from_=0,
to=100,
orient=Tk.HORIZONTAL,
length=100)
self.volslider.pack(side=Tk.LEFT)
ctrlpanel.pack(side=Tk.BOTTOM)
ctrlpanel2 = ttk.Frame(self.parent)
self.scale_var = Tk.DoubleVar()
self.timeslider_last_val = ""
self.timeslider = Tk.Scale(ctrlpanel2,
variable=self.scale_var,
command=self.scale_sel,
from_=0,
to=1000,
orient=Tk.HORIZONTAL,
length=500)
self.timeslider.pack(side=Tk.BOTTOM, fill=Tk.X, expand=1)
self.timeslider_last_update = time.time()
ctrlpanel2.pack(side=Tk.BOTTOM, fill=Tk.X)
# VLC player controls
self.Instance = vlc.Instance()
self.player = self.Instance.media_player_new()
# below is a test, now use the File->Open file menu
#media = self.Instance.media_new('output.mp4')
#self.player.set_media(media)
#self.player.play() # hit the player button
#self.player.video_set_deinterlace(str_to_bytes('yadif'))
self.timer = ttkTimer(self.OnTimer, 1.0)
self.timer.start()
self.parent.update()
import glob
import vlc
import os
os.environ['XDG_RUNTIME_DIR'] = '/run/user/1000'
video_folder = '/videos/youtube_scenes/'
video_type = 'mp4'
videos = glob.glob(video_folder + '*.' + video_type)
for v in videos:
print v
vlc_inst = vlc.Instance('--aout=alsa', '--alsa-samplerate=44100',
'--input-repeat=99999999', '--no-video-title-show',
'--video-on-top', '--fullscreen',
'--mouse-hide-timeout=0')
#media = [vlc_inst.media_new_path(v) for v in videos]
media = [vlc_inst.media_new_path('/videos/youtube_scenes/fireplace.webm')]
p = vlc_inst.media_player_new()
p.set_media(media[0])
p.set_fullscreen(True)
p.play()
while (1):
continue
def __init__(self):
self.display = Display()
self.registration = Registration()
self.on = False
self.channels = []
self.instance = vlc.Instance()
self.log = vlc.Log()
self.player = self.instance.media_player_new()
self.events = self.player.event_manager()
self.media = self.instance.media_new("")
self.selectedChannel = None
self.lastPowerState = None
self.volume = int(os.environ["mnm_volume"])
self.setVolume(self.volume)
self.turnOnTime = None
# A variable to hold the buffer timer.
# Removes buffer from the state if there hasn't been sent another buffer event
# since the timer started.
self.bufferTimer = None
# What the state was previous to buffering
self.preBufferState = None
# Is set when fetching channels. If it fails, we assume the server is down.
self.serverUp = True
# Bitrates
# Put an int in the bitrate variable, and the stream closest to that bitrate will be used.
# 32 kbps - Poor audio quality
# 48 kbps - A reasonable lower end rate for longer speech-only podcasts
# 64 kbps - A common bitrate for speech podcasts.
# 128 kbps - Common standard for musical and high quality podcasts.
# 320 kbps - Very high quality - almost indistinguishable from a CD.
self.bitrate = int(os.environ["mnm_bitrate"])
# Is set if the radio is updating (Dictionary)
self.updating = None
# String
# Is set if there is a global error (ie. not related to channels)
self.error = None
# String
# Is set if there is an error on the channel
# Ie. if we couldn't open the channel
self.channelError = None
# State of radio (Dictionary)
# { code: "buffering" || "ended" || "opening" || "paused" || "playing" || "stopped", text: "text description" }
self.state = {"code": "starting", "text": _("Starting")}
# When the user started listening. For analytics purposes.
self.startedListeningTime = None
self.saveListeningHistory = helpers.castToBool(
os.environ["mnm_saveListeningHistory"])
self.sendState = helpers.castToBool(os.environ["mnm_sendState"])
# Listen for VLC events
self.instance.log_set(logCallback, None)
self.events.event_attach(vlc.EventType.MediaPlayerOpening,
self.openingEvent)
self.events.event_attach(vlc.EventType.MediaPlayerBuffering,
self.bufferingEvent)
self.events.event_attach(vlc.EventType.MediaPlayerPlaying,
self.playingEvent)
self.events.event_attach(vlc.EventType.MediaPlayerPaused,
self.pausedEvent)
self.events.event_attach(vlc.EventType.MediaPlayerStopped,
self.stoppedEvent)
self.events.event_attach(vlc.EventType.MediaPlayerEndReached,
self.endReachedEvent)
self.events.event_attach(vlc.EventType.MediaPlayerEncounteredError,
self.errorEvent)
import vlc
Instance = vlc.Instance('--fullscreen')
player = Instance.media_player_new()
Media = Instance.media_new('song.mp4')
player.set_media(Media)
player.play()
while True:
pass
def __init__(self, *args):
if args:
instance = vlc.Instance(*args)
self.media = instance.media_player_new()
else:
self.media = vlc.MediaPlayer()
def assistant(command, html_content=(), r1=()):
if 'shutdown' in command:
AssistantResponse('Bye bye Sir. Have a nice day')
sys.exit()
# open website
elif 'open' in command:
reg_ex = re.search('open (.+)', command)
if reg_ex:
domain = reg_ex.group(1)
print(domain)
url = 'https://www.' + domain
webbrowser.open(url)
AssistantResponse('The website you have requested has been opened for you Sir.')
else:
pass
# greetings
elif 'hello' in command:
day_time = int(strftime('%H'))
if day_time < 12:
AssistantResponse('Hello Sir. Good morning')
elif 12 <= day_time < 18:
AssistantResponse('Hello Sir. Good afternoon')
else:
AssistantResponse("Hello Sir. Good evening")
# top stories from google news
elif 'news for today' in command:
try:
news_url = "https://news.google.com/news/rss"
Client = urllib.request.urlopen(news_url)
xml_page = Client.read()
Client.close()
soup_page = soup(xml_page, "xml")
news_list = soup_page.findAll("item")
for news in news_list[:15]:
AssistantResponse(news.title.text.encode('utf-8'))
except Exception as e:
print(e)
# current weather
elif 'current weather' in command:
reg_ex = re.search('current weather in (.*)', command)
if reg_ex:
city = reg_ex.group(1)
owm = OWM(API_key='ab0d5e80e8dafb2cb81fa9e82431c1fa')
obs = owm.weather_at_place(city)
w = obs.get_weather()
k = w.get_status()
x = w.get_temperature(unit='celsius')
AssistantResponse(
'Current weather in %s is %s. The maximum temperature is %0.2f and the minimum temperature is %0.2f '
'degree celsius' % (
city, k, x['temp_max'], x['temp_min']))
# time
elif 'time' in command:
now = datetime.datetime.now()
AssistantResponse('Current time is %d hours %d minutes' % (now.hour, now.minute))
# email
elif 'email' in command:
AssistantResponse('Who is the recipient?')
recipient = myCommand()
if 'rajat' in recipient:
AssistantResponse('What should I say to him?')
content = myCommand()
mail = smtplib.SMTP('smtp.gmail.com', 587)
mail.ehlo()
mail.starttls()
mail.login('your_email_address', 'your_password')
mail.sendmail('sender_email', 'receiver_email', content)
mail.close()
AssistantResponse('Email has been sent successfully. You can check your inbox.')
else:
AssistantResponse('I don\'t know what you mean!')
# launch reddit
elif 'launch' in command:
reg_ex = re.search('launch (.*)', command)
if reg_ex:
subprocess.Popen(["open", "-n", "/Applications/" + reddit.app], stdout=subprocess.PIPE)
AssistantResponse('I have launched the desired application')
# launch song
elif 'play me a song' in command:
Assistant_Response('What song should I play Sir?')
audio2 = r1.listen(source)
voice_d = r1.recognize_google(audio2)
search_results = re.findall(r'href=\"/watch\?v=(.{11})', html_content.read().decode())
t = ("http://www.youtube.com/watch?v=" + search_results[0])
video = pafy.new(t)
best = video.getbest()
playurl = best.url
Instance = vlc.Instance()
player = Instance.media_player_new()
Media = Instance.media_new(playurl)
Media.get_mrl()
player.set_media(Media)
player.play()
datetime.time.sleep(120)
# Python 2.7.13
# -*- coding: ascii -*-
import vlc
import time
from time import sleep
from flask import Flask
from flask import render_template
from flask import request
import threading
playlist = [['http://ic7.101.ru:8000/a200', 'Relax'],
['http://ic7.101.ru:8000/a202', 'Comedy'],
['http://ic7.101.ru:8000/a101', 'Romantic'],
['http://185.39.195.90:8000/montecarlo_128', 'Monte Carlo']]
instance = vlc.Instance('--input-repeat=-1', '--fullscreen')
player = instance.media_player_new()
class Alarm (threading.Thread):
def run (self):
print('Heres Johny!')
sleep(10)
print('Feel good')
def fire_alarm(media=playlist[0][0], hour=7, minute=30, delay=60*5):
player.stop()
volume = 0
player.audio_set_volume(volume)
player.set_media(media)
print('start at {0}:{1}'.format(hour, minute))
# remake trigger -->
def __init__(self, parent, title=None):
self.lastValue = ''
Tk.Frame.__init__(self, parent)
self.parent = parent
if title == None:
title = "tk_vlc"
self.parent.title(title)
style = ttk.Style()
style.configure("BW.TLabel", foreground="black", background="black")
# The second panel holds controls
self.player = None
self.videopanel = ttk.Frame(self.parent, style="BW.TLabel")
# self.videopanel.config(bg="black")
self.canvas = Tk.Canvas(self.videopanel).pack(fill=Tk.BOTH, expand=1)
self.videopanel.pack(fill=Tk.BOTH, expand=1)
#frame = ttk.Frame(root, width=1000, height=1000)
self.videopanel.bind("<Button-1>", self.pressedOne)
self.videopanel.bind("<Double-Button-1>", self.pressedTwo)
ctrlpanel = ttk.Frame(self.parent, style="BW.TLabel")
pause = ttk.Button(ctrlpanel, text="Pause", command=self.OnPause)
play = ttk.Button(ctrlpanel, text="Play", command=self.OnPlay)
stop = ttk.Button(ctrlpanel, text="Stop", command=self.OnStop)
load = ttk.Button(ctrlpanel, text="LoadMain", command=self.OnLoad)
loadB = ttk.Button(ctrlpanel, text="LoadTemp", command=self.OnLoadB)
self.blackFrame = ttk.Frame(self.parent, style="BW.TLabel")
self.blackFrame.place(x=0,
y=0,
width=root.winfo_screenwidth(),
height=root.winfo_screenheight())
self.blackFrame.bind("<Button-1>", self.pressedOne)
# pause.pack(side=Tk.LEFT)
# play.pack(side=Tk.LEFT)
# stop.pack(side=Tk.LEFT)
# load.pack(side=Tk.LEFT)
loadB.pack(side=Tk.LEFT)
ctrlpanel2 = ttk.Frame(self.parent, style="BW.TLabel")
self.scale_var = Tk.DoubleVar()
self.timeslider_last_val = ""
self.timeslider = Tk.Scale(ctrlpanel2,
variable=self.scale_var,
command=self.scale_sel,
from_=0,
to=1000,
orient=Tk.HORIZONTAL,
length=500)
self.timeslider.pack(side=Tk.BOTTOM, fill=Tk.X, expand=1)
self.timeslider_last_update = time.time()
# ctrlpanel.pack(side=Tk.BOTTOM)
#ctrlpanel2.pack(side=Tk.BOTTOM, fill=Tk.X)
# VLC player controls
self.Instance = vlc.Instance('--no-xlib --verbose=0')
self.player = self.Instance.media_player_new()
self.player.audio_set_volume(100)
self.player.video_set_scale(0)
self.player.video_set_aspect_ratio('16:9')
self.player.video_set_deinterlace('on')
# self.player.set_fullscreen(True)
# below is a test, now use the File->Open file menu
media = self.Instance.media_new(video)
self.player.set_media(media)
# self.player.play() # hit the player button
# self.player.video_set_deinterlace(str_to_bytes('yadif'))
self.timer = ttkTimer(self.OnTimer, 0.5)
self.timer.start()
self.parent.update()
right_class.append(CLASSES[i])
right_dict = collections.Counter(right_class)
right_keys = list(right_dict.keys())
right_string = "There are: "
for i in right_keys:
right_string = right_string + str(
right_dict[i]) + ' ' + i + ', '
right_string = right_string + "on the right"
right_tts = gTTS(text=right_string, lang='en', slow=False)
right_tts.save("right.mp3")
# print(right_string)
try:
vlc_instance = vlc.Instance()
player = vlc_instance.media_player_new()
media = vlc_instance.media_new("./right.mp3")
player.set_media(media)
player.play()
time.sleep(.1)
duration = player.get_length() / 1000
time.sleep(duration)
#p = vlc.MediaPlayer("./right.mp3")
#length = p.get_length()
#p.play()
#time.sleep(length)
print("right:", duration)
except IOError:
print("No right objects file")
def __init__(self):
self.libvlc_Instance = vlc.Instance('--verbose 0')
self.libvlc_player = self.libvlc_Instance.media_player_new()
def __init__(self, parent, title=None, video=''):
Tk.Frame.__init__(self, parent)
self.parent = parent # == root
self.parent.title(title or "tkVLCplayer")
self.video = expanduser(video)
# Menu Bar
# File Menu
menubar = Tk.Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = _Tk_Menu(menubar)
fileMenu.bind_shortcuts_to(parent) # XXX must be root?
fileMenu.add_shortcut("Open...", 'o', self.OnOpen)
fileMenu.add_separator()
fileMenu.add_shortcut("Play", 'p', self.OnPlay) # Play/Pause
fileMenu.add_command(label="Stop", command=self.OnStop)
fileMenu.add_separator()
fileMenu.add_shortcut("Mute", 'm', self.OnMute)
fileMenu.add_separator()
fileMenu.add_shortcut("Close", 'w' if _isMacOS else 's', self.OnClose)
if _isMacOS: # intended for and tested on macOS
fileMenu.add_separator()
fileMenu.add_shortcut("Full Screen", 'f', self.OnFullScreen)
menubar.add_cascade(label="File", menu=fileMenu)
self.fileMenu = fileMenu
self.playIndex = fileMenu.index("Play")
self.muteIndex = fileMenu.index("Mute")
# first, top panel shows video
self.videopanel = ttk.Frame(self.parent)
self.canvas = Tk.Canvas(self.videopanel)
self.canvas.pack(fill=Tk.BOTH, expand=1)
self.videopanel.pack(fill=Tk.BOTH, expand=1)
# panel to hold buttons
buttons = ttk.Frame(self.parent)
self.playButton = ttk.Button(buttons, text="Play", command=self.OnPlay)
stop = ttk.Button(buttons, text="Stop", command=self.OnStop)
self.muteButton = ttk.Button(buttons, text="Mute", command=self.OnMute)
self.playButton.pack(side=Tk.LEFT)
stop.pack(side=Tk.LEFT)
self.muteButton.pack(side=Tk.LEFT)
self.volMuted = False
self.volVar = Tk.IntVar()
self.volSlider = Tk.Scale(buttons,
variable=self.volVar,
command=self.OnVolume,
from_=0,
to=100,
orient=Tk.HORIZONTAL,
length=200,
showvalue=0,
label='Volume')
self.volSlider.pack(side=Tk.LEFT)
buttons.pack(side=Tk.BOTTOM)
# panel to hold player time slider
timers = ttk.Frame(self.parent)
self.timeVar = Tk.DoubleVar()
self.timeSliderLast = 0
self.timeSlider = Tk.Scale(timers,
variable=self.timeVar,
command=self.OnTime,
from_=0,
to=1000,
orient=Tk.HORIZONTAL,
length=500,
showvalue=0) # label='Time',
self.timeSlider.pack(side=Tk.BOTTOM, fill=Tk.X, expand=1)
self.timeSliderUpdate = time.time()
timers.pack(side=Tk.BOTTOM, fill=Tk.X)
# VLC player
args = []
if _isLinux:
args.append('--no-xlib')
self.Instance = vlc.Instance(args)
self.player = self.Instance.media_player_new()
self.parent.bind("<Configure>",
self.OnConfigure) # catch window resize, etc.
self.parent.update()
self.OnTick() # set the timer up
import vlc
instance = vlc.Instance()
class VLCPlayer:
def __init__(self):
self.player = instance.media_player_new()
self.player.audio_output_set("Scaletempo")
self.length = 0
def set_position(self, position):
self.player.set_position(position / self.get_length())
def get_position(self):
return self.player.get_position()
def get_length(self):
self.length = self.player.get_length() / 1000
return self.length
def is_playing(self):
return self.player.get_state() == vlc.State.Playing
def set_tempo(self, tempo):
self.player.set_rate(tempo)
def get_tempo(self):
return self.player.get_rate()
def play(self):
def __init__(self, parent=None):
self.instance = vlc.Instance()
# Dict containing player instances
self.streamList = {}
import sys, os
import vlc
from pympress.util import IS_POSIX, IS_MAC_OS, IS_WINDOWS
from pympress import builder
vlc_opts=['--no-video-title-show']
if IS_POSIX:
vlc_opts.append('--no-xlib')
if IS_WINDOWS and vlc.plugin_path:
# let python find the DLLs
os.environ['PATH'] = vlc.plugin_path + ';' + os.environ['PATH']
#: A single vlc.Instance() to be shared by (possible) multiple players.
instance = vlc.Instance(vlc_opts)
def get_window_handle(window):
""" Uses ctypes to call gdk_win32_window_get_handle which is not available
in python gobject introspection porting (yet ?)
Solution from http://stackoverflow.com/a/27236258/1387346
Args:
window (:class:`~Gdk.Window`): The window for which we want to get the handle
Returns:
The handle to the win32 window
"""
# get the c gpointer of the gdk window
ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object]
#if mrl.startswith('upnp'):
display(instance, mrl)
return mrl_list
def printMediaMeta(media):
strbuff = ''
for i in range(12):
meta = vlc.Meta(i)
strbuff += str(media.get_meta(meta)) + ', '
print strbuff
if __name__ == '__main__':
vlc_instance = vlc.Instance("--no-video --aout=alsa")
# vlc_instance = vlc.get_default_instance()
sd = vlc_instance.media_discoverer_new_from_name('upnp')
# sd.start()
time.sleep(10)
print 'is media discovery running', sd.is_running()
#sd.stop()
ml = sd.media_list()
print 'media list count: ', ml.count()
for x in range(ml.count()):
media = ml.item_at_index(x)
printMediaMeta(media)
#print 'media is: ', dir(media)
mrl = media.get_mrl()
