Python2.7 & G-Streamer-1.0: tcpclientsrc: Not linked (-1)

Hej, er der en Python - G-Streamer kender, der kan hjælpe mig med at få min pipeline til at rulle..?
Er ret grøn inden for Python & G-Steamer med kodningen, men jeg kan få opsætningen til at køre med gst-launch-1.0. i begge ender.
Scriptet er oprindeligt fra pygst-tutorial-org. fundet på Git-hub.
Setup: Pipeline(A = tcpserversink streamer til Pipeline(B = tcpclientsrc.
Server sender Caps.  Den ruller med gst-launch-1.0
Jeg hat så prøvet at lave Pipeline(B) i Python.
Først med videokilde lokalt og det kørte, så programmet er Ok. Så ændrede jeg til tcpclientsrc og så gik det knap så godt...
Mit problem er at når Pipelinen skal rulle, bliver den sat på pause og jeg får fejlmeddelsen:
Error: gst-stream-error-quark: Intern datastrømsfejl. (1) gstbasesrc.c(2943): gst_base_src_loop (): /GstPipeline:player/GstTCPClientSrc:tcpclientsrc_1:
streaming task paused, reason not-linked (-1)

Jeg hat læst gst-docs, Dev-mailling list, forummer, guides og examples, men ingen steder er der en løsning med tcpclientsink og jeg er ikke blevet klogere af læsningen, andet end jeg tror at jeg måske mangler en pad til tcpclientsrc uden helt at kunne afkode hvordan eller om det er fejlen.
Så jeg bliver mægtig glad hvis der en der kan fortælle mig, hvad der er gået galt i scriptet
På forhånd tak.

#!/usr/bin/env python

import os, platform

try:
  import gi
except:
  print("No GI")
try:
  gi.require_version('Gtk', '3.0')
  from gi.repository import GObject,Gtk as Gtk
except:
  print("No Gtk")
try:
  gi.require_version ('Gst', '1.0')
  from gi.repository import Gst
except:
  print("No Gst")
try:
# Needed for window.get_xid(), xvimagesink.set_window_handle(), respectively:
  gi.require_version('GdkX11', '3.0')
  from gi.repository import GdkX11
except:
  print("No GdkX11 3.0")
try:
  gi.require_version('GstVideo', '1.0')
  from gi.repository import GstVideo
except:
  print("No GstVideo 1.0")
  sys.exit(1)


class GTK_Main(object):
     
    def __init__(self):
        ## Create a window,
        self.gladefile = ("hello_Gstream_tcpclient_work.glade")
        self.builder = Gtk.Builder()
        self.builder.add_from_file(self.gladefile)
        self.builder.connect_signals(self)
       
        ## Create objects by name from Glade
        self.window = self.builder.get_object("window")
        self.movie_window = self.builder.get_object("movie_window")
        self.button1 = self.builder.get_object("button1")
        self.entry_host_1 =
self.builder.get_object("entry_host_1")
        self.entry_port_1 = self.builder.get_object("entry_port_1")

        self.window.show_all()

        ## Create pipeline & connect bus
        self.player = Gst.Pipeline.new("player")
        bus = self.player.get_bus()
        bus.add_signal_watch()
        bus.enable_sync_message_emission()
        bus.connect("message", self.on_message)
        bus.connect("sync-message::element", self.on_sync_message)

        ## Create tcpclientsr, gdpdepay, rtph264depay, h264parse, decodebin,
        ## videoconvert, autovideosink
        self.tcpclientsrc_1 = Gst.ElementFactory.make("tcpclientsrc", "tcpclientsrc_1")
        self.gdpdepay_1 = Gst.ElementFactory.make("gdpdepay", "gdpdepay_1")
        self.rtph264depay_1 = Gst.ElementFactory.make("rtph264depay", "rtph264depay_1")
        self.h264parse_1 = Gst.ElementFactory.make("h264parse", "h264parse_1")
        self.decodebin_1 = Gst.ElementFactory.make("decodebin", "decodebin_1")
        self.videoconvert_1 = Gst.ElementFactory.make("videoconvert", "videoconvert_1")
        self.autovideosink = Gst.ElementFactory.make("autovideosink", "autovideosink")

        ## Add elements to pibeline
        self.player.add(self.tcpclientsrc_1)
        self.player.add(self.gdpdepay_1)
        self.player.add(self.rtph264depay_1)
        self.player.add(self.h264parse_1)
        self.player.add(self.decodebin_1)
        self.player.add(self.videoconvert_1)
        self.player.add(self.autovideosink)

        ## Link elements
        self.tcpclientsrc_1.link(self.gdpdepay_1)
        self.gdpdepay_1.link(self.rtph264depay_1)
        self.rtph264depay_1.link(self.h264parse_1)
        self.h264parse_1.link(self.decodebin_1)
        self.decodebin_1.link(self.videoconvert_1)
        self.videoconvert_1.link(self.autovideosink)

    ## Create handles
    def on_window_destroy(self, object, data=None):
        Gtk.main_quit()
     
    def on_button1_clicked(self, object, data=None):
        w = self.entry_host_1.get_text().strip()
        self.start_stop(w)
           
    def start_stop(self, w):
        if self.button1.get_label() == "Start":
            self.tcpiphost_1 = self.entry_host_1.get_text().strip()
            self.tcpport_1 = int(self.entry_port_1.get_text().strip())
            self.tcpclientsrc_1.set_property("host", self.tcpiphost_1)
            self.tcpclientsrc_1.set_property("port", self.tcpport_1)
            self.button1.set_label("Stop")
            self.player.set_state(Gst.State.PLAYING)
        else:
            self.player.set_state(Gst.State.NULL)
            self.button1.set_label("Start")
               
    def on_message(self, bus, message):
        t = message.type
        if t == Gst.MessageType.EOS:
            self.player.set_state(Gst.State.NULL)
            self.button1.set_label("Start")
        elif t == Gst.MessageType.ERROR:
            self.player.set_state(Gst.State.NULL)
            err, debug = message.parse_error()
            print "Error: %s" % err, debug
            self.button1.set_label("Start")
           
    def on_sync_message(self, bus, message):
        if message.get_structure().get_name() == 'prepare-window-handle':
            imagesink = message.src
            imagesink.set_property("force-aspect-ratio", True)
            imagesink.set_window_handle(self.movie_window.get_property('window').get_xid())


GObject.threads_init()
Gst.init(None)       
GTK_Main()
Gtk.main()