Beispiel #1
1
def prevSong():
    global path
    global currentSongIndex
    if(currentSongIndex < 0 and globalPlayer.is_playing()):
        currentSongIndex = len(songList)
    else:
        currentSongIndex = currentSongIndex - 1

    globalPlayer = OMXPlayer(path + songList[currentSongIndex])
    globalPlayer.play()
Beispiel #2
0
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"
class OMXPlayerTest(unittest.TestCase):
    MEDIA_FILE_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), '../media/test_media_1.mp4')

    def setUp(self):
        self.player = OMXPlayer(self.MEDIA_FILE_PATH)
        sleep(1) # Give the player time to start up

    def tearDown(self):
        self.player.quit()
Beispiel #4
0
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()
Beispiel #5
0
def createPlayer(filepath):
    try:
        global player
        global video_opened
        global clip_duration
        player = OMXPlayer(filepath, args=['--no-osd','-o','both','--win','0 0 450 300'])
        clip_duration = player.duration()
        video_opened = 1
        logging.getLogger('omxplayer.play').addHandler(logging.NullHandler()) #silence logging handlers message
    except Exception as e:
        print("Trying to open video again: %s" % e)
        sleep(1)
        exit()
    def player(self, current_file):
        print(current_file,'\n','\tPlaying')
        # Set output window size
        self.omx = OMXPlayer(current_file, args=["--win", " 0,0,640,480"])
        self.omx.play()
        try:
            self.omx.set_position(15.0)
            while True:
                try:
                    if not(self.omx.playback_status()):
                        # If file ended.. stop playback
                        print('\n\tStopped\n')
                        self.omx.stop()
                        break
                    
                    else:
                        # Print time elapsed
                        print('\r\t','{0:.2f}'.format(self.omx.position()),
                              '/', '{0:.2f}'.format(self.omx.duration())+
                              ' seconds', end = ''),
                        sys.stdout.flush()
                    
                except Exception, e:
                    # dBUS exception for file that 
                    # finished playing. Ignore!
                    pass

        except KeyboardInterrupt, e:
            # Catch Ctrl+C and stop playing
            # current file
            print('Stopping Playback..', e)
            self.omx.stop()
Beispiel #7
0
    def _play_ba(self, ba_path, stop, time_status, save_file):
        """
        function qui lance une bande-annonce dans omx player
        """
        player = OMXPlayer(ba_path, args=['-o', 'hdmi', '-b', '--no-osd'])
        player.play()

        # affichage d'un ecran noir pour ne pas voir l'ecran de la ba precedente
        # brievement avant le changement d'ecran
        self._display_slide(env_variables.black_image, 1)
        logging.info("ba: %s, status: %s" % (ba_path, player.playback_status()))                        

        # tant que la ba n'est pas fini ou stoppee, on attend
        while True:
            try:
                if player.playback_status() == "Playing" and stop is False and time_status is False:
                    sleep(1)
                    stop = pickle.load(open( save_file, "rb" ))
                    #logging.info("%s, %s, %s" % (player.playback_status(),stop, time_status))  
                else:
                    logging.warn("before player quit")
                    player.quit()
                    # sortie boucle while
                    break
            except DBusException:
                logging.warn("dbus exception")
                # cette exception est levee a la fin de la ba, sortie du while
                break
        return stop
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
Beispiel #9
0
class TV(threading.Thread):
    def __init__(self):
        super(TV, self).__init__()
        print("Initializing TV")
        self.red_alert = False
        self.player = None
        self.reset()

        #Register Events
        signal('SYSTEM_stopping').connect(self.clean_up)
        signal('tv.redalert').connect(self.alert)
        signal('alert.red.toggle').connect(self.alert)
        signal('code_47').connect(self.reset)

    def reset(self, sender='anonymous'):
        os.system('pkill omxplayer')
        self.player = OMXPlayer("http://repo.posttwo.pt/redalert.mp4",
                                args=['--no-osd', '--no-keys', '-b', '--loop'])
        self.player.pause()

    def tv_set_pi(self):
        subprocess.call("echo 'as' | cec-client -s &", shell=True)
        #os.system('echo "as" | cec-client -s')

    def tv_set_chrome(self):
        subprocess.call("echo 'txn 4f:82:20:00' | cec-client -s &", shell=True)
        #os.system('echo "txn 4f:82:20:00" | cec-client -s')

    def alert(self, sender='anonymous'):
        if not self.red_alert:
            self.red_alert = True
            self.tv_set_pi()
            print("RED ALERT ON")
            self.player.set_position(0)
            self.player.play()
        else:
            self.red_alert = False
            self.tv_set_chrome()
            self.player.pause()

    def clean_up(self, sender='anonymous'):
        print("TV Cleaning Up")
        self.player.quit()
