Stop video if tick is more than the end, only for last file.

        Parameters
        ----------
        tick : int
            time in ms from the beginning of the file

        useless?
509602
def stop_video(self, tick):
        
        if self.cnt_video == self.n_video:
            if tick >= self.end_diff:
                self.idx_button.setText('Start')
                self.video.stop()
1049332
def pause(self):
        
        if self._end_time is not None:
            # the stopwatch is already paused
            return
        self._end_time = datetime.datetime.now()
        self._elapsed_time += self._end_time - self._start_time
1323809
def first_interval_ending(self, end: datetime.datetime) \
            -> Optional[Interval]:
        
        for i in self.intervals:
            if i.end == end:
                return i
        return None
670942
def end_datetime(self) -> Optional[datetime.datetime]:
        
        if not self.intervals:
            return None
        return max([x.end for x in self.intervals])
511201
def stop_recording(self):
        """"""
        self._stop_recording.set()
        with self._source_lock:
            self._source.stop()
        self._recording = False
1228640
async def end(self):
        """"""
        try:
            await self.proc.wait()
        finally:
            # Cleanup temporary files.
            for temporary_file in self.temporary_files:
                temporary_file.close()
            self.temporary_files = []

        return self.proc.returncode
833382
def stop(self, message):
        
        self._stop = time.clock()
        VSGLogger.info("{0:<20} - Finished [{1}s]".format(message, self.pprint(self._stop - self._start)))
65360
def cleanup_video(self):
        '''
        
        '''
        if self.video_source_process is not None:
            self.video_source_process.terminate()
            logger.info('Terminated video process: %s',
                        self.video_source_process.pid)
            self.video_source_process = None
908651
function stop(id, formatted) {
  const elapsed = timers[id].elapsed + msDiff(process.hrtime(), timers[id].start);

  clear(id);
  return formatted ? format(elapsed) : elapsed;
}
623340
def stop_video_recording(self):
        

        self.runner.info_log("Stopping video recording...")

        self.execute_command("./stop_recording.sh")
        # self.runner.info_log("output: %s"%output)

        sleep(5)

        self.scp_file_remote_to_local(
            self.remote_video_recording_file_path,
            self.local_video_recording_file_path
        )
1335139
public void stop() {
		thread.requestStop = true;
		long start = System.currentTimeMillis()+timeout;
		while( start > System.currentTimeMillis() && thread.running )
			Thread.yield();

		device.stopDepth();
		device.stopVideo();
		device.close();
	}
426395
def stop(self):
        
        self._cmds_q.put(("stop",))
        for recorder in self._data_stream_recorders:
            recorder._stop()
        try:
            self._syncer.terminate()
        except Exception:
            pass
855550
def end(self):
        """"""
        if self._properties.get("endMs") is None:
            return None
        return _helpers._datetime_from_microseconds(
            int(self._properties.get("endMs")) * 1000.0
        )
1134188
def catch_end_signal(self, signum, frame):
        
        if self.end_signal_caught:
            self.log('Previous signal caught, will end soon')
            return

        signal_name = dict((getattr(signal, n), n) for n in dir(signal)
                        if n.startswith('SIG') and '_' not in n).get(signum, signum)

        if self.status == 'running':
            self.log('Catched %s signal: stopping after current job' % signal_name,
                     level='critical')
        else:
            delay = self.timeout if self.status == 'waiting' else self.fetch_priorities_delay
            self.log('Catched %s signal: stopping in max %d seconds' % (
                     signal_name, delay), level='critical')

        self.end_signal_caught = self.end_forced = True
715160
def end_output (self, **kwargs):
        
        self.xml_endtag(u"linkchecker")
        self.xml_end_output()
        self.close_fileoutput()
919098
def stop(self):
		

		logger.debug("Stopping playback")
		# Stop the clock
		self.clock.stop()
		# Set plauyer status to ready
		self.status = READY
1082367
@Deprecated
    public void stopWatching(File file) {
        if (file == null) {
            throw new IllegalArgumentException("Null file argument");
        }
        synchronized (mutex) {
            stopWatchingInternal(file.toPath());
        }
    }