zzkt/osc
1
0
Fork 0
Code Issues 7 Pull requests Projects Releases Activity Actions

make osc-examples use usocket for portability

Browse source
This commit is contained in:
rick 2017-11-30 15:01:08 -08:00
parent 7a147fa702
commit 8169205c89
1 changed files with 54 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
osc-examples.lisp
View file

@ -19,69 +19,69 @@
;; ;;
;; eg. listen on port 6667 for incoming msgs ;; eg. listen on port 6667 for incoming msgs
;; ;;
;; (osc-listen 6667) ;; (osc-receive-test 6667)
;; eg. send a test message to localhost port 6668
;;
;; (osc-send-test "localhost" 6668)
;; ;;
;; eg. listen on port 6667 and send to 10.0.89:6668 ;; eg. listen on port 6667 and send to 10.0.89:6668
;; note the ip# is formatted as a vector ;; note the ip# is formatted as a vector
;; ;;
;; (osc-reflector 6667 #(10 0 0 89) 6668) ;; (osc-reflector-test 6667 #(10 0 0 89) 6668)
;; ;;
;;;;;:::;;: ; ; ;::: ; ;; ;; ; ;; ; ;;;;;:::;;: ; ; ;::: ; ;; ;; ; ;; ;
(require :sb-bsd-sockets) (eval-when (:compile-toplevel :load-toplevel)
(use-package :osc) (ql:quickload :osc)
(use-package :sb-bsd-sockets) (ql:quickload :usocket)
(use-package :osc)
(use-package :usocket))
(defun osc-listen-test (port)
(defun osc-listen (port)
"a basic test function which attempts to decode an osc message a given port." "a basic test function which attempts to decode an osc message a given port."
(let ((s (make-udp-socket)) (let ((s (socket-connect nil nil
(buffer (make-sequence '(vector (unsigned-byte 8)) 1024))) :local-port port
(socket-bind s #(0 0 0 0) port) :protocol :datagram
:element-type '(unsigned-byte 8)))
(buffer (make-sequence '(vector (unsigned-byte 8)) 1024)))
(format t "listening on localhost port ~A~%~%" port) (format t "listening on localhost port ~A~%~%" port)
(unwind-protect (unwind-protect
(loop do (loop do
(socket-receive s buffer nil) (socket-receive s buffer (length buffer))
(format t "receiveded -=> ~S~%" (osc:decode-bundle buffer))) (format t "received -=> ~S~%" (osc:decode-bundle buffer)))
(when s (socket-close s))))) (when s (socket-close s)))))
(defun osc-send-test (host port)
"a basic test function which sends osc test message to a given port/hostname."
(let ((s (socket-connect host port
:protocol :datagram
:element-type '(unsigned-byte 8)))
(b (osc:encode-message "/foo/bar" "baz" 1 2 3 (coerce PI 'single-float))))
(format t "listening on localhost port ~A~%~%" port)
(unwind-protect
(socket-send s b (length b))
(when s (socket-close s)))))
(defun osc-reflector (listen-port send-ip send-port) (defun osc-reflector-test (listen-port send-host send-port)
"reflector.. . listens on a given port and sends out on another "reflector.. . listens on a given port and sends out on another"
note ip#s need to be in the format #(127 0 0 1) for now.. ." (let ((in (socket-connect nil nil
(let ((in (make-udp-socket)) :local-port listen-port
(out (make-udp-socket)) :protocol :datagram
(buffer (make-sequence '(vector (unsigned-byte 8)) 512))) :element-type '(unsigned-byte 8)))
(socket-bind in #(0 0 0 0) listen-port) (out (socket-connect send-host send-port
(socket-connect out send-ip send-port) :protocol :datagram
(let ((stream :element-type '(unsigned-byte 8)))
(socket-make-stream (buffer (make-sequence '(vector (unsigned-byte 8)) 1024)))
out :input t :output t (unwind-protect
:element-type '(unsigned-byte 8) :buffering :full))) (loop do
(unwind-protect (socket-receive in buffer (length buffer))
(loop do (format t "glonked -=> message: ~{~A, ~}~%"
(socket-receive in buffer nil) (osc:decode-bundle buffer))
(let ((oscuff (osc:decode-bundle buffer))) (let ((mess (apply #'osc:encode-message
(format t "glonked -=> message with ~S~% arg(s)" (length oscuff)) (cons "/echo"
(write-stream-t1 stream oscuff))) (osc:decode-message buffer)))))
(when in (socket-close in)) (socket-send out mess (length mess))))
(when out (socket-close out)))))) (when in (socket-close in))
(when out (socket-close out)))))
(defun make-udp-socket()
(make-instance 'inet-socket :type :datagram :protocol :udp))
(defun write-stream-t1 (stream osc-message)
"writes a given message to a stream. keep in mind that when using a buffered
stream any funtion writing to the stream should call (finish-output stream)
after it sends the mesages,. ."
(write-sequence
(osc:encode-message "/bzzp" "got" "it" )
stream)
(finish-output stream))
(defmacro osc-write-to-stream (stream &body args)
`(progn (write-sequence (osc:encode-message ,@args) ,stream)
(finish-output ,stream)))
;end ;end