Beispiel #10
0
def on_show_video_2(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
Beispiel #11
0
    def play(self, resource, subtitles=None, *args, **kwargs):
        """
        Play 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 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)
            self._init_player_handlers()
        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._player.pause()
        self._player.play()
        return self.status()
Beispiel #12
0
def omxplayerRestart(file):
    global gl_omxplayer
    try:
        alpha = int(spinAlpha.get())
    except:
        alpha = 210
    if alpha > 255:
        alpha = 255
    elif alpha < 0:
        alpha = 0
    spinAlpha.delete(0, tkinter.END)
    spinAlpha.insert(0, alpha)
    # 1. Prüfen, ob omxplayer bereits läuft:
    if not gl_omxplayer is None:
        gl_omxplayer.stop()
        gl_omxplayer.quit()
        gl_omxplayer = None
        try:
            bauwong.update() # DoEvents
        except:
            pass
    # 2. Neue omxplayer-Instanz erstellen und die Wiedergabe der angegebenen Datei starten:
    playing = False
    starttim = time.time() # Vergangene Sekunden seit dem 01. Januar 1970
    while playing == False:
        # Diese Schleife ist notwendig, da der omxplayer manchmal
        # beim Start eines Titels "Zeile 67:  <pid> Abgebrochen" meldet.
        # In diesem Falle würde sofort zum übernächsten Titel gesprungen werden,
        # was für den unbedarften Benutzer nicht nachvollziehbar ist!
        gl_omxplayer = OMXPlayer(file, ['--alpha', str(alpha)])
        if gl_omxplayer is None:
            playing = False
        else:
            txt = gl_omxplayer.playback_status()
            playing = txt == "Playing" or txt == "Paused"
            gl_omxplayer.play()
            #gl_omxplayer.set_position(0.0) # Sofort mit voller Lautstärke beginnen, kein Fading!
        # Timeout berücksichtigen:    
        tim = time.time()
        if tim - starttim >= 2.5:
            playing = True # Schleife immer verlassen, wenn die Datei nach 2,5s immer noch nicht abgespielt wird
        time.sleep(0.1)
    updateButPlayPause()    
Beispiel #13
0
	def create(self):
		videoToPlay = pafy.new("https://www.youtube.com/watch?v=" + self.info["encrypted_id"]);

		bestaudio = videoToPlay.getbestaudio(preftype="m4a", ftypestrict=True);
		file_name =  dir_path + "/music/" + self.id + ".m4a";
		try :
		   bestaudio.download(file_name);
		except:
		   pass
		self.player.quit()
		self.player = OMXPlayer(file_name, pause=True);
		
		AudioSegment.from_file(file_name).export(dir_path + "/music/" + self.id + ".mp3", format="mp3");
		
		r = requests.post(addr_serv + "/serv", data=str(self.id));
		if r.status_code != 200:
			print(r);
			print("error post to 2nd server");
		else:
			print("postb 2nd ok");
Beispiel #14
0
class Player:
    def __init__(self, path):
        self.path = path
        self.player = OMXPlayer(
            self.path, args=["--loop", "-o", "local", "--win", "0,0,640,480"])
        # self.player.play()
        # self.player.set_position(10.0)
        # self.player.pause()

    def play(self):
        self.player.play()

    def pause(self):
        self.player.pause()

    def toggle(self):
        self.player.play_pause()

    def reset(self):
        self.player.pause()
        self.player.set_position(0.0)
Beispiel #15
0
def state_bee_pollunated():
    logger.info('starting state_after')
    global after_movie_controller
    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()
Beispiel #16
0
def main():
    global logger
    logger = logging.getLogger("BarkBack")
    logger.setLevel('DEBUG')
    stdout = logging.StreamHandler(stream=sys.stdout)
    stdout.setFormatter(
        logging.Formatter(fmt='%(asctime)s %(levelname)s:%(message)s',
                          datefmt='%Y-%m-%d %I:%M:%S %p'))
    logger.addHandler(stdout)

    ReadConfig()
    InitLogger()
    InitMQTTC()

    global player_volumes
    player_volumes = tuple(
        int(x) for x in config['OMXPlayer']['vols'].split(','))

    global player
    player = OMXPlayer(path=config['OMXPlayer']['path'],
                       extensions=tuple(
                           config['OMXPlayer']['extensions'].split(',')),
                       adev=config['OMXPlayer']['adev'],
                       vol=player_volumes[0])

    mic = monitor(
        adc_channel=config['Monitor'].getint('adc_channel'),
        spi_channel=config['Monitor'].getint('spi_channel'),
        high_volume=config['Monitor'].getint('high_volume'),
        high_volume_period=config['Monitor'].getint('high_volume_period'),
        high_volume_max=config['Monitor'].getint('high_volume_max'),
        on_high_volume=on_high_volume,
        sample_time=config['Monitor'].getfloat('sample_time'),
        Hz=config['Monitor'].getint('hz'))

    global last_events
    last_events = deque([], len(player_volumes) - 1)

    # This loop main purpose is:
    #    Keep program running
    #    Output DEBUG volume data
    #    Poll MQTTC for subscribed topics
    while True:
        time.sleep(1)
        logger.debug(
            "volume_avg=%1.3f volume_max=%d high_count=%d" %
            (mic.volume_avg, mic.volume_max, mic.high_volume_count),
            {'msgid': 'volume'})
        mqttc_publish(
            config['CloudMQTT']['topic_volume'],
            '{"Average":%1.3f,"Max":%d,"High_Count":%d}' %
            (mic.volume_avg, mic.volume_max, mic.high_volume_count))
        mqttc_loop()
Beispiel #17
0
def state_dust_complete():
    logger.info('starting state_dust_complete')
    global dust_complete_movie_controller
    logger.debug('starting sync play of dust_complete movie')
    dust_complete_movie_controller.play_sync()
    logger.debug('sync play of dust_complete movie ended')
    dust_complete_movie_controller.quit()
    logger.debug('opening new object for dust_complete_movie_controller')
    dust_complete_movie_controller = OMXPlayer(filename=dust_complete_video_file, args=['--no-osd'])
    time.sleep(0.25)
    logger.debug('starting async play of idle movie')
    idle_movie_controller.play()
Beispiel #18
0
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")
Beispiel #19
0
 def tryPlayingFormat(self, formatId):
     if self.isStarted():
         self.stop()
     try:
         self.formatId = formatId
         print('Trying to play ', formatId, 'path:',
               self.currVideo.getRessourcePath(formatId))
         self.omxProcess = OMXPlayer(
             self.currVideo.getRessourcePath(formatId), args=['-b'])
         # Wait a bit for loading before disqualifying the format
         while self.omxProcess.playback_status() == 'Paused':
             sleep(0.01)
         if self.isPlaying():
             print('isplaying:True')
             return True
     except Exception as e:
         self.clearPlayer()
         print(str(e), str(self.currVideo.getFormatList()))
     # Handle the case in which the format couldn't be played
     self.stop()
     self.formatId = 0
     return False
Beispiel #20
0
def get_subplayer2(stream_num):
    p = OMXPlayer(
        sub_streams[stream_num],
        args=[
            "--layer=20",
            "--threshold=0",
            "--video_fifo=0",
            "--timeout=0",
            "--genlog",
            "--win=1280,540,1920,1020",
            "--avdict=rtsp_transport:tcp"
        ]
    )
    return p
Beispiel #21
0
def get_player(stream_num):
    p = OMXPlayer(
        streams[stream_num],
        args=[
            "--layer=20",
            "--threshold=0",
            "--video_fifo=0",
            "--timeout=0",
            "--genlog",
            "--win=0,180,1280,900",
            "--avdict=rtsp_transport:tcp"
        ]
    )
    return p
Beispiel #22
0
    def play(self, resource):
        if resource.startswith('youtube:') \
                or resource.startswith('https://www.youtube.com/watch?v='):
            resource = self._get_youtube_content(resource)
        elif resource.startswith('magnet:?'):
            response = self.download_torrent(resource)
            resources = response.output
            if resources:
                self.videos_queue = resources
                resource = self.videos_queue.pop(0)
            else:
                error = 'Unable to download torrent {}'.format(resource)
                logging.warning(error)
                return Response(errors=[error])

        logging.info('Playing {}'.format(resource))

        if self.player:
            try:
                self.player.stop()
                self.player = None
            except Exception as e:
                logging.exception(e)
                logging.warning(
                    'Unable to stop a previously running instance ' +
                    'of OMXPlayer, trying to play anyway')

        try:
            self.player = OMXPlayer(resource, args=self.args)
            self._init_player_handlers()
        except DBusException as e:
            logging.warning('DBus connection failed: you will probably not ' +
                            'be able to control the media')
            logging.exception(e)

        return self.status()
Beispiel #23
0
def DisplayLive(context, window) :

        current_channel = 0

        link = JsonFileForType(context.type_id)
        live_list_data = json.load(open("Imago/json/" + link + ".json"))

        pygame.draw.rect(window, pygame.Color(0, 0, 0), pygame.Rect(0, 0, 1920, 1080))

        for index in range(1, 8) :
                channel = (index + current_channel) % 8
                channel_logo_img_url = live_list_data[str(channel)]["Icon"]
                DisplayText(str(channel + 1) + ".", "font_alert_big", WHITE, 40, 820 - 110 * index, window)
                DisplayImageFromFile("Imago/" + channel_logo_img_url + ".png", window, 80, 820 - 110 * index)

        DisplayImageFromFile("Imago/img/Icons/up.png", window, 200, 800)
        
        channel_logo_img_url = live_list_data[str(current_channel % 8)]["Icon"]        
        DisplayText(str(current_channel + 1) + ".", "font_alert_big", WHITE, 40, 900, window)
        DisplayImageFromFile("Imago/" + channel_logo_img_url + ".png", window, 80, 900)

        DisplayImageFromFile("Imago/img/Icons/down.png", window, 200, 1000)
        
        DisplayText("En ce moment :", "font_alert_big", LIGHT_GREY, 550, 785, window)
        video_id_now = live_list_data[str(current_channel % 8)]["Video"]["Now"]["Video_id"] 
        DisplayImageFromYoutube(video_id_now, window, 550, 830)
        DisplayImageFromFile("Imago/img/thumbnail_background40.png", window, 550, 830)
        tvshow_title = live_list_data[str(current_channel % 8)]["Video"]["Now"]["Name"] 
        DisplayText(tvshow_title, "font_alert_big", WHITE, 590, 850, window)

        DisplayText("A suivre :", "font_alert_big", LIGHT_GREY, 1235, 785, window)
        video_id_next = live_list_data[str(current_channel % 8)]["Video"]["Next"]["Video_id"] 
        DisplayImageFromYoutube(video_id_next, window, 1235, 830)
        DisplayImageFromFile("Imago/img/thumbnail_background40.png", window, 1235, 830)
        tvshow_title = live_list_data[str(current_channel % 8)]["Video"]["Next"]["Name"] 
        DisplayText(tvshow_title, "font_alert_big", WHITE, 1275, 850, window)

        pygame.draw.rect(window, pygame.Color(0, 0, 0), pygame.Rect(550, 0, 1920, 772))
        DisplayText("Chargement en cours...", "font_alert_big", (180, 180, 180), 950, 380, window)

        pygame.display.flip()

        youtube_id = live_list_data[str(current_channel)]["Video"]["Now"]["Video_id"] 
        #context.player = OMXPlayer(PathVideo(youtube_id), args=['--no-osd', '--win', '0, 0, 1920, 1080'])
        context.player = OMXPlayer(PathVideo(youtube_id), args=['--no-osd', '--win', '550, 0, 1920, 772'])

        return
Beispiel #24
0
def state_bee_pollunated():
    logger.info('starting state_after')
    global after_movie_controller
    logger.debug('starting sync play of after movie')
    GPIO.output(bee_light_o, True)
    logger.debug('Flag female to start blinking')
    GPIO.output(male_to_female_o, True)
    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)
    logger.debug('starting async play of wait movie')
    wait_movie_controller.play()
    return state_wait()
Beispiel #25
0
    def getAudio(self, senserValue):

        FTPCon = self.getFtpConnect()
        audio_file = senserValue + ".mp3"
        FTPCon.cwd(
            '/home/garaage/sound/app/head/')  # change FTP SERVER Directory
        os.chdir(r"/home/pi/BBomi")  # change directory
        print(audio_file)

        #download
        FTPCon.retrbinary('RETR ' + audio_file, open(audio_file, 'wb').write)
        print("down")
        print(" download ok")

        #call Play Method
        OMXPlayer(audio_file)
        time.sleep(3)
        FTPCon.close()
Beispiel #26
0
 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(3)
             player.pause()
             #if you got to quit you can't re-open
             player.quit()
         #<loopTest
         self.forTesCount += 1
         if self.forTesCount % 1000 == 0:
             print "recNOW"
         #loopTest>
         time.sleep(0.01)
def route_player_open_new_file(request, file):
    global current_thing_playing
    path_to_file = file_container.match_hash_for_file(file)
    current_thing_playing = file_container.match_hash_for_file_name(file)
    global player
    if player is not None:
        player.quit()
	kill_player_pids(dbus_daemon_handle)
        player = OMXPlayer(path_to_file)
	player.play()
    else:
    	player = OMXPlayer(path_to_file)
    	player.play()
    return path_to_file
Beispiel #28
0
    def _loadPath(self, videoPath):
        # close existing video
        if self.player:
            self._unload()

        self.logger.debug('loading player with command: {0} {1}'.format(
            videoPath, ' '.join(self.args)))
        # this will be paused by default

        if OMXPlayer:
            # start omx player without osd and sending audio through analog jack
            self.player = OMXPlayer(
                videoPath,
                args=self.args)  #['--no-osd', '--adev', 'local', '-b'])
        else:
            self.logger.warning(
                'No OMXPlayer not available, cannot load file: {0}'.format(
                    videoPath))

        self.loadEvent(self, videoPath)
Beispiel #29
0
def UpdateLive(context, current_channel, window) :

        try :
                context.player.stop()
        except :
                print("error")

        link = JsonFileForType(context.type_id)
        live_list_data = json.load(open("Imago/json/" + link + ".json"))

        pygame.draw.rect(window, pygame.Color(0, 0, 0), pygame.Rect(550, 0, 1920, 772))
        DisplayText("Chargement en cours...", "font_alert_big", (180, 180, 180), 950, 380, window)

        pygame.display.flip()

        youtube_id = live_list_data[str(current_channel)]["Video"]["Now"]["Video_id"]
        #context.player.load(PathVideo(youtube_id))
        context.player = OMXPlayer(PathVideo(youtube_id), args=['--no-osd', '--win', '550, 0, 1920, 772'])

        return
Beispiel #30
0
 def processing(self):
     """
     - Get videostream from youtube-dl
     - Launch omxplayer
     :return:
     """
     # It can't connect to dbus sometimes, looks good
     try:
         proc = subprocess.Popen(
             ["youtube-dl", "-f", "best", "-g", self.video_url],
             stdout=subprocess.PIPE,
         )
         realurl = proc.stdout.read()
         OMXPlayer(realurl.decode("utf-8", "strict")[:-1],
                   args=["-o", "local"])
     except:
         pass
     # for FIFO queue
     while self.checkIfProcessRunning():
         time.sleep(3)
Beispiel #31
0
def reset_handler():
    emit("reset", "", broadcast=True)
    global firstTrigger
    firstTrigger = True
    global occupied
    occupied = False
    global player
    player = OMXPlayer(VIDEO_FILE_3, args=['--no-osd', '--no-keys', '-b'])
    player.play()
    sleep(1)
    player.pause()
    ledDriver.setPWM(UPPER_SHELL_RED, 4095, 0)
    ledDriver.setPWM(UPPER_SHELL_GREEN, 4095, 0)
    ledDriver.setPWM(UPPER_SHELL_BLUE, 4095, 0)
    ledDriver.setPWM(UNDER_SEAT_PWM_R, 4095, 0)
    ledDriver.setPWM(UNDER_SEAT_PWM_G, 4095, 0)
    ledDriver.setPWM(UNDER_SEAT_PWM_B, 4095, 0)
Beispiel #32
0
def previousAction(event):
    print("Previous")

    global mode
    global currentStation

    if mode == 'radio':

        previousStationUrl = None
        previusStation = None

        for key, value in radioStations.items():

            if key == currentStation:
                break

            previousStationUrl = value
            previousStation = key

        currentStation = previousStation
        player = OMXPlayer(previousStationUrl)

        print(currentStation)
Beispiel #33
0
def playOnce(file, clock):
    global PLAYING, HAVE_STOP
    # 停止之前播放的视频
    PLAYING = False
    while HAVE_STOP is False:
        continue
    # 播放新视频
    PLAYING = True
    HAVE_STOP = False
    video_path = Path(file)
    clock = float(clock)
    contin = True
    player = OMXPlayer(video_path)
    now_clock = 0
    while contin:
        sleep(SLEEP_STEP)
        now_clock += SLEEP_STEP
        if now_clock == clock:
            PLAYING = False
            break
        if PLAYING is False:
            contin = False
    HAVE_STOP = True
Beispiel #34
0
class PlayVoidAudio(Thread):
    def __init__(self):
        Thread.__init__(self)

    def terminate(self):  # activated by Stop button
        self.player.stop()
        print('Terminating thread...')

    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()
Beispiel #35
0
def play_mp3(event):
    print("Play mp3")

    global player
    global mode

    if player is not None:
        print("Already playing - quit")
        player.quit()
        player = None
        mode = None
    else:
        print("Start player")
        player = OMXPlayer('/home/pi/mp3/Beck.mp3')
        player.pause()
        mode = "MP3"
        player.play()
        print("Play")
    def scp_and_play(self):
        self.scp_handler = SCPHandler(self.hostname,self.username,self.password)
        self.remote_file = "/tmp/{}".format(self.filename.split("/")[-1])
        self.scp_handler.scp(self.filename,self.remote_file)
        filename = self.filename.split("/")[-1].replace("\\","")
        self.messageField.setStringValue_("Upload starting...")
        time.sleep(0.5)
        while self.scp_handler.progress != 100:
            time.sleep(0.1)
            message = "Uploading {filename} to {remote}\nProgress: {p}%".format(
                                filename=filename,
                                remote=self.hostname,
                                p=self.scp_handler.progress)
            self.messageField.setStringValue_(message)
        
        message = "Uploading {filename} to {remote}\nProgress: Done".format(
                                filename=filename,
                                remote=self.hostname)
        self.messageField.setStringValue_(message)
        
        # start player
        self.omxplayer = OMXPlayer(self.hostname, self.username, self.password)
        self.omxplayer.play(self.remote_file)
        self.nowPlayingField.setStringValue_("Currently Playing:\n{}".format(filename))
        self.setPlayButtons(True)

        # poll for status of video
        # (don't start polling until omxplayer has had some time to get started)
        time.sleep(10)
        while self.omxplayer.playing:
            time.sleep(1)

        # reset when playing is done
        self.setPlayButtons(False)
        self.uploadButton.setEnabled_(True)
        self.nowPlayingField.setStringValue_("Nothing playing")
def play():
    '''
        start the programm
        Returns:
    '''

    print("get video path from config")
    # load config
    video_path = read_config()

    # get mp4 files from video_path
    video_list = read_directory(video_path)

    if video_list:
        for video in video_list:
            print("Play: " + video)
            player = OMXPlayer(video)
            player.play()
            player.quit()
        return "Playlist end"
    else:
        return "There is no valid video in " + video_path
        sleep(5)
class RPiMediaPlayerController(NSWindowController):

    audio_formats = ['mp3','mpa','flac','ogg','wav','wma','m4a']
    video_formats = ['avi','wmv','mpg','mpeg','mp4','mkv','m4v','m2v','mpv','ogv','flv','mov'] 
    media_patterns = re.compile(".*\.("+"|".join(audio_formats+video_formats)+")$", re.IGNORECASE)

    hostnameField = objc.IBOutlet()
    usernameField = objc.IBOutlet()
    passwordField = objc.IBOutlet()
    filenameField = objc.IBOutlet()
    messageField  = objc.IBOutlet()
    nowPlayingField = objc.IBOutlet()

    playButton = objc.IBOutlet()
    fButton    = objc.IBOutlet()
    ffButton   = objc.IBOutlet()
    bButton    = objc.IBOutlet()
    bbButton   = objc.IBOutlet()
    stopButton = objc.IBOutlet()
    volupButton   = objc.IBOutlet()
    voldownButton = objc.IBOutlet()
    
    uploadButton = objc.IBOutlet()

    playButtons = (
            'playButton',
            'fButton',
            'ffButton',
            'bButton',
            'bbButton',
            'stopButton',
            'volupButton',
            'voldownButton',
            )
    
    def setPlayButtons(self,enable):
        for button in self.playButtons:
            eval('self.{}'.format(button)).setEnabled_(enable)

    def scp_and_play(self):
        self.scp_handler = SCPHandler(self.hostname,self.username,self.password)
        self.remote_file = "/tmp/{}".format(self.filename.split("/")[-1])
        self.scp_handler.scp(self.filename,self.remote_file)
        filename = self.filename.split("/")[-1].replace("\\","")
        self.messageField.setStringValue_("Upload starting...")
        time.sleep(0.5)
        while self.scp_handler.progress != 100:
            time.sleep(0.1)
            message = "Uploading {filename} to {remote}\nProgress: {p}%".format(
                                filename=filename,
                                remote=self.hostname,
                                p=self.scp_handler.progress)
            self.messageField.setStringValue_(message)
        
        message = "Uploading {filename} to {remote}\nProgress: Done".format(
                                filename=filename,
                                remote=self.hostname)
        self.messageField.setStringValue_(message)
        
        # start player
        self.omxplayer = OMXPlayer(self.hostname, self.username, self.password)
        self.omxplayer.play(self.remote_file)
        self.nowPlayingField.setStringValue_("Currently Playing:\n{}".format(filename))
        self.setPlayButtons(True)

        # poll for status of video
        # (don't start polling until omxplayer has had some time to get started)
        time.sleep(10)
        while self.omxplayer.playing:
            time.sleep(1)

        # reset when playing is done
        self.setPlayButtons(False)
        self.uploadButton.setEnabled_(True)
        self.nowPlayingField.setStringValue_("Nothing playing")

    def windowDidLoad(self):
        NSWindowController.windowDidLoad(self)
        self.setPlayButtons(False)

    @objc.IBAction
    def upload_(self, sender):
        self.hostname = self.hostnameField.stringValue()
        self.username = self.usernameField.stringValue()
        self.password = self.passwordField.stringValue()
        self.filename = self.filenameField.stringValue()
        if not os.path.isfile(self.filename):
            self.messageField.setStringValue_("File not found.")
            return
        if not self.media_patterns.match(self.filename):
            self.messageField.setStringValue_("Please only provide audio or video files")
            return
        self.uploadButton.setEnabled_(False)
        self.filename = string_to_path(self.filename)
        scp_and_play_thread = Thread(target=self.scp_and_play, args=())
        scp_and_play_thread.daemon = True
        scp_and_play_thread.start()
    
    @objc.IBAction
    def playpause_(self, sender):
        self.omxplayer.toggle_play()

    @objc.IBAction
    def f_(self, sender):
        self.omxplayer.f()

    @objc.IBAction
    def ff_(self, sender):
        self.omxplayer.ff()

    @objc.IBAction
    def b_(self, sender):
        self.omxplayer.b()

    @objc.IBAction
    def bb_(self, sender):
        self.omxplayer.bb()

    @objc.IBAction
    def volup_(self, sender):
        self.omxplayer.volup()

    @objc.IBAction
    def voldown_(self, sender):
        self.omxplayer.voldown()

    @objc.IBAction
    def stop_(self, sender):
        self.omxplayer.close()
        self.setPlayButtons(False)
        self.uploadButton.setEnabled_(True)
        self.nowPlayingField.setStringValue_("Nothing playing")
Beispiel #39
0
def play(url='/home/pi/nihao.mp3'):
    OMXPlayer(url).play()
    print(os.getcwd())
Beispiel #40
0
    with PiCamera() as camera:
        camera.resolution = (1024, 768)
        camera.start_preview()
        camera.annotate_text = "Press red button to post to Twitter"
        rightbutton.wait_for_press()
        camera.annotate_text = ""
        camera.capture(photo_path)
        camera.stop_preview()
        
    photo_tweet(photo_path)

    sleep(5)
        
while True:
    #replace with you video, always needs to reestablish variable or won't loop video
    player = OMXPlayer("test.mov")
    print("Press the left button to play")
    rightbutton.when_pressed = player.pause
    leftbutton.wait_for_press()
    player.play()
    print(player.playback_status())
    try:
        while player.playback_status():
            if player.playback_status() == "Paused":
                terrorcam()
    except:
        pass
    print("Waiting for motion")
    pir.wait_for_motion()
    tweetpic()
    
Beispiel #41
0
    globalPlayer.play()

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()


readSongData()
globalPlayer = OMXPlayer(path + songList[0])

while True:
    if(not globalPlayer.is_playing() and not isPaused):
        nextSong()

    while port.inWaiting() < 2:
        pass
    newHeading = ord(port.read())
    newSide = ord(port.read())

    if(newSide == 3 or newSide == 6):
        if(currentSide != 3 and currentSide != 6):
            pause()

    if(currentSide == 3 or currentSide == 6):
Beispiel #42
0
from omxplayer import OMXPlayer
from MTC import MTC


if __name__ == "__main__":

    from time import sleep
    import threading

    player = OMXPlayer('chem.mp4', args=['--no-osd'])
    mtc = MTC()
    player.play()

    def get_mtc():
        while True:
            mtc.readFrame()

    mtc_time = threading.Thread(target=get_mtc)
    mtc_time.start()
    speed = 0
    lastm, lastp = 0, 0

    sleep(1)
    av = []
    first_seek = True

    tol = 0.1

    try:
      while True:
        player_pos = player.position()
Beispiel #43
0
import os
import RPi.GPIO as GPIO
import time
import cuFunctions
from omxplayer import OMXPlayer
#allows to kill omxplayer process in case of crash
os.system('sudo killall omxplayer.bin')

GPIO.setmode(GPIO.BCM)

GPIO.setup(5, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(6, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(13, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(19, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(26, GPIO.IN, pull_up_down = GPIO.PUD_UP)
player = OMXPlayer('/home/pi/Documents/Cabin-TIMERonly.mp4', ['--no-osd'])

#This code is for debugging purposes, incase system freezes it forces close after 30 seconds
timeout = time.time() + 30

while True:
    button_quit = GPIO.input(5)
    button_lose = GPIO.input(6)
    button_win = GPIO.input(13)
    button_start = GPIO.input(19)
    button_loop = GPIO.input(26)
    print('Error Code #002')
    player.play()
    if (button_loop == False):
        print('Loop Trigger by GameMaster')
        #       cuFunctions.loopvideo(player())
import sys
import os
import time
from omxplayer import OMXPlayer

player = OMXPlayer('/mnt/music.mp3')
player.play()
time.sleep(20)
player.stop()
#!/usr/bin/env python2
import os.path
from time import sleep
from omxplayer import OMXPlayer
from smoke_tests import TEST_MEDIA_FILE_1, TEST_MEDIA_FILE_2

player = OMXPlayer(TEST_MEDIA_FILE_1, pause=True)
print("Start playing vid1")
player.play()
sleep(2)
print("Stop playing vid1")
player.pause()
sleep(2)

player.load(TEST_MEDIA_FILE_2, pause=True)
print("Start playing vid2")
player.play()
sleep(2)
print("Stop playing vid2")
player.pause()
sleep(2)

print("Exit")
player.quit()
sleep(1)
import sys
from omxplayer import OMXPlayer
from time import sleep


args = ['-vol -1500.00']
#player = OMXPlayer(sys.argv[1], args=['--no-osd', '--no-keys', '-b'])
player = OMXPlayer(sys.argv[1], args=args)
#player = OMXPlayer(sys.argv[1])


#player.set_volume(-1500.00)
player.play()
sleep(5)
player.pause()

player.quit()
 def setUp(self):
     self.player = OMXPlayer(self.MEDIA_FILE_PATH)
     sleep(1) # Give the player time to start up
Beispiel #48
0
def testVideo(video_id=None):
    print "Incoming video request"
    vid1 = OMXPlayer(TEST_MEDIA_FILE_1, pause=True)
    print("Start playing")
    vid1.set_position(70)
    dur = vid1.duration()
    print dur
    vid1.play()
    sleep(2)
    print("Stop playing")
    vid1.pause()
    time.sleep(2)
    vid1.load(TEST_MEDIA_FILE_2)
    vid1.play()
    sleep(2)
    print("Exit")
    vid1.quit()
class Controller(object):
    def __init__(self):
        pass

    def check_new_files(self):
        '''
        check new files from _DIR
        '''
        self._files = []
        for files in os.listdir(_DIR):
            if files.endswith(('wmv', 'mp4', 'mov', 'avi')):
               self._files.append(os.path.join(_DIR, files))
            else:
                pass

    def play_files(self):
        '''
        Play all the files sequentially
        '''
        self.idx = 0
        while True:
            # Loop over list of files
            self.current_file = self._files[self.idx]
            self.idx = (self.idx + 1) % len(self._files)
            self.next_file = self._files[self.idx]
            # Play files one after the other
            self.player(self.current_file)
            
    def player(self, current_file):
        print(current_file,'\n','\tPlaying')
        # Set output window size
        self.omx = OMXPlayer(current_file, args=["--win", " 0,0,640,480"])
        self.omx.play()
        try:
            self.omx.set_position(15.0)
            while True:
                try:
                    if not(self.omx.playback_status()):
                        # If file ended.. stop playback
                        print('\n\tStopped\n')
                        self.omx.stop()
                        break
                    
                    else:
                        # Print time elapsed
                        print('\r\t','{0:.2f}'.format(self.omx.position()),
                              '/', '{0:.2f}'.format(self.omx.duration())+
                              ' seconds', end = ''),
                        sys.stdout.flush()
                    
                except Exception, e:
                    # dBUS exception for file that 
                    # finished playing. Ignore!
                    pass

        except KeyboardInterrupt, e:
            # Catch Ctrl+C and stop playing
            # current file
            print('Stopping Playback..', e)
            self.omx.stop()
	def do_POST(self):
		global player
		global home_path

		jsonData = json.loads(self.rfile.read(int(self.headers.getheader('content-length'))))

		print 'Data received from phone : '
		print jsonData

		command = jsonData['command'];
		if command == 'pause' and 'player' in globals():
			player.pause()
		elif command == 'seek_backward' and 'player' in globals():
			player.action(19)
		elif command == 'seek_forward' and 'player' in globals():
			player.action(20)
		elif command == 'seek_fast_backward' and 'player' in globals():
			player.action(21)
		elif command == 'seek_fast_forward' and 'player' in globals():
			player.action(22)
		elif command == 'previous_audio_stream' and 'player' in globals():
			player.action(6)
		elif command == 'next_audio_stream' and 'player' in globals():
			player.action(7)
		elif command == 'previous_subtitle_stream' and 'player' in globals():
			player.action(10)
		elif command == 'next_subtitle_stream' and 'player' in globals():
			player.action(11)
		elif command == 'decrease_subtitle_delay' and 'player' in globals():
			player.action(13)
		elif command == 'increase_subtitle_delay' and 'player' in globals():
			player.action(14)
		elif command == 'stop' and 'player' in globals():
			player.stop()
			player.quit()
			del player
		elif command == 'delete_file':
			os.remove(jsonData['path'])
		elif command == 'delete_folder':
			shutil.rmtree(jsonData['path'])
		elif command == 'poweroff':
			call(['sudo', 'poweroff'])
		elif command == 'reboot':
			call(['sudo', 'reboot'])
		elif command == 'play':
			if 'player' in globals():
				player.stop()
				player.quit()

			player = OMXPlayer(jsonData['path'], args=['-b'])
			player.play()
		elif command == 'is_playing':
			if 'player' in globals():
				SendResponse(self, {'command': command, 'path': player.get_filename()})
			else:
				SendResponse(self, {'command': command, 'path': ''})

		elif command == 'list_dir':
			path = jsonData['path'] if 'path' in jsonData else home_path

			files = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) and os.path.splitext(f)[1] in SUPPORTED_FORMATS]
			dirs = [f for f in os.listdir(path) if os.path.isdir(os.path.join(path, f))]

			files.sort()
			dirs.sort()

			SendResponse(self, {'command': command, 'path': path, 'files': files, 'dirs': dirs})
Beispiel #51
0
#set up GPIO using BCM numbering

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
up = 12
down = 11
enter = 7

#All Gpio's as input and pull up
GPIO.setup(up, GPIO.IN, pull_up_down=GPIO.PUD_UP
           )  # Set button "up" as input and Activate pull up resistor
GPIO.setup(down, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(enter, GPIO.IN, pull_up_down=GPIO.PUD_UP)

#Funny, the player quits after one run (while becomes False), but finishes without error. No loop = dbus error
player = OMXPlayer(default, args=['-o', 'local', '--loop'])
player.set_video_pos(
    200, 200, 627,
    440)  #video files are ?854 × 480px.? Divide with two + x1 and y1

while player.is_playing():
    #TODO: create a way for videos to be in a mill. Look over c# prg.

    #player = OMXPlayer(default, args=['-o', 'local'], )
    #player.set_video_pos(200, 200, 627, 440)

    if GPIO.input(up) == 0:
        player.load(vida)
        player.set_video_pos(200, 200, 627, 440)
        print("button1 pushed")
        player.play()
Beispiel #52
0
    def run(self):
        time_status = False
        stop = False
        save_file = os.path.join(env_variables.home_ba, 'save.p')
        pickle.dump(stop, open( save_file, "wb" ))
        logging.info("in run method")
    
        # tant que l'on a pas appuye sur "stopper les ba", on continue !
        if self.timer_in_seconds is None:
            env_variables.lock.acquire()
            # on joue toutes les bande-annonces une seule fois
            for track in self.ba_file_list:
                # sortie de la boucle for si stop = True
                if stop is True:
                    break

                # lancement de la ba
                player = OMXPlayer(track, args=['-o', 'hdmi', '-b', '--no-osd'])
                player.play()
                
                # affichage d'un ecran noir pour ne pas voir l'ecran de la ba precedente
                # brievement avant le changement d'ecran
                try:
                    return_code = subprocess.call("export DISPLAY=:0;/usr/bin/feh --no-fehbg --bg-scale '" + env_variables.black_image +"'", shell=True)
                except Exception as e:
                    logging.error('black image display failed: %s' % str(e))
                sleep(1)
                logging.info("ba: %s, status: %s" % (track, player.playback_status()))

                # tant que la ba n'est pas fini ou stoppee, on attend
                while True:
                    try:
                        if player.playback_status() == "Playing" and stop is False:
                            sleep(1)
                            stop = pickle.load(open( save_file, "rb" ))
                            #logging.info("%s, %s" % (player.playback_status(),stop))  
                        else:
                            logging.warn("before player quit - timer is None")
                            player.quit()
                            # sortie boucle while
                            break
                    except DBusException:
                        # cette exception est levee a la fin de la ba, sortie du while
                        logging.warn("dbus exception - timer is None")
                        break

                    # affichage du display entre deux bande-annonces
                    # recuperation image correspondante a la ba
                    if stop is False and track != env_variables.ba_carte_fidelite:
                        try:
                            image = track.split('.mp4')[0] + '.jpg'
                            logging.info("slide montre: %s" % image)
                            command = "export DISPLAY=:0;/usr/bin/feh --no-fehbg --bg-scale '" + image +"'"
                            return_code = subprocess.call(command, shell=True)
                            if return_code == 0:
                                sleep(env_variables.temps_entre_2_ba)
                            else:
                                raise RuntimeError
                        except Exception as e:
                            logging.error("command is:%s" % command)
                            logging.error("display slide return code: %i" % return_code)
                            logging.error('image display failed: %s' % str(e))
            
            env_variables.lock.release()

        else:
            env_variables.lock.acquire()
            # ajouter un check de la valeur de timer
            timeout = time.time() + self.timer_in_seconds

            while stop is False and time_status is False:
                
                for track in self.ba_file_list:

                    # sortie de la boucle for si stop = True
                    if stop or time_status:
                        break

                    # lancement de la ba
                    player = OMXPlayer(track, args=['-o', 'hdmi', '-b', '--no-osd'])
                    player.play()

                    # affichage d'un ecran noir pour ne pas voir l'ecran de la ba precedente
                    # brievement avant le changement d'ecran
                    try:
                        return_code = subprocess.call("export DISPLAY=:0;/usr/bin/feh --no-fehbg --bg-scale '" + env_variables.black_image +"'", shell=True)
                    except Exception as e:
                        logging.error('black image display failed: %s' % str(e))
                    sleep(1)
                    logging.info("ba: %s, status: %s" % (track, player.playback_status()))                        

                    # tant que la ba n'est pas fini ou stoppee, on attend
                    while True:
                        try:
                            if player.playback_status() == "Playing" and stop is False and time_status is False:
                                sleep(1)
                                stop = pickle.load(open( save_file, "rb" ))
                                time_status = time.time() > timeout
                                #logging.info("%s, %s, %s" % (player.playback_status(),stop, time_status))  
                            else:
                                logging.warn("before player quit - timer is set")
                                player.quit()
                                # sortie boucle while
                                break
                        except DBusException:
                            logging.warn("dbus exception - timer is set")
                            # cette exception est levee a la fin de la ba, sortie du while
                            break

                    # affichage du display entre deux bande-annonces
                    # recuperation image correspondante a la ba
                    if stop is False and track != env_variables.ba_carte_fidelite:
                        try:
                            image = track.split('.mp4')[0] + '.jpg'
                            logging.info("slide montre: %s" % image)
                            command = "export DISPLAY=:0;/usr/bin/feh --no-fehbg --bg-scale '" + image +"'"
                            return_code = subprocess.call(command, shell=True)
                            if return_code == 0:
                                sleep(env_variables.temps_entre_2_ba)
                            else:
                                raise RuntimeError
                        except Exception as e:
                            logging.error("command is:%s" % command)
                            logging.error("display slide return code: %i" % return_code)
                            logging.error('image display failed: %s' % str(e))

            env_variables.lock.release()

            if time_status is True:
                subprocess.call(['sudo', 'shutdown', '-h', 'now'])
Beispiel #53
0
#!/usr/bin/env python2
import os.path
from time import sleep
from omxplayer import OMXPlayer
from . import TEST_MEDIA_FILE_1, TEST_MEDIA_FILE_2

vid1 = OMXPlayer(TEST_MEDIA_FILE_1)
print("Start playing vid1")
vid1.play()
sleep(2)
print("Stop playing vid1")
vid1.pause()
sleep(2)
print("Exit vid1")
vid1.exit()
sleep(1)

vid2 = OMXPlayer(TEST_MEDIA_FILE_2)
print("Start playing vid2")
vid2.play()
sleep(2)
print("Stop playing vid2")
vid2.pause()
sleep(2)
print("Exit vid2")
vid2.exit()
Beispiel #54
0
for row in reader:
    if is_Header:
        Header = row
        is_Header = False
    else:
        SongDict[int(row[0])] = {}
        for index in range(1, len(Header)):
            
            if Header[index] == "BPM":
                SongDict[int(row[0])][Header[index]] = int(row[index])
            else:
                SongDict[int(row[0])][Header[index]] = row[index]


Song = (SongDict[1]["Title"]+'.mp3')
player = OMXPlayer('/home/pi/Music/' + Song)
logfile = open("/home/pi/SMIKE/Log.txt", "w")
try:
    #UpdateSong(1)
    
    player.play()
    player.set_volume(CurrentVolume)
    
    ##Tick
    while True:
        ##Frequqncy Interpolation
       
        
        Frequency += (ActualFrequency-Frequency)*0.025
        Frequency = min(Frequency, 4000)
        #print(Frequency)