#!/usr/bin/env python3

import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst
gi.require_version('GstWebRTC', '1.0')
from gi.repository import GstWebRTC
gi.require_version('GstSdp', '1.0')
from gi.repository import GstSdp
gi.require_version('Rsvg', '2.0')
from gi.repository import Rsvg
import cairo
from ctypes import *
from contextlib import contextmanager
import time

Gst.init(None)

class GstMapInfo(Structure):
    _fields_ = [("memory", c_void_p),        # GstMemory *memory
                ("flags", c_int),            # GstMapFlags flags
                ("data", POINTER(c_byte)),   # guint8 *data
                ("size", c_size_t),          # gsize size
                ("maxsize", c_size_t),       # gsize maxsize
                ("user_data", c_void_p * 4), # gpointer user_data[4]
                ("_gst_reserved", c_void_p * 4)]

libgst = CDLL("libgstreamer-1.0.so.0")

GST_MAP_INFO_POINTER = POINTER(GstMapInfo)

# gst_buffer_map
libgst.gst_buffer_map.argtypes = [c_void_p, GST_MAP_INFO_POINTER, c_int]
libgst.gst_buffer_map.restype = c_int

# gst_buffer_unmap
libgst.gst_buffer_unmap.argtypes = [c_void_p, GST_MAP_INFO_POINTER]
libgst.gst_buffer_unmap.restype = None

# gst_mini_object_is_writable
libgst.gst_mini_object_is_writable.argtypes = [c_void_p]
libgst.gst_mini_object_is_writable.restype = c_int

def map_gst_buffer(pbuffer, flags):
    if pbuffer is None:
        raise TypeError("Cannot pass NULL to map_gst_buffer")

    ptr = hash(pbuffer)
    if flags & 2 and libgst.gst_mini_object_is_writable(ptr) == 0:
        raise ValueError("Writable array requested but buffer is not writeable")

    mapping = GstMapInfo()
    success = libgst.gst_buffer_map(ptr, mapping, flags)

    if not success:
        raise RuntimeError("Couldn't map buffer")

    try:
        # Cast POINTER(c_byte) to POINTER to array of c_byte with size mapping.size
        # Returns not pointer but the object to which pointer points
        return cast(mapping.data, POINTER(c_byte * mapping.size)).contents
    finally:
        libgst.gst_buffer_unmap(ptr, mapping)

class GstRenderer(object):
    def __init__(self, width, height, output):
        self.width, self.height = width, height

        self.surface = cairo.ImageSurface(cairo.FORMAT_RGB24, self.width, self.height)
        self.context = cairo.Context(self.surface)
        self.context.scale(1.0, 1.0)

        pipeline = "appsrc name=input emit-signals=false format=time do-timestamp=false is-live=false block=false caps=video/x-raw,width=%d,height=%d,format=BGRA,framerate=25/1,pixel-aspect-ratio=1/1,interlace-mode=progressive" % (self.width, self.height)
        pipeline += " ! videoconvert"
        pipeline += " ! queue"
        if output.endswith(".mov"):
            pipeline += " ! qtmux"
        else:
            raise Exception("Unsupported file ending for gst renderer: %s" % output)

#        if output.endswith(".ts"):
#            pipeline += " ! mpeg2enc format=5 aspect=3 framerate=3 bitrate=10000"
#            pipeline += " ! mpegvideoparse"
#            pipeline += " ! mpegtsmux"
#        elif output.endswith(".mkv"):
#            pipeline += " ! x264enc"
#            pipeline += " ! matroskamux"
#        else:
#            raise Exception("Unsupported file ending for gst renderer: %s" % output)

        pipeline += " ! filesink name=filesink"

        self.framebuf = Gst.Buffer.new_wrapped(b'\x00' * (4*width*height))
        self.framebuf.duration = 10**9 / 25
        self.framebuf.dts = 0
        self.framebuf.pts = 0
        self.mapped_framebuf = map_gst_buffer(self.framebuf, Gst.MapFlags.READ | Gst.MapFlags.WRITE)

        self.pipe = Gst.parse_launch(pipeline)
        self.appsrc = self.pipe.get_by_name("input")
        self.filesink = self.pipe.get_by_name("filesink")
        self.filesink.set_property("location", output)

        self.bus = self.pipe.get_bus()
        self.bus.add_signal_watch()

        self.pipe.set_state(Gst.State.PLAYING)

    def render_frame(self, svg):
        handle = Rsvg.Handle()
        svghandle = handle.new_from_data(svg.encode())

        width, height = svghandle.get_dimensions().width, svghandle.get_dimensions().height
        self.context.scale(self.width / width, self.height / height)
        svghandle.render_cairo(self.context)

        frame = bytes(self.surface.get_data())
        memmove(self.mapped_framebuf, frame, len(frame))

        self.framebuf.dts += self.framebuf.duration
        self.framebuf.pts = self.framebuf.dts

        self.appsrc.emit("push-buffer", self.framebuf)

    def close(self):
        self.appsrc.emit("end-of-stream")
        self.pipe.send_event(Gst.Event.new_eos())

        while True:
            message = self.bus.pop()
            if not message:
                time.sleep(0.1)
                continue
            if message.type == Gst.MessageType.EOS:
                break


        self.pipe.set_state(Gst.State.NULL)