lo.h   lo.h 
skipping to change at line 33 skipping to change at line 33
/** /**
* \file lo.h The liblo main headerfile and high-level API functions. * \file lo.h The liblo main headerfile and high-level API functions.
*/ */
#include "lo/lo_endian.h" #include "lo/lo_endian.h"
#include "lo/lo_types.h" #include "lo/lo_types.h"
#include "lo/lo_osc_types.h" #include "lo/lo_osc_types.h"
#include "lo/lo_errors.h" #include "lo/lo_errors.h"
#include "lo/lo_lowlevel.h" #include "lo/lo_lowlevel.h"
#if 1
#include "lo/lo_serverthread.h"
#endif
/** /**
* \defgroup liblo High-level OSC API * \defgroup liblo High-level OSC API
* *
* Defines the high-level API functions necessary to implement OSC support. * Defines the high-level API functions necessary to implement OSC support.
* Should be adequate for most applications, but if you require lower level * Should be adequate for most applications, but if you require lower level
* control you can use the functions defined in lo_lowlevel.h * control you can use the functions defined in lo_lowlevel.h
* @{ * @{
*/ */
skipping to change at line 188 skipping to change at line 191
*/ */
int lo_address_errno(lo_address a); int lo_address_errno(lo_address a);
/** /**
* \brief Return the error string from the last failed lo_send() or * \brief Return the error string from the last failed lo_send() or
* lo_address_new() call * lo_address_new() call
*/ */
const char *lo_address_errstr(lo_address a); const char *lo_address_errstr(lo_address a);
/** /**
* \brief Create a new server thread to handle incoming OSC
* messages.
*
* Server threads take care of the message reception and dispatch by
* transparently creating a system thread to handle incoming messages.
* Use this if you do not want to handle the threading yourself.
*
* \param port If NULL is passed then an unused port will be chosen by the
* system, its number may be retrieved with lo_server_thread_get_port()
* so it can be passed to clients. Otherwise a decimal port number, service
* name or UNIX domain socket path may be passed.
* \param err_h A function that will be called in the event of an error bei
ng
* raised. The function prototype is defined in lo_types.h
*/
lo_server_thread lo_server_thread_new(const char *port, lo_err_handler err_
h);
/**
* \brief Create a new server thread to handle incoming OSC
* messages, and join a UDP multicast group.
*
* Server threads take care of the message reception and dispatch by
* transparently creating a system thread to handle incoming messages.
* Use this if you do not want to handle the threading yourself.
*
* \param group The multicast group to join. See documentation on IP
* multicast for the acceptable address range; e.g., http://tldp.org/HOWTO/
Multicast-HOWTO-2.html
* \param port If NULL is passed then an unused port will be chosen by the
* system, its number may be retrieved with lo_server_thread_get_port()
* so it can be passed to clients. Otherwise a decimal port number, service
* name or UNIX domain socket path may be passed.
* \param err_h A function that will be called in the event of an error bei
ng
* raised. The function prototype is defined in lo_types.h
*/
lo_server_thread lo_server_thread_new_multicast(const char *group, const ch
ar *port,
lo_err_handler err_h);
/**
* \brief Create a new server thread to handle incoming OSC
* messages, specifying protocol.
*
* Server threads take care of the message reception and dispatch by
* transparently creating a system thread to handle incoming messages.
* Use this if you do not want to handle the threading yourself.
*
* \param port If NULL is passed then an unused port will be chosen by the
* system, its number may be retrieved with lo_server_thread_get_port()
* so it can be passed to clients. Otherwise a decimal port number, service
* name or UNIX domain socket path may be passed.
* \param proto The protocol to use, should be one of LO_UDP, LO_TCP or LO_
UNIX.
* \param err_h A function that will be called in the event of an error bei
ng
* raised. The function prototype is defined in lo_types.h
*/
lo_server_thread lo_server_thread_new_with_proto(const char *port, int prot
o,
lo_err_handler err_h);
/**
* \brief Free memory taken by a server thread
*
* Frees the memory, and, if currently running will stop the associated thr
ead.
*/
void lo_server_thread_free(lo_server_thread st);
/**
* \brief Add an OSC method to the specifed server thread.
*
* \param st The server thread the method is to be added to.
* \param path The OSC path to register the method to. If NULL is passed th
e
* method will match all paths.
* \param typespec The typespec the method accepts. Incoming messages with
* similar typespecs (e.g. ones with numerical types in the same position)
will
* be coerced to the typespec given here.
* \param h The method handler callback function that will be called it a
* matching message is received
* \param user_data A value that will be passed to the callback function, h
,
* when its invoked matching from this method.
*/
lo_method lo_server_thread_add_method(lo_server_thread st, const char *path
,
const char *typespec, lo_method_handler h,
void *user_data);
/**
* \brief Delete an OSC method from the specifed server thread.
*
* \param st The server thread the method is to be removed from.
* \param path The OSC path of the method to delete. If NULL is passed the
* method will match the generic handler.
* \param typespec The typespec the method accepts.
*/
void lo_server_thread_del_method(lo_server_thread st, const char *path,
const char *typespec);
/**
* \brief Start the server thread
*
* \param st the server thread to start.
* \return Less than 0 on failure, 0 on success.
*/
int lo_server_thread_start(lo_server_thread st);
/**
* \brief Stop the server thread
*
* \param st the server thread to start.
* \return Less than 0 on failure, 0 on success.
*/
int lo_server_thread_stop(lo_server_thread st);
/**
* \brief Return the port number that the server thread has bound to.
*/
int lo_server_thread_get_port(lo_server_thread st);
/**
* \brief Return a URL describing the address of the server thread.
*
* Return value must be free()'d to reclaim memory.
*/
char *lo_server_thread_get_url(lo_server_thread st);
/**
* \brief Return the lo_server for a lo_server_thread
*
* This function is useful for passing a thread's lo_server
* to lo_send_from().
*/
lo_server lo_server_thread_get_server(lo_server_thread st);
/** \brief Return true if there are scheduled events (eg. from bundles) wai
ting
* to be dispatched by the thread */
int lo_server_thread_events_pending(lo_server_thread st);
/**
* \brief Create a new OSC blob type. * \brief Create a new OSC blob type.
* *
* \param size The amount of space to allocate in the blob structure. * \param size The amount of space to allocate in the blob structure.
* \param data The data that will be used to initialise the blob, should be * \param data The data that will be used to initialise the blob, should be
* size bytes long. * size bytes long.
*/ */
lo_blob lo_blob_new(int32_t size, const void *data); lo_blob lo_blob_new(int32_t size, const void *data);
/** /**
* \brief Free the memory taken by a blob * \brief Free the memory taken by a blob
 End of changes. 2 change blocks. 
145 lines changed or deleted 3 lines changed or added


 lo_endian.h   lo_endian.h 
skipping to change at line 21 skipping to change at line 21
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details. * GNU Lesser General Public License for more details.
* *
* $Id$ * $Id$
*/ */
#ifndef LO_ENDIAN_H #ifndef LO_ENDIAN_H
#define LO_ENDIAN_H #define LO_ENDIAN_H
#include <sys/types.h> #include <sys/types.h>
#ifdef _MSC_VER
#ifndef UINTSDEFINED
#define UINTSDEFINED
#define int32_t __int32
#define int64_t __int64
#define uint32_t unsigned __int32
#define uint64_t unsigned __int64
#define uint8_t unsigned __int8
#endif
#else
#include <stdint.h> #include <stdint.h>
#endif
#ifdef WIN32 #if defined(WIN32) || defined(_MSC_VER)
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#else #else
#include <netinet/in.h> #include <netinet/in.h>
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
skipping to change at line 89 skipping to change at line 101
#else #else
typedef union { typedef union {
uint64_t all; uint64_t all;
struct { struct {
uint32_t a; uint32_t a;
uint32_t b; uint32_t b;
} part; } part;
} lo_split64; } lo_split64;
static inline uint64_t lo_swap64(uint64_t x) #ifdef _MSC_VER
#define LO_INLINE __inline
#else
#define LO_INLINE inline
#endif
static LO_INLINE uint64_t lo_swap64(uint64_t x)
{ {
lo_split64 in, out; lo_split64 in, out;
in.all = x; in.all = x;
out.part.a = lo_swap32(in.part.b); out.part.a = lo_swap32(in.part.b);
out.part.b = lo_swap32(in.part.a); out.part.b = lo_swap32(in.part.a);
return out.all; return out.all;
} }
#undef LO_INLINE
#endif #endif
/* Host to OSC and OSC to Host conversion macros */ /* Host to OSC and OSC to Host conversion macros */
#if 0 #if 0
#define lo_htoo16(x) (x) #define lo_htoo16(x) (x)
#define lo_htoo32(x) (x) #define lo_htoo32(x) (x)
#define lo_htoo64(x) (x) #define lo_htoo64(x) (x)
#define lo_otoh16(x) (x) #define lo_otoh16(x) (x)
#define lo_otoh32(x) (x) #define lo_otoh32(x) (x)
 End of changes. 5 change blocks. 
