naspro: cebccb1b4718 naspro-bridges-bad/ladspa/pluglib.c

naspro

view naspro-bridges-bad/ladspa/pluglib.c @ 170:cebccb1b4718

Build system related stuff

author	Stefano D'Angelo <zanga.mail@gmail.com>
date	Fri Mar 12 00:49:32 2010 +0200 (2010-03-12)
parents	d7568c8379c1
children	4f7243a606b1

line source

1 /*

2 * NASPRO - NASPRO Architecture for Sound Processing

3 * LADSPA bridge

4 *

6 *

7 * See the COPYING file for license conditions.

8 */

10 #include <stdlib.h>

11 #include <stdio.h>

12 #include <string.h>

13 #include <errno.h>

15 #include <ladspa.h>

17 #include <NASPRO/core/lib.h>

19 #include "pluglib.h"

20 #include "descriptor.h"

21 #include "lrdf.h"

23 nacore_avl_tree_t _naladspa_pluglib_desc_tree = NULL;

25 struct pluglib

26 {

27 nacore_dl_module_t dl_module;

28 struct nacore_descriptor *descs;

29 size_t descs_count;

30 struct nacore_port_descriptor *port_descs;

31 size_t port_descs_count;

32 char *uris;

33 size_t uris_size;

34 };

36 static struct pluglib *pluglibs = NULL;

37 static size_t pluglibs_count = 0;

39 static nacore_avl_tree_t uid_tree;

41 static size_t

42 uint_to_dec_str_len(unsigned long i)

43 {

44 size_t ret;

46 ret = 0;

47 do

48 {

49 i /= 10;

50 ret++;

51 }

52 while (i != 0);

54 return ret;

55 }

57 static void

58 pluglib_load(const char *file, const char *basename, void *data)

59 {

60 nacore_dl_module_t dl_module;

61 const LADSPA_Descriptor *ldesc;

62 LADSPA_Descriptor_Function get_desc;

63 struct pluglib *tmp_pluglibs;

64 struct nacore_descriptor *tmp_descs;

65 struct nacore_port_descriptor *tmp_port_descs;

66 char *tmp_uris;

67 size_t descs_count, ports_count, uris_size;

68 unsigned long i;

69 void *p;

71 dl_module = nacore_dl_open(file);

72 if (dl_module == NULL)

73 goto dl_open_err;

75 if (nacore_dl_sym(dl_module, "naspro_backbridge") != NULL)

76 goto backbridge;

78 *(void **)(&get_desc) = nacore_dl_sym(dl_module, "ladspa_descriptor");

79 if (get_desc == NULL)

80 goto get_desc_err;

82 for (i = 0, descs_count = 0, ports_count = 0, uris_size = 0;

83 (ldesc = get_desc(i)) != NULL; i++)

84 {

85 p = nacore_avl_tree_find(uid_tree, (void *)&ldesc->UniqueID);

86 if (p != NULL)

87 continue;

89 nacore_avl_tree_add(uid_tree, (void *)ldesc);

91 ports_count += ldesc->PortCount;

92 uris_size += uint_to_dec_str_len(ldesc->UniqueID) + 12;

93 descs_count++;

94 }

95 if (descs_count == 0)

96 goto no_desc;

98 tmp_descs = malloc(descs_count * sizeof(struct nacore_descriptor));

99 if (tmp_descs == NULL)

100 goto descs_err;

101

102 tmp_port_descs = NULL;

103 if (ports_count != 0)

104 {

105 tmp_port_descs = malloc(ports_count

106 * sizeof(struct nacore_port_descriptor));

107 if (tmp_port_descs == NULL)

108 goto port_descs_err;

109 }

110

111 tmp_uris = malloc(uris_size);

112 if (tmp_uris == NULL)

113 goto uris_err;

114

115 tmp_pluglibs = realloc(pluglibs,

116 (pluglibs_count + 1) * sizeof(struct pluglib));

117 if (tmp_pluglibs == NULL)

118 goto pluglibs_err;

119

120 pluglibs = tmp_pluglibs;

121 tmp_pluglibs = pluglibs + pluglibs_count;

122 pluglibs_count++;

123

124 tmp_pluglibs->dl_module = dl_module;

125

126 tmp_pluglibs->descs = tmp_descs;

127 tmp_pluglibs->descs_count = descs_count;

128 tmp_pluglibs->port_descs = tmp_port_descs;

129 tmp_pluglibs->port_descs_count = ports_count;

130 tmp_pluglibs->uris = tmp_uris;

131 tmp_pluglibs->uris_size = uris_size;

132

133 for (i = 0, descs_count = 0, ports_count = 0, uris_size = 0;

134 (ldesc = get_desc(i)) != NULL; i++)

135 {

136 p = nacore_avl_tree_find(uid_tree, (void *)&ldesc->UniqueID);

137 if (p != ldesc)

138 continue;

139

140 tmp_pluglibs->descs[descs_count].port_descs =

141 tmp_pluglibs->port_descs + ports_count;

142 tmp_pluglibs->descs[descs_count].port_descs_count =

143 ldesc->PortCount;

144 tmp_pluglibs->descs[descs_count].uri =

145 tmp_pluglibs->uris + uris_size;

146 sprintf(tmp_pluglibs->descs[descs_count].uri, "urn:ladspa:%lu",

147 ldesc->UniqueID);

148

149 _naladspa_descriptor_fill(tmp_pluglibs->descs + descs_count,

150 ldesc);

151

152 nacore_avl_tree_add(_naladspa_pluglib_desc_tree,

153 tmp_pluglibs->descs + descs_count);

154

155 ports_count += ldesc->PortCount;

156 uris_size += uint_to_dec_str_len(ldesc->UniqueID) + 12;

157 descs_count++;

158 }

159

160 return;

161

162 pluglibs_err:

163 free(tmp_uris);

164 uris_err:

165 if (tmp_port_descs != NULL)

166 free(tmp_port_descs);

167 port_descs_err:

168 free(tmp_descs);

169 descs_err:

170 no_desc:

171 get_desc_err:

172 backbridge:

173 nacore_dl_close(dl_module);

174 dl_open_err:

175 return;

176 }

177

178 static int

179 uid_content_cmp(void *c1, void *c2)

180 {

181 if (((LADSPA_Descriptor *)c1)->UniqueID

182 < ((LADSPA_Descriptor *)c2)->UniqueID)

183 return -1;

184 if (((LADSPA_Descriptor *)c1)->UniqueID

185 == ((LADSPA_Descriptor *)c2)->UniqueID)

186 return 0;

187 return 1;

188 }

189

190 static int

191 uid_key_cmp(void *content, void *key)

192 {

193 if (((LADSPA_Descriptor *)content)->UniqueID < *((unsigned long *)key))

194 return -1;

195 if (((LADSPA_Descriptor *)content)->UniqueID == *((unsigned long *)key))

196 return 0;

197 return 1;

198 }

199

200 void

201 _naladspa_pluglib_load_all()

202 {

203 char *ladspa_path;

204

205 _naladspa_pluglib_desc_tree = nacore_avl_tree_new(

206 nacore_content_cmp_descriptor_by_uri,

207 nacore_key_cmp_descriptor_by_uri);

208 if (_naladspa_pluglib_desc_tree == NULL)

209 return;

210

211 uid_tree = nacore_avl_tree_new(uid_content_cmp, uid_key_cmp);

212 if (uid_tree == NULL)

213 {

214 nacore_avl_tree_free(_naladspa_pluglib_desc_tree);

215 _naladspa_pluglib_desc_tree = NULL;

216 return;

217 }

218

219 _naladspa_lrdf_load_all();

220

221 ladspa_path = nacore_env_get_var("LADSPA_PATH");

222 if (NACORE_STRING_IS_NULL_OR_EMPTY(ladspa_path))

223 {

224 nacore_path_home_for_each(LADSPA_DEFAULT_HOME_PATH,

225 pluglib_load,

226 nacore_dl_filename_filter, NULL);

227 nacore_path_for_each(LADSPA_DEFAULT_SYSTEM_PATH,

228 pluglib_load, nacore_dl_filename_filter,

229 NULL);

230 }

231 else

232 nacore_path_for_each(ladspa_path, pluglib_load,

233 nacore_dl_filename_filter, NULL);

234

235 if (ladspa_path != NULL)

236 nacore_env_free_var_value(ladspa_path);

237

238 nacore_avl_tree_free(uid_tree);

239 }

240

241 void

242 _naladspa_pluglib_unload_all()

243 {

244 size_t i, j;

245

246 if (pluglibs == NULL)

247 return;

248

249 for (i = 0; i < pluglibs_count; i++)

250 {

251 for (j = 0; j < pluglibs[i].descs_count; j++)

252 _naladspa_descriptor_free_data(pluglibs[i].descs + j);

253

254 nacore_dl_close(pluglibs[i].dl_module);

255 free(pluglibs[i].descs);

256 free(pluglibs[i].port_descs);

257 free(pluglibs[i].uris);

258 }

259

260 free(pluglibs);

261 pluglibs = NULL;

262 pluglibs_count = 0;

263

264 _naladspa_lrdf_unload_all();

265

266 nacore_avl_tree_free(_naladspa_pluglib_desc_tree);

267 _naladspa_pluglib_desc_tree = NULL;

268 }