def __init__(self, *args, **kwargs):
     super(self.__class__, self).__init__(*args, **kwargs)
     self.right = create_svg('ninja_right.svg')
     self.left = create_svg('ninja.svg')
     self.dead = create_svg('ninja_death.svg')
     self.sounds = [StaticSource(load('resources/sounds/ninja_hiya_1.ogg')),
                    StaticSource(load('resources/sounds/ninja_hiya_2.ogg'))]

    def media(self, name, streaming=True):
        '''Load a sound or video resource.

        The meaning of `streaming` is as for `media.load`.  Compressed
        sources cannot be streamed (that is, video and compressed audio
        cannot be streamed from a ZIP archive).

        :Parameters:
            `name` : str
                Filename of the media source to load.
            `streaming` : bool
                True if the source should be streamed from disk, False if
                it should be entirely decoded into memory immediately.

        :rtype: `media.Source`
        '''
        self._require_index()
        from pyglet import media
        try:
            location = self._index[name]
            if isinstance(location, FileLocation):
                # Don't open the file if it's streamed from disk -- AVbin
                # needs to do it.
                path = os.path.join(location.path, name)
                return media.load(path, streaming=streaming)
            else:
                file = location.open(name)
                return media.load(name, file=file, streaming=streaming)
        except KeyError:
            raise ResourceNotFoundException(name)

def play(audio):
    if audio != "silent":
        player1 = Player()
        player1.queue(load(join(DATA, "chronotank.ogg")))
        player1.queue(load(join(DATA, "imagine_a_world.ogg")))
        player1.play()

        player2 = Player()
        player2.eos_action = Player.EOS_LOOP
        player2.queue(load(join(DATA, "stupidsongimadenofarting.ogg")))
        player2.play()

def find_resource(type, filename):
    """return resource given type (e.g. RESOURCE_IMAGE) and filename"""

    path = os.path.join(path_for_resource_type(type), filename)

    if type == RESOURCE_IMAGE: return image.load(path)
    if type == RESOURCE_FONT:  return font.load(path)
    if type == RESOURCE_SOUND: return media.load(path, streaming=False)
    if type == RESOURCE_MUSIC: return media.load(path, streaming=True)

    assert False

 def load_source(self, filename):
     print 'loading source: ', filename
     self.source = media.load(filename)
     try:
         self.source = media.load(filename)
         print '1'
         self.width = int(self.source.video_format.width)
         self.height = int(self.source.video_format.height)
         self.duration = self.source.duration
         print 'loaded movie.. height: ', self.height, ' | width: ', self.width
     except:
         print 'failed to open movie!'
         ValueError('failed to open movie!')

def main():
    usage = '%prog [options] FILE'

    parser = OptionParser(usage)

    parser.add_option("--format", type='string', default=None)

    (options, args) = parser.parse_args()

    in_filename = args[0]

    if options.format is None or options.format.lower() != 'mono8':
        raise NotImplementedError('Only mono8 format is supported with no '
                                  'autodetection. Use "--format=mono8".')

    source = media.load(in_filename)
    imn, ts = get_frame(source)

    file_base = os.path.splitext(in_filename)[0]
    out_filename = file_base+'.fmf'

    fmf = fmf_mod.FlyMovieSaver(out_filename,
                                format='MONO8',
                                bits_per_pixel=8,
                                version=3,
                                )

    while imn is not None:
        fmf.add_frame( imn, ts )
        imn, ts = get_frame(source)

def queue_soundtrack(song='8bp069-06-she-streets.mp3', soundtrack=None):
    if not soundtrack:
        soundtrack = media.Player()
        soundtrack.eos_action = 'loop'

    soundtrack.queue(media.load(data_file(song)))
    return soundtrack

