def __init__(self, value="C", secs=0.5, octave=4, sampleRate=44100,
                 bits=16, name='', autoLog=True, loops=0, stereo=True):
        """
        """
        self.name = name  # only needed for autoLogging
        self.autoLog = autoLog

        if stereo == True:
            stereoChans = 2
        else:
            stereoChans = 0
        if bits == 16:
            # for pygame bits are signed for 16bit, signified by the minus
            bits = -16

        # check initialisation
        if not mixer.get_init():
            pygame.mixer.init(sampleRate, bits, stereoChans, 3072)

        inits = mixer.get_init()
        if inits is None:
            init()
            inits = mixer.get_init()
        self.sampleRate, self.format, self.isStereo = inits

        # try to create sound
        self._snd = None
        # distinguish the loops requested from loops actual because of
        # infinite tones (which have many loops but none requested)
        # -1 for infinite or a number of loops
        self.requestedLoops = self.loops = int(loops)
        self.setSound(value=value, secs=secs, octave=octave)

 def build_samples(self):
     period = int(round(get_init()[0] / self.frequency))
     samples = array("h", [0] * period)
     amplitude = 2 ** (abs(get_init()[1]) - 1) - 1
     for time in xrange(period):
         if time < period / 2:
             samples[time] = amplitude
         else:
             samples[time] = -amplitude
     return samples

    def test_get_init__returns_exact_values_used_for_init(self):
        return 
        # fix in 1.9 - I think it's a SDL_mixer bug.

        # TODO: When this bug is fixed, testing through every combination
        #       will be too slow so adjust as necessary, at the moment it
        #       breaks the loop after first failure

        configs = []
        for f in FREQUENCIES:
            for s in SIZES:
                for c in CHANNELS:
                    configs.append ((f,s,c))

        print (configs)
    

        for init_conf in configs:
            print (init_conf)
            f,s,c = init_conf
            if (f,s) == (22050,16):continue
            mixer.init(f,s,c)

            mixer_conf = mixer.get_init()
            import time
            time.sleep(0.1)

            mixer.quit()
            time.sleep(0.1)

            if init_conf != mixer_conf:
                continue
            self.assertEquals(init_conf, mixer_conf)

def stop_channel(channel):
    """ Stop sound on a channel. """
    if mixer.get_init():
        mixer.Channel(channel).stop()
        # play short silence to avoid blocking the channel - it won't play on queue()
        silence = pygame.sndarray.make_sound(numpy.zeros(1, numpy.int16))
        mixer.Channel(channel).play(silence)

    def todo_test_pre_init__keyword_args(self):
        # Fails on Mac; probably older SDL_mixer
## Probably don't need to be so exhaustive. Besides being slow the repeated
## init/quit calls may be causing problems on the Mac.
##        configs = ( {'frequency' : f, 'size' : s, 'channels': c }
##                    for f in FREQUENCIES
##                    for s in SIZES
##                    for c in CHANNELS )
        configs = [{'frequency' : 44100, 'size' : 16, 'channels' : 1}]

        for kw_conf in configs:
            mixer.pre_init(**kw_conf)
            mixer.init()

            mixer_conf = mixer.get_init()
            
            self.assertEquals(
                # Not all "sizes" are supported on all systems.
                (mixer_conf[0], abs(mixer_conf[1]), mixer_conf[2]),
                (kw_conf['frequency'],
                 abs(kw_conf['size']),
                 kw_conf['channels'])
            )
            
            mixer.quit()

    def __init__(self, display_w, display_h):
        pygame.init()
        mixer.init()
        font.init()

        # check if the mixer was successfully initialized
        if mixer.get_init() is None:
            print("Failed to initialize the audio mixer module.")

        if font.get_init() is None:
            print("Failed to initialize the font module.")

        self.fps = 120
        self.world = None
        self.gui = Gui(self)

        # Create screen display with 32 bits per pixel, no flags set
        self.display = pygame.display.set_mode((display_w, display_h), pygame.HWSURFACE, 32)
        self.delta_time = 0.0
        self.debug = False
        self.paused = False

        self.print_fps = False

        self.worlds = list()

        self.game = None

 def build_samples(frequency):
     """Build an array of the wave for this frequency"""
     # Hz is cycles per second
     # period = 44100 Hz / 440 Hz = 100 samples per cycle
     # Given samples and cycles per second get the period of each cycle
     period = int(round(mixer.get_init()[0] / frequency))
     # Make one full wave's period
     samples = array("h", [0] * period)
     # Fill with a square wave
     amplitude = 2 ** (abs(mixer.get_init()[1]) - 1) - 1
     for time in xrange(period):
         if time < period / 2:
             samples[time] = amplitude
         else:
             samples[time] = -amplitude
     return samples

