labrecorder 1.0.0rc0__cp311-cp311-macosx_26_0_arm64.whl

Frameworks/lsl.framework/Versions/A/include/lsl/resolver.h

@@ -0,0 +1,156 @@
+#pragma once
+#include "common.h"
+#include "types.h"
+
+/// @file resolver.h Stream resolution functions
+
+/** @defgroup continuous_resolver The lsl_continuous_resolver
+ * @ingroup resolve
+ *
+ * Streams can be resolved at a single timepoint once (@ref resolve) or continuously in the
+ * background.
+ * @{
+ */
+
+/**
+ * Construct a new #lsl_continuous_resolver that resolves all streams on the network.
+ *
+ * This is analogous to the functionality offered by the free function lsl_resolve_all().
+ * @param forget_after When a stream is no longer visible on the network (e.g. because it was shut
+ * down), this is the time in seconds after which it is no longer reported by the resolver.
+ *
+ * The recommended default value is 5.0.
+ */
+extern LIBLSL_C_API lsl_continuous_resolver lsl_create_continuous_resolver(double forget_after);
+
+/**
+ * Construct a new lsl_continuous_resolver that resolves all streams with a specific value for a given
+ * property.
+ *
+ * This is analogous to the functionality provided by the free function lsl_resolve_byprop()
+ * @param prop The #lsl_streaminfo property that should have a specific value (e.g., "name", "type",
+ * "source_id", or "desc/manufaturer").
+ * @param value The string value that the property should have (e.g., "EEG" as the type property).
+ * @param forget_after When a stream is no longer visible on the network (e.g., because it was shut
+ * down), this is the time in seconds after which it is no longer reported by the resolver.
+ * The recommended default value is 5.0.
+ */
+extern LIBLSL_C_API lsl_continuous_resolver lsl_create_continuous_resolver_byprop(const char *prop, const char *value, double forget_after);
+
+/**
+ * Construct a new lsl_continuous_resolver that resolves all streams that match a given XPath 1.0
+ * predicate.
+ *
+ * This is analogous to the functionality provided by the free function lsl_resolve_bypred()
+ * @param pred The predicate string, e.g.
+ * `"name='BioSemi'" or "type='EEG' and starts-with(name,'BioSemi') and count(info/desc/channel)=32"`
+ * @param forget_after When a stream is no longer visible on the network (e.g., because it was shut
+ * down), this is the time in seconds after which it is no longer reported by the resolver.
+ * The recommended default value is 5.0.
+ */
+extern LIBLSL_C_API lsl_continuous_resolver lsl_create_continuous_resolver_bypred(const char *pred, double forget_after);
+
+/**
+ * Obtain the set of currently present streams on the network (i.e. resolve result).
+ *
+ * @param res A continuous resolver (previously created with one of the
+ * lsl_create_continuous_resolver() functions).
+ * @param buffer A user-allocated buffer to hold the current resolve results.<br>
+ * @attention It is the user's responsibility to either destroy the resulting streaminfo objects or
+ * to pass them back to the LSL during during creation of an inlet.
+ * @attention The stream_infos returned by the resolver are only short versions that do not include
+ * the lsl_get_desc() field (which can be arbitrarily big).
+ *
+ * To obtain the full stream information you need to call lsl_get_info() on the inlet after you have
+ * created one.
+ * @param buffer_elements The user-provided buffer length.
+ * @return The number of results written into the buffer (never more than the provided # of slots)
+ * or a negative number if an error has occurred (values corresponding to #lsl_error_code_t).
+ */
+extern LIBLSL_C_API int32_t lsl_resolver_results(lsl_continuous_resolver res, lsl_streaminfo *buffer, uint32_t buffer_elements);
+
+/// Destructor for the continuous resolver.
+extern LIBLSL_C_API void lsl_destroy_continuous_resolver(lsl_continuous_resolver res);
+
+/// @}
+
+/** @defgroup resolve Resolving streams on the network
+ * @{*/
+
+/**
+ * Resolve all streams on the network.
+ *
+ * This function returns all currently available streams from any outlet on the network.
+ * The network is usually the subnet specified at the local router, but may also include a multicast
+ * group of machines (given that the network supports it), or a list of hostnames.<br>
+ * These details may optionally be customized by the experimenter in a configuration file
+ * (see page Network Connectivity in the LSL wiki).
+ * This is the default mechanism used by the browsing programs and the recording program.
+ * @param[out] buffer A user-allocated buffer to hold the resolve results.
+ * @attention It is the user's responsibility to either destroy the resulting streaminfo objects or
+ * to pass them back to the LSL during during creation of an inlet.
+ *
+ * @attention The stream_info's returned by the resolver are only short versions that do not include
+ * the lsl_get_desc() field (which can be arbitrarily big).
+ * To obtain the full stream information you need to call lsl_get_info() on the inlet after you have
+ * created one.
+ * @param buffer_elements The user-provided buffer length.
+ * @param wait_time The waiting time for the operation, in seconds, to search for streams.
+ * The recommended wait time is 1 second (or 2 for a busy and large recording operation).
+ * @warning If this is too short (<0.5s) only a subset (or none) of the outlets that are present on
+ * the network may be returned.
+ * @return The number of results written into the buffer (never more than the provided # of slots)
+ *         or a negative number if an error has occurred (values corresponding to lsl_error_code_t).
+ */
+extern LIBLSL_C_API int32_t lsl_resolve_all(lsl_streaminfo *buffer, uint32_t buffer_elements, double wait_time);
+
+/**
+ * Resolve all streams with a given value for a property.
+ *
+ * If the goal is to resolve a specific stream, this method is preferred over resolving all streams
+ * and then selecting the desired one.
+ * @param[out] buffer A user-allocated buffer to hold the resolve results.
+ * @attention It is the user's responsibility to either destroy the resulting streaminfo objects or
+ * to pass them back to the LSL during during creation of an inlet.
+ *
+ * @attention The stream_info's returned by the resolver are only short versions that do not include
+ * the lsl_get_desc() field (which can be arbitrarily big). To obtain the full stream information
+ * you need to call lsl_get_info() on the inlet after you have created one.
+ * @param buffer_elements The user-provided buffer length.
+ * @param prop The streaminfo property that should have a specific value (`"name"`, `"type"`,
+ * `"source_id"`, or, e.g., `"desc/manufaturer"` if present).
+ * @param value The string value that the property should have (e.g., "EEG" as the type).
+ * @param minimum Return at least this number of streams.
+ * @param timeout Optionally a timeout of the operation, in seconds (default: no timeout).
+ * If the timeout expires, less than the desired number of streams (possibly none) will be returned.
+ * @return The number of results written into the buffer (never more than the provided # of slots)
+ * or a negative number if an error has occurred (values corresponding to #lsl_error_code_t).
+ */
+extern LIBLSL_C_API int32_t lsl_resolve_byprop(lsl_streaminfo *buffer, uint32_t buffer_elements, const char *prop, const char *value, int32_t minimum, double timeout);
+
+/**
+ * Resolve all streams that match a given predicate.
+ *
+ * Advanced query that allows to impose more conditions on the retrieved streams;
+ * the given string is an [XPath 1.0 predicate](http://en.wikipedia.org/w/index.php?title=XPath_1.0)
+ * for the `<info>` node (omitting the surrounding []'s)
+ * @param[out] buffer A user-allocated buffer to hold the resolve results.
+ * @attention It is the user's responsibility to either destroy the resulting streaminfo objects or
+ * to pass them back to the LSL during during creation of an inlet.
+ *
+ * @attention The stream_info's returned by the resolver are only short versions that do not include
+ * the lsl_get_desc() field (which can be arbitrarily big). To obtain the full stream information
+ * you need to call lsl_get_info() on the inlet after you have created one.
+ * @param buffer_elements The user-provided buffer length.
+ * @param pred The predicate string, e.g.
+ * `name='BioSemi'` or `type='EEG' and starts-with(name,'BioSemi') and count(info/desc/channel)=32`
+ * @param minimum Return at least this number of streams.
+ * @param timeout Optionally a timeout of the operation, in seconds (default: no timeout).
+ *                If the timeout expires, less than the desired number of streams (possibly none)
+ * will be returned.
+ * @return The number of results written into the buffer (never more than the provided # of slots)
+ *         or a negative number if an error has occurred (values corresponding to lsl_error_code_t).
+ */
+extern LIBLSL_C_API int32_t lsl_resolve_bypred(lsl_streaminfo *buffer, uint32_t buffer_elements, const char *pred, int32_t minimum, double timeout);
+
+/// @}

