Example #1
0
 def run_link(self, link_config, audio_interface):
     """
       Run a new TX or RX node.
     """
     # We're now entering the realm where we should desperately try and
     # maintain a link under all circumstances forever.
     self.logger.info("Link %s initial setup start on %s" % (link_config.name, self.node_name))
     link_logger = self.logger_factory.getLogger('node.%s.link.%s' % (self.node_name, link_config.name))
     while True:
         try:
             if audio_interface.mode == 'tx':
                 try:
                     link_logger.info("Starting up transmitter")
                     transmitter = RTPTransmitter(self.node_name, link_config, audio_interface)
                     transmitter.run()
                     caps = transmitter.get_caps()
                     link_logger.debug("Got caps from transmitter, setting config")
                     link_config.set("caps", caps)
                     transmitter.loop()
                 except ElementNotFoundError as e:
                     link_logger.critical("GStreamer element missing: %s - will now exit" % e)
                     sys.exit(1)
                 except Exception as e:
                     link_logger.exception("Transmitter crashed for some reason! Restarting...")
                     time.sleep(0.5)
             elif audio_interface.mode == 'rx':
                 link_logger.info("Waiting for transmitter capabilities...")
                 caps = link_config.blocking_get("caps")
                 link_logger.info("Got caps from transmitter")
                 try:
                     link_logger.info("Starting up receiver")
                     receiver = RTPReceiver(self.node_name, link_config, audio_interface)
                     receiver.run()
                     receiver.loop()
                 except ElementNotFoundError as e:
                     link_logger.critical("GStreamer element missing: %s - will now exit" % e)
                     sys.exit(1)
                 except Exception as e:
                     link_logger.exception("Receiver crashed for some reason! Restarting...")
                     time.sleep(0.1)
             else:
                 link_logger.critical("Unknown audio interface mode (%s)!" % audio_interface.mode)
                 sys.exit(1)
         except Exception as e:
             link_logger.exception("Unknown exception thrown - please report this as a bug! %s" % e)
             raise
Example #2
0
 def run_link(self, link_config, audio_interface):
     """
       Run a new TX or RX node.
     """
     # We're now entering the realm where we should desperately try and
     # maintain a link under all circumstances forever.
     self.logger.info("Link %s initial setup start on %s" %
                      (link_config.name, self.node_name))
     link_logger = self.logger_factory.getLogger(
         'node.%s.link.%s' % (self.node_name, link_config.name))
     while True:
         try:
             if audio_interface.mode == 'tx':
                 try:
                     link_logger.info("Starting up transmitter")
                     transmitter = RTPTransmitter(self.node_name,
                                                  link_config,
                                                  audio_interface)
                     transmitter.run()
                     caps = transmitter.get_caps()
                     link_logger.debug(
                         "Got caps from transmitter, setting config")
                     link_config.set("caps", caps)
                     transmitter.loop()
                 except Exception as e:
                     link_logger.exception(
                         "Transmitter crashed for some reason! Restarting..."
                     )
                     time.sleep(0.5)
             elif audio_interface.mode == 'rx':
                 link_logger.info("Waiting for transmitter capabilities...")
                 caps = link_config.blocking_get("caps")
                 link_logger.info("Got caps from transmitter")
                 try:
                     link_logger.info("Starting up receiver")
                     receiver = RTPReceiver(self.node_name, link_config,
                                            audio_interface)
                     receiver.run()
                     receiver.loop()
                 except Exception as e:
                     link_logger.exception(
                         "Receiver crashed for some reason! Restarting...")
                     time.sleep(0.1)
             else:
                 link_logger.critical("Unknown audio interface mode (%s)!" %
                                      audio_interface.mode)
                 sys.exit(1)
         except Exception as e:
             link_logger.exception(
                 "Unknown exception thrown - please report this as a bug! %s"
                 % e)
             raise