def playSound(nom):
    """Joue un son une fois"""
    global volumeGlobal, volumeSons
    if not mixer.get_init() : mixer.init()
    son = mixer.Sound('Sons/' + nom + '.ogg')
    son.set_volume(float(volumeGlobal)*float(volumeSound)/10000)
    son.play()

def initPygame(rate=22050, bits=16, stereo=True, buffer=1024):
    """If you need a specific format for sounds you need to run this init
    function. Run this *before creating your visual.Window*.

    The format cannot be changed once initialised or once a Window has been created.

    If a Sound object is created before this function is run it will be
    executed with default format (signed 16bit stereo at 22KHz).

    For more details see pygame help page for the mixer.
    """
    global Sound, audioDriver
    Sound = SoundPygame
    audioDriver='n/a'
    if stereo==True: stereoChans=2
    else:   stereoChans=0
    if bits==16: bits=-16 #for pygame bits are signed for 16bit, signified by the minus
    mixer.init(rate, bits, stereoChans, buffer) #defaults: 22050Hz, 16bit, stereo,
    sndarray.use_arraytype("numpy")
    setRate, setBits, setStereo = mixer.get_init()
    if setRate!=rate:
        logging.warn('Requested sound sample rate was not poossible')
    if setBits!=bits:
        logging.warn('Requested sound depth (bits) was not possible')
    if setStereo!=2 and stereo==True:
        logging.warn('Requested stereo setting was not possible')

    def __init__(self,value="C",secs=0.5,octave=4, sampleRate=44100, bits=16):
        """
        """

        #check initialisation
        if not mixer.get_init():
            pygame.mixer.init(22050, -16, 2, 3072)
        
        inits = mixer.get_init()
        if inits is None:
            init()
            inits = mixer.get_init()                
        self.sampleRate, self.format, self.isStereo = inits
        
        #try to create sound
        self._snd=None
        self.setSound(value=value, secs=secs, octave=octave)

    def play(self, name, queue_sounds=False, play_next_queued_sound=False, loop_forever=False, callback=None):

        if not mixer.get_init():
            print "Mixer not initialized! Cannot play sound."

        #channel = mixer.find_channel()
        #channel.play(self.sounds[id])

        sound_item = self.sounds[name]

        if queue_sounds:
            if mixer.music.get_busy():
                mixer.music.queue(sound_item.path)
                print "Queued sound: " + name

                if play_next_queued_sound:
                    mixer.music.play()
                    if callback:
                        print "Channel playback end callback defined"
                        self.channel_playback_ended_listener(mixer.music, callback)

            else:
                mixer.music.load(sound_item.path)
                if loop_forever:
                    mixer.music.play(-1)
                else:
                    mixer.music.play()

                print "Playing sound: " + name

                if callback:
                        print "Channel playback end callback defined"
                        self.channel_playback_ended_listener(mixer.music, callback)

        else:

            if loop_forever:
                loops = -1
            else:
                loops = 0

            if sound_item.delay == sound_item.delay_min == sound_item.delay_max == 0:
                sound_item.sound.play(loops)

            elif sound_item.delay > 0:
                #pygame.time.wait(sound_item.delay)
                self.play_after_delay(sound_item.sound, sound_item.delay, loops)

            elif sound_item.delay_min == sound_item.delay_max:
                self.play_after_delay(sound_item.sound, sound_item.delay_min, loops)
                #pygame.time.wait(sound_item.delay_min)

            elif sound_item.delay_min > 0 and sound_item.delay_max > 0:
                rand = random.randrange(sound_item.delay_min, sound_item.delay_max, 250)
                #pygame.time.wait(rand)
                self.play_after_delay(sound_item.sound, rand, loops)

            print "Playing sound: " + name

    def __init__(self,value="C",secs=0.5,octave=4, sampleRate=44100, bits=16, name='', autoLog=True):
        """
        """
        self.name=name#only needed for autoLogging
        self.autoLog=autoLog
        #check initialisation
        if not mixer.get_init():
            pygame.mixer.init(sampleRate, -16, 2, 3072)

        inits = mixer.get_init()
        if inits is None:
            init()
            inits = mixer.get_init()
        self.sampleRate, self.format, self.isStereo = inits

        #try to create sound
        self._snd=None
        self.setSound(value=value, secs=secs, octave=octave)

 def todo_test_init__zero_values(self):
     # Ensure that argument values of 0 are replaced with
     # preset values. No way to check buffer size though.
     mixer.pre_init(44100, 8, 1)  # None default values
     mixer.init(0, 0, 0)
     try:
         self.failUnlessEqual(mixer.get_init(), (44100, 8, 1))
     finally:
         mixer.quit()
         mixer.pre_init(0, 0, 0, 0)