def playSounds(instrument, notes, mutex, turnstile, turnstile2, counter):
	sound = media.load(instrument, streaming=False)
	pitch = 0
	for c in notes:
		mutex.acquire()
		counter.increment()
		if counter.get() == counter.getNum():
			turnstile2.acquire()
			turnstile.release()
		mutex.release()
		turnstile.acquire()
		turnstile.release()
		if c.isdigit():
			player = media.Player()
			player.queue(sound)
			player.pitch = (2.0**(float(c)/12))
			#player.pitch = int(c)
			#print player.pitch
			player.play()
			sleep(2)
		mutex.acquire()
		counter.decrement()
		if counter.get() == 0:
			turnstile.acquire()
			turnstile2.release()
		mutex.release()
		turnstile2.acquire()
		turnstile2.release()

def queueSoundtrack(song):
    global soundtrack
    if not soundtrack:
        soundtrack = media.Player()
        soundtrack.eos_action = 'loop'
    soundtrack.queue(media.load(os.path.join(data.data_dir, song)))
    return soundtrack

 def load_file(self, name, ext, path):
     if ext in self.image_filetypes:
         self.image_dict[name + ext] = image.load(os.path.join(path, 
             '%s%s' % (name, ext))).get_texture()
         print "Image '%s' loaded!" % (name + ext)
     if ext in self.sound_filetypes:
         self.sound_dict[name + ext] = media.load(path + os.sep + name + ext,
                                                  streaming = False)
         print "Sound '%s' loaded!" % (name + ext)

def load_sound(path):
    """Load a static sound source from the sounds directory.

    :Parameters:
        `path` : str
            The relative path from the sounds directory to the file.

    """
    sound_path = os.path.join(DATA_DIR, "sounds", path)
    return media.load(sound_path, streaming=False)

def main():
    director.init(**window)
    main_scene = Scene(StartLayer())

    player = Player()
    player.queue(load("resources/audios/cave.wav"))
    player.eos_action = player.EOS_LOOP
    player.play()

    director.run(main_scene)

def load_song(path):
    """Load a music stream from the music directory.

    :Parameters:
        `path` : str
            The relative path from the music directory to the file.

    """
    song_path = os.path.join(DATA_DIR, "music", path)
    return media.load(song_path)

    def __init__(self, parent, file=None, source=None, playing=False,
                 x=0, y=0, z=0, width=None, height=None, scale=True, **kw):
        self.parent = parent
        self.scale = scale

        if file is not None:
            source = self.source = media.load(file, streaming=True)
        else:
            assert source is not None, 'one of file or source is required'

        self.player = media.Player()
        self.player.eos_action = self.player.EOS_PAUSE
        self.player.on_eos = self.on_eos

        # poke at the video format
        if not source.video_format:
            raise ValueError("Movie file doesn't contain video")
        video_format = source.video_format
        if width is None:
            width = video_format.width
            if video_format.sample_aspect > 1:
                width *= video_format.sample_aspect
        if height is None:
            height = video_format.height
            if video_format.sample_aspect < 1:
                height /= video_format.sample_aspect

        super().__init__(parent, x, y, z, width, height, **kw)

        # control frame top-level
        c = self.control = Frame(self, bgcolor=(1, 1, 1, .5),
                                 is_visible=False, width='100%', height=64)

        # controls underlay
        f = Frame(c, is_transparent=True, width='100%', height='100%')
        f.layout = layouts.Horizontal(f, valign='center', halign='center',
                                      padding=10)
        c.play = Image(f, data.load_gui_image('media-play.png'),
                       classes=('-play-button',), is_visible=not playing)
        c.pause = Image(f, data.load_gui_image('media-pause.png'),
                        bgcolor=None, classes=('-pause-button',),
                        is_visible=playing)
        fi = Frame(f, is_transparent=True)
        c.range = Image(fi, data.load_gui_image('media-range.png'))
        im = data.load_gui_image('media-position.png')
        c.position = Image(fi, im, x=0, y=-2, classes=('-position',))
        c.time = Label(f, '00:00', font_size=20)
        c.anim = None

        # make sure we get at least one frame to display
        self.player.queue(source)
        clock.schedule(self.update)
        self.playing = False
        if playing:
            self.play()