Example #3
0
class Node(object):
    """
        OpenOB node instance.

        Nodes run links. Each Node looks after its end of a link, ensuring
        that it remains running and tries to recover from failures, as well as
        responding to configuration changes.

        Nodes have a name; everything else is link specific.

        For instance, a node might be the 'studio' node, which would run a
        'tx' end for the 'stl' link.

        Nodes have a config host which is where they store their inter-Node
        data and communicate with other Nodes.
    """
    def __init__(self, node_name):
        """Set up a new node."""
        self.node_name = node_name
        self.logger_factory = LoggerFactory()
        self.logger = self.logger_factory.getLogger('node.%s' % self.node_name)

    def run_link(self, link_config, audio_interface):
        """
          Run a new TX or RX node.
        """
        # We're now entering the realm where we should desperately try and
        # maintain a link under all circumstances forever.
        self.logger.info("Link %s initial setup start on %s" %
                         (link_config.name, self.node_name))
        link_logger = self.logger_factory.getLogger(
            'node.%s.link.%s.%s' %
            (self.node_name, link_config.name, audio_interface.mode))
        while True:
            try:
                if audio_interface.mode == 'tx':
                    try:
                        transmitter = RTPTransmitter(self.node_name,
                                                     link_config,
                                                     audio_interface)
                        link_logger.info("Starting up transmitter")
                        transmitter.run()
                        caps = transmitter.get_caps()
                        link_logger.info("Got caps, setting config - %s" %
                                         caps)
                        link_config.set("caps", caps)
                        transmitter.loop()
                    except ElementNotFoundError, e:
                        link_logger.critical(
                            "GStreamer element missing: %s - will now exit" %
                            e)
                        sys.exit(1)
                    except Exception, e:
                        link_logger.exception(
                            "Transmitter crashed for some reason! Restarting..."
                        )
                        time.sleep(0.5)
                elif audio_interface.mode == 'rx':
                    link_logger.info("Waiting for transmitter capabilities...")
                    caps = link_config.blocking_get("caps")
                    link_logger.info("Got caps from transmitters - %s" % caps)
                    try:
                        link_logger.info("Starting up receiver")
                        receiver = RTPReceiver(self.node_name, link_config,
                                               audio_interface)
                        receiver.run()
                        receiver.loop()
                    except ElementNotFoundError, e:
                        link_logger.critical(
                            "GStreamer element missing: %s - will now exit" %
                            e)
                        sys.exit(1)