2 lines changed or deleted 20 lines changed or added


 lo_lowlevel.h   lo_lowlevel.h 
skipping to change at line 32 skipping to change at line 32
/** /**
* \file lo_lowlevel.h The liblo headerfile defining the low-level API * \file lo_lowlevel.h The liblo headerfile defining the low-level API
* functions. * functions.
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdarg.h> #include <stdarg.h>
#include <sys/types.h>
#ifdef _MSC_VER #ifdef _MSC_VER
#define ssize_t SSIZE_T #define ssize_t SSIZE_T
#define uint32_t unsigned __int32 #define uint32_t unsigned __int32
#else #else
#include <stdint.h> #include <stdint.h>
#endif #endif
#include "lo/lo_types.h" #include "lo/lo_types.h"
#include "lo/lo_errors.h" #include "lo/lo_errors.h"
skipping to change at line 109 skipping to change at line 110
* \param b The bundle itself * \param b The bundle itself
*/ */
int lo_send_bundle_from(lo_address targ, lo_server serv, lo_bundle b); int lo_send_bundle_from(lo_address targ, lo_server serv, lo_bundle b);
/** /**
* \brief Create a new lo_message object * \brief Create a new lo_message object
*/ */
lo_message lo_message_new(); lo_message lo_message_new();
/** /**
* \brief Add one to a message's reference count.
*
* Messages are reference counted. If a message is multiply referenced,
* the message's counter should be incremented. It is automatically
* decremented by lo_message_free lo_message_free_recursive, with
* lo_message_free_recursive being the preferable method.
*/
void lo_message_incref(lo_message m);
/**
* \brief Create a new lo_message object by cloning an already existing one
*/
lo_message lo_message_clone(lo_message m);
/**
* \brief Free memory allocated by lo_message_new() and any subsequent * \brief Free memory allocated by lo_message_new() and any subsequent
* \ref lo_message_add_int32 lo_message_add*() calls. * \ref lo_message_add_int32 lo_message_add*() calls.
*/ */
void lo_message_free(lo_message m); void lo_message_free(lo_message m);
/** /**
* \brief Append a number of arguments to a message. * \brief Append a number of arguments to a message.
* *
* The data will be added in OSC byteorder (bigendian). * The data will be added in OSC byteorder (bigendian).
* *
skipping to change at line 417 skipping to change at line 433
/** /**
* \brief Get the Time-to-Live value for a given target address. * \brief Get the Time-to-Live value for a given target address.
* *
* \param t An OSC address. * \param t An OSC address.
* \return An integer specifying the scope of a multicast UDP message. * \return An integer specifying the scope of a multicast UDP message.
*/ */
int lo_address_get_ttl(lo_address t); int lo_address_get_ttl(lo_address t);
/** /**
* \brief Set the network interface to use for a given target address.
*
* The caller should specify either the iface or ip variable. The IP,
* if specified, should match the same network family as the OSC
* address. (That is, should correctly correspond to IPv4 or IPv6.)
* Typically the assigned network interface will only be used in the
* case of sending multicast messages. It is recommended to use the
* if_nameindex POSIX function to get a list of network interface
* names.
*
* \param t An OSC address.
* \param iface The name of a network interface on the local system.
* \param ip The IP address of a network interface on the local system.
* \return 0 if the interface was successfully identified, or non-zero
* otherwise.
*/
int lo_address_set_iface(lo_address t, const char *iface, const char *ip);
/**
* \brief Get the name of the network interface assigned to an OSC address
.
*
* \param t An OSC address.
* \return A string pointer or 0 if no interface has been assigned.
* Caller should not modify the provided string. It is a
* legal pointer until the next call to lo_address_set_iface
* or lo_address_free.
*/
const char* lo_address_get_iface(lo_address t);
/**
* \brief Set the TCP_NODELAY flag on outgoing TCP connections.
* \param t The address to set this flag for.
* \param enable Non-zero to set the flag, zero to unset it.
* \return the previous value of this flag.
*/
int lo_address_set_tcp_nodelay(lo_address t, int enable);
/**
* \brief Set outgoing stream connections (e.g., TCP) to be
* transmitted using the SLIP packetizing protocol.
* \param t The address to set this flag for.
* \param enable Non-zero to set the flag, zero to unset it.
* \return the previous value of this flag.
*/
int lo_address_set_stream_slip(lo_address t, int enable);
/**
* \brief Create a new bundle object. * \brief Create a new bundle object.
* *
* OSC Bundles encapsulate one or more OSC messages and may include a times tamp * OSC Bundles encapsulate one or more OSC messages and may include a times tamp
* indicating when the bundle should be dispatched. * indicating when the bundle should be dispatched.
* *
* \param tt The timestamp when the bundle should be handled by the receive r. * \param tt The timestamp when the bundle should be handled by the receive r.
* Pass LO_TT_IMMEDIATE if you want the receiving server to dispa tch * Pass LO_TT_IMMEDIATE if you want the receiving server to dispa tch
* the bundle as soon as it receives it. * the bundle as soon as it receives it.
*/ */
lo_bundle lo_bundle_new(lo_timetag tt); lo_bundle lo_bundle_new(lo_timetag tt);
/** /**
* \brief Add one to a bundle's reference count.
*
* Bundles are reference counted. If a bundle is multiply referenced,
* the bundle's counter should be incremented. It is automatically
* decremented by lo_bundle_free lo_bundle_free_recursive, with
* lo_bundle_free_recursive being the preferable method.
*/
void lo_bundle_incref(lo_bundle b);
/**
* \brief Adds an OSC message to an existing bundle. * \brief Adds an OSC message to an existing bundle.
* *
* The message passed is appended to the list of messages in the bundle to be * The message passed is appended to the list of messages in the bundle to be
* dispatched to 'path'. * dispatched to 'path'.
* *
* \return 0 if successful, less than 0 otherwise. * \return 0 if successful, less than 0 otherwise.
*/ */
int lo_bundle_add_message(lo_bundle b, const char *path, lo_message m); int lo_bundle_add_message(lo_bundle b, const char *path, lo_message m);
/** /**
* \brief Adds an OSC bundle to an existing bundle.
*
* The child bundle passed is appended to the list of child bundles|message
s in the parent bundle to be
* dispatched.
*
* \return 0 if successful, less than 0 otherwise.
*/
int lo_bundle_add_bundle(lo_bundle b, lo_bundle n);
/**
* \brief Return the length of a bundle in bytes. * \brief Return the length of a bundle in bytes.
* *
* Includes the marker and typetage length. * Includes the marker and typetage length.
* *
* \param b The bundle to be sized * \param b The bundle to be sized
*/ */
size_t lo_bundle_length(lo_bundle b); size_t lo_bundle_length(lo_bundle b);
/** /**
* \brief Return the number of top-level elements in a bundle.
*
* \param b The bundle to be counted.
*/
unsigned int lo_bundle_count(lo_bundle b);
/**
* \brief Gets the element type contained within a bundle.
*
* Returns a lo_element_type at a given index within a bundle.
* \return The requested lo_element_type if successful, otherwise 0.
*/
lo_element_type lo_bundle_get_type(lo_bundle b, int index);
/**
* \brief Gets a nested bundle contained within a bundle.
*
* Returns a lo_bundle at a given index within a bundle.
*
* \return The requested lo_bundle if successful, otherwise 0.
*/
lo_bundle lo_bundle_get_bundle(lo_bundle b, int index);
/**
* \brief Gets a message contained within a bundle.
*
* Returns a lo_message at a given index within a bundle, and
* optionally the path associated with that message.
*
* \return The requested lo_message if successful, otherwise 0.
*/
lo_message lo_bundle_get_message(lo_bundle b, int index,
const char **path);
/**
* \brief Serialise the bundle object to an area of memory and return a * \brief Serialise the bundle object to an area of memory and return a
* pointer to the serialised form. * pointer to the serialised form.
* *
* \param b The bundle to be serialised * \param b The bundle to be serialised
* \param to The address to serialise to, memory will be allocated if to is * \param to The address to serialise to, memory will be allocated if to is
* NULL. * NULL.
* \param size If this pointer is non-NULL the size of the memory area * \param size If this pointer is non-NULL the size of the memory area
* will be written here * will be written here
* *
* The returned form is suitable to be sent over a low level OSC transport, * The returned form is suitable to be sent over a low level OSC transport,
skipping to change at line 470 skipping to change at line 589
void *lo_bundle_serialise(lo_bundle b, void *to, size_t *size); void *lo_bundle_serialise(lo_bundle b, void *to, size_t *size);
/** /**
* \brief Frees the memory taken by a bundle object. * \brief Frees the memory taken by a bundle object.
* *
* \param b The bundle to be freed. * \param b The bundle to be freed.
*/ */
void lo_bundle_free(lo_bundle b); void lo_bundle_free(lo_bundle b);
/** /**
* \brief Frees the memory taken by a bundle object and messages in the bu * \brief Frees the memory taken by a bundle object and its messages and n
ndle. ested bundles recursively.
*
* \param b The bundle, which may contain messages and nested bundles, to b
e freed.
*/
void lo_bundle_free_recursive(lo_bundle b);
/**
* \brief Obsolete, use lo_bundle_free_recursive instead.
* *
* \param b The bundle, which may contain messages, to be freed. * \param b The bundle, which may contain messages and nested bundles, to b e freed.
*/ */
void lo_bundle_free_messages(lo_bundle b); void lo_bundle_free_messages(lo_bundle b);
/** /**
* \brief Return true if the type specified has a numerical value, such as * \brief Return true if the type specified has a numerical value, such as
* LO_INT32, LO_FLOAT etc. * LO_INT32, LO_FLOAT etc.
* *
* \param a The type to be tested. * \param a The type to be tested.
*/ */
int lo_is_numerical_type(lo_type a); int lo_is_numerical_type(lo_type a);
skipping to change at line 569 skipping to change at line 695
* Otherwise a decimal port number or service name or may be passed. * Otherwise a decimal port number or service name or may be passed.
* If using UNIX domain sockets then a socket path should be passed here. * If using UNIX domain sockets then a socket path should be passed here.
* \param err_h An error callback function that will be called if there is an * \param err_h An error callback function that will be called if there is an
* error in messge reception or server creation. Pass NULL if you do not wa nt * error in messge reception or server creation. Pass NULL if you do not wa nt
* error handling. * error handling.
*/ */
lo_server lo_server_new_multicast(const char *group, const char *port, lo_server lo_server_new_multicast(const char *group, const char *port,
lo_err_handler err_h); lo_err_handler err_h);
/** /**
* \brief Create a new server instance, and join a UDP multicast
* group, optionally specifying which network interface to use.
* Note that usually only one of iface or ip are specified.
*
* \param group The multicast group to join. See documentation on IP
* multicast for the acceptable address range; e.g., http://tldp.org/HOWTO/
Multicast-HOWTO-2.html
* \param port If using UDP then NULL may be passed to find an unused port.
* Otherwise a decimal port number or service name or may be passed.
* If using UNIX domain sockets then a socket path should be passed here.
* \param iface A string specifying the name of a network interface to
* use, or zero if not specified.
* \param ip A string specifying the IP address of a network interface
* to use, or zero if not specified.
* \param err_h An error callback function that will be called if there is
an
* error in messge reception or server creation. Pass NULL if you do not wa
nt
* error handling.
*/
lo_server lo_server_new_multicast_iface(const char *group, const char *port
,
const char *iface, const char *ip,
lo_err_handler err_h);
/**
* \brief Create a new server instance, taking port and the optional
* multicast group IP from an URL string.
*
* \param url The URL to specify the server parameters.
* \param err_h An error callback function that will be called if there is
an
* error in messge reception or server creation. Pass NULL if you do not wa
nt
* error handling.
* \return A new lo_server instance.
*/
lo_server lo_server_new_from_url(const char *url,
lo_err_handler err_h);
/**
* \brief Enables or disables type coercion during message dispatch.
* \param server The server to toggle this option for.
* \param enable Non-zero to enable, or zero to disable type coercion.
* \return The previous value of this option.
*/
int lo_server_enable_coercion(lo_server server, int enable);
/**
* \brief Free up memory used by the lo_server object * \brief Free up memory used by the lo_server object
*/ */
void lo_server_free(lo_server s); void lo_server_free(lo_server s);
/** /**
* \brief Wait for an OSC message to be received * \brief Wait for an OSC message to be received
* *
* \param s The server to wait for connections on. * \param s The server to wait for connections on.
* \param timeout A timeout in milliseconds to wait for the incoming packet . * \param timeout A timeout in milliseconds to wait for the incoming packet .
* a value of 0 will return immediately. * a value of 0 will return immediately.
skipping to change at line 637 skipping to change at line 806
* *
* \param s The server the method is to be removed from. * \param s The server the method is to be removed from.
* \param path The OSC path of the method to delete. If NULL is passed the * \param path The OSC path of the method to delete. If NULL is passed the
* method will match the generic handler. * method will match the generic handler.
* \param typespec The typespec the method accepts. * \param typespec The typespec the method accepts.
*/ */
void lo_server_del_method(lo_server s, const char *path, void lo_server_del_method(lo_server s, const char *path,
const char *typespec); const char *typespec);
/** /**
* \brief Add bundle notification handlers to the specified server.
*
* \param s The server the method is to be added to.
* \param sh The callback function that will be called before the messages
* of a bundle are dispatched
* \param eh The callback function that will be called after the messages
* of a bundle are dispatched
* \param user_data A value that will be passed to the user_data parameter
* of both callback functions.
*/
int lo_server_add_bundle_handlers(lo_server s,
lo_bundle_start_handler sh,
lo_bundle_end_handler eh,
void *user_data);
/**
* \brief Return the file descriptor of the server socket. * \brief Return the file descriptor of the server socket.
* *
* If the server protocol supports exposing the server's underlying * If the server protocol supports exposing the server's underlying
* receive mechanism for monitoring with select() or poll(), this function * receive mechanism for monitoring with select() or poll(), this function
* returns the file descriptor needed, otherwise, it returns -1. * returns the file descriptor needed, otherwise, it returns -1.
* *
* WARNING: when using this function beware that not all OSC packets that a re * WARNING: when using this function beware that not all OSC packets that a re
* received are dispatched immediately. lo_server_events_pending() and * received are dispatched immediately. lo_server_events_pending() and
* lo_server_next_event_delay() can be used to tell if there are pending * lo_server_next_event_delay() can be used to tell if there are pending
* events and how long before you should attempt to receive them. * events and how long before you should attempt to receive them.
skipping to change at line 673 skipping to change at line 858
int lo_server_get_protocol(lo_server s); int lo_server_get_protocol(lo_server s);
/** /**
* \brief Return an OSC URL that can be used to contact the server. * \brief Return an OSC URL that can be used to contact the server.
* *
* The return value should be free()'d when it is no longer needed. * The return value should be free()'d when it is no longer needed.
*/ */
char *lo_server_get_url(lo_server s); char *lo_server_get_url(lo_server s);
/** /**
* \brief Toggle event queue.
* If queueing is enabled, timetagged messages that are sent in
* advance of the current time will be put on an internal queue, and
* they will be dispatched at the indicated time. By default,
* queueing is enabled. Use this function to disable it, if it is
* desired to have a server process messages immediately. In that
* case, use lo_message_get_timestamp() to get the message timestamp
* from within a method handler.
* \param s A liblo server
* \param queue_enabled Zero to disable queue, non-zero to enable.
* \param dispatch_remaining If non-zero, previously queued messages
* will be immediately dispatched when queue
* is disabled.
* \return The previous state of queue behaviour. Zero if queueing
* was previously disabled, non-zero otherwise.
*/
int lo_server_enable_queue(lo_server s, int queue_enabled,
int dispatch_remaining);
/**
* \brief Return true if there are scheduled events (eg. from bundles) * \brief Return true if there are scheduled events (eg. from bundles)
* waiting to be dispatched by the server * waiting to be dispatched by the server
*/ */
int lo_server_events_pending(lo_server s); int lo_server_events_pending(lo_server s);
/** /**
* \brief Return the time in seconds until the next scheduled event. * \brief Return the time in seconds until the next scheduled event.
* *
* If the delay is greater than 100 seconds then it will return 100.0. * If the delay is greater than 100 seconds then it will return 100.0.
*/ */
skipping to change at line 848 skipping to change at line 1053
/** \brief Pretty-print a lo_server object. */ /** \brief Pretty-print a lo_server object. */
void lo_server_pp(lo_server s); void lo_server_pp(lo_server s);
/** \brief Pretty-print a lo_method object. */ /** \brief Pretty-print a lo_method object. */
void lo_method_pp(lo_method m); void lo_method_pp(lo_method m);
/** \brief Pretty-print a lo_method object, but prepend a given prefix /** \brief Pretty-print a lo_method object, but prepend a given prefix
* to all field names. */ * to all field names. */
void lo_method_pp_prefix(lo_method m, const char *p); void lo_method_pp_prefix(lo_method m, const char *p);
/** \brief Pretty-print a lo_server_thread object. */
void lo_server_thread_pp(lo_server_thread st);
/** @} */ /** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 12 change blocks. 
5 lines changed or deleted 217 lines changed or added


 lo_macros.h   lo_macros.h 
skipping to change at line 39 skipping to change at line 39
/* \brief A set of macros to represent different communications transports /* \brief A set of macros to represent different communications transports
*/ */
#define LO_DEFAULT 0x0 #define LO_DEFAULT 0x0
#define LO_UDP 0x1 #define LO_UDP 0x1
#define LO_UNIX 0x2 #define LO_UNIX 0x2
#define LO_TCP 0x4 #define LO_TCP 0x4
/* an internal value, ignored in transmission but check against LO_MARKER i n the /* an internal value, ignored in transmission but check against LO_MARKER i n the
* argument list. Used to do primitive bounds checking */ * argument list. Used to do primitive bounds checking */
#define LO_MARKER_A 0xdeadbeef #ifdef __LP64__
#define LO_MARKER_B 0xf00baa23 # define LO_MARKER_A (void *)0xdeadbeefdeadbeef
# define LO_MARKER_B (void *)0xf00baa23f00baa23
#else /*__LP64__*/
# define LO_MARKER_A (void *)0xdeadbeef
# define LO_MARKER_B (void *)0xf00baa23
#endif
#define LO_ARGS_END LO_MARKER_A, LO_MARKER_B #define LO_ARGS_END LO_MARKER_A, LO_MARKER_B
#define lo_message_add_varargs(msg, types, list) \ #define lo_message_add_varargs(msg, types, list) \
lo_message_add_varargs_internal(msg, types, list, __FILE__, __LINE__) lo_message_add_varargs_internal(msg, types, list, __FILE__, __LINE__)
#ifdef __GNUC__ #ifdef _MSC_VER
#ifndef USE_ANSI_C
#define USE_ANSI_C
#endif
#endif
#ifdef DLL_EXPORT
#ifndef USE_ANSI_C
#define USE_ANSI_C
#endif
#endif
#ifdef USE_ANSI_C
/* In non-GCC compilers, there is no support for variable-argument
* macros, so provide "internal" vararg functions directly instead. */
int lo_message_add(lo_message msg, const char *types, ...);
int lo_send(lo_address targ, const char *path, const char *types, ...);
int lo_send_timestamped(lo_address targ, lo_timetag ts, const char *path, c
onst char *types, ...);
int lo_send_from(lo_address targ, lo_server from, lo_timetag ts, const char
*path, const char *types, ...);
#else // !USE_ANSI_C
#define lo_message_add(msg, types...) \ #define lo_message_add(msg, types...) \
lo_message_add_internal(msg, __FILE__, __LINE__, types, \ lo_message_add_internal(msg, __FILE__, __LINE__, types, \
LO_MARKER_A, LO_MARKER_B) LO_MARKER_A, LO_MARKER_B)
#define lo_send(targ, path, types...) \ #define lo_send(targ, path, types...) \
lo_send_internal(targ, __FILE__, __LINE__, path, types, \ lo_send_internal(targ, __FILE__, __LINE__, path, types, \
LO_MARKER_A, LO_MARKER_B) LO_MARKER_A, LO_MARKER_B)
#define lo_send_timestamped(targ, ts, path, types...) \ #define lo_send_timestamped(targ, ts, path, types...) \
lo_send_timestamped_internal(targ, __FILE__, __LINE__, ts, path, \ lo_send_timestamped_internal(targ, __FILE__, __LINE__, ts, path, \
types, LO_MARKER_A, LO_MARKER_B) types, LO_MARKER_A, LO_MARKER_B)
#define lo_send_from(targ, from, ts, path, types...) \ #define lo_send_from(targ, from, ts, path, types...) \
lo_send_from_internal(targ, from, __FILE__, __LINE__, ts, path, \ lo_send_from_internal(targ, from, __FILE__, __LINE__, ts, path, \
types, LO_MARKER_A, LO_MARKER_B) types, LO_MARKER_A, LO_MARKER_B)
#else #endif // USE_ANSI_C
/* In non-GCC compilers, there is no support for variable-argument
* macros, so provide "internal" vararg functions directly instead. */
int lo_message_add(lo_message msg, const char *types, ...);
int lo_send(lo_address targ, const char *path, const char *types, ...);
int lo_send_timestamped(lo_address targ, lo_timetag ts, const char *path, c
onst char *types, ...);
int lo_send_from(lo_address targ, lo_server from, lo_timetag ts, const char
*path, const char *types, ...);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 3 change blocks. 
16 lines changed or deleted 34 lines changed or added


 lo_osc_types.h   lo_osc_types.h 
