def __init__(self, gpio_number, movie_1, movie_2):
self.logger = logging.getLogger('tree_player')
self.logger.info('starting player')
self.logger.info('movie 1: {}'.format(movie_1))
self.logger.info('movie 2: {}'.format(movie_2))
self.logger.info('GPIO: {} (BCM)'.format(gpio_number))
self.stop_gpio = 21
self.logger.info('stop GPIO: {} (BCM)'.format(self.stop_gpio))
self.control_gpio = gpio_number
self.movie_1 = movie_1
self.movie_2 = movie_2
self.current_state = None
self.polling_tries = 0
self.stop_state = 0
self.stop_tries = 0
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.control_gpio, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(self.stop_gpio, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#GPIO.add_event_detect(self.control_gpio, GPIO.BOTH, callback=self.event, bouncetime=300)
#GPIO.add_event_detect(self.stop_gpio, GPIO.FALLING, callback=self.quit, bouncetime=200)
#self.movie_1_controller = omxplayer.OMXPlayer(mediafile=self.movie_1, args=r'--loop -b --no-osd', start_playback=False)
#self.movie_2_controller = omxplayer.OMXPlayer(mediafile=self.movie_2, args=r'--loop -b --no-osd', start_playback=False)
self.movie_1_controller = OMXPlayer(filename=self.movie_1,
args=['--loop', '-b', '--no-osd'])
self.movie_2_controller = OMXPlayer(filename=self.movie_2,
args=['--loop', '-b', '--no-osd'])
sleep(1)
self.running = True
self.button_reader_thread = threading.Thread(target=self.button_reader)
self.button_reader_thread.start()
def display():
movo = leerNombre()
if movo == 1 or movo == 2 or movo == 3 or movo == 4 or movo == 5 or movo == 6 or movo == 7 or movo == 8 or movo == 9 or movo == 10 or movo == 11 or movo == 12 or movo == 14 or movo == 15 or movo == 16 or movo == 17 or movo == 18 or movo == 19 or movo == 20 or movo == 21 or movo == 22 or movo == 23 or movo == 24:
OMXPlayer(movo, args=['--adev hdmi', '--layer 1', '--loop'])
if movo == 9 or movo == 10 or movo == 11 or movo == 12 or movo == 13 or movo == 14:
OMXPlayer(movo, args=['--adev hdmi', '--layer 2', '--loop'])
def play(self, desiredClip):
if (desiredClip is not None):
if self.isPlaying():
self.stop()
self.clip = desiredClip
if (self.clip.isLooping == False):
self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys'])
else:
self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys', '--loop'])
if (self.idleClip is not desiredClip):
self.omx.exitEvent += lambda a, b: self.clipEndEvent() # will this assign multiple times?
def voice_object_Out(voice):
player = OMXPlayer(
os.path.join(CWD_PATH, 'voice', 'guide_voice', 'this.mp3'))
time.sleep(0.8)
player.quit()
player = OMXPlayer(
os.path.join(CWD_PATH, 'voice', 'object_voice', voice + '.mp3'))
time.sleep(1.0)
player.quit()
player = OMXPlayer(os.path.join(CWD_PATH, 'voice', 'guide_voice',
'is.mp3'))
time.sleep(1.0)
player.quit()
def play(self, source):
'''
Play audio file from local storage
@params String source
Audio file path where will be playing.
'''
print(source)
try:
if self.player is None:
self.player = OMXPlayer(source)
elif self.player.is_playing() is False:
self.player = OMXPlayer(source)
except Exception as excep:
print(excep)
def mirror(self):
self.player = OMXPlayer("udp://0.0.0.0:8090?listen",
args=[
'-o', 'hdmi', '--lavfdopts',
'probesize:8000', '--timeout', '0',
'--threshold', '0'
])
def play_video():
db = shelve.open('datastore', 'c')
video_index = db.get('video_index', 0)
videos = db.get('videos', [])
if video_index >= len(videos):
video_index = 0
if video_index >= len(videos):
return
db['video_index'] = video_index
db.close()
print "play " + videos[video_index]
videofile = os.path.abspath(os.getcwd()) + "/video/" + videos[video_index]
print videofile
player = OMXPlayer(videofile, args=['--no-osd', '--no-keys', '-b'])
player.play()
while 1:
try:
print player.playback_status()
except:
print "error end"
player.quit()
return
def playVideoGo(video_name, start=0, length=0):
print "Incoming video request"
videofile_path = "video/" + video_name
# TODO check is file en with mp4 or mov
print "video to play: " + videofile_path
video = OMXPlayer(videofile_path, pause=True)
# set video clip duration
if start > 0:
video.set_position(start)
# set video clip duration
if length == 0:
dur = video.duration()
durint = int(dur)
video.play()
time.sleep(durint)
else:
video.play()
print length
time.sleep(length)
print("Stop playing")
video.quit()
return "Video file played, lol"
def thread_target(self):
while True:
self.recData=com.Receive()
#ここに受け取ったデータ: recDataをphantomからrealに変換し、
#real側でくっつけて、返すものが求められる
if (self.recData != 0 and self.recData is not None):
#<Playing>
print "start play"
player = OMXPlayer("movs/"+dictRM[dictPR[str(self.recData)]]+".mp4")
player.play()
time.sleep(14)
player.pause()
#if you got to quit you can't re-open
player.quit()
global realData
realData="After"
print "[After?]: ",realData,"[.]"
#global MainFrame
#MainFrame.Close()
#MainApp = wx.App()
#MainFrame = CFrame()
#MainFrame.Center()
#MainFrame.Show()
#MainApp.MainLoop()
#<loopTest
self.forTesCount+=1
if self.forTesCount%1000 == 0:
print "recNOW"
#loopTest>
time.sleep(0.01)
def state_female_pollinated(is_timeout):
logger.debug('pausing blink movie')
blink_movie_controller.pause()
time.sleep(0.25)
logger.debug('returning blink movie to starting position')
blink_movie_controller.set_position(0)
time.sleep(0.25)
logger.info('starting state_female_pollinated')
global after_movie_controller
logger.debug('Flag female to start blinking')
GPIO.output(female_to_male_o, True)
if not is_timeout:
GPIO.output(female_to_fruit_o, True)
logger.debug('starting sync play of after movie')
after_movie_controller.play_sync()
logger.debug('sync play of after movie ended')
after_movie_controller.quit()
logger.debug('opening new object for after_movie_controller')
after_movie_controller = OMXPlayer(filename=after_video_file,
args=['--no-osd'])
time.sleep(0.25)
idle_movie_controller.play()
time.sleep(2)
GPIO.output(female_to_male_o, False)
GPIO.output(female_to_fruit_o, False)
logger.debug('starting async play of idle movie')
def thread_target(self):
while True:
self.recData = com.Receive()
#ここに受け取ったデータ: recDataをphantomからrealに変換し、
#real側でくっつけて、返すものが求められる
if (self.recData != 0 and self.recData is not None):
#<Merge>
global movName
movName = dictSP[str(self.recData)] + "-" + movName
if os.path.exists("movs/" + movName + ".mp4") is False:
movName = "NA"
#<Playing>
print "startPlay"
player = OMXPlayer("movs/" + movName + ".mp4")
player.play()
time.sleep(player.duration() - 5)
com.Send(int(dictPS.get(dictMA.get(movName, "NA"), "0")))
time.sleep(5)
#player.pause()
#if you got to quit you can't re-open
player.quit()
print "endPlay"
#このあとに静止画を表示するなら、dictMA[movName]
#<loopTest
self.forTesCount += 1
if self.forTesCount % 1000 == 0:
print "recNOW"
#loopTest>
time.sleep(0.01)
def play_some_commercials(max_commercials_per_break):
try:
comm_source = get_random_commercial()
comm_player = OMXPlayer(comm_source, args=['--no-osd', '--blank'], dbus_name="omxplayer.player1")
comm_player.set_video_pos(40,10,660,470);
comm_player.set_aspect_mode('fill');
comm_player.hide_video()
comm_player.pause()
#comm_player.set_volume(-1)
comm_i = max_commercials_per_break
while(comm_i>=0):
comm_source = get_random_commercial()
print('Playing commercial #' + str(comm_i), comm_source)
contents = urllib2.urlopen("http://127.0.0.1/?current_comm=" + urllib.quote_plus(comm_source)).read()
comm_player.load(comm_source)
comm_player.pause()
sleep(0.1)
if comm_i==4:
comm_player.show_video()
comm_player.play()
err_pos = 4
while (1):
try:
comm_position = math.floor(comm_player.position())
except:
break
comm_i = comm_i - 1
sleep(1)
except:
print("Error playing commercial from function")
def play_radio(event):
print("Play radio")
global player
global mode
global currentStation
if player is not None:
print("Already playing - quit")
player.quit()
player = None
mode = None
else:
print("Start online radio player")
for key, value in radioStations.items():
player = OMXPlayer(value)
print(key)
currentStation = key
break
player.pause()
mode = "radio"
player.play()
print("Play")
def on_show_video_2(message):
if (message['data'] == ID):
if (player):
player.quit()
player = OMXPlayer("path/to/file.mp4")
print message
def test_exit_event_on_video_end(self):
player = OMXPlayer(MEDIA_2_SECOND_FILE_PATH)
exit_fn = Mock()
player.exitEvent += exit_fn
sleep(3)
exit_fn.assert_called_once_with(player, 0)
def start_media(self, host):
address = "http://" + str(host) + ":8090/video"
self.player = OMXPlayer(address,
args=[
'-o', 'hdmi', '--timeout', '600',
'--lavfdopts', 'probesize:15000',
'--threshold', '1'
])
def youtube(self):
proc = subprocess.Popen(['youtube-dl', '-g', '-f', 'mp4', self.url],
stdout=subprocess.PIPE)
url = proc.stdout.read()
if url.decode("utf-8") == '':
return False
self.player = OMXPlayer(url.decode("utf-8", "strict")[:-1])
return True
def play_omxplayer(uri):
log('playing %s in omxplayer...' % uri)
global player
if get_player() is not None:
player.stop()
player = OMXPlayer(uri,
args='-b -r --audio_queue=10 --video_queue=40',
start_playback=True)
def on_show_video_1(message):
if (message['data'] == ID):
if (player):
player.quit()
player = OMXPlayer(VIDEO_FILE_1)
print message
def __init__(self, path):
subprocess.call('sudo killall omxplayer.bin', shell=True)
self.path = path
global filepath; filepath = self.path
global omx; omx = OMXPlayer(self.path, args=argsomx)
omx.set_aspect_mode('stretch')
#if omx.playback_status == 'Playing' or omx.playback_status == 'Paused':
global omxisplaying; omxisplaying = True
def test_exit_event_on_quit(self):
player = OMXPlayer(MEDIA_FILE_PATH)
exit_fn = Mock()
player.exitEvent += exit_fn
sleep(1)
player.quit()
exit_fn.assert_called_once_with(player, -15)
def music():
text = "wow, exciting song"
file_path='/home/pi/music.mp3'
player=OMXPlayer(file_path)
player.play()
sleep(7)
player.pause()
player.quit()
return statement(text)
def StartClick(event):#forSTARTbutton:!!!!need be changed!!!!!!!!!!!!!
STATbutton.SetBackgroundColour("#0000FF")#JustForTest
#<Playing>
player = OMXPlayer("movs/"+dictRM[realData]+".mp4")
player.play()
time.sleep(3)
player.pause()
#if you got to quit you can't re-open
player.quit()
def playAudio(self, path):
print("Playing audio file at path {}".format(path))
if self.isPlaying():
self.stop()
self.player = OMXPlayer(source=path, args=['-o', 'local'])
self.player.stopEvent += lambda event: self.__playingFinished()
self.player.play()
self.__handle_async(self.__checkPlaying, False)
def on_show_video_1(message):
if (message['id'] == ID):
global player
if (player):
player.quit()
player = OMXPlayer("path/to/file.mp4",
args=['--no-osd', '--no-keys', '-b'])
print message
def play(self, resource=None, subtitles=None, *args, **kwargs):
"""
Play or resume playing a resource.
:param resource: Resource to play. Supported types:
* Local files (format: ``file://<path>/<file>``)
* Remote videos (format: ``https://<url>/<resource>``)
* YouTube videos (format: ``https://www.youtube.com/watch?v=<id>``)
* Torrents (format: Magnet links, Torrent URLs or local Torrent files)
:param subtitles: Subtitles file
"""
if not resource:
if not self._player:
self.logger.warning('No OMXPlayer instances running')
else:
self._player.play()
return self.status()
else:
self._play_started.clear()
self._post_event(MediaPlayRequestEvent, resource=resource)
if subtitles:
args += ('--subtitles', subtitles)
resource = self._get_resource(resource)
if self._player:
try:
self._player.stop()
self._player = None
except Exception as e:
self.logger.exception(e)
self.logger.warning(
'Unable to stop a previously running instance ' +
'of OMXPlayer, trying to play anyway')
from dbus import DBusException
try:
from omxplayer import OMXPlayer
self._player = OMXPlayer(resource, args=self.args)
except DBusException as e:
self.logger.warning(
'DBus connection failed: you will probably not ' +
'be able to control the media')
self.logger.exception(e)
self._post_event(MediaPlayEvent, resource=resource)
self._init_player_handlers()
if not self._play_started.wait(timeout=self.timeout):
self.logger.warning(
f'The player has not sent a play started event within {self.timeout}'
)
return self.status()
def main():
args1 = ['-no-osd', '--dbus_name=org.mpris.MediaPlayer2.omxplayer1']
args2 = ['-no-osd', '--dbus_name=org.mpris.MediaPlayer2.omxplayer2']
try:
player1 = OMXPlayer(choice(trans_films), args=args1)
player2 = OMXPlayer(choice(trans_films), args=args2)
#play_film(player, "tv-static-transition.mp4", duration=1)
while True:
play_film(player1, choice(trans_films), duration=1)
play_film(player2, choice(rotate_films), duration=10)
print "Done."
except KeyboardInterrupt:
# Kill the `omxplayer` process gracefully.
player.quit()
def nextSong():
global currentSongIndex
global path
if (currentSongIndex >= len(songList) and globalPlayer.is_playing()):
currentSongIndex = 0
else:
currentSongIndex = currentSongIndex + 1
globalPlayer = OMXPlayer(path + songList[currentSongIndex])
globalPlayer.play()
def start_up():
GPIO.setup(PROJECTOR_MENU, GPIO.OUT)
GPIO.setup(PROJECTOR_ON_OFF, GPIO.OUT)
GPIO.setup(AUDIO_LED, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(AUDIO_PLUG_DETECT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SEAT_OCCUPANCY, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#GPIO.add_event_detect(SEAT_OCCUPANCY, GPIO.FALLING, callback = seat_occupied, bouncetime = 200)
#GPIO.add_event_detect(AUDIO_PLUG_DETECT, GPIO.FALLING, callback = audio_plug_insert, bouncetime = 200)
GPIO.output(PROJECTOR_MENU, GPIO.LOW)
GPIO.output(PROJECTOR_ON_OFF, GPIO.HIGH)
sleep(1.0)
GPIO.output(PROJECTOR_ON_OFF, GPIO.LOW)
sleep(25.0)
# pulse 3 times to select HDMIi
print "pulse for hdmi"
GPIO.output(PROJECTOR_MENU, GPIO.HIGH)
sleep(0.7)
GPIO.output(PROJECTOR_MENU, GPIO.LOW)
sleep(0.7)
GPIO.output(PROJECTOR_MENU, GPIO.HIGH)
sleep(0.7)
GPIO.output(PROJECTOR_MENU, GPIO.LOW)
sleep(0.7)
GPIO.output(PROJECTOR_MENU, GPIO.HIGH)
sleep(0.7)
GPIO.output(PROJECTOR_MENU, GPIO.LOW)
sleep(3)
player = OMXPlayer(VIDEO_FILE_1)
player.play()
# now what ?
print "started"
sleep(5)
player.pause()
sleep(3.0)
player.quit()
player = OMXPlayer(VIDEO_FILE_2)
player.play()
sleep(2)
player.quit()
def run(self):
self.player = OMXPlayer(
'/home/pi/donics/MoS_TimingRemix_3Void_CleanStartEnd.mp3')
self.player.pause()
self.player.pause()
self.player.set_position(0.0)
#time.sleep(.1)
print "play"
self.player.play()