Frameworks/lsl.framework/Versions/A/include/lsl/streaminfo.h

@@ -0,0 +1,196 @@
+#pragma once
+#include "common.h"
+#include "types.h"
+
+/// @file streaminfo.h Stream info functions
+
+/** @defgroup streaminfo The lsl_streaminfo object
+ *
+ * The #lsl_streaminfo object keeps a stream's meta data and connection settings.
+ * @{
+ */
+
+/**
+ * Construct a new streaminfo object.
+ *
+ * Core stream information is specified here. Any remaining meta-data can be added later.
+ * @param name Name of the stream.<br>
+ * Describes the device (or product series) that this stream makes available
+ *             (for use by programs, experimenters or data analysts). Cannot be empty.
+ * @param type Content type of the stream. Please see https://github.com/sccn/xdf/wiki/Meta-Data (or
+ * web search for: XDF meta-data) for pre-defined content-type names, but you can also make up your
+ * own. The content type is the preferred way to find streams (as opposed to searching by name).
+ * @param channel_count Number of channels per sample.
+ * This stays constant for the lifetime of the stream.
+ * @param nominal_srate The sampling rate (in Hz) as advertised by the
+ * datasource, if regular (otherwise set to #LSL_IRREGULAR_RATE).
+ * @param channel_format Format/type of each channel.<br>
+ * If your channels have different formats, consider supplying multiple streams
+ * or use the largest type that can hold them all (such as #cft_double64).
+ *
+ * A good default is #cft_float32.
+ * @param source_id Unique identifier of the source or device, if available (e.g. a serial number).
+ * Allows recipients to recover from failure even after the serving app or device crashes.
+ * May in some cases also be constructed from device settings.
+ * @return A newly created streaminfo handle or NULL in the event that an error occurred.
+ */
+extern LIBLSL_C_API lsl_streaminfo lsl_create_streaminfo(const char *name, const char *type, int32_t channel_count, double nominal_srate, lsl_channel_format_t channel_format, const char *source_id);
+
+/// Destroy a previously created streaminfo object.
+extern LIBLSL_C_API void lsl_destroy_streaminfo(lsl_streaminfo info);
+
+/// Copy an existing streaminfo object (rarely used).
+extern LIBLSL_C_API lsl_streaminfo lsl_copy_streaminfo(lsl_streaminfo info);
+
+/**
+ * Name of the stream.
+ *
+ * This is a human-readable name.
+ * For streams offered by device modules, it refers to the type of device or product series  that is
+ * generating the data of the stream. If the source is an application, the name may be a more
+ * generic or specific identifier. Multiple streams with the same name can coexist, though
+ * potentially at the cost of ambiguity (for the recording app or experimenter).
+ * @return An immutable library-owned pointer to the string value. @sa lsl_destroy_string()
+ */
+extern LIBLSL_C_API const char *lsl_get_name(lsl_streaminfo info);
+
+/**
+ * Content type of the stream.
+ *
+ * The content type is a short string such as "EEG", "Gaze" which describes the content carried by
+ * the channel (if known). If a stream contains mixed content this value need not be assigned but
+ * may instead be stored in the description of channel types. To be useful to applications and
+ * automated processing systems using the recommended content types is preferred. Content types
+ * usually follow those pre-defined in the [wiki](https://github.com/sccn/xdf/wiki/Meta-Data) (or
+ * web search for: XDF meta-data).
+ * @return An immutable library-owned pointer to the string value. @sa lsl_destroy_string()
+ */
+extern LIBLSL_C_API const char *lsl_get_type(lsl_streaminfo info);
+
+/**
+* Number of channels of the stream.
+* A stream has at least one channels; the channel count stays constant for all samples.
+*/
+extern LIBLSL_C_API int32_t lsl_get_channel_count(lsl_streaminfo info);
+
+/**
+ * Sampling rate of the stream, according to the source (in Hz).
+ *
+ * If a stream is irregularly sampled, this should be set to #LSL_IRREGULAR_RATE.
+ *
+ * Note that no data will be lost even if this sampling rate is incorrect or if a device has
+ * temporary hiccups, since all samples will be recorded anyway (except for those dropped by the
+ * device itself). However, when the recording is imported into an application, a good importer may
+ * correct such errors more accurately if the advertised sampling rate was close to the specs of the
+ * device.
+ */
+extern LIBLSL_C_API double lsl_get_nominal_srate(lsl_streaminfo info);
+
+/**
+ * Channel format of the stream.
+ * All channels in a stream have the same format.
+ * However, a device might offer multiple time-synched streams  each with its own format.
+ */
+extern LIBLSL_C_API lsl_channel_format_t lsl_get_channel_format(lsl_streaminfo info);
+
+/**
+ * Unique identifier of the stream's source, if available.
+ *
+ * The unique source (or device) identifier is an optional piece of information that, if available,
+ * allows that endpoints (such as the recording program) can re-acquire a stream automatically once
+ * it is back online.
+ * @return An immutable library-owned pointer to the string value. @sa lsl_destroy_string()
+ */
+extern LIBLSL_C_API const char *lsl_get_source_id(lsl_streaminfo info);
+
+/**
+* Protocol version used to deliver the stream.
+*/
+extern LIBLSL_C_API int32_t lsl_get_version(lsl_streaminfo info);
+
+/**
+* Creation time stamp of the stream.
+*
+* This is the time stamp when the stream was first created
+* (as determined via local_clock() on the providing machine).
+*/
+extern LIBLSL_C_API double lsl_get_created_at(lsl_streaminfo info);
+
+/**
+ * Unique ID of the stream outlet (once assigned).
+ *
+ * This is a unique identifier of the stream outlet, and is guaranteed to be different
+ * across multiple instantiations of the same outlet (e.g., after a re-start).
+ * @return An immutable library-owned pointer to the string value. @sa lsl_destroy_string()
+ */
+extern LIBLSL_C_API const char *lsl_get_uid(lsl_streaminfo info);
+
+/**
+ * Session ID for the given stream.
+ *
+ * The session id is an optional human-assigned identifier of the recording session.
+ * While it is rarely used, it can be used to prevent concurrent recording activitites
+ * on the same sub-network (e.g., in multiple experiment areas) from seeing each other's streams
+ * (assigned via a configuration file by the experimenter, see Network Connectivity on the LSL
+ * wiki).
+ * @return An immutable library-owned pointer to the string value. @sa lsl_destroy_string()
+ */
+extern LIBLSL_C_API const char *lsl_get_session_id(lsl_streaminfo info);
+
+/// Hostname of the providing machine (once bound to an outlet). Modification is not permitted.
+extern LIBLSL_C_API const char *lsl_get_hostname(lsl_streaminfo info);
+
+/**
+* Extended description of the stream.
+*
+* It is highly recommended that at least the channel labels are described here.
+* See code examples on the LSL wiki. Other information, such as amplifier settings,
+* measurement units if deviating from defaults, setup information, subject information, etc.,
+* can be specified here, as well. Meta-data recommendations follow the XDF file format project
+* (github.com/sccn/xdf/wiki/Meta-Data or web search for: XDF meta-data).
+*
+* @attention if you use a stream content type for which meta-data recommendations exist, please
+* try to lay out your meta-data in agreement with these recommendations for compatibility with other applications.
+*/
+extern LIBLSL_C_API lsl_xml_ptr lsl_get_desc(lsl_streaminfo info);
+
+/**
+ * Retrieve the entire streaminfo in XML format.
+ *
+ * This yields an XML document (in string form) whose top-level element is `<info>`. The info
+ * element contains one element for each field of the streaminfo class, including:
+ *
+ *   - the core elements `<name>`, `<type>`, `<channel_count>`, `<nominal_srate>`,
+ *   `<channel_format>`, `<source_id>`
+ *   - the misc elements `<version>`, `<created_at>`, `<uid>`, `<session_id>`,
+ *   `<v4address>`, `<v4data_port>`, `<v4service_port>`, `<v6address>`, `<v6data_port>`,
+ *   `<v6service_port>`
+ *   - the extended description element `<desc>` with user-defined sub-elements.
+ * @return A pointer to a copy of the XML text or NULL in the event that an error occurred.
+ * @note It is the user's responsibility to deallocate this string when it is no longer needed.
+ */
+extern LIBLSL_C_API char *lsl_get_xml(lsl_streaminfo info);
+
+/// Number of bytes occupied by a channel (0 for string-typed channels).
+extern LIBLSL_C_API int32_t lsl_get_channel_bytes(lsl_streaminfo info);
+
+/// Number of bytes occupied by a sample (0 for string-typed channels).
+extern LIBLSL_C_API int32_t lsl_get_sample_bytes(lsl_streaminfo info);
+
+/**
+ * Tries to match the stream info XML element @p info against an
+ * <a href="https://en.wikipedia.org/wiki/XPath#Syntax_and_semantics_(XPath_1.0)">XPath</a> query.
+ *
+ * Example query strings:
+ * @code
+ * channel_count>5 and type='EEG'
+ * type='TestStream' or contains(name,'Brain')
+ * name='ExampleStream'
+ * @endcode
+ */
+extern LIBLSL_C_API int32_t lsl_stream_info_matches_query(lsl_streaminfo info, const char *query);
+
+/// Create a streaminfo object from an XML representation
+extern LIBLSL_C_API lsl_streaminfo lsl_streaminfo_from_xml(const char *xml);
+
+/// @}

