Pause all the sounds in the pool.
765697
function () {
    var i;
    var sound;

    this.isPlaying = false;
    for (i = 0; i < this.pool.children.length; i++) {
      sound = this.pool.children[i];
      if (!sound.source || !sound.source.buffer || !sound.isPlaying || sound.isPaused) {
        continue;
      }
      sound.isPaused = true;
      sound.pause();
    }
  }
239571
def pause(self):
        """"""
        yield from self.manager.query("POST", "containers/{}/pause".format(self._cid))
        self.status = "suspended"
        log.info("Docker container '{name}' [{image}] paused".format(name=self._name, image=self._image))
680603
def pause(self):
		
		if self.decoder.status == mediadecoder.PAUSED:
			self.decoder.pause()
			self.paused = False
		elif self.decoder.status == mediadecoder.PLAYING:
			self.decoder.pause()
			self.paused = True
		else:
			print("Player not in pausable state")
499187
public synchronized final void pause() {
        if (isStop) return ;

        isPause = true;
        mPauseTimeInFuture = mStopTimeInFuture - SystemClock.elapsedRealtime();
        mHandler.removeMessages(MSG);
    }
750515
function() {
			var t = this;
			
			setTimeout(function() {
				t.$obj.removeClass(t.factory.classes.play);
			}, this.factory.timer.interval);
		}
253544
def terminate_pool(self):
        """"""

        if self.pool is not None:
            self.pool.terminate()
            self.pool.join()
            del(self.pool)
            self.pool = None
1146642
def close(self, suppress_logging=False):
        
        pool_names = list(self.pools)
        for name in pool_names:
            self._close(name, suppress_logging)
1130113
@Override
  public void stop() {
    LOGGER.debug("Shutting down PooledExecutionService");
    running = false;
    scheduledExecutor.shutdownNow();
    for (Iterator<Entry<String, ThreadPoolExecutor>> it = pools.entrySet().iterator(); it.hasNext(); ) {
      Entry<String, ThreadPoolExecutor> e = it.next();
      try {
        destroyPool(e.getKey(), e.getValue());
      } finally {
        it.remove();
      }
    }
    try {
      while(!scheduledExecutor.awaitTermination(30, SECONDS)) {
        LOGGER.warn("Timeout while waiting on scheduler to finish, keep waiting");
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
1032925
public void pause ()
    {
        if (_state != AL10.AL_PLAYING) {
            log.warning("Tried to pause stream that wasn't playing.");
            return;
        }
        _source.pause();
        _state = AL10.AL_PAUSED;
    }
1186088
def toggle_play_pause(self):
        """"""
        # Use Play/Pause button only for sources which support NETAUDIO
        if (self._state == STATE_PLAYING and
                self._input_func in self._netaudio_func_list):
            return self._pause()
        elif self._input_func in self._netaudio_func_list:
            return self._play()
131598
function(audio) {
      var self = this || Howler;

      // Don't add audio to the pool if we don't know if it has been unlocked.
      if (audio._unlocked) {
        self._html5AudioPool.push(audio);
      }

      return self;
    }
214339
def stop_all(self):
        """"""
        if self.aotask is not None:
            self.aotask.stop()
        self.aitask.stop()
        self.daq_lock.release()
        self.aitask = None
        self.aotask = None
503171
def pause(self):
        """"""
        res = librtmp.RTMP_Pause(self.client.rtmp, 1)

        if res < 1:
            raise RTMPError("Failed to pause")
959594
function() {
         var self = this;

         // Stop playing any active sounds.
         var sounds = self._sounds;
         for (var i=0; i<sounds.length; i++) {
           // Stop the sound if it is currently playing.
           if (!sounds[i]._paused) {
             self.stop(sounds[i]._id);
           }

           // Remove the source or disconnect.
           if (!self._webAudio) {
             // Set the source to 0-second silence to stop any downloading (except in IE).
             var checkIE = /MSIE |Trident\//.test(Howler._navigator && Howler._navigator.userAgent);
             if (!checkIE) {
               sounds[i]._node.src = 'data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA';
             }

             // Remove any event listeners.
             sounds[i]._node.removeEventListener('error', sounds[i]._errorFn, false);
             sounds[i]._node.removeEventListener(Howler._canPlayEvent, sounds[i]._loadFn, false);

             // Release the Audio object back to the pool.
             Howler._releaseHtml5Audio(sounds[i]._node);
           }

           // Empty out all of the nodes.
           delete sounds[i]._node;

           // Make sure all timers are cleared out.
           self._clearTimer(sounds[i]._id);
         }

         // Remove the references in the global Howler object.
         var index = Howler._howls.indexOf(self);
         if (index >= 0) {
           Howler._howls.splice(index, 1);
         }

         // Delete this sound from the cache (if no other Howl is using it).
         var remCache = true;
         for (i=0; i<Howler._howls.length; i++) {
           if (Howler._howls[i]._src === self._src || self._src.indexOf(Howler._howls[i]._src) >= 0) {
             remCache = false;
             break;
           }
         }

         if (cache && remCache) {
           delete cache[self._src];
         }

         // Clear global errors.
         Howler.noAudio = false;

         // Clear out `self`.
         self._state = 'unloaded';
         self._sounds = [];
         self = null;

         return null;
       }
748784
def resume(self):
        """"""
        with self.condition:
            self.paused = False
            self.condition.notify_all()
1312152
function (processSound) {
    var found;
    var i;
    var sound;

    if (!this.loaded) {
      warn('Sound not loaded yet. It will be played once it finished loading');
      this.mustPlay = true;
      return;
    }

    found = false;
    this.isPlaying = true;
    for (i = 0; i < this.pool.children.length; i++) {
      sound = this.pool.children[i];
      if (!sound.isPlaying && sound.buffer && !found) {
        if (processSound) { processSound(sound); }
        sound.play();
        sound.isPaused = false;
        found = true;
        continue;
      }
    }

    if (!found) {
      warn('All the sounds are playing. If you need to play more sounds simultaneously ' +
           'consider increasing the size of pool with the `poolSize` attribute.', this.el);
      return;
    }

    this.mustPlay = false;
  }
640297
def stop_event_stream(self):
        
        if self._stream:
            self._stream.stop()
            self._stream.join()
            self._stream = None
            with self._events.mutex:
                self._events.queue.clear()