def on_message(bus: Gst.Bus,
message: Gst.Message,
app,
) -> bool:
"""Callback for handling bus messages"""
# TAG and DURATION_CHANGED seem to be the most common
if message.type == Gst.MessageType.TAG:
pass
elif message.type == Gst.MessageType.DURATION_CHANGED:
pass
elif message.type == Gst.MessageType.STREAM_STATUS:
status, owner = message.parse_stream_status() # type: Gst.StreamStatusType, Gst.Element
logger.debug(f"{owner.name}:status:{status.value_name}")
elif message.type == Gst.MessageType.STATE_CHANGED:
old, new, pending = message.parse_state_changed() # type: Gst.State, Gst.State, Gst.State
logger.debug(
f"{message.src.name}:state-change:"
f"{old.value_name}->{new.value_name}")
elif message.type == Gst.MessageType.EOS:
logger.debug(f"Got EOS")
app.quit()
elif message.type == Gst.MessageType.ERROR:
err, errmsg = message.parse_error() # type: GLib.Error, str
logger.error(f'{err}: {errmsg}')
app.quit()
elif message.type == Gst.MessageType.WARNING:
err, errmsg = message.parse_warning() # type: GLib.Error, str
logger.warning(f'{err}: {errmsg}')
else:
if mce.DEBUG:
logger.debug(
f"{message.src.name}:{Gst.MessageType.get_name(message.type)}")
return True
def on_message(self, _, message: Gst.Message):
"""Handles messages from the stream"""
if message.type == Gst.MessageType.EOS:
# Handle End of Stream
self.quit()
elif message.type == Gst.MessageType.ERROR:
err, debug = message.parse_error()
logging.error(err, debug)
elif message.type == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
logging.warning(err, debug)
return True
def on_message(self, bus: Gst.Bus, message: Gst.Message):
"""Handles messages from the stream"""
if message.type == Gst.MessageType.EOS:
# Handle End of Stream
self.EOS.set()
self.quit()
elif message.type == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(err, debug)
elif message.type == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
print(err, debug)
return True
def bus_call(bus: Gst.Bus, message: Gst.Message, loop: GLib.MainLoop):
t = message.type
if t == Gst.MessageType.EOS:
sys.stdout.write("End-of-stream\n")
loop.quit()
elif t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
sys.stderr.write("Error: %s: %s\n" % (err, debug))
loop.quit()
elif t == Gst.MessageType.WARNING:
# Handle warnings
err, debug = message.parse_warning()
sys.stderr.write("Warning: %s: %s\n" % (err, debug))
return True
def on_message(bus: Gst.Bus, message:Gst.Message, loop: GLib.MainLoop):
mtype = message.type
if mtype == Gst.MessageType.EOS:
print('End Of Stream')
loop.quit()
elif mtype == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(err, debug)
loop.quit()
elif mtype == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
print(err, debug)
return True
def _on_async_done(self, bus: Gst.Bus, message: Gst.Message) -> None:
"""
Handler for `async_done` messages
By default, it will pop any futures available in `self.futures`
and call their result.
"""
msg = message.parse_async_done()
logger.debug("Unhandled ASYNC_DONE message: %s on %s", msg, bus)
def on_message(bus: Gst.Bus, message: Gst.Message, loop: GObject.MainLoop):
mtype = message.type
"""
Gstreamer Message Types and how to parse
https://lazka.github.io/pgi-docs/Gst-1.0/flags.html#Gst.MessageType
"""
if mtype == Gst.MessageType.EOS:
print("End of stream")
loop.quit()
elif mtype == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(err, debug)
loop.quit()
elif mtype == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
print(err, debug)
return True
def on_qos(self, bus: Gst.Bus, message: Gst.Message) -> None:
"""
Handler for `qos` messages
By default it will parse the error message,
log to `error` and append to `self.errors`
"""
live, running_time, stream_time, timestamp, duration = message.parse_qos(
)
logger.warning(
"Qos message: live:%s - running:%s - stream:%s - timestamp:%s - duration:%s received from %s on %s",
live, running_time, stream_time, timestamp, duration,
message.src.get_name(), bus)
def on_message(_: Gst.Bus, message: Gst.Message, loop: GObject.MainLoop):
message_type = message.type
if message_type == Gst.MessageType.EOS:
print("End of stream")
loop.quit()
elif message_type == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(err, debug)
loop.quit()
return True
def msg_handler(self, _bus: Gst.Bus, msg: Gst.Message) -> None:
"""Handle pipeline messages"""
if msg.type == Gst.MessageType.EOS:
print('End of stream, exiting', file=sys.stderr)
self.quit()
elif msg.type == Gst.MessageType.ERROR:
print('Fatal error:', msg.parse_error(), file=sys.stderr)
self.quit()
elif msg.type == Gst.MessageType.CLOCK_LOST:
print('Clock lost, resetting', file=sys.stderr)
self._element.set_state(Gst.State.PAUSED)
self._element.set_state(Gst.State.PLAYING)
def __on_gst_message(bus, message: Gst.Message):
"""
Handle messages from gst.
"""
global __speed
global __set_speed
t = message.type
if t == Gst.MessageType.BUFFERING:
if (message.percentage < 100):
__player.set_state(Gst.State.PAUSED)
log.info("Buffering…")
else:
__player.set_state(Gst.State.PLAYING)
log.info("Buffering finished.")
elif t == Gst.MessageType.EOS:
next_track()
elif t == Gst.MessageType.ERROR:
error, debug_msg = message.parse_error()
if error.code == Gst.ResourceError.NOT_FOUND:
stop()
unload()
emit_event("stop")
log.warning("gst: Resource not found. Stopping player.")
reporter.warning("player",
"gst: Resource not found. Stopping player.")
return
err, debug = message.parse_error()
log.error(err)
log.debug(debug)
reporter.error("player", err)
emit_event("error", err)
elif t == Gst.MessageType.STATE_CHANGED:
state = get_gst_player_state()
if state == Gst.State.PLAYING or state == Gst.State.PAUSED:
auto_jump()
def on_device_monitor_message(self, bus: Gst.Bus, message: Gst.Message,
user_data):
logger.debug('Message: {}', message)
# A private GstV4l2Device or GstPipeWireDevice type
if message.type == Gst.MessageType.DEVICE_ADDED:
added_dev: Optional[Gst.Device] = message.parse_device_added()
if not added_dev:
return True
logger.debug('Added: {}', added_dev)
cam_path = get_device_path(added_dev)
cam_name = added_dev.get_display_name()
# Check if this cam already in the list, add to list if not.
for row in self.webcam_store:
if row[0] == cam_path:
break
else:
self.webcam_store.append((cam_path, cam_name))
return True
elif message.type == Gst.MessageType.DEVICE_REMOVED:
removed_dev: Optional[Gst.Device] = message.parse_device_removed()
if not removed_dev:
return True
logger.debug('Removed: {}', removed_dev)
cam_path = get_device_path(removed_dev)
ppl_source = self.gst_pipeline.get_by_name(self.GST_SOURCE_NAME)
if cam_path == ppl_source.get_property('device'):
self.gst_pipeline.set_state(Gst.State.NULL)
# Find the entry of just-removed in the list and remove it.
itr: Optional[Gtk.TreeIter] = None
for row in self.webcam_store:
logger.debug('Row: {}', row)
if row[0] == cam_path:
itr = row.iter
break
if itr:
logger.debug('To remove {} from list', cam_path)
self.webcam_store.remove(itr)
return True
def on_error(self, bus: Gst.Bus, message: Gst.Message) -> None:
"""
Handler for `error` messages
By default it will parse the error message,
log to `error` and append to `self.errors`
"""
err, debug = message.parse_error()
logger.error("Error received from element %s:%s on %s",
message.src.get_name(), err.message, bus)
if debug is not None:
logger.error("Debugging information: %s", debug)
self.teardown()
self.events.error.set()
def _on_state_changed(self, bus: Gst.Bus, message: Gst.Message) -> None: # pylint: disable=unused-argument
"""
Handler for `state_changed` messages
By default will only log to `debug`
"""
old, new, _ = message.parse_state_changed()
if message.src != self.pipeline:
return
logger.info(
"State changed from %s to %s",
Gst.Element.state_get_name(old),
Gst.Element.state_get_name(new),
)
self.events.pick_state(new)
def bus_call(bus: Gst.Bus, message: Gst.Message, loop: GLib.MainLoop):
# https://stackoverflow.com/questions/49858346/how-te-retrieve-stream-statistics-in-gstreamer
t = message.type
sys.stdout.write("Received message from -> %s \n" % (message.src.name))
if t == Gst.MessageType.EOS:
sys.stdout.write("End-of-stream\n")
elif t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
sys.stderr.write("Error: %s: %s\n" % (err, debug))
elif t == Gst.MessageType.WARNING:
# Handle warnings
err, debug = message.parse_warning()
sys.stderr.write("Warning: %s: %s\n" % (err, debug))
# https://git.smart-cactus.org/ben/cam-stream/blob/0483fa5d3bb82e8a4212d7190d4541ed4d0653d5/stream.py
elif t == Gst.MessageType.STATE_CHANGED:
sys.stderr.write('state changed: %s\n' %
(message.parse_state_changed(), ))
elif t == Gst.MessageType.STREAM_STATUS:
sys.stderr.write('stream status: %s\n' %
(message.parse_stream_status(), ))
elif t == Gst.MessageType.QOS:
# Handle Qus
live, running_time, stream_time, timestamp, duration = message.parse_qos(
)
#sys.stderr.write("Qos Message: live %r, running_time %i, stream_time %i, timestamp: %i, duration: %i \n" % (live, running_time, stream_time, timestamp, duration))
#sys.stderr.write('qos: %s' % (message.parse_qos(),))
elif t == Gst.MessageType.ELEMENT:
sys.stderr.write('Element message: %s\n' %
(message.get_structure().to_string(), ))
elif t == Gst.MessageType.BUFFERING:
sys.stderr.write('Buffering message: %s\n' %
(message.get_structure().to_string(), ))
elif t == Gst.MessageType.PROGRESS:
sys.stderr.write('Progress message: %s\n' %
(message.get_structure().to_string(), ))
else:
sys.stderr.write('Bus message: %s: %s \n' % (message.timestamp, t))
pprint(message)
return True
def on_warning(self, bus: Gst.Bus, message: Gst.Message):
warn, debug = message.parse_warning()
self.log.warning("Gstreamer.%s: %s. %s", self, warn, debug)
def on_error(self, bus: Gst.Bus, message: Gst.Message):
err, debug = message.parse_error()
self.log.error("Gstreamer.%s: Error %s: %s. ", self, err, debug)
self._shutdown_pipeline()