skipping to change at line 26 skipping to change at line 26
#ifndef LO_OSC_TYPES_H #ifndef LO_OSC_TYPES_H
#define LO_OSC_TYPES_H #define LO_OSC_TYPES_H
/** /**
* \file lo_osc_types.h A liblo header defining OSC-related types and * \file lo_osc_types.h A liblo header defining OSC-related types and
* constants. * constants.
*/ */
#ifdef _MSC_VER #ifdef _MSC_VER
#ifndef UINTSDEFINED
#define UINTSDEFINED
#define int32_t __int32 #define int32_t __int32
#define int64_t __int64 #define int64_t __int64
#define uint32_t unsigned __int32 #define uint32_t unsigned __int32
#define uint64_t unsigned __int64 #define uint64_t unsigned __int64
#define uint8_t unsigned __int8 #define uint8_t unsigned __int8
#endif
#else #else
#include <stdint.h> #include <stdint.h>
#endif #endif
/** /**
* \addtogroup liblo * \addtogroup liblo
* @{ * @{
*/ */
/** /**
skipping to change at line 52 skipping to change at line 55
*/ */
typedef struct { typedef struct {
/** The number of seconds since Jan 1st 1900 in the UTC timezone. */ /** The number of seconds since Jan 1st 1900 in the UTC timezone. */
uint32_t sec; uint32_t sec;
/** The fractions of a second offset from above, expressed as 1/2^32 nds /** The fractions of a second offset from above, expressed as 1/2^32 nds
* of a second */ * of a second */
uint32_t frac; uint32_t frac;
} lo_timetag; } lo_timetag;
/** /**
* \brief An enumeration of bundle element types liblo can handle.
*
* The element of a bundle can either be a message or an other bundle.
*/
typedef enum {
/** bundle element is a message */
LO_ELEMENT_MESSAGE = 1,
/** bundle element is a bundle */
LO_ELEMENT_BUNDLE = 2
} lo_element_type;
/**
* \brief An enumeration of the OSC types liblo can send and receive. * \brief An enumeration of the OSC types liblo can send and receive.
* *
* The value of the enumeration is the typechar used to tag messages and to * The value of the enumeration is the typechar used to tag messages and to
* specify arguments with lo_send(). * specify arguments with lo_send().
*/ */
typedef enum { typedef enum {
/* basic OSC types */ /* basic OSC types */
/** 32 bit signed integer. */ /** 32 bit signed integer. */
LO_INT32 = 'i', LO_INT32 = 'i',
/** 32 bit IEEE-754 float. */ /** 32 bit IEEE-754 float. */
skipping to change at line 129 skipping to change at line 144
* distinguish strings and symbols. */ * distinguish strings and symbols. */
char S; char S;
/** Standard C, 8 bit, char. */ /** Standard C, 8 bit, char. */
unsigned char c; unsigned char c;
/** A 4 byte MIDI packet. */ /** A 4 byte MIDI packet. */
uint8_t m[4]; uint8_t m[4];
/** OSC TimeTag value. */ /** OSC TimeTag value. */
lo_timetag t; lo_timetag t;
} lo_arg; } lo_arg;
/** \brief A timetag constant representing "now". */
/* Note: No struct literals in MSVC */ /* Note: No struct literals in MSVC */
#ifdef _MSC_VER #ifdef _MSC_VER
#ifndef USE_ANSI_C
#define USE_ANSI_C
#endif
#endif
#ifdef DLL_EXPORT
#ifndef USE_ANSI_C
#define USE_ANSI_C
#endif
#endif
/** \brief A timetag constant representing "now". */
#ifdef USE_ANSI_C
lo_timetag lo_get_tt_immediate(); lo_timetag lo_get_tt_immediate();
#define LO_TT_IMMEDIATE lo_get_tt_immediate() #define LO_TT_IMMEDIATE lo_get_tt_immediate()
#else #else // !USE_ANSI_C
#define LO_TT_IMMEDIATE ((lo_timetag){0U,1U}) #define LO_TT_IMMEDIATE ((lo_timetag){0U,1U})
#endif #endif // USE_ANSI_C
/** @} */ /** @} */
#endif #endif
 End of changes. 7 change blocks. 