Frameworks/lsl.framework/Versions/A/include/lsl/types.h

@@ -0,0 +1,60 @@
+#ifndef LSL_TYPES
+#define LSL_TYPES
+
+/**
+ * @class lsl_streaminfo
+ * Handle to a stream info object.
+ *
+ * Stores the declaration of a data stream.
+ * Represents the following information:
+ *
+ *  - stream data format (number of channels, channel format)
+ *  - core information (stream name, content type, sampling rate)
+ *  - optional meta-data about the stream content (channel labels, measurement units, etc.)
+ *
+ * Whenever a program wants to provide a new stream on the lab network it will typically first
+ * create an lsl_streaminfo to describe its properties and then construct an #lsl_outlet with it to
+ * create the stream on the network. Other parties who discover/resolve the outlet on the network
+ * can query the stream info; it is also written to disk when recording the stream (playing a
+ * similar role as a file header).
+ */
+typedef struct lsl_streaminfo_struct_ *lsl_streaminfo;
+
+/**
+ * @class lsl_outlet
+ * A stream outlet handle.
+ * Outlets are used to make streaming data (and the meta-data) available on the lab network.
+ */
+typedef struct lsl_outlet_struct_ *lsl_outlet;
+
+/**
+ * @class lsl_inlet
+ * A stream inlet handle.
+ * Inlets are used to receive streaming data (and meta-data) from the lab network.
+ */
+typedef struct lsl_inlet_struct_ *lsl_inlet;
+
+/**
+ * @class lsl_xml_ptr
+ * A lightweight XML element tree handle; models the description of a streaminfo object.
+ * XML elements behave like advanced pointers into memory that is owned by some respective
+ * streaminfo.
+ * Has a name and can have multiple named children or have text content as value;
+ * attributes are omitted.
+ * @note The interface is modeled after a subset of pugixml's node type and is compatible with it.
+ * Type-casts between pugi::xml_node_struct* and #lsl_xml_ptr are permitted (in both directions)
+ * since the types are binary compatible.
+ * @sa [pugixml documentation](https://pugixml.org/docs/manual.html#access).
+ */
+typedef struct lsl_xml_ptr_struct_ *lsl_xml_ptr;
+
+/**
+ * @class lsl_continuous_resolver
+ *
+ * Handle to a convenience object that resolves streams continuously in the background throughout
+ * its lifetime and which can be queried at any time for the set of streams that are currently
+ * visible on the network.
+ */
+typedef struct lsl_continuous_resolver_ *lsl_continuous_resolver;
+
+#endif // LSL_TYPES

