Changeset 5511:e2207bedaf0e in roaraudio for libroar

Timestamp:

05/28/12 12:25:20 (12 years ago)

Author:

phi

Branch:

default

Phase:

public

Message:

Added a way to register plugin parts with a universal API (Closes: #245)

File:

• libroar/roardl.c (modified) (6 diffs)

libroar/roardl.c

@@ -68 +68 @@
 };
 
+// TODO: this should be removed on next SONAME change.
+static struct roar_dl_lhandle * __currently_inited = NULL;
 
 struct roar_dl_librarypara * roar_dl_para_new(const char * args, void * binargv,
@@ -193 +195 @@
  ROAR_DBG("_roardl2ldl(lhandle=%p) = ?", lhandle);
 
- if ( lhandle == ROAR_DL_HANDLE_DEFAULT ) {
-  ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_DEFAULT);
-  return RTLD_DEFAULT;
- }
-
- if ( lhandle == ROAR_DL_HANDLE_NEXT ) {
-  ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_NEXT);
-  return RTLD_NEXT;
+ if ( (void*)lhandle < (void*)128 ) {
+  switch ((int)(void*)lhandle) {
+   case (int)(void*)ROAR_DL_HANDLE_DEFAULT:
+   case (int)(void*)ROAR_DL_HANDLE_LIBROAR:
+   case (int)(void*)ROAR_DL_HANDLE_APPLICATION:
+     ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_DEFAULT);
+     return RTLD_DEFAULT;
+    break;
+   case (int)(void*)ROAR_DL_HANDLE_NEXT:
+     ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_NEXT);
+     return RTLD_NEXT;
+    break;
+  }
  }
 
@@ -464 +471 @@
  }
 
+ roar_dl_unregister_fn(lhandle);
+
  if ( lhandle->lib != NULL && lhandle->lib->unload != NULL ) {
   roar_dl_context_restore(lhandle);
@@ -528 +537 @@
                                          const char * prefix,
                                          struct roar_dl_librarypara * para) {
+ struct roar_dl_lhandle * old_init;
 #define _SUFFIX "_roaraudio_library_init"
  char name[80] = _SUFFIX;
@@ -626 +636 @@
  }
 
+ old_init = __currently_inited;
+ __currently_inited = lhandle;
  for (i = 0; i < ROAR_DL_FN_MAX; i++) {
   if ( lib->func[i] != NULL )
    lib->func[i](para, lib);
  }
+ __currently_inited = old_init;
+
 
  if ( lib->global_data_pointer != NULL ) {
@@ -838 +852 @@
 }
 
+
+#define __MAX_FNREGS 24
+static struct __fnregs {
+ struct roar_dl_lhandle * lhandle;
+ int subtype;
+ const void * object;
+ size_t objectlen;
+ int version;
+ int options;
+} __fnrefs[ROAR_DL_FN_MAX][__MAX_FNREGS];
+
+static int  __fnreg_check_trigger(const struct __fnregs * handle) {
+ if ( handle->subtype != ROAR_DL_FNREG_SUBTYPE )
+  return -1;
+ if ( handle->version != ROAR_DL_FNREG_VERSION )
+  return -1;
+ if ( handle->objectlen != ROAR_DL_FNREG_SIZE )
+  return -1;
+
+ return 0;
+}
+
+static void __fnreg_trigger_if_match(const struct roar_dl_fnreg * callback,
+                                     const struct __fnregs * reg,
+                                     int fn,
+                                     enum roar_dl_fnreg_action action) {
+ if ( callback->fn != -1 && callback->fn != fn )
+  return;
+ if ( callback->subtype != -1 && callback->subtype != reg->subtype )
+  return;
+ if ( callback->version != -1 && callback->version != reg->version )
+  return;
+
+ if ( callback->callback == NULL )
+  return;
+
+ callback->callback(action, fn, reg->subtype, reg->object, reg->objectlen, reg->version, reg->options, callback->userdata, reg->lhandle);
+}
+
+static void __fnreg_trigger_by_reg(const struct __fnregs * reg, enum roar_dl_fnreg_action action, int fn) {
+ size_t j;
+
+ for (j = 0; j < __MAX_FNREGS; j++) {
+  if ( __fnrefs[ROAR_DL_FN_REGFN][j].lhandle != NULL ) {
+   if ( __fnreg_check_trigger(&(__fnrefs[ROAR_DL_FN_REGFN][j])) == -1 )
+    continue;
+   __fnreg_trigger_if_match(__fnrefs[ROAR_DL_FN_REGFN][j].object, reg, fn, action);
+  }
+ }
+}
+
+static void __fnreg_trigger_by_handler(const struct __fnregs * handle, enum roar_dl_fnreg_action action) {
+ size_t i, j;
+
+ if ( __fnreg_check_trigger(handle) == -1 )
+  return;
+
+ for (i = 0; i < ROAR_DL_FN_MAX; i++) {
+  for (j = 0; j < __MAX_FNREGS; j++) {
+   if ( __fnrefs[i][j].lhandle != NULL ) {
+    __fnreg_trigger_if_match(handle->object, &(__fnrefs[i][j]), i, action);
+   }
+  }
+ }
+}
+
+int roar_dl_register_fn(struct roar_dl_lhandle * lhandle, int fn, int subtype, const void * object, size_t objectlen, int version, int options) {
+ struct __fnregs * c = NULL;
+ size_t i;
+
+ if ( lhandle == NULL )
+  lhandle = __currently_inited;
+
+ if ( lhandle == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
+  return -1;
+ }
+
+ if ( fn < 0 || fn >= ROAR_DL_FN_MAX ) {
+  roar_err_set(ROAR_ERROR_RANGE);
+  return -1;
+ }
+
+ if ( object == NULL || objectlen == 0 ) {
+  roar_err_set(ROAR_ERROR_INVAL);
+  return -1;
+ }
+
+ for (i = 0; i < __MAX_FNREGS; i++) {
+  if ( __fnrefs[fn][i].lhandle != NULL )
+   continue;
+  c = &(__fnrefs[fn][i]);
+  break;
+ }
+
+ if ( c == NULL ) {
+  roar_err_set(ROAR_ERROR_NOSPC);
+  return -1;
+ }
+
+ c->lhandle   = lhandle;
+ c->subtype   = subtype;
+ c->object    = object;
+ c->objectlen = objectlen;
+ c->version   = version;
+
+ if ( fn == ROAR_DL_FN_REGFN ) {
+  __fnreg_trigger_by_handler(c, ROAR_DL_FNREG);
+ } else {
+  __fnreg_trigger_by_reg(c, ROAR_DL_FNREG, fn);
+ }
+
+ return 0;
+}
+
+int roar_dl_unregister_fn(struct roar_dl_lhandle * lhandle) {
+ size_t i, j;
+
+//} __fnrefs[ROAR_DL_FN_MAX][__MAX_FNREGS];
+
+ if ( lhandle == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
+  return -1;
+ }
+
+ for (i = 0; i < ROAR_DL_FN_MAX; i++) {
+  for (j = 0; j < __MAX_FNREGS; j++) {
+   if ( __fnrefs[i][j].lhandle == lhandle ) {
+    if ( i == ROAR_DL_FN_REGFN ) {
+     __fnreg_trigger_by_handler(&(__fnrefs[i][j]), ROAR_DL_FNUNREG);
+    } else {
+     __fnreg_trigger_by_reg(&(__fnrefs[i][j]), ROAR_DL_FNUNREG, i);
+    }
+    memset(&(__fnrefs[i][j]), 0, sizeof(__fnrefs[i][j]));
+    __fnrefs[i][j].lhandle = NULL;
+   }
+  }
+ }
+
+ return 0;
+}
+
 //ll