spacepaste

Paste details

reply | raw

  1.  
  2. import os
  3. import StringIO
  4. import pymedia
  5. import threading
  6. import logging
  8. # Audio options
  9. WAV = {
  10. "bytes_minimum":4096,
  11. }
  13. MP3 = {
  14. "bytes_minimum":4096*2,
  15. }
  17. OGG = {
  18. "bytes_minimum":4096*4,
  19. }
  22. FORMATS = {
  23. ".wav":WAV,
  24. ".mp3":MP3,
  25. ".ogg":OGG,
  26. }
  28. __doc__ = """This library contains the Player class which is the threaded player for music/sfx playback with the backing of pymedia library."""
  30. class Player(threading.Thread):
  31. '''Simple media player written with threaded support based on pymedia.
  33. This threaded player will attempt to retrieve data from any kind of file object with seek
  34. and read method. It will then, based on the passed filename, decide which codec to use and
  35. demux + decode the data on the fly. It will require the constant FORMATS
  36. to be declared, with the number of bytes per tick to read.
  38. Player can be played, paused or stopped. However, the change will only manifest
  39. itself when the tick passed (ie enough data was processed). This is FORMATS based
  40. because different formats need different minimal data volume per block to success
  41. fully demux and decode.
  43. '''
  45. def __init__(self):
  46. '''Constructor'''
  47. threading.Thread.__init__(self)
  49. self.alive = True
  50. self.dec = None
  51. self.volume = 1.0
  52. self.repeat = True
  53. self.data = None
  54. self.finfoformat = None
  55. self.audioobj = None
  56. self.mplay = False
  58. def null():
  59. pass # empty call in case we do not need the exception_call
  61. self.exception_call = null
  64. def set_exception_callback(self, what):
  65. self.exception_call = what
  68. def __set_volume(self):
  69. """Internal volume setter.
  71. This method it called every tick to set the volume.
  72. """
  73. volume = int(100 * self.volume)
  74. vol = (volume << 8) + volume
  75. if vol > ((100 << 8) + 100):
  76. vol = (100 << 8) + 100
  77. elif vol < 0:
  78. vol = 0
  79. self.audioobj.setVolume(vol)
  82. def get_volume(self):
  83. """returns the volume.
  85. Returns:
  87. volume - 0xFFFF formated volume (100 is max).
  89. This volume is the volume of the sound mixer, not the track itself!
  90. """
  91. volume = self.audioobj.getVolume()
  92. return volume
  95. def is_alive(self):
  96. """returns the thread status."""
  97. return self.alive
  100. def change_repeat(self, repeatval):
  101. """changes the repeat of the music/sound playback.
  103. Parameters:
  105. repeatval - Boolean
  106. """
  107. self.repeat = repeatval
  110. def add_data(self, io, ext="foo.wav"):
  111. """loads the demuxer and Input/Output object.
  113. Parameters:
  115. io - File like object, with seek and read methods
  117. Optional parameters:
  119. ext - File name containing extension, used for initializing demuxer.
  120. """
  121. self.finfoformat = FORMATS[os.path.splitext(ext)[1]]
  122. self.dm = pymedia.muxer.Demuxer(str.split(ext,".")[-1].lower())
  124. self.data = io
  125. self.data.seek(0)
  128. def play(self):
  129. """starts the playback."""
  130. self.mplay = True
  133. def pause(self):
  134. """pauses the playback."""
  135. self.mplay = False
  138. def resume(self):
  139. """resumes the playback"""
  140. self.play()
  143. def stop(self):
  144. """suspends the playback and kills the thread."""
  145. self.pause()
  146. self.kill()
  149. def kill(self):
  150. """kills the thread."""
  151. self.alive = False
  154. def run(self):
  155. """main thread instance loop.
  157. This loop operates in ticks, with one tick being one round of the loop.
  158. The loop starts with loading the data from the IO source into the buffer
  159. then if the data is less than the full amount, it will either decide to
  160. reload the buffer or to kill the playback and the loop (based on the
  161. repeat value).
  163. Afterwards, it will try to demux the frames out of the loaded buffer
  164. and should it succeed, it will then play all the frames it was successful
  165. in the demuxing.
  167. The volume setter is set every time the frame is being played, so the fadeout
  168. should be working on the system that is supporting it (not supporting systems
  169. include PulseAudio or Alsa, but Windows seems to work).
  171. In this part of the loop, the audio playback device is instantiated, and should
  172. it fail with SoundError exception, it will be logged and thread will be promptly
  173. killed with a return. The callback exception will be called as well.
  175. If no problems were detected, the playback will continue until the whole IO object
  176. was used and either loop or end.
  177. """
  178. buf = ""
  179. while self.alive:
  180. if self.mplay:
  181. buf += self.data.read(self.finfoformat["bytes_minimum"])
  182. if len(buf) < self.finfoformat["bytes_minimum"]:
  183. if self.repeat:
  184. self.data.seek(0)
  185. else:
  186. self.kill()
  187. try:
  188. frames = self.dm.parse(buf)
  189. except:
  190. frames = None
  191. if frames:
  192. for fr in frames:
  193. if not self.mplay:
  194. break
  195. if self.dec is None:
  196. self.dec = pymedia.audio.acodec.Decoder(self.dm.streams[fr[0]])
  197. dat = self.dec.decode(fr[1])
  198. if dat is not None:
  199. if self.audioobj is None:
  200. try:
  201. self.audioobj = pymedia.audio.sound.Output(dat.sample_rate, dat.channels, pymedia.audio.sound.AFMT_S16_LE)
  202. except pymedia.audio.sound.SoundError, e:
  203. logging.error("Music thread failed with: %s" %str(e))
  204. self.exception_call()
  205. return
  207. self.__set_volume()
  208. self.audioobj.play(dat.data)
  209. buf = ""
  211.  
Powered by spacepaste. Paste removal.