Move reference and blob stuff from atom extension to a separate "reference" extension.

1 files changed, 1 insertions, 136 deletions

diff --git a/ext/atom.lv2/atom.h b/ext/atom.lv2/atom.h
index 2895efd..d69c547 100644
--- a/ext/atom.lv2/atom.h
+++ b/ext/atom.lv2/atom.h
@@ -28,8 +28,7 @@
 #ifndef LV2_ATOM_H
 #define LV2_ATOM_H
 
-#define LV2_ATOM_URI         "http://lv2plug.in/ns/ext/atom"
-#define LV2_BLOB_SUPPORT_URI "http://lv2plug.in/ns/ext/atom#blobSupport"
+#define LV2_ATOM_URI "http://lv2plug.in/ns/ext/atom"
 
 #define LV2_ATOM_REFERENCE_TYPE 0
 
@@ -81,11 +80,6 @@ typedef struct _LV2_Atom {
 } LV2_Atom;
 
 /**
-   Reference, an LV2_Atom with type 0.
-*/
-typedef LV2_Atom LV2_Atom_Reference;
-
-/**
    The body of an atom:Literal.
 */
 typedef struct _LV2_Atom_Literal {
@@ -120,133 +114,4 @@ typedef struct _LV2_Object {
 	uint8_t  properties[]; /**< Sequence of LV2_Atom_Property */
 } LV2_Object;
 
-/* Optional Blob Support */
-
-/**
-   Dynamically Allocated LV2 Blob.
- 
-   This is an opaque blob of data of any type, dynamically allocated in memory.
-   Unlike an LV2_Atom, a blob is not necessarily POD. Plugins MUST only refer
-   to blobs via a Reference (an LV2_Atom with type 0), there is no way for a
-   plugin to directly copy or destroy a Blob.
- 
-   This is a pointer to host data which is opaque to the plugin. Plugins MUST
-   NOT interpret this data in any way, except via host-provided functions in
-   LV2_Blob_Support.
-*/
-typedef void* LV2_Blob;
-
-typedef void* LV2_Blob_Support_Data;
-
-typedef void (*LV2_Blob_Destroy)(LV2_Blob* blob);
-
-/**
-   The data field of the LV2_Feature for atom:BlobSupport.
- 
-   A host which supports blobs must pass an LV2_Feature to the plugin's
-   instantiate method with 'URI' = "http://lv2plug.in/ns/ext/atom#BlobSupport"
-   and 'data' pointing to an instance of this struct. All fields of this struct
-   MUST be set to non-NULL values by the host, except possibly 'data'.
-*/
-typedef struct {
-
-	/**
-	   Pointer to opaque host data.
-	 
-	   The plugin MUST pass this to any call to functions in this struct.
-	   Otherwise, the plugin MUST NOT interpret this value in any way.
-	*/
-	LV2_Blob_Support_Data data;
-
-	/**
-	   The size of a reference, in bytes.
-	 
-	   This value is provided by the host so plugins can allocate large enough
-	   chunks of memory to store references. Note a reference is an LV2_Atom
-	   with type atom:Reference, hence ref_size is a uint16, like
-	   LV2_Atom.size.
-	*/
-	uint16_t ref_size;
-	
-	/**
-	   Return the Blob referred to by @a ref.
-	 
-	   The returned value MUST NOT be used in any way other than by calling
-	   methods defined in LV2_Blob_Support (e.g. it MUST NOT be directly
-	   accessed, copied, or destroyed). The actual payload of the blob can
-	   be accessed with LV2_Blob_Support.blob_get.
-	*/
-	LV2_Blob (*ref_get)(LV2_Blob_Support_Data data,
-	                    LV2_Atom_Reference*   ref);
-
-	/**
-	   Copy a reference.
-	   This copies a reference but not the blob it refers to,
-	   i.e. after this call @a dst and @a src refer to the same LV2_Blob.
-	*/
-	void (*ref_copy)(LV2_Blob_Support_Data data,
-	                 LV2_Atom_Reference*   dst,
-	                 LV2_Atom_Reference*   src);
-
-	/**
-	   Reset (release) a reference.
-	   After this call, @a ref is invalid. Implementations must be sure to
-	   call this function when necessary, or memory leaks will result. The
-	   specific times this is necessary MUST be defined by any extensions that
-	   define a mechanism for transporting atoms. The standard semantics are:
-	   <ul><li>Whenever passed a Reference (e.g. via a Port) and run, the
-	   plugin owns that reference.</li>
-	   <li>The plugin owns any reference it creates (e.g. by using blob_new or
-	   ref_copy).</li>
-	   <li>For any reference it owns, the plugin MUST either:
-	   <ul><li>Copy the reference and store it (to be used in future runs and
-	   released later).</li>
-	   <li>Copy the reference to an output port exactly once.</li>
-	   <li>Release it with ref_reset.</li></ul></li>
-	   </ul>
-	*/
-	void (*ref_reset)(LV2_Blob_Support_Data data,
-	                  LV2_Atom_Reference*   ref);
-
-	/**
-	   Initialize a reference to point to a newly allocated Blob.
-
-	   @param data Must be the data member of this struct.
-	   @param ref Pointer to an area of memory at least as large as
-	   the ref_size field of this struct. On return, this will
-	   be the unique reference to the new blob, which is owned by the
-	   caller. Assumed to be uninitialised, i.e. the caller MUST NOT
-	   pass a valid reference since this could cause a memory leak.
-	   @param destroy Function to destroy this blob. This function
-	   MUST clean up any resources contained in the blob, but MUST NOT
-	   attempt to free the memory pointed to by its LV2_Blob* parameter
-	   (since this is allocated by the host).
-	   @param type ID of type of blob to allocate.
-	   @param size Size of blob to allocate in bytes.
-	*/
-	void (*blob_new)(LV2_Blob_Support_Data data,
-	                 LV2_Atom_Reference*   ref,
-	                 LV2_Blob_Destroy      destroy,
-	                 uint32_t              type,
-	                 size_t                size);
-	
-	/**
-	   Get blob's type as an ID.
-	 
-	   The return value may be any type URI, mapped to an integer with the
-	   URI Map extension with <code>context = NULL</code>.
-	*/
-	uint32_t (*blob_type)(LV2_Blob blob);
-
-	/**
-	   Get blob's body.
-	 
-	   Returns a pointer to the start of the blob data. The format of this
-	   data is defined by the return value of the type method. It MUST NOT
-	   be used in any way by code which does not understand that type.
-	*/
-	void* (*blob_data)(LV2_Blob blob);
-	
-} LV2_Blob_Support;
-
 #endif /* LV2_ATOM_H */