Example #1
0
  def bgthread_proc(self):
    while (not self.is_bgthread_stopped()):
      sleep(0.1)
      self.bglock.acquire()
      self.loadcond.acquire()
      if self.loadfile:
        if self.mp3:
          del self.mp3
        self.mp3 = Movie(self.loadfile)
        self.set_time(0)
        self.loadfile = None
        self.loadcond.notify()
      self.loadcond.release()
      if self.paused:
	self.bglock.release()
	continue
      is_busy = self.is_busy()
      if is_busy:
        t = self.get_time()+0.1
        self.set_time(t)
        if not self.lastbusy:
          self.eventhandler.event("Playing Started")
        self.eventhandler.event("Time Advance")
      else:
        if self.lastbusy:
	  self.set_time(0)
          self.eventhandler.event("Playing Stopped")
      self.lastbusy = is_busy
      self.bglock.release()
    self.eventhandler.event("Hardware Quit")
    def __init__(self,driver,screen,movie=None):
        states.State.__init__(self,driver,screen)

        #related to pausing/stopping the movie
        self.start_time = pygame.time.get_ticks()
        self.paused = False
        self.timer = False

        self.timer_start = 0
        self.timer_duration = 0

        self.max_time = 4

        self.current_time = 0
        self.prev_time = 0

        self.screen = screen

        screen.fill((0,0,0))
        pygame.display.flip()

        #make sure we have a movie to play
        if movie is None:
            print "Need a movie to play!"
            sys._driver.quit()

        self.movie = Movie(movie)

        #invalid video file, so we quit
        if not self.movie.has_video():
            print "No video in file, or unrecognized file format!"
            self._driver.quit()
        else:
            if self.movie.has_audio():
                self.movie.set_volume(1.0)

        #set the play area to be in the middle of the screen
        sw,sh = self.screen.get_size()
        mw,mh = self.movie.get_size()
        left = sw/2 - mw/2
        top = sh/2 - mh/2
        playarea = pygame.Rect(left,top,mw,mh)

        self.movie_resolution = self.movie.get_size()
        self.regular_resolution = self.screen.get_size()
        self.movie.set_display(self.screen,playarea)
class MoviePlay(states.State):
    def __init__(self,driver,screen,movie=None):
        states.State.__init__(self,driver,screen)

        #related to pausing/stopping the movie
        self.start_time = pygame.time.get_ticks()
        self.paused = False
        self.timer = False

        self.timer_start = 0
        self.timer_duration = 0

        self.max_time = 4

        self.current_time = 0
        self.prev_time = 0

        self.screen = screen

        screen.fill((0,0,0))
        pygame.display.flip()

        #make sure we have a movie to play
        if movie is None:
            print "Need a movie to play!"
            sys._driver.quit()

        self.movie = Movie(movie)

        #invalid video file, so we quit
        if not self.movie.has_video():
            print "No video in file, or unrecognized file format!"
            self._driver.quit()
        else:
            if self.movie.has_audio():
                self.movie.set_volume(1.0)

        #set the play area to be in the middle of the screen
        sw,sh = self.screen.get_size()
        mw,mh = self.movie.get_size()
        left = sw/2 - mw/2
        top = sh/2 - mh/2
        playarea = pygame.Rect(left,top,mw,mh)

        self.movie_resolution = self.movie.get_size()
        self.regular_resolution = self.screen.get_size()
        self.movie.set_display(self.screen,playarea)

    def paint(self,screen):
        screen.fill((0,0,0))
        pygame.display.flip()

        self.movie.play()
        pygame.event.clear()

        while self.movie.get_busy() or self.paused:
            seconds = pygame.time.get_ticks()
            elapsed = seconds - self.start_time
            self.current_time = int( elapsed / 1000 )

            if self.timer:
                self.timer_duration = self.current_time - self.timer_start

            if self.timer_duration >= self.max_time:
                break

            for event in pygame.event.get():
                if event.type == QUIT:
                    self.movie.stop()

                if event.type == KEYUP or event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        self.movie.stop()

                    
                if event.type == MOUSEBUTTONDOWN:
                    self.timer = not self.timer
                    self.timer_start = self.current_time

                elif event.type == MOUSEBUTTONUP:
                    self.timer = not self.timer
                    if self.timer_duration >= self.max_time:
                        break
                    else:
                        if self.paused:
                            lightsOff()
                            self.movie.play()
                        else:
                            lightsOn()
                            self.movie.pause()
                        self.paused = not self.paused

        pygame.event.clear()
        screen.fill((0,0,0))
        pygame.display.flip()
        self.movie.stop()

        self._driver.replace( MainScreen(self._driver, self.screen ) )

    def mouseDownEvent(self,x,y):
        return
    
    def keyEvent(self,key,unicode,pressed):
        return 
Example #4
0
class MP3Handler:

  def __init__(self, eventhandler):
    self.bgthread = None
    self.bglock = allocate()
    self.lastbusy = 0
    self.time = 0
    self.loadfile = None
    self.loadcond = Condition()
    self.mp3 = None
    self.paused = 0
    self.eventhandler = eventhandler

  def start_bgthread(self):
    self.bgthread = 1
    self.bgthread = start_new_thread(self.bgthread_proc, ())

  def is_bgthread_stopped(self):
    self.bglock.acquire()
    stopped = (self.bgthread == None)
    self.bglock.release()
    return stopped

  def bgthread_proc(self):
    while (not self.is_bgthread_stopped()):
      sleep(0.1)
      self.bglock.acquire()
      self.loadcond.acquire()
      if self.loadfile:
        if self.mp3:
          del self.mp3
        self.mp3 = Movie(self.loadfile)
        self.set_time(0)
        self.loadfile = None
        self.loadcond.notify()
      self.loadcond.release()
      if self.paused:
	self.bglock.release()
	continue
      is_busy = self.is_busy()
      if is_busy:
        t = self.get_time()+0.1
        self.set_time(t)
        if not self.lastbusy:
          self.eventhandler.event("Playing Started")
        self.eventhandler.event("Time Advance")
      else:
        if self.lastbusy:
	  self.set_time(0)
          self.eventhandler.event("Playing Stopped")
      self.lastbusy = is_busy
      self.bglock.release()
    self.eventhandler.event("Hardware Quit")

  def stop_bgthread(self):
    self.bglock.acquire()
    self.bgthread = None
    self.bglock.release()

  def set_time(self, t):
    if t<0:
      t = 0
    elif self.mp3 and t>self.mp3.get_length():
      t = self.mp3.get_length()
    self.time = t

  def get_time(self):
    t = self.time
    return t

  def load(self, mp3file):
    self.bglock.acquire()
    self.loadcond.acquire()
    self.bglock.release()
    self.loadfile = mp3file
    # wait for the background thread to load the MP3 file
    self.loadcond.wait()
    self.loadcond.release()

  def play(self):
    self.bglock.acquire()
    if self.mp3:
      self.mp3.play()
      self.set_time(0)
    self.bglock.release()

  def stop(self):
    self.bglock.acquire()
    if self.mp3:
      if self.paused:
        self.paused = 0
        self.lastbusy = 1
      self.mp3.stop()
    self.bglock.release()

  def rewind(self):
    self.bglock.acquire()
    if self.mp3:
      self.mp3.rewind()
      self.set_time(0)
    self.bglock.release()

  def forward(self, n_sec):
    self.bglock.acquire()
    self.set_time(self.get_time()+n_sec)
    self.bglock.release()

  def backward(self, n_sec):
    self.bglock.acquire()
    self.set_time(self.get_time()-n_sec)
    self.bglock.release()

  def pause(self):
    self.bglock.acquire()
    if self.mp3:
      if self.is_busy():
        self.mp3.pause()
        self.last_pause_time=self.get_time()
        self.paused = 1
        self.lastbusy = 0
    self.bglock.release()

  def resume(self):
    self.bglock.acquire()
    if self.mp3:
      if not self.is_busy() and self.paused:
        self.lastbusy = 0
        if self.get_time()!=self.last_pause_time:
          self.mp3.stop()
          self.mp3.rewind()
          self.mp3.skip(self.get_time())
          self.mp3.play()
        else:
          self.mp3.pause()
        self.paused=0
    self.bglock.release()

  def is_busy(self):
    return self.mp3 and self.mp3.get_busy()