3 lines changed or deleted 30 lines changed or added


 lo_throw.h   lo_throw.h 
skipping to change at line 26 skipping to change at line 26
#ifndef LO_THROW_H #ifndef LO_THROW_H
#define LO_THROW_H #define LO_THROW_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void lo_throw(lo_server s, int errnum, const char *message, const char *pat h); void lo_throw(lo_server s, int errnum, const char *message, const char *pat h);
/*! Since the liblo error handler does not provide a context pointer,
* it can be provided by associating it with a particular server
* through this thread-safe API. */
void *lo_error_get_context();
void lo_server_set_error_context(lo_server s, void *user_data);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 8 lines changed or added


 lo_types.h   lo_types.h 
skipping to change at line 28 skipping to change at line 28
#define LO_TYPES_H #define LO_TYPES_H
/** /**
* \file lo_types.h The liblo headerfile defining types used by this API. * \file lo_types.h The liblo headerfile defining types used by this API.
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef WIN32 #if defined(WIN32) || defined(_MSC_VER)
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#else #else
#include <netdb.h> #include <netdb.h>
#endif #endif
#include <pthread.h>
#include "lo/lo_osc_types.h" #include "lo/lo_osc_types.h"
#define LO_DISABLE 0 //!< Disable a boolean option.
#define LO_ENABLE 1 //!< Enable a boolean option.
/** /**
* \brief A reference to an OSC service. * \brief A reference to an OSC service.
* *
* Created by calls to lo_address_new() or lo_address_new_from_url(). * Created by calls to lo_address_new() or lo_address_new_from_url().
*/ */
typedef void *lo_address; typedef void *lo_address;
/** /**
* \brief A object to store an opaque binary data object. * \brief A object to store an opaque binary data object.
* *
skipping to change at line 137 skipping to change at line 138
* \param msg A structure containing the original raw message as received. No * \param msg A structure containing the original raw message as received. No
* type coercion will have occured and the data will be in OSC byte order * type coercion will have occured and the data will be in OSC byte order
* (bigendian). * (bigendian).
* \param user_data This contains the user_data value passed in the call to * \param user_data This contains the user_data value passed in the call to
* lo_server_thread_add_method. * lo_server_thread_add_method.
*/ */
typedef int (*lo_method_handler)(const char *path, const char *types, typedef int (*lo_method_handler)(const char *path, const char *types,
lo_arg **argv, int argc, lo_message msg, lo_arg **argv, int argc, lo_message msg,
void *user_data); void *user_data);
/**
* \brief A callback function to receive notification of a bundle being
* dispatched by the server or server thread.
*
* This callback allows applications to be aware of incoming bundles
* and preserve ordering and atomicity of messages in bundles.
*
* If installed with lo_server_add_bundle_handlers, this callback will be
* called with \a time set to the time tag of the bundle, and \a user_data
* set to the user_data parameter passed to lo_server_add_bundle_handlers.
*
* Note that bundles may be nested, in which case calls to the bundle start
* and end handlers will also be nested. The application can keep track of
* nested bundles in a stack-like manner by treating the start handler as
* "push" and the end handler as "pop". For example, a bundle containing t
wo
* bundles would fire 6 callbacks: begin, begin, end, begin, end, end.
*/
typedef int (*lo_bundle_start_handler)(lo_timetag time, void *user_data);
/**
* \brief A callback function to receive notification of a bundle dispatch
* being completed by the server or server thread.
*
* If installed with lo_server_add_bundle_handlers, this callback will be
* called after all the messages of a bundle have been dispatched with
* \a user_data set to the user_data parameter passed to
* lo_server_add_bundle_handlers.
*/
typedef int (*lo_bundle_end_handler)(void *user_data);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 4 change blocks. 
3 lines changed or deleted 35 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/