def init_sound(experiment):

	print(
		u"openexp.sampler._legacy.init_sound(): sampling freq = %d, buffer size = %d" \
		% (experiment.sound_freq, experiment.sound_buf_size))
	if hasattr(mixer, u'get_init') and mixer.get_init():
		print(
			u'openexp.sampler._legacy.init_sound(): mixer already initialized, closing')
		pygame.mixer.quit()
	mixer.pre_init(experiment.sound_freq, experiment.sound_sample_size, \
		experiment.sound_channels, experiment.sound_buf_size)
	mixer.init()

 def test_sound_mixer(self):
     """Tests that the app can initialize the pygame audio mixer."""
     import pygame.mixer as mix
     mix.init()
     # check that the mixer initialized
     self.assertIsNotNone(mix.get_init())
     # try to play a sound
     mix.music.load(settings.ARMED_SOUND_FILE)
     mix.music.play()
     while mix.music.get_busy():
         continue
     mix.quit()

    def __init__(self,value="C",secs=0.5,octave=4, sampleRate=44100, bits=16,
                 name='', autoLog=True, loops=0):
        """
        """
        self.name=name#only needed for autoLogging
        self.autoLog=autoLog
        #check initialisation
        if not mixer.get_init():
            pygame.mixer.init(sampleRate, -16, 2, 3072)

        inits = mixer.get_init()
        if inits is None:
            init()
            inits = mixer.get_init()
        self.sampleRate, self.format, self.isStereo = inits

        #try to create sound
        self._snd=None
        #distinguish the loops requested from loops actual because of infinite tones
        # (which have many loops but none requested)
        self.requestedLoops = self.loops = int(loops) #-1 for infinite or a number of loops
        self.setSound(value=value, secs=secs, octave=octave)

 def _check_quit(self):
     """Quit the mixer if not running a program and sound quiet for a while."""
     if self.next_tone != [None, None, None, None]:
         self.quiet_ticks = 0
     else:
         self.quiet_ticks += 1
         if not self._persist and self.quiet_ticks > self.quiet_quit:
             # mixer is quiet and we're not running a program.
             # quit to reduce pulseaudio cpu load
             # this takes quite a while and leads to missed frames...
             if mixer.get_init() is not None:
                 mixer.quit()
             self.quiet_ticks = 0

def check_quit():
    """ Quit the mixer if not running a program and sound quiet for a while. """
    global quiet_ticks
    if next_tone != [None, None, None, None]:
        quiet_ticks = 0
    else:
        quiet_ticks += 1
        if not persist and quiet_ticks > quiet_quit:
            # mixer is quiet and we're not running a program.
            # quit to reduce pulseaudio cpu load
            # this takes quite a while and leads to missed frames...
            if mixer.get_init() is not None:
                mixer.quit()
            quiet_ticks = 0

 def alt_1_pushed(self):
     if self.data[1]!='':
         if mixer.get_init()!=None:
             if self.mp3media[1]!=None:
                 mixer.music.load(self.mp3media[1])
                 mixer.music.set_volume(config.config['mp3_volume'] / 100.0)
                 mixer.music.play()
         config.config['mascot'] = self.data[1]
         self.setPixmaps()
         self.width = int(self.pixmaps[0].width() * config.config['picture_scale'])
         self.height = int(self.pixmaps[0].height() * config.config['picture_scale'])
         self.resize(self.width, self.height)
         self.label.setGeometry(QtCore.QRect(0, 0, self.width, self.height))
         config.write()

def init_sound(experiment):

	"""
	Initializes the pygame mixer before the experiment begins.

	Arguments:
	experiment -- An instance of libopensesame.experiment.experiment
	"""

	print "openexp.sampler._legacy.init_sound(): sampling freq = %d, buffer size = %d" \
		% (experiment.sound_freq, experiment.sound_buf_size)
	if hasattr(mixer, 'get_init') and mixer.get_init():
		print 'openexp.sampler._legacy.init_sound(): mixer already initialized, closing'
		pygame.mixer.quit()
	mixer.pre_init(experiment.sound_freq, experiment.sound_sample_size, \
		experiment.sound_channels, experiment.sound_buf_size)	
	mixer.init()