def main():
    fname='/home/evan/Desktop/openJarvis/openJarvis/speech/tdfw.mp3'
    src=media.load(fname)
    player=media.Player()
    player.queue(src)
    player.volume=1.0
    player.play()
    try:
        pyglet.app.run()
    except KeyboardInterrupt:
        player.next()

def is_audio_file(filename, media_file = None):
    if not media_file:
        try:
            media_file = media.load(filename)
        except:
            return False

    if media_file.video_format:
        return False

    return (media_file.audio_format is not None)

 def playAudioFile(self, filename, stream=False):
     try:
         volume = float(self.volume) / 100.0
         if self.player:
             src = media.load(filename, streaming=stream)
             self.player.queue(src)
             self.player.volume = volume
             self.player.play()
         elif self.isDarwin:
             subprocess.call(["afplay -v {0} {1}".format(volume, filename)], shell=True)
     except Exception as e:
         logging.error("SoundThread.playAudioFile exception: %s", e)

def playSounds(instrument, notes):
	sound = media.load(instrument, streaming=False)
	pitch = 0
	for c in notes:
		if c.isdigit():
			player = media.Player()
			player.queue(sound)
			player.pitch = (2.0**(float(c)/12))
			#player.pitch = int(c)
			#print player.pitch
			player.play()
			sleep(2)

    def __init__(self, parent, file=None, source=None, title=None,
                 playing=False, bgcolor=(1, 1, 1, 1), color=(0, 0, 0, 1),
                 font_size=20, **kw):
        """Pass in a filename as "file" or a pyglet Source as "source".
        """
        self.parent = parent

        if file is not None:
            source = media.load(file, streaming=True)
        else:
            assert source is not None, 'one of file or source is required'

        self.player = media.Player()

        # poke at the audio format
        if not source.audio_format:
            raise ValueError("File doesn't contain audio")

        super().__init__(parent, bgcolor=bgcolor, **kw)

        # lay it out

        # control frame top-level
        c = self.control = Frame(self, width='100%', height=64)

        ft = Frame(c, is_transparent=True, width='100%', height='100%')
        ft.layout = layouts.Vertical(ft)
        Label(ft, title or 'unknown', color=color, bgcolor=bgcolor,
              padding=2, font_size=font_size)

        # controls underlay
        f = Frame(ft, is_transparent=True, width='100%', height='100%')
        f.layout = layouts.Horizontal(f, valign='center', halign='center',
                                      padding=10)
        c.play = Image(f, data.load_gui_image('media-play.png'),
                       classes=('-play-button',), is_visible=not playing)
        c.pause = Image(f, data.load_gui_image('media-pause.png'),
                        bgcolor=None, classes=('-pause-button',),
                        is_visible=playing)
        fi = Frame(f, is_transparent=True)
        c.range = Image(fi, data.load_gui_image('media-range.png'))
        c.position = Image(fi, data.load_gui_image('media-position.png'),
                           y=-2, classes=('-position',))
        c.time = Label(f, '00:00', font_size=20)
        c.anim = None

        # make sure we get at least one frame to display
        self.player.queue(source)
        clock.schedule(self.update)
        self.playing = False
        if playing:
            self.play()

		def playAudioFile(self, filename, stream=False):
			try:
				volume = float(SoundManager.soundVolume) / 100.0
				if gPygletAvailable:
					src = media.load(filename, streaming=stream)
					player = media.Player()
					player.queue(src)
					player.volume = volume
					player.play()
				elif self.isDarwin:
					subprocess.call(["afplay -v {0} {1}".format(volume, filename)], shell=True)
			except Exception as e:
				print "SoundThread.playAudioFile exception: %s" % str(e)