def on_audio(audio_data):
if is_listening:
# TODO identify audio segments and batch up the data into a new AudioData message
# publish the new message using the publisher
size = len(audio_data.data)
buffer = gst.buffer_new_and_alloc(size)
buffer[0:size] = audio_data.data
src.emit("push-buffer", buffer)
def push_gap(self, src, gap_duration_s):
gap_start = self.next_output_timestamp / gst.SECOND
gap_duration = gap_duration_s * gst.SECOND
gap_samples = gap_duration_s * self.rate
gap_end = gap_start + self.waitTime
# FIXME
# For a real gap buffer, you would want zero samples. (I think.)
#gap_samples = 0
gap_vals = np.zeros(gap_samples)
gap_vals = gap_vals.astype(np.float32)
buffer_len = gap_vals.nbytes
buf = gst.buffer_new_and_alloc(buffer_len)
buf[:buffer_len - 1] = np.getbuffer(gap_vals)
# Again, for a real gap buffer, you'd want to set this flag.
#buf.flag_set(gst.BUFFER_FLAG_GAP)
buf.timestamp = self.next_output_timestamp
buf.duration = gap_duration
buf.offset = self.current_offset
buf.offset_end = self.current_offset + gap_samples
src.emit("push-buffer", buf)
src.info("gst clock = %d" % int(src.get_clock().get_time()))
src.info("No files! Pushed gap with start=%d, duration=%d latency=%d" %
(buf.timestamp / gst.SECOND, gap_duration / gst.SECOND,
(gpstime.GpsSecondsFromPyUTC(time.time()) - gap_end)))
if self.logger:
outDict = {}
outDict['type'] = 'buffer'
outDict['time'] = datetime.datetime.now().isoformat()
outDict['is_gap'] = True
outDict['gpsstart'] = buf.timestamp / gst.SECOND
outDict['duration'] = gap_duration / gst.SECOND
outDict['latency'] = gpstime.GpsSecondsFromPyUTC(
time.time()) - gap_end
self.logger.info(json.dumps(outDict))
self.next_output_timestamp += buf.duration
self.current_offset = buf.offset_end
return
def push_gap(self, src, gap_duration_s):
gap_start = self.next_output_timestamp / gst.SECOND
gap_duration = gap_duration_s * gst.SECOND
gap_samples = gap_duration_s * self.rate
gap_end = gap_start + self.waitTime
# FIXME
# For a real gap buffer, you would want zero samples. (I think.)
#gap_samples = 0
gap_vals = np.zeros(gap_samples)
gap_vals = gap_vals.astype(np.float32)
buffer_len = gap_vals.nbytes
buf = gst.buffer_new_and_alloc(buffer_len)
buf[:buffer_len-1] = np.getbuffer(gap_vals)
# Again, for a real gap buffer, you'd want to set this flag.
#buf.flag_set(gst.BUFFER_FLAG_GAP)
buf.timestamp = self.next_output_timestamp
buf.duration = gap_duration
buf.offset = self.current_offset
buf.offset_end = self.current_offset + gap_samples
src.emit("push-buffer", buf)
src.info("gst clock = %d" % int(src.get_clock().get_time()))
src.info("No files! Pushed gap with start=%d, duration=%d latency=%d" %
(buf.timestamp/gst.SECOND,gap_duration/gst.SECOND,(gpstime.GpsSecondsFromPyUTC(time.time()) - gap_end)))
if self.logger:
outDict = {}
outDict['type'] = 'buffer'
outDict['time'] = datetime.datetime.now().isoformat()
outDict['is_gap'] = True
outDict['gpsstart'] = buf.timestamp/gst.SECOND
outDict['duration'] = gap_duration/gst.SECOND
outDict['latency'] = gpstime.GpsSecondsFromPyUTC(time.time()) - gap_end
self.logger.info(json.dumps(outDict))
self.next_output_timestamp += buf.duration
self.current_offset = buf.offset_end
return
def need_data(self, src, need_bytes=None):
src.info("----------------------------------------------------")
src.info("Received need-data signal, %s." % time.asctime())
self.check_for_new_files(self.next_output_timestamp)
try:
filePath = self.fileQueue.popleft()
except IndexError:
if self.idq_log:
# Check to see what is the latest stride that iDQ is working on.
stride_start, stride_end = idq.most_recent_realtime_stride(
self.idq_log)
if stride_start * gst.SECOND > self.next_output_timestamp:
# The iDQ process has moved on. Push a gap.
gap_duration_s = stride_start - self.next_output_timestamp / gst.SECOND
self.push_gap(src, gap_duration_s)
# If no iDQ log file is available, or if the stride we want is still being
# worked on by iDQ, we wait.
time.sleep(self.waitTime)
# Try it again.
self.check_for_new_files(self.next_output_timestamp)
try:
filePath = self.fileQueue.popleft()
except IndexError:
# Push gap equivalent to the wait time and return.
self.push_gap(src, self.waitTime)
return True
# Ah, we have a file.
# Get the gpsstart time from the filename.
rest = filePath[len(self.fullCurrentPrefix):]
gpsstart = int(rest.split('-')[2])
# Let's re-derive the duration. maybe it changed?
rest = rest.split('-')[3]
duration = int(rest[:rest.find(self.inputExt)])
# Is this file later than the one we were expecting?
# If so, we can be sure that the one we wanted will never show up.
# We might as well push a gap and then continue to process
# the file that we have available.
if gpsstart * gst.SECOND > self.next_output_timestamp:
gap_duration_s = gpsstart - self.next_output_timestamp / gst.SECOND
self.push_gap(src, gap_duration_s)
# Down to business. We must read in data from the npy file in order to
# create the buffer. First load the numpy array.
src.info("processing %s" % filePath)
veto_vals = wrapNpLoad(filePath)
veto_vals = veto_vals.astype(np.float32)
# Build the buffer.
buffer_len = veto_vals.nbytes
buf = gst.buffer_new_and_alloc(buffer_len)
buf[:buffer_len - 1] = np.getbuffer(veto_vals)
buf.timestamp = gpsstart * gst.SECOND
# gst buffers require:
# buffer_duration * rate / gst.SECOND = (offset_end - offset)
# The offset is zero since our data begin at the beginning
# of the buffer.
buf_end = gpsstart + duration
buf.duration = duration * gst.SECOND
buf.offset = self.current_offset
buf.offset_end = self.current_offset + duration * self.rate
buf.caps = self.caps
# Push the buffer into the stream (a side effect of
# emitting this signal).
src.emit("push-buffer", buf)
# XXX FIXME Use a real gstreamer clock for latency instead? Make sure to fix it in
# the other places too. Okay?
#src.info("pushed buffer with start=%d, duration=%d, latency=%d" %
# (gpsstart,duration, (int(src.get_clock().get_time())-buf.timestamp)/gst.SECOND))
src.info("pushed buffer with start=%d, duration=%d, latency=%d" %
(gpsstart, duration,
(gpstime.GpsSecondsFromPyUTC(time.time()) - buf_end)))
if self.logger:
outDict = {}
outDict['type'] = 'buffer'
outDict['time'] = datetime.datetime.now().isoformat()
outDict['is_gap'] = False
outDict['gpsstart'] = gpsstart
outDict['duration'] = duration
outDict['latency'] = gpstime.GpsSecondsFromPyUTC(
time.time()) - buf_end
self.logger.info(json.dumps(outDict))
self.next_output_timestamp += buf.duration
self.current_offset = buf.offset_end
return True
def need_data(self, src, need_bytes=None):
src.info("----------------------------------------------------")
src.info("Received need-data signal, %s." % time.asctime())
self.check_for_new_files(self.next_output_timestamp)
try:
filePath = self.fileQueue.popleft()
except IndexError:
if self.idq_log:
# Check to see what is the latest stride that iDQ is working on.
stride_start, stride_end = idq.most_recent_realtime_stride(self.idq_log)
if stride_start * gst.SECOND > self.next_output_timestamp:
# The iDQ process has moved on. Push a gap.
gap_duration_s = stride_start - self.next_output_timestamp / gst.SECOND
self.push_gap(src, gap_duration_s)
# If no iDQ log file is available, or if the stride we want is still being
# worked on by iDQ, we wait.
time.sleep(self.waitTime)
# Try it again.
self.check_for_new_files(self.next_output_timestamp)
try:
filePath = self.fileQueue.popleft()
except IndexError:
# Push gap equivalent to the wait time and return.
self.push_gap(src, self.waitTime)
return True
# Ah, we have a file.
# Get the gpsstart time from the filename.
rest = filePath[len(self.fullCurrentPrefix):]
gpsstart = int(rest.split('-')[2])
# Let's re-derive the duration. maybe it changed?
rest = rest.split('-')[3]
duration = int(rest[:rest.find(self.inputExt)])
# Is this file later than the one we were expecting?
# If so, we can be sure that the one we wanted will never show up.
# We might as well push a gap and then continue to process
# the file that we have available.
if gpsstart * gst.SECOND > self.next_output_timestamp:
gap_duration_s = gpsstart - self.next_output_timestamp / gst.SECOND
self.push_gap(src, gap_duration_s)
# Down to business. We must read in data from the npy file in order to
# create the buffer. First load the numpy array.
src.info("processing %s" % filePath)
veto_vals = wrapNpLoad(filePath)
veto_vals = veto_vals.astype(np.float32)
# Build the buffer.
buffer_len = veto_vals.nbytes
buf = gst.buffer_new_and_alloc(buffer_len)
buf[:buffer_len-1] = np.getbuffer(veto_vals)
buf.timestamp = gpsstart * gst.SECOND
# gst buffers require:
# buffer_duration * rate / gst.SECOND = (offset_end - offset)
# The offset is zero since our data begin at the beginning
# of the buffer.
buf_end = gpsstart + duration
buf.duration = duration * gst.SECOND
buf.offset = self.current_offset
buf.offset_end = self.current_offset + duration * self.rate
buf.caps = self.caps
# Push the buffer into the stream (a side effect of
# emitting this signal).
src.emit("push-buffer", buf)
# XXX FIXME Use a real gstreamer clock for latency instead? Make sure to fix it in
# the other places too. Okay?
#src.info("pushed buffer with start=%d, duration=%d, latency=%d" %
# (gpsstart,duration, (int(src.get_clock().get_time())-buf.timestamp)/gst.SECOND))
src.info("pushed buffer with start=%d, duration=%d, latency=%d" %
(gpsstart,duration,(gpstime.GpsSecondsFromPyUTC(time.time()) - buf_end)))
if self.logger:
outDict = {}
outDict['type'] = 'buffer'
outDict['time'] = datetime.datetime.now().isoformat()
outDict['is_gap'] = False
outDict['gpsstart'] = gpsstart
outDict['duration'] = duration
outDict['latency'] = gpstime.GpsSecondsFromPyUTC(time.time()) - buf_end
self.logger.info(json.dumps(outDict))
self.next_output_timestamp += buf.duration
self.current_offset = buf.offset_end
return True
