class Ticker: def __init__(self, lookback, exchange, symbol, bid, ask, updated_at): self.exchange = exchange self.symbol = symbol self.bid = bid self.ask = ask self.updated_at = updated_at self.bid_lookback = RingBuffer(capacity=lookback, dtype=object) self.ask_lookback = RingBuffer(capacity=lookback, dtype=object) def get_bid(self): return self.bid def get_ask(self): return self.ask def get_time(self): return self.updated_at def update(self, data): self.bid = data['bid'] self.ask = data['ask'] self.updated_at = data['time'] self.bid_lookback.append(self.bid) self.ask_lookback.append(self.ask)
def __init__(self, name, limits, setpoints, duration, gait_generator=None): self.setpoints_history = RingBuffer(capacity=100, dtype=list) self.setpoints_redo_list = RingBuffer(capacity=100, dtype=list) self.gait_generator = gait_generator super(ModifiableJointTrajectory, self).__init__(name, limits, setpoints, duration) self.interpolated_setpoints = self.interpolate_setpoints()
def __init__(self, state_inputs, init_size=int(5e4), max_size=int(1e5), prioritized=False): self.init_size = init_size self.max_size = max_size self.prioritized = prioritized self.size = 0 self.state_inputs = state_inputs self.buffers = {} for elem in TRANSITION_ELEMS: if elem in ['s', 's_next']: self.buffers[elem] = {} for key in state_inputs.keys(): self.buffers[elem][key] = \ RingBuffer( capacity=max_size, dtype=(np.float32, state_inputs[key])) elif elem is 'a': self.buffers[elem] = \ RingBuffer( capacity=max_size, dtype=(np.float32, state_inputs['actions'])) else: self.buffers[elem] = \ RingBuffer( capacity=max_size, dtype=np.float32)
class CausalVelocityFilter(): """Calculates the derivative of data that's appended to the internal buffer and allows you to get a moving average of the derivative with window size defined by the init. """ def __init__(self, windowSize): """Initializes self. windowSize defines the width of the moving average buffer. Too narrow and it doesn't do much filtering, too wide and it lags behind the acutal derivative """ self._derivativeBuffer = RingBuffer(windowSize) self._previousDatum = 0.0 def get_datum(self): """Get the present rate of change of the incomimg data""" return np.mean(self._derivativeBuffer) def append(self, datum, timeElapsed): """Add a measurement and an elapsed time to the filter's internal buffer to be able to find the rate of change. """ self._derivativeBuffer.append( (datum - self._previousDatum) / timeElapsed) self._previousDatum = datum
def __init__(self, view, robot): self.view = view # Default values self.gait_directory = None self.playback_speed = 100 self.time_slider_thread = None self.current_time = 0 self.robot = robot empty_subgait_file = os.path.join( rospkg.RosPack().get_path('march_rqt_gait_generator'), 'resource/empty_gait/empty_subgait/empty_subgait.subgait') self.subgait = ModifiableSubgait.from_file(robot, empty_subgait_file, self) self.settings_changed_history = RingBuffer(capacity=100, dtype=list) self.settings_changed_redo_list = RingBuffer(capacity=100, dtype=list) standing = Subgait.from_file(robot, empty_subgait_file) previous_subgait_controller = SideSubgaitController( view=self.view.side_subgait_view['previous'], default=standing) next_subgait_controller = SideSubgaitController( view=self.view.side_subgait_view['next'], default=standing) self.side_subgait_controller = { 'previous': previous_subgait_controller, 'next': next_subgait_controller } self.connect_buttons() self.view.load_gait_into_ui(self.subgait) for joint in self.subgait.joints: self.connect_plot(joint)
def __init__(self, state_shape, n_actions, epsilon=None): self.capacity = 100000 self.state_memory = RingBuffer(capacity=self.capacity, dtype=(np.uint8, state_shape)) self.next_state_memory = RingBuffer(capacity=self.capacity, dtype=(np.uint8, state_shape)) self.action_memory = RingBuffer(capacity=self.capacity, dtype=np.uint8) self.reward_memory = RingBuffer(capacity=self.capacity, dtype=np.uint16) self.done_memory = RingBuffer(capacity=self.capacity, dtype=np.bool) self.n_actions = n_actions self.state_shape = state_shape self.gamma = 0.99 if epsilon is None: self.epsilon = 1.0 self.epsilon_decay = 0.9997 self.epsilon_min = 0.05 self.decay_epsilon = True else: self.epsilon = epsilon self.decay_epsilon = False self.q = None
def __init__( self, checkpoint: Path, threshold: float = 0.9, smoothing: int = 5, timeout: float = 1.0, ): self.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") self.model, self.config = model_from_checkpoint(checkpoint, device=self.device) self.model = self.model.eval().to(self.device) self.extractor = init_feature_extractor(self.config) self.threshold = threshold self.smoothing = smoothing self.timeout = timeout self.input_samples = self.config.fft_window_step * ( self.model.input_size - 1) self.preds_buffer = RingBuffer(self.smoothing, "float32") self.raw_input_buffer = RingBuffer(capacity=self.input_samples, dtype="float32") self.raw_input_buffer.extend( np.zeros(self.input_samples, dtype="float32")) self.cooldown_time = 0
def import_gait(self): file_name, f = self.view.open_file_dialogue() if file_name != '': gait = ModifiableSubgait.from_file(self.robot, file_name, self) else: gait = None if gait is None: rospy.logwarn('Could not load gait %s', file_name) return if gait.gait_type is None or gait.gait_type == '': gait.gait_type = 'walk_like' self.subgait = gait was_playing = self.time_slider_thread is not None self.stop_time_slider_thread() self.view.load_gait_into_ui(self.subgait) for joint in self.subgait.joints: self.connect_plot(joint) self.current_time = 0 if was_playing: self.start_time_slider_thread() self.gait_directory = '/'.join(file_name.split('/')[:-3]) rospy.loginfo('Setting gait directory to %s', str(self.gait_directory)) self.view.change_gait_directory_button.setText(self.gait_directory) # Clear undo and redo history self.settings_changed_history = RingBuffer(capacity=100, dtype=list) self.settings_changed_redo_list = RingBuffer(capacity=100, dtype=list)
class RingbufferMonitor(Monitor): def __init__(self, capacity=100, key='training_loss', name='ringbuffer_monitor'): super().__init__(name=name) self.capacity = capacity self.key = key self.value_buffer = None self.step_buffer = RingBuffer(capacity=capacity, dtype='float32') self.previous_session_steps = 0 self.last_step = 0 def start_session(self, num_steps, **kwargs): self.previous_session_steps += self.last_step def write(self, data, step, **kwargs): if self.key in data.keys(): value = data[self.key] if isinstance(value, Tensor): dtype = value.data.cpu().numpy().dtype value = self._to_scalar(value) else: dtype = np.array(value).dtype if self.value_buffer is None: self.value_buffer = RingBuffer(capacity=self.capacity, dtype=dtype) self.value_buffer.append(value) self.step_buffer.append(step + self.previous_session_steps) self.last_step = math.ceil(step) def mean(self, *args, **kwargs): return np.array(self.value_buffer).mean(*args, **kwargs) def std(self, *args, **kwargs): return np.array(self.value_buffer).std(*args, **kwargs) @property def movement_index(self): steps = self.step_buffer if len(steps) < self.capacity: # not enough information gathered yet to say... return None else: step_difference = (steps[-1] - steps[0]) midpoint = np.argmax(steps >= steps[0] + (step_difference // 2)) values = np.array(self.value_buffer) first = values[:midpoint] last = values[midpoint:] d = (np.abs(first.mean() - last.mean()) / (2 * np.sqrt(first.std() * last.std()))) return d
def __init__(self, latent_size, stddv_p, stddv, hot_start, N, batch_size, accuracy_bloomf=0.01, static=False): self.i = 0 self.I = 0 self.BI = 1 #self.guessed_z = [] self.DYNAMIC = False self.hot_start = hot_start self.latent_size = latent_size self.stddv_p = stddv_p self.stddv = stddv self.LOG = False self.STATIC = static self.init_att_size = 0 self.N = N self.batch_size = batch_size self.accuracy_bloomf = accuracy_bloomf self.matched_i = 0 self.P = [] if not self.STATIC: self.guessed_z = RingBuffer(capacity=self.memory_bank_size, dtype=(np.float32, self.latent_size))
class SensirionSBPlot(QWidget): def __init__(self, plot_title, color, bufferSize): super().__init__() masterLayout = QVBoxLayout() self.pen = mkPen(color, width=1.25) layout = QVBoxLayout() self.group = QGroupBox(plot_title) self.plot = PlotWidget() self.plot.getPlotItem().showGrid(x=True, y=True, alpha=1) if "qdarkstyle" in sys.modules: self.plot.setBackground((25, 35, 45)) self.buffer = RingBuffer(capacity=bufferSize, dtype=float) self.group.setLayout(layout) layout.addWidget(self.plot) masterLayout.addWidget(self.group) self.setLayout(masterLayout) def change_capacity(self, value): if value > len(self.buffer): newBuf = RingBuffer(capacity=value, dtype=float) newBuf.extend(self.buffer) self.buffer = newBuf elif value < len(self.buffer): newBuf = RingBuffer(capacity=value, dtype=float) newBuf.extend(self.buffer[:-value]) self.buffer = newBuf def update_plot(self, sample): self.plot.clear() self.buffer.append(sample) self.plot.plot(self.buffer, pen=self.pen, symbolPen=self.pen, symbol='o', symbolSize=5, name="symbol ='o'")
def init_buf(): '''Initialize buffer''' buf = RingBuffer(p.winsamp, dtype=np.int16) eps = np.finfo(float).eps for _ in range(p.winsamp): buf.append(eps) return buf
def main(): window = RingBuffer(capacity=100, dtype=(float, 4)) with open("log.json", "r") as data_file: for line in data_file: data = ujson.loads(line) if data['data']['cpu']['percent'] < 50: window.append( [data['data']['cpu']['percent'], data['ts'], 0, 0]) print(np.mean(window, 0)[0])
def __init__(self, current_time): self._flow_rate_sample_times = RingBuffer(2) self._flow_rate_sample_times.append(current_time) self._tidal_volume_filter = TidalVolume(current_time) self._peep_filter = PEEP(0.1) self._pip_filter = PIP(0.1) self._most_recent_pressure = 0.0 self._most_recent_flow_rate = 0.0
def __init__(self, windowSize): """Initializes self. windowSize defines the width of the moving average buffer. Too narrow and it doesn't do much filtering, too wide and it lags behind the acutal derivative """ self._derivativeBuffer = RingBuffer(windowSize) self._previousDatum = 0.0
def test_negative_indices_give_recent_data_with_unfull_buffer(self): r = RingBuffer(10) for i in range(5): r.append(i) for i in reversed(range(-len(r), 0)): self.assertAlmostEqual(r[i], r[i + 5], msg="Fails to index from the back of " "the filled portion of the buffer " "given a negative index.")
def __init__(self, lookback, exchange, symbol, bid, ask, updated_at): self.exchange = exchange self.symbol = symbol self.bid = bid self.ask = ask self.updated_at = updated_at self.bid_lookback = RingBuffer(capacity=lookback, dtype=object) self.ask_lookback = RingBuffer(capacity=lookback, dtype=object)
def test_sizes(self): r = RingBuffer(5, dtype=(int, 2)) self.assertEqual(r.maxlen, 5) self.assertEqual(len(r), 0) self.assertEqual(r.shape, (0, 2)) r.append([0, 0]) self.assertEqual(r.maxlen, 5) self.assertEqual(len(r), 1) self.assertEqual(r.shape, (1, 2))
def __init__(self, capacity=100, key='training_loss', name='ringbuffer_monitor'): super().__init__(name=name) self.capacity = capacity self.key = key self.value_buffer = None self.step_buffer = RingBuffer(capacity=capacity, dtype='float32') self.previous_session_steps = 0 self.last_step = 0
def __init__(self, port_name = 'COM6', baud_rate = 9600, stack_size = 100, num_data_bytes = 2, data_types = [], data_length = []): self.port = port_name self.baud = baud_rate self.stack_size = stack_size self.num_data_bytes = num_data_bytes self.data_types = data_types self.data_length = data_length # self.numData = numData # TO ERASE! self.rawdata_bytes = bytearray(num_data_bytes) # give an array for each type of data and store them in a ring buffer of size len(self.data_types) self.data = RingBuffer(capacity = stack_size, dtype=(float, (len(self.data_types),))) self.data_to_append = np.zeros( shape=(len(self.data_types),) ) self.is_run = True self.is_receiving = False self.thread = None self.plot_timer = 0 self.previous_timer = 0 # self.csvData = [] # define binning for polar heatmap self.min_sensor_distance = 20 self.max_sensor_distance = 200 self.radius_bins_heatmap = np.linspace(self.min_sensor_distance,self.max_sensor_distance, 16) self.angle_bins_heatmap = np.linspace(-0.1,2*np.pi-0.1, 40) ### MIDI Settings ### self.mido_outports = mido.get_output_names() print("Trying to connect to MIDI port:", self.mido_outports[1]) try: self.midi_outport = mido.open_output(self.mido_outports[1]) print("Connected to MIDI port:", self.mido_outports[1]) except IOError: print("Error connecting to MIDI port:", self.mido_outports[1]) sys.exit(1) #[F2,G#2, C3, C#3, D#3, F3] C# Major scale # self.notes = [41, 44, 48, 49, 51, 53, 58, 60] # self.note_status = [False]*len(self.notes) #[F#2,G#2, C3, C#3, D#3, F3, G#3, A#4] self.notes = [42, 44, 48, 49, 51, 53, 58, 60] self.note_status = [False]*len(self.notes) print('\nTrying to connect to: ' + str(port_name) + ' at ' + str(baud_rate) + ' BAUD.') try: self.serial_connection = serial.Serial(port_name, baud_rate, timeout=4) print('Connected to ' + str(port_name) + ' at ' + str(baud_rate) + ' BAUD.\n') except: print("Failed to connect with " + str(port_name) + ' at ' + str(baud_rate) + ' BAUD.') sys.exit(1)
class AudioStream(object): def __init__(self,rate=8192,T=4): # stream constants self.RATE = rate self.CHUNK = int(self.RATE/100) # 40 times per second #self.FORMAT = pyaudio.paFloat32 self.CHANNELS = 1 self.pause = False self.T =T # self.init_buff() # stream object # self.p = pyaudio.PyAudio() self.stream = sd.InputStream(channels=1, samplerate=rate, callback=self.fill_buffer, blocksize=self.CHUNK) self.stream.start() #self.stream = self.p.open( # format=pyaudio.paInt16, # channels=1, rate=self.RATE, # input=True, frames_per_buffer=self.CHUNK, # Run the audio stream asynchronously to fill the buffer object. # This is necessary so that the input device's buffer doesn't # overflow while the calling thread makes network requests, etc. # stream_callback=self.fill_buffer, # ) def init_buff(self): # at first I wanted to extend the data previously recorded, but obviously they were recorded at a different sampling rate. We therefore have to start anew self.buffsize =int(self.RATE*self.T) #self.buff = deque(maxlen=self.buffsize) self.buff = RingBuffer(capacity=self.buffsize)#,dtype=np.int16) self.fftwindow = hann(self.buffsize) def fill_buffer(self, in_data, frame_count, time_info, status_flags): """Continuously collect data from the audio stream, into the buffer.""" #d_converted = np.fromstring(in_data, 'int16') #print(d_converted) #print(in_data) self.buff.extend(in_data[:,0]) #self.buff.extend(in_data[1::2]) #return None, pyaudio.paContinue def calc_fft(self): data = np.array(self.buff) if data.shape[0]!= self.buffsize: print('loading samples %i%%'%(data.shape[0]/self.buffsize*100)) return(None) data = np.multiply(data,self.fftwindow) yf = fft(data) yf = yf[1:int(yf.shape[0]/2)] fftdata = np.abs(yf) return(fftdata)
def do_set_caps(self, icaps, ocaps): in_info = GstAudio.AudioInfo() in_info.from_caps(icaps) out_info = GstVideo.VideoInfo() out_info.from_caps(ocaps) self.convert_info = GstAudio.AudioInfo() self.convert_info.set_format(GstAudio.AudioFormat.S32, in_info.rate, in_info.channels, in_info.position) self.converter = GstAudio.AudioConverter.new(GstAudio.AudioConverterFlags.NONE, in_info, self.convert_info, None) self.fig = plt.figure() dpi = self.fig.get_dpi() self.fig.patch.set_alpha(0.3) self.fig.set_size_inches(out_info.width / float(dpi), out_info.height / float(dpi)) self.ax = plt.Axes(self.fig, [0., 0., 1., 1.]) self.fig.add_axes(self.ax) self.ax.set_axis_off() self.ax.set_ylim((GLib.MININT, GLib.MAXINT)) self.agg = self.fig.canvas.switch_backends(FigureCanvasAgg) self.h = None samplesperwindow = int(in_info.rate * in_info.channels * self.window_duration) self.thinning_factor = max(int(samplesperwindow / out_info.width - 1), 1) cap = int(samplesperwindow / self.thinning_factor) self.ax.set_xlim([0, cap]) self.ringbuffer = RingBuffer(capacity=cap) self.ringbuffer.extend([0.0] * cap) self.frame_duration = Gst.util_uint64_scale_int(Gst.SECOND, out_info.fps_d, out_info.fps_n) self.next_time = self.frame_duration self.agg.draw() self.background = self.fig.canvas.copy_from_bbox(self.ax.bbox) self.samplesperbuffer = Gst.util_uint64_scale_int(in_info.rate * in_info.channels, out_info.fps_d, out_info.fps_n) self.next_offset = self.samplesperbuffer self.cur_offset = 0 self.buf_offset = 0 return True
def find_convergence_episode(rewards_list, buffer_size=3): import numpy as np from numpy_ringbuffer import RingBuffer convergence_buffer = RingBuffer(capacity=buffer_size) res = -1 for index, reward_value in enumerate(rewards_list): convergence_buffer.append(reward_value) if (len(np.unique(convergence_buffer)) == 1 and len(convergence_buffer) == 3): res = index - 1 return res return res
def __init__(self): super().__init__() capacity = 256 self.buffer1 = RingBuffer(capacity=capacity, dtype=np.float32) self.buffer2 = RingBuffer(capacity=capacity, dtype=np.float32) self.buffer3 = RingBuffer(capacity=capacity, dtype=np.float32) self.buffer4 = RingBuffer(capacity=capacity, dtype=np.float32) self.plot = PlotWidget() self.plot.getPlotItem().showGrid(x=True, y=True, alpha=1) self.plot.addLegend() if "qdarkstyle" in sys.modules: self.plot.setBackground((25, 35, 45)) self.bufferSizeEdit = QLineEdit() self.bufferSizeEdit.setText(str(capacity)) self.bufferSizeEdit.setValidator(QRegExpValidator(QRegExp("[0-9]*"))) self.bufferSizeEdit.editingFinished.connect(self.change_capacity) self.layout = QVBoxLayout() group = QGroupBox("Combined controller plot") layout = QVBoxLayout() layout.addWidget(self.plot) innerLayout = QHBoxLayout() innerLayout.addWidget(QLabel("Buffer size")) innerLayout.addWidget(self.bufferSizeEdit) layout.addLayout(innerLayout) group.setLayout(layout) self.layout.addWidget(group) self.setLayout(self.layout)
def __init__(self, default, view, lock_checked=False, default_checked=False, subgait=None): self._lock_checked = lock_checked self._default_checked = default_checked self._subgait = subgait self._default = default self.view = view self.settings_history = RingBuffer(capacity=100, dtype=list) self.settings_redo_list = RingBuffer(capacity=100, dtype=list)
def __init__(self, worker_id, hparams, processing_queue): self.id = worker_id self.hparams = hparams self.processing_queue = processing_queue self.inbox_queue = mp.Queue() self.experience_queue = mp.Queue() self.global_obs = dict() self.state = RingBuffer(capacity=self.hparams['state_dim'], dtype=np.float32) self.process = mp.Process( target=self.run )
def __init__(self): self.img = None self.number = 0 self.prev_guesses = RingBuffer(capacity=5, dtype=(float, (10))) self.fontsize = 0 self.block_pos = (0, 0) self.physical_pos = (0, 0) self.n = 0 # Guesses the number every self.maxtimer frames (10), to not overuse resources self.maxtimer = 10 self.timer = self.maxtimer - 1
class CausalIntegralFilter(): def __init__(self, initial_value, initial_time): self._y = initial_value self._t_buffer = RingBuffer(2) self._t_buffer.append(initial_time) def append_integral_value(self, y): self._y = y def append(self, dydt, t): self._t_buffer.append(t) self._y += dydt * (self._t_buffer[-1] - self._t_buffer[-2]) def get_datum(self): return self._y
def __init__(self, channel_len, window_class, window_overlap, sampling_freq, ring_lock): global ring_data threading.Thread.__init__(self) Saving.__init__(self) self.clf = None self.window_class = window_class # seconds self.window_overlap = window_overlap # seconds self.sampling_freq = sampling_freq self.counter = -1 self.ring_lock = ring_lock self.flag_channel_same_len = False self.__ring_channel_len = len(ring_data) self.__channel_len = channel_len self.data_raw = [ RingBuffer(capacity=int(self.window_class * self.sampling_freq), dtype=np.float64) for __ in range(self.__ring_channel_len) ] self.channel_decode = [] self.prediction = [] # self.prediction = [[] for __ in range(self.__channel_len)] Display.__init__(self, self.__channel_len)
def __init__(self, name, MIN_PITCH, MAX_PITCH, rescale_range, smoothing=50): self.name = name self.MIN_PITCH = MIN_PITCH self.MAX_PITCH = MAX_PITCH self.min_pitch_range = float('inf') self.max_pitch_range = float('-inf') self.rescale_range = rescale_range self.img = np.zeros((512, 512, 3), np.uint8) self.smooth_buffer = RingBuffer(capacity=smoothing, dtype=np.int) self.all_pitches = [] self.full_signal = []
class AudioPlotFilter(GstBase.BaseTransform): __gstmetadata__ = ('AudioPlotFilter','Filter', \ 'Plot audio waveforms', 'Mathieu Duponchelle') __gsttemplates__ = (Gst.PadTemplate.new("src", Gst.PadDirection.SRC, Gst.PadPresence.ALWAYS, OCAPS), Gst.PadTemplate.new("sink", Gst.PadDirection.SINK, Gst.PadPresence.ALWAYS, ICAPS)) __gproperties__ = { "window-duration": (float, "Window Duration", "Duration of the sliding window, in seconds", 0.01, 100.0, DEFAULT_WINDOW_DURATION, GObject.ParamFlags.READWRITE ) } def __init__(self): GstBase.BaseTransform.__init__(self) self.window_duration = DEFAULT_WINDOW_DURATION def do_get_property(self, prop): if prop.name == 'window-duration': return self.window_duration else: raise AttributeError('unknown property %s' % prop.name) def do_set_property(self, prop, value): if prop.name == 'window-duration': self.window_duration = value else: raise AttributeError('unknown property %s' % prop.name) def do_transform(self, inbuf, outbuf): if not self.h: self.h, = self.ax.plot(np.array(self.ringbuffer), lw=0.5, color='k', path_effects=[pe.Stroke(linewidth=1.0, foreground='g'), pe.Normal()]) else: self.h.set_ydata(np.array(self.ringbuffer)) self.fig.canvas.restore_region(self.background) self.ax.draw_artist(self.h) self.fig.canvas.blit(self.ax.bbox) s = self.agg.tostring_argb() outbuf.fill(0, s) outbuf.pts = self.next_time outbuf.duration = self.frame_duration self.next_time += self.frame_duration return Gst.FlowReturn.OK def __append(self, data): arr = np.array(data) end = self.thinning_factor * int(len(arr) / self.thinning_factor) arr = np.mean(arr[:end].reshape(-1, self.thinning_factor), 1) self.ringbuffer.extend(arr) def do_generate_output(self): inbuf = self.queued_buf _, info = inbuf.map(Gst.MapFlags.READ) res, data = self.converter.convert(GstAudio.AudioConverterFlags.NONE, info.data) data = memoryview(data).cast('i') nsamples = len(data) - self.buf_offset if nsamples == 0: self.buf_offset = 0 inbuf.unmap(info) return Gst.FlowReturn.OK, None if self.cur_offset + nsamples < self.next_offset: self.__append(data[self.buf_offset:]) self.buf_offset = 0 self.cur_offset += nsamples inbuf.unmap(info) return Gst.FlowReturn.OK, None consumed = self.next_offset - self.cur_offset self.__append(data[self.buf_offset:self.buf_offset + consumed]) inbuf.unmap(info) _, outbuf = GstBase.BaseTransform.do_prepare_output_buffer(self, inbuf) ret = self.do_transform(inbuf, outbuf) self.next_offset += self.samplesperbuffer self.cur_offset += consumed self.buf_offset += consumed return ret, outbuf def do_transform_caps(self, direction, caps, filter_): if direction == Gst.PadDirection.SRC: res = ICAPS else: res = OCAPS if filter_: res = res.intersect(filter_) return res def do_fixate_caps(self, direction, caps, othercaps): if direction == Gst.PadDirection.SRC: return othercaps.fixate() else: so = othercaps.get_structure(0).copy() so.fixate_field_nearest_fraction("framerate", DEFAULT_FRAMERATE_NUM, DEFAULT_FRAMERATE_DENOM) so.fixate_field_nearest_int("width", DEFAULT_WIDTH) so.fixate_field_nearest_int("height", DEFAULT_HEIGHT) ret = Gst.Caps.new_empty() ret.append_structure(so) return ret.fixate() def do_set_caps(self, icaps, ocaps): in_info = GstAudio.AudioInfo() in_info.from_caps(icaps) out_info = GstVideo.VideoInfo() out_info.from_caps(ocaps) self.convert_info = GstAudio.AudioInfo() self.convert_info.set_format(GstAudio.AudioFormat.S32, in_info.rate, in_info.channels, in_info.position) self.converter = GstAudio.AudioConverter.new(GstAudio.AudioConverterFlags.NONE, in_info, self.convert_info, None) self.fig = plt.figure() dpi = self.fig.get_dpi() self.fig.patch.set_alpha(0.3) self.fig.set_size_inches(out_info.width / float(dpi), out_info.height / float(dpi)) self.ax = plt.Axes(self.fig, [0., 0., 1., 1.]) self.fig.add_axes(self.ax) self.ax.set_axis_off() self.ax.set_ylim((GLib.MININT, GLib.MAXINT)) self.agg = self.fig.canvas.switch_backends(FigureCanvasAgg) self.h = None samplesperwindow = int(in_info.rate * in_info.channels * self.window_duration) self.thinning_factor = max(int(samplesperwindow / out_info.width - 1), 1) cap = int(samplesperwindow / self.thinning_factor) self.ax.set_xlim([0, cap]) self.ringbuffer = RingBuffer(capacity=cap) self.ringbuffer.extend([0.0] * cap) self.frame_duration = Gst.util_uint64_scale_int(Gst.SECOND, out_info.fps_d, out_info.fps_n) self.next_time = self.frame_duration self.agg.draw() self.background = self.fig.canvas.copy_from_bbox(self.ax.bbox) self.samplesperbuffer = Gst.util_uint64_scale_int(in_info.rate * in_info.channels, out_info.fps_d, out_info.fps_n) self.next_offset = self.samplesperbuffer self.cur_offset = 0 self.buf_offset = 0 return True