Frameworks/lsl.framework/Versions/A/include/lsl/xml.h

@@ -0,0 +1,103 @@
+#pragma once
+#include "common.h"
+#include "types.h"
+
+/// @file inlet.h XML functions
+
+/** @defgroup xml_ptr The lsl_xml_ptr object
+ * @{
+ */
+
+// XML Tree Navigation
+
+/** Get the first child of the element. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_first_child(lsl_xml_ptr e);
+
+/** Get the last child of the element. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_last_child(lsl_xml_ptr e);
+
+/** Get the next sibling in the children list of the parent node. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_next_sibling(lsl_xml_ptr e);
+
+/** Get the previous sibling in the children list of the parent node. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_previous_sibling(lsl_xml_ptr e);
+
+/** Get the parent node. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_parent(lsl_xml_ptr e);
+
+
+// XML Tree Navigation by Name
+
+/** Get a child with a specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_child(lsl_xml_ptr e, const char *name);
+
+/** Get the next sibling with the specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_next_sibling_n(lsl_xml_ptr e, const char *name);
+
+/** Get the previous sibling with the specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_previous_sibling_n(lsl_xml_ptr e, const char *name);
+
+
+// Content Queries
+
+/** Whether this node is empty. */
+extern LIBLSL_C_API int32_t lsl_empty(lsl_xml_ptr e);
+
+/** Whether this is a text body (instead of an XML element). True both for plain char data and CData. */
+extern LIBLSL_C_API int32_t  lsl_is_text(lsl_xml_ptr e);
+
+/** Name of the element. */
+extern LIBLSL_C_API const char *lsl_name(lsl_xml_ptr e);
+
+/** Value of the element. */
+extern LIBLSL_C_API const char *lsl_value(lsl_xml_ptr e);
+
+/** Get child value (value of the first child that is text). */
+extern LIBLSL_C_API const char *lsl_child_value(lsl_xml_ptr e);
+
+/** Get child value of a child with a specified name. */
+extern LIBLSL_C_API const char *lsl_child_value_n(lsl_xml_ptr e, const char *name);
+
+
+// Data Modification
+
+/// Append a child node with a given name, which has a (nameless) plain-text child with the given text value.
+extern LIBLSL_C_API lsl_xml_ptr lsl_append_child_value(lsl_xml_ptr e, const char *name, const char *value);
+
+/// Prepend a child node with a given name, which has a (nameless) plain-text child with the given text value.
+extern LIBLSL_C_API lsl_xml_ptr lsl_prepend_child_value(lsl_xml_ptr e, const char *name, const char *value);
+
+/// Set the text value of the (nameless) plain-text child of a named child node.
+extern LIBLSL_C_API int32_t lsl_set_child_value(lsl_xml_ptr e, const char *name, const char *value);
+
+/**
+* Set the element's name.
+* @return 0 if the node is empty (or if out of memory).
+*/
+extern LIBLSL_C_API int32_t lsl_set_name(lsl_xml_ptr e, const char *rhs);
+
+/**
+* Set the element's value.
+* @return 0 if the node is empty (or if out of memory).
+*/
+extern LIBLSL_C_API int32_t lsl_set_value(lsl_xml_ptr e, const char *rhs);
+
+/** Append a child element with the specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_append_child(lsl_xml_ptr e, const char *name);
+
+/** Prepend a child element with the specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_prepend_child(lsl_xml_ptr e, const char *name);
+
+/** Append a copy of the specified element as a child. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_append_copy(lsl_xml_ptr e, lsl_xml_ptr e2);
+
+/** Prepend a child element with the specified name. */
+extern LIBLSL_C_API lsl_xml_ptr lsl_prepend_copy(lsl_xml_ptr e, lsl_xml_ptr e2);
+
+/** Remove a child element with the specified name. */
+extern LIBLSL_C_API void lsl_remove_child_n(lsl_xml_ptr e, const char *name);
+
+/** Remove a specified child element. */
+extern LIBLSL_C_API void lsl_remove_child(lsl_xml_ptr e, lsl_xml_ptr e2);
+
+/// @}

Frameworks/lsl.framework/Versions/A/include/lsl_c.h

@@ -0,0 +1,36 @@
+#ifndef LSL_C_H
+#define LSL_C_H
+
+/** @file lsl_c.h LSL C API for the lab streaming layer
+ *
+ * The lab streaming layer provides a set of functions to make instrument data accessible
+ * in real time within a lab network. From there, streams can be picked up by recording programs,
+ * viewing programs or custom experiment applications that access data streams in real time.
+ *
+ * The API covers two areas:
+ * - The "push API" allows to create stream outlets and to push data (regular or irregular
+ * measurement time series, event data, coded audio/video frames, etc.) into them.
+ * - The "pull API" allows to create stream inlets and read time-synched experiment data from them
+ *   (for recording, viewing or experiment control).
+ *
+ * To use this library you need to link to the liblsl library that comes with
+ * this header. Under Visual Studio the library is linked in automatically.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lsl/common.h"
+#include "lsl/inlet.h"
+#include "lsl/outlet.h"
+#include "lsl/resolver.h"
+#include "lsl/streaminfo.h"
+#include "lsl/types.h"
+#include "lsl/xml.h"
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif