file2cam.py

#!/usr/bin/python3

import gi
gi.require_version('Gst', '1.0')
gi.require_version('Gtk', '3.0')
from gi.repository import Gst, Gtk, GLib
import sys
import datetime
import textwrap


class Player:
    async_done = None

    def __init__(self, filename):
        self.pipeline = Gst.Pipeline("file2cam")
        self.pipeline.bus.add_signal_watch()
        self.pipeline.bus.connect('message', self.print_message)
        self.pipeline.bus.connect('message', self.handle_message)

        self.src = Gst.ElementFactory.make('videotestsrc', "loader")
        #self.src.set_property('pattern', 'ball')
        self.pipeline.add(self.src)

        self.sink = Gst.ElementFactory.make('v4l2sink', "camera")
        self.sink.set_property('device', '/dev/video0')  # FIXME: Do search for available loopback devices
        print(self.sink.get_property('device-name'))
        self.pipeline.add(self.sink)

        self.src.link(self.sink)

    def handle_message(self, bus, message):
        if message.type == Gst.MessageType.ASYNC_DONE:
            if self.async_done:
                self.async_done()
        elif message.type == Gst.MessageType.EOS:
            Gtk.main_quit()

    def print_message(self, bus, message):
        print(bus.name, Gst.MessageType.get_name(message.type), end='\t')
        if message.type == Gst.MessageType.ERROR:
            err, msg = message.parse_error()
            print("{} ({}:{})".format(err.message, err.domain, err.code))
            print(textwrap.indent(msg, '>\t'))
        elif message.type == Gst.MessageType.STATE_CHANGED:
            old, new, pending = message.parse_state_changed()
            print("{} -> {} ({})".format(
                old.value_nick, new.value_nick, pending.value_nick
                ))
        elif message.type == Gst.MessageType.STREAM_STATUS:
            status, ele = message.parse_stream_status()
            print("{} on {}".format(status.value_nick, ele.get_name()))
        elif message.type == Gst.MessageType.ASYNC_DONE:
            ns = message.parse_async_done()  # nanoseconds
            if ns == 0xffffffffffffffff:
                print("Took ???")
            else:
                print("Took {} (ns)".format(ns))
        else:
            print()

    def ready(self):
        print("Ready:", self.pipeline.set_state(Gst.State.READY).value_name)

    def pause(self):
        print("Pause:", self.pipeline.set_state(Gst.State.PAUSED).value_name)

    def play(self):
        print("Play:", self.pipeline.set_state(Gst.State.PLAYING).value_name)

    def __del__(self):
        self.pipeline.set_state(Gst.State.NULL)

argv = Gst.init(sys.argv)
p = Player(None)


def async_done():
    p.play()
    p.async_done = None
p.async_done = async_done

p.ready()
GLib.idle_add(p.pause)  # Warm it up, after ready

Gtk.main()