Stop recording from the audio source.
511201
def stop_recording(self):
        """"""
        self._stop_recording.set()
        with self._source_lock:
            self._source.stop()
        self._recording = False
1278971
public void stopListenting() {
        if (channel != null) {
            log.info("closing server channel");
            channel.close().syncUninterruptibly();
            channel = null;
        }
    }
834591
function stopAudioCapture() {

        // Disconnect media source node from script processor
        if (source)
            source.disconnect();

        // Disconnect associated script processor node
        if (processor)
            processor.disconnect();

        // Stop capture
        if (mediaStream) {
            var tracks = mediaStream.getTracks();
            for (var i = 0; i < tracks.length; i++)
                tracks[i].stop();
        }

        // Remove references to now-unneeded components
        processor = null;
        source = null;
        mediaStream = null;

        // End stream
        writer.sendEnd();

    }
341943
def stop(self):
        
        if self.socket is not None:
            self.socket.close()
            self.socket = None
            self.data = None
1157829
def stop(self):
        
        # Check that everything is running
        if not self._running:
            logging.warning('PhoXi not running. Aborting stop')
            return False

        # Stop the subscribers
        self._color_im_sub.unregister()
        self._depth_im_sub.unregister()
        self._normal_map_sub.unregister()

        # Disconnect from the camera
        rospy.ServiceProxy('phoxi_camera/disconnect_camera', Empty)()

        self._running = False

        return True
882262
def stop(self):
        """"""
        self.state = False
        with display_manager(self.display) as d:
            d.record_disable_context(self.ctx)
            d.ungrab_keyboard(X.CurrentTime)
        with display_manager(self.display2):
            d.record_disable_context(self.ctx)
            d.ungrab_keyboard(X.CurrentTime)
619264
def stop(self):
        
        self.debug("()")
        try:
            self.unjoin()
            time.sleep(2)
        except:
            self.exception("Failed to leave audience")
        super(SensorClient, self).stop()
45339
def stop_playback(self):
        """"""
        self._sink.flush()
        self._sink.stop()
        self._playing = False
566620
public void stop()
    {
        if (mCamera != null)
        {
            mCamera.startPreview();
            mCamera.release();
            mCamera = null;
            mTryOpenCamera = false;
            onStop();
        }
    }
983982
def stop(self):
        """"""
        if self.thread:
            self.running = False
            if isinstance(self.stream, ReadWriteStream):
                self.stream.write(b'\0' * self.chunk_size)
            self.thread.join()
            self.thread = None

        self.engine.stop()

        if self.pa:
            self.pa.terminate()
            self.stream.stop_stream()
            self.stream = self.pa = None
678895
public void stopListening()
    {
        if (isIsolated()) {
            this.loggerManager.popLogListener();
        } else {
            this.observationManager.removeListener(this.logListener.getName());
        }
        this.observationManager.removeListener(this.progress.getName());

        // Make sure the progress is closed
        this.progress.getRootStep().finish();
    }
442912
def stop_listening(cls, event, func):
        """"""
        signal(event).disconnect(func, sender=cls)
954533
def stop(self):
        '''
        
        '''
        assert(self.model)
        assert(self.user_interface)
        assert(self.target)
        self.user_interface.stop()
        self.target.teardown()
        self.dataman.submit_task(None)
        self._un_set_signal_handler()
474775
public void stopRecording() {
        IRecordingListener listener = null;
        if (recordingListener != null && (listener = recordingListener.get()).isRecording()) {
            sendRecordStopNotify();
            notifyRecordingStop();
            // remove the listener
            removeStreamListener(listener);
            // stop the recording listener
            listener.stop();
            // clear and null-out the thread local
            recordingListener.clear();
            recordingListener = null;
        }
    }
1196694
public void stopRecording(){
        if (currentAudioState.get()== PAUSED_STATE || currentAudioState.get()==RECORDING_STATE){
            currentAudioState.getAndSet(STOPPED_STATE);
            onTimeCompletedTimer.cancel();
            onTimeCompletedTimer=null;
            onTimeCompletionTimerTask=null;
        }
        else{
            Log.w(TAG,"Audio recording is not in a paused or recording state.");
        }
        currentAudioRecordingThread=null;//The existing thread will die out on its own, but not before attempting to convert the file into WAV format.
    }
948176
function () {
      this.idle();

      delete this.recording;

      this.recording = new Recording({
        timeBetweenLoops:       this.options.timeBetweenLoops,
        loop:                   this.options.loop,
        requestProtocolVersion: this.controller.connection.opts.requestProtocolVersion,
        serviceVersion:         this.controller.connection.protocol.serviceVersion
      });

      this.controller.emit('playback.stop', this);
    }
1099828
def stop_recording(self):
        
        if not self._recording:
            raise Exception("Cannot stop a video recording when it's not recording!")
        self._cmd_q.put(('stop',))
        self._recording = False