Example #4
0
    def run(self, opts):
        print("-- OpenOB Audio Link")
        print(" -- Starting Up")
        print(" -- Parameters: %s" % opts)
        # We're now entering the realm where we should desperately try and maintain a link under all circumstances forever.
        while True:
            try:
                # Set up redis and connect
                config = None
                while True:
                    try:
                        config = redis.Redis(opts.config_host)
                        print(" -- Connected to configuration server")
                        break
                    except Exception, e:
                        print(
                            Fore.BLACK + Back.RED +
                            " -- Couldn't connect to Redis! Ensure your configuration host is set properly, and you can connect to the default Redis port on that host from here (%s)."
                            % e)
                        print(
                            "    Waiting half a second and attempting to connect again."
                            + Fore.RESET + Back.RESET)
                        time.sleep(0.5)

                # So if we're a transmitter, let's set the options the receiver needs to know about
                link_key = "openob2:" + opts.link_name + ":"
                if opts.mode == 'tx':
                    if opts.encoding == 'celt' and int(opts.bitrate) > 192:
                        print(
                            Fore.BLACK + Back.YELLOW +
                            " -- WARNING: Can't use bitrates higher than 192kbps for CELT, limiting"
                            + Fore.RESET + Back.RESET)
                        opts.bitrate = 192
                    # We're a transmitter!
                    config.set(link_key + "port", opts.port)
                    config.set(link_key + "ipv6", opts.ipv6)
                    config.set(link_key + "jitter_buffer", opts.jitter_buffer)
                    config.set(link_key + "encoding", opts.encoding)
                    config.set(link_key + "bitrate", opts.bitrate)
                    print(" -- Configured receiver with:")
                    print("   - Base Port:     %s" %
                          config.get(link_key + "port"))
                    print("   - Jitter Buffer: %s ms" %
                          config.get(link_key + "jitter_buffer"))
                    print("   - Encoding:      %s" %
                          config.get(link_key + "encoding"))
                    print("   - Bitrate:       %s kbit/s" %
                          config.get(link_key + "bitrate"))
                    # Okay, we can't set caps yet - we need to configure ourselves first.
                    opus_opts = {
                        'audio': True,
                        'bandwidth': -1000,
                        'frame-size': opts.framesize,
                        'complexity': opts.complexity,
                        'constrained-vbr': True,
                        'inband-fec': opts.fec,
                        'packet-loss-percentage': opts.loss,
                        'dtx': opts.dtx
                    }
                    try:
                        transmitter = RTPTransmitter(
                            audio_input=opts.audio_input,
                            audio_device=opts.device,
                            base_port=opts.port,
                            ipv6=opts.ipv6,
                            encoding=opts.encoding,
                            bitrate=opts.bitrate,
                            jack_name=("openob_tx_%s" % opts.link_name),
                            receiver_address=opts.receiver_host,
                            opus_options=opus_opts)
                        # Set it up, get caps
                        try:
                            transmitter.run()
                            config.set(link_key + "caps",
                                       transmitter.get_caps())
                            print("   - Caps:          %s" %
                                  config.get(link_key + "caps"))
                            transmitter.loop()
                        except Exception, e:
                            print(
                                Fore.BLACK + Back.RED +
                                " -- Lost connection or otherwise had the transmitter fail on us, restarting (%s)"
                                % e)
                            time.sleep(0.5)
                    except gst.ElementNotFoundError, e:
                        print(Fore.BLACK + Back.RED + (
                            " -- Couldn't fulfill our gstreamer module dependencies! You don't have the following element available: %s"
                            % e) + Fore.RESET + Back.RESET)
                        sys.exit(1)
                else:
                    # We're a receiver!
                    # Default values.
                    port = 3000
                    caps = ''
                    jitter_buffer = 150
                    encoding = 'opus'
                    bitrate = '96'
                    while True:
                        try:
                            if config.get(link_key + "port") == None:
                                print(
                                    Fore.BLACK + Back.YELLOW +
                                    " -- Unable to configure myself from the configuration host; has the transmitter been started yet, and have you got the same link name on each end?"
                                )
                                print(
                                    "    Waiting half a second and attempting to reconfigure myself."
                                    + Fore.RESET + Back.RESET)
                                time.sleep(0.5)
                            port = int(config.get(link_key + "port"))
                            ipv6 = int(config.get(link_key + "ipv6"))
                            caps = config.get(link_key + "caps")
                            jitter_buffer = int(
                                config.get(link_key + "jitter_buffer"))
                            encoding = config.get(link_key + "encoding")
                            bitrate = int(config.get(link_key + "bitrate"))
                            print(" -- Configured from transmitter with:")
                            print("   - Base Port:     %s" % port)
                            print("   - Jitter Buffer: %s ms" % caps)
                            print("   - Encoding:      %s" % encoding)
                            print("   - Bitrate:       %s kbit/s" % bitrate)
                            print("   - Caps:          %s" % caps)
                            break
                        except Exception, e:
                            print(
                                Fore.BLACK + Back.YELLOW +
                                " -- Unable to configure myself from the configuration host; has the transmitter been started yet? (%s)"
                                % e)
                            print(
                                "    Waiting half a second and attempting to reconfigure myself."
                                + Fore.RESET + Back.RESET)
                            time.sleep(0.5)
                            #raise
                    # Okay, we can now configure ourself
                    receiver = RTPReceiver(audio_output=opts.audio_output,
                                           audio_device=opts.device,
                                           base_port=port,
                                           ipv6=ipv6,
                                           encoding=encoding,
                                           caps=caps,
                                           bitrate=bitrate,
                                           jitter_buffer=jitter_buffer,
                                           jack_name=("openob_tx_%s" %
                                                      opts.link_name))
                    try:
                        receiver.run()
                        receiver.loop()
                    except Exception, e:
                        print(Fore.BLACK + Back.RED + (
                            " -- Lost connection or otherwise had the receiver fail on us, restarting (%s)"
                            % e) + Fore.RESET + Back.RESET)
                        time.sleep(0.5)
