osc-examples.lisp

@@ -19,69 +19,74 @@
 ;;
 ;;  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 #(127 0 0 1) 6668)
 ;;
 ;;  eg. listen on port 6667 and send to 10.0.89:6668
 ;;     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)
+  (defpackage osc-examples (:use :cl :osc :usocket)))
+(in-package :osc-examples)
 
-
+(defun osc-receive-test (port)
-(defun osc-listen (port) 
+  "a basic test function which attempts to decode an osc message on given port.
-  "a basic test function which attempts to decode an osc message a given port."
+  note ip#s need to be in the format #(127 0 0 1) for now.. ."
-  (let ((s (make-udp-socket))
+  (let ((s (socket-connect nil nil
+			   :local-port port
+			   :local-host #(127 0 0 1)
+			   :protocol :datagram
+			   :element-type '(unsigned-byte 8)))
 	(buffer (make-sequence '(vector (unsigned-byte 8)) 1024)))
-    (socket-bind s #(0 0 0 0) port)
     (format t "listening on localhost port ~A~%~%" port)
     (unwind-protect
 	 (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)))))
 
+(defun osc-send-test (host port)
+  "a basic test function which sends osc test message to a given port/hostname.
+  note ip#s need to be in the format #(127 0 0 1) for now.. ."
+  (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 "sending to ~a on port ~A~%~%" host 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
   note ip#s need to be in the format #(127 0 0 1) for now.. ."
-  (let ((in (make-udp-socket))
+  (let ((in (socket-connect nil nil
-        (out (make-udp-socket))
+			    :local-port listen-port
-	(buffer (make-sequence '(vector (unsigned-byte 8)) 512)))
+			    :local-host #(127 0 0 1)
-    (socket-bind in #(0 0 0 0) listen-port)
+			    :protocol :datagram
-    (socket-connect out send-ip send-port)
+			    :element-type '(unsigned-byte 8)))
-    (let ((stream 
+	(out (socket-connect send-host send-port
-	   (socket-make-stream
+			     :protocol :datagram
-	    out :input t :output t 
+			     :element-type '(unsigned-byte 8)))
-	    :element-type '(unsigned-byte 8) :buffering :full)))
+	(buffer (make-sequence '(vector (unsigned-byte 8)) 1024)))
     (unwind-protect
 	 (loop do
-		(socket-receive in buffer nil)
+	      (socket-receive in buffer (length buffer))
-		(let ((oscuff (osc:decode-bundle buffer)))
+	      (format t "glonked -=> message: ~{~A, ~}~%"
-		  (format t "glonked -=> message with ~S~% arg(s)" (length oscuff))
+		      (osc:decode-bundle buffer))
-		  (write-stream-t1 stream oscuff)))
+	      (let ((mess (apply #'osc:encode-message
+				 (cons "/echo"
+				       (osc:decode-message buffer)))))
+		(socket-send out mess (length mess))))
       (when in (socket-close in))
- 	(when out (socket-close out)))))) 
+      (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