liblo-devel Mailing List for LibLO

On Tue, Jan 19, 2010 at 2:55 AM, IOhannes m zmoelnig <zmo...@ie...> wrote:
> this means that you have to make sure that you get the stream from the
> beginning, as there is no other way to find the beginning of a new
> package within the stream.

Forgot to mention, on this point the CNMAT folks have been encouraging
developers to go towards using SLIP encoding to help with this
problem.  Personally I'm not convinced that it's needed over TCP but
is probably useful for serial ports.  (Although over serial maybe
you'd also want an error-correcting packet protocol..)

Anyways, it might be interesting in liblo to optionally support SLIP
for stream protocols.

http://cnmat.berkeley.edu/user/andy_schmeder/blog/2008/01/05/note_slip_osc
http://lists.create.ucsb.edu/pipermail/osc_dev/2008-January/001294.html

Steve

Hi,

I think IOhanne's explanation was accurate.  I'd love to do more
testing and standardization of different OSC/TCP implementations, we
should definitely make sure we are all on the same page.

As for IOhanne's request for bidirectional TCP, this is still on the
table for liblo.  Suggested API changes or patches on this topic are
welcome.

I haven't had time to work on liblo lately, but hopefully I will get
back to it once some of my other responsibilities (i.e., writing
papers) are handled.

Steve



On Tue, Jan 19, 2010 at 7:54 AM, Alexandre Quessy <ale...@qu...> wrote:
> Allo IOhannes !
> Thanks for the hint. (how come I didn't get to read that paragraph?)
> That means it's going to be quite easy to implement. Then, we're almost.
> Oh, yeah, we'll make sure it work bidirectionally. :-)
>
> a
>
> IOhannes m zmoelnig wrote:
>> Alexandre Quessy wrote:
>>> Hello everyone!
>>> Arjan Scherpenisse (from Amsterdam) and I have just finished a new
>>> pure-Python implementation of OSC using Twisted. You can read or get it
>>> from http://bitbucket.org/arjan/twisted-osc/
>>>
>>> As a liblo user, I know that liblo (kind of) supports TCP as well. I
>>> would like to know how is the parsing done. Is there a separator that
>>> you use ? In UDP, each message is in a datagram, so they are naturally
>>> separated. In TCP, there is no such a separation. How do you distinguish
>>> each message or bundle ?
>>>
>>
>> in section "OSC Packets" of the "Open Sound Control 1.0 Specification"
>> [1] it says: "In a stream-based protocol such as TCP, the stream should
>> begin with an int32 giving the size of the first packet, followed by the
>> contents of the first packet, followed by the size of the second packet,
>> etc."
>> (in short: prefix every OSCpackage with a 32bit number indicating the
>> length of the OSCpackage)
>>
>> not being a liblo developer, i find that this has been implemented
>> correctly (at least i was able to send data to or(?) from Pd to liblo
>> via tcp/ip.
>>
>> this means that you have to make sure that you get the stream from the
>> beginning, as there is no other way to find the beginning of a new
>> package within the stream.
>>
>>
>> btw, while you are there, make sure that bi-directional communication
>> via tcp/ip works with your implementation.
>>
>>
>> fgmasdr
>> IOhannes
>>
>>
>>
>>
>>
>>
>>
>>
>> [1] http://opensoundcontrol.org/spec-1_0
>>
>>
>> ------------------------------------------------------------------------
>>
>> ------------------------------------------------------------------------------
>> Throughout its 18-year history, RSA Conference consistently attracts the
>> world's best and brightest in the field, creating opportunities for Conference
>> attendees to learn about information security's most important issues through
>> interactions with peers, luminaries and emerging and established companies.
>> http://p.sf.net/sfu/rsaconf-dev2dev
>>
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> liblo-devel mailing list
>> lib...@li...
>> https://lists.sourceforge.net/lists/listinfo/liblo-devel
>
> ------------------------------------------------------------------------------
> Throughout its 18-year history, RSA Conference consistently attracts the
> world's best and brightest in the field, creating opportunities for Conference
> attendees to learn about information security's most important issues through
> interactions with peers, luminaries and emerging and established companies.
> http://p.sf.net/sfu/rsaconf-dev2dev
> _______________________________________________
> liblo-devel mailing list
> lib...@li...
> https://lists.sourceforge.net/lists/listinfo/liblo-devel
>

Allo IOhannes !
Thanks for the hint. (how come I didn't get to read that paragraph?)
That means it's going to be quite easy to implement. Then, we're almost.
Oh, yeah, we'll make sure it work bidirectionally. :-)

a

IOhannes m zmoelnig wrote:
> Alexandre Quessy wrote:
>> Hello everyone!
>> Arjan Scherpenisse (from Amsterdam) and I have just finished a new
>> pure-Python implementation of OSC using Twisted. You can read or get it
>> from http://bitbucket.org/arjan/twisted-osc/
>>
>> As a liblo user, I know that liblo (kind of) supports TCP as well. I
>> would like to know how is the parsing done. Is there a separator that
>> you use ? In UDP, each message is in a datagram, so they are naturally
>> separated. In TCP, there is no such a separation. How do you distinguish
>> each message or bundle ?
>>
> 
> in section "OSC Packets" of the "Open Sound Control 1.0 Specification"
> [1] it says: "In a stream-based protocol such as TCP, the stream should
> begin with an int32 giving the size of the first packet, followed by the
> contents of the first packet, followed by the size of the second packet,
> etc."
> (in short: prefix every OSCpackage with a 32bit number indicating the
> length of the OSCpackage)
> 
> not being a liblo developer, i find that this has been implemented
> correctly (at least i was able to send data to or(?) from Pd to liblo
> via tcp/ip.
> 
> this means that you have to make sure that you get the stream from the
> beginning, as there is no other way to find the beginning of a new
> package within the stream.
> 
> 
> btw, while you are there, make sure that bi-directional communication
> via tcp/ip works with your implementation.
> 
> 
> fgmasdr
> IOhannes
> 
> 
> 
> 
> 
> 
> 
> 
> [1] http://opensoundcontrol.org/spec-1_0
> 
> 
> ------------------------------------------------------------------------
> 
> ------------------------------------------------------------------------------
> Throughout its 18-year history, RSA Conference consistently attracts the
> world's best and brightest in the field, creating opportunities for Conference
> attendees to learn about information security's most important issues through
> interactions with peers, luminaries and emerging and established companies.
> http://p.sf.net/sfu/rsaconf-dev2dev
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> liblo-devel mailing list
> lib...@li...
> https://lists.sourceforge.net/lists/listinfo/liblo-devel

Alexandre Quessy wrote:
> Hello everyone!
> Arjan Scherpenisse (from Amsterdam) and I have just finished a new
> pure-Python implementation of OSC using Twisted. You can read or get it
> from http://bitbucket.org/arjan/twisted-osc/
> 
> As a liblo user, I know that liblo (kind of) supports TCP as well. I
> would like to know how is the parsing done. Is there a separator that
> you use ? In UDP, each message is in a datagram, so they are naturally
> separated. In TCP, there is no such a separation. How do you distinguish
> each message or bundle ?
> 

in section "OSC Packets" of the "Open Sound Control 1.0 Specification"
[1] it says: "In a stream-based protocol such as TCP, the stream should
begin with an int32 giving the size of the first packet, followed by the
contents of the first packet, followed by the size of the second packet,
etc."
(in short: prefix every OSCpackage with a 32bit number indicating the
length of the OSCpackage)

not being a liblo developer, i find that this has been implemented
correctly (at least i was able to send data to or(?) from Pd to liblo
via tcp/ip.

this means that you have to make sure that you get the stream from the
beginning, as there is no other way to find the beginning of a new
package within the stream.


btw, while you are there, make sure that bi-directional communication
via tcp/ip works with your implementation.


fgmasdr
IOhannes








[1] http://opensoundcontrol.org/spec-1_0

Hello everyone!
Arjan Scherpenisse (from Amsterdam) and I have just finished a new
pure-Python implementation of OSC using Twisted. You can read or get it
from http://bitbucket.org/arjan/twisted-osc/

As a liblo user, I know that liblo (kind of) supports TCP as well. I
would like to know how is the parsing done. Is there a separator that
you use ? In UDP, each message is in a datagram, so they are naturally
separated. In TCP, there is no such a separation. How do you distinguish
each message or bundle ?

Thanks !

a