Example #5
0
  def run(self, opts):
    print("-- OpenOB Audio Link")
    print(" -- Starting Up")
    print(" -- Parameters: %s" % opts)
    # We're now entering the realm where we should desperately try and maintain a link under all circumstances forever.
    while True:
      try:
        # Set up redis and connect
        config = None
        while True:
          try:
            config = redis.Redis(opts.config_host)
            print(" -- Connected to configuration server")
            break
          except Exception, e:
            print(Fore.BLACK + Back.RED + " -- Couldn't connect to Redis! Ensure your configuration host is set properly, and you can connect to the default Redis port on that host from here (%s)." % e)
            print("    Waiting half a second and attempting to connect again." + Fore.RESET + Back.RESET)
            time.sleep(0.5)

        # So if we're a transmitter, let's set the options the receiver needs to know about
        link_key = "openob2:"+opts.link_name+":"
        if opts.mode == 'tx':
          if opts.encoding == 'celt' and int(opts.bitrate) > 192:
            print(Fore.BLACK + Back.YELLOW + " -- WARNING: Can't use bitrates higher than 192kbps for CELT, limiting" + Fore.RESET + Back.RESET)
            opts.bitrate = 192
          # We're a transmitter!
          config.set(link_key+"port", opts.port)
          config.set(link_key+"ipv6", opts.ipv6)
          config.set(link_key+"jitter_buffer", opts.jitter_buffer)
          config.set(link_key+"encoding", opts.encoding)
          config.set(link_key+"bitrate", opts.bitrate)
          print(" -- Configured receiver with:")
          print("   - Base Port:     %s" % config.get(link_key+"port"))
          print("   - Jitter Buffer: %s ms" % config.get(link_key+"jitter_buffer"))
          print("   - Encoding:      %s" % config.get(link_key+"encoding"))
          print("   - Bitrate:       %s kbit/s" % config.get(link_key+"bitrate"))
          # Okay, we can't set caps yet - we need to configure ourselves first.
          opus_opts = {'audio': True, 'bandwidth': -1000, 'frame-size': opts.framesize, 'complexity': opts.complexity, 'constrained-vbr': True, 'inband-fec': opts.fec, 'packet-loss-percentage': opts.loss, 'dtx': opts.dtx}
          try:
            transmitter = RTPTransmitter(audio_input=opts.audio_input, audio_device=opts.device, base_port=opts.port, ipv6=opts.ipv6, encoding=opts.encoding, bitrate=opts.bitrate, jack_name=("openob_tx_%s" % opts.link_name), receiver_address=opts.receiver_host, opus_options=opus_opts)
            # Set it up, get caps
            try:
              transmitter.run()
              config.set(link_key+"caps", transmitter.get_caps())
              print("   - Caps:          %s" % config.get(link_key+"caps"))
              transmitter.loop()
            except Exception, e:
              print(Fore.BLACK + Back.RED + " -- Lost connection or otherwise had the transmitter fail on us, restarting (%s)" % e)
              time.sleep(0.5)
          except gst.ElementNotFoundError, e:
            print(Fore.BLACK + Back.RED + (" -- Couldn't fulfill our gstreamer module dependencies! You don't have the following element available: %s" % e) + Fore.RESET + Back.RESET)
            sys.exit(1)
        else:
          # We're a receiver!
          # Default values.
          port = 3000
          caps = ''
          jitter_buffer = 150
          encoding = 'opus'
          bitrate = '96'
          while True:
            try:
              if config.get(link_key+"port") == None:
                print(Fore.BLACK + Back.YELLOW + " -- Unable to configure myself from the configuration host; has the transmitter been started yet, and have you got the same link name on each end?")
                print("    Waiting half a second and attempting to reconfigure myself." + Fore.RESET + Back.RESET)
                time.sleep(0.5)
              port = int(config.get(link_key+"port"))
              ipv6 = int(config.get(link_key+"ipv6"))
              caps = config.get(link_key+"caps")
              jitter_buffer = int(config.get(link_key+"jitter_buffer"))
              encoding = config.get(link_key+"encoding")
              bitrate = int(config.get(link_key+"bitrate"))
              print(" -- Configured from transmitter with:")
              print("   - Base Port:     %s" % port)
              print("   - Jitter Buffer: %s ms" % caps)
              print("   - Encoding:      %s" % encoding)
              print("   - Bitrate:       %s kbit/s" % bitrate)
              print("   - Caps:          %s" % caps)
              break
            except Exception, e:
              print(Fore.BLACK + Back.YELLOW + " -- Unable to configure myself from the configuration host; has the transmitter been started yet? (%s)" % e)
              print("    Waiting half a second and attempting to reconfigure myself." + Fore.RESET + Back.RESET)
              time.sleep(0.5)
              #raise
          # Okay, we can now configure ourself
          receiver = RTPReceiver(audio_output=opts.audio_output, audio_device=opts.device, base_port=port, ipv6=ipv6, encoding=encoding, caps=caps, bitrate=bitrate, jitter_buffer=jitter_buffer, jack_name=("openob_tx_%s" % opts.link_name) )
          try:
            receiver.run()
            receiver.loop()
          except Exception, e:
            print(Fore.BLACK + Back.RED + (" -- Lost connection or otherwise had the receiver fail on us, restarting (%s)" % e) + Fore.RESET + Back.RESET)
            time.sleep(0.5)