diff options
author | Thomas Martitz <kugel@rockbox.org> | 2010-08-27 00:29:50 +0000 |
---|---|---|
committer | Thomas Martitz <kugel@rockbox.org> | 2010-08-27 00:29:50 +0000 |
commit | 194174a371b16dfc24960d1e33371c0a7ef1c2c2 (patch) | |
tree | b924bf74a96bb7dedcaebb45319569c003d81e8b /apps/codecs.c | |
parent | 97d2a6ec5ca8ace8daed29c8c69aab9595147b3a (diff) | |
download | rockbox-194174a371b16dfc24960d1e33371c0a7ef1c2c2.tar.gz rockbox-194174a371b16dfc24960d1e33371c0a7ef1c2c2.zip |
2nd try: Introduce a small api for loading code (codecs,plugins) from disk/memory.
It's a used by codec/plugin loading and vastly reduces code duplication. It's also a step forward in getting rid of libuisimulator in the application ports.
Apparently sh needs linker symbols prefixed with _ even if they're referenced without from C code.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27902 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs.c')
-rw-r--r-- | apps/codecs.c | 101 |
1 files changed, 37 insertions, 64 deletions
diff --git a/apps/codecs.c b/apps/codecs.c index 9e77dd9099..b072c65f40 100644 --- a/apps/codecs.c +++ b/apps/codecs.c | |||
@@ -28,6 +28,7 @@ | |||
28 | #include <ctype.h> | 28 | #include <ctype.h> |
29 | #include <stdarg.h> | 29 | #include <stdarg.h> |
30 | #include "string-extra.h" | 30 | #include "string-extra.h" |
31 | #include "load_code.h" | ||
31 | #include "debug.h" | 32 | #include "debug.h" |
32 | #include "button.h" | 33 | #include "button.h" |
33 | #include "dir.h" | 34 | #include "dir.h" |
@@ -74,26 +75,13 @@ size_t codec_size; | |||
74 | 75 | ||
75 | extern void* plugin_get_audio_buffer(size_t *buffer_size); | 76 | extern void* plugin_get_audio_buffer(size_t *buffer_size); |
76 | 77 | ||
78 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) && defined(HAVE_RECORDING) | ||
77 | #undef open | 79 | #undef open |
78 | static int open(const char* pathname, int flags, ...) | 80 | static int open(const char* pathname, int flags, ...) |
79 | { | 81 | { |
80 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) | ||
81 | int fd; | ||
82 | if (flags & O_CREAT) | ||
83 | { | ||
84 | va_list ap; | ||
85 | va_start(ap, flags); | ||
86 | fd = sim_open(pathname, flags, va_arg(ap, unsigned int)); | ||
87 | va_end(ap); | ||
88 | } | ||
89 | else | ||
90 | fd = sim_open(pathname, flags); | ||
91 | |||
92 | return fd; | ||
93 | #else | ||
94 | return file_open(pathname, flags); | 82 | return file_open(pathname, flags); |
95 | #endif | ||
96 | } | 83 | } |
84 | #endif | ||
97 | struct codec_api ci = { | 85 | struct codec_api ci = { |
98 | 86 | ||
99 | 0, /* filesize */ | 87 | 0, /* filesize */ |
@@ -197,62 +185,46 @@ void codec_get_full_path(char *path, const char *codec_root_fn) | |||
197 | CODECS_DIR, codec_root_fn); | 185 | CODECS_DIR, codec_root_fn); |
198 | } | 186 | } |
199 | 187 | ||
200 | static int codec_load_ram(int size, struct codec_api *api) | 188 | static int codec_load_ram(void *handle, struct codec_api *api) |
201 | { | 189 | { |
202 | struct codec_header *hdr; | 190 | struct codec_header *hdr = lc_get_header(handle); |
203 | int status; | 191 | int status; |
204 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | 192 | |
205 | hdr = (struct codec_header *)codecbuf; | 193 | if (hdr == NULL |
206 | |||
207 | if (size <= (signed)sizeof(struct codec_header) | ||
208 | || (hdr->magic != CODEC_MAGIC | 194 | || (hdr->magic != CODEC_MAGIC |
209 | #ifdef HAVE_RECORDING | 195 | #ifdef HAVE_RECORDING |
210 | && hdr->magic != CODEC_ENC_MAGIC | 196 | && hdr->magic != CODEC_ENC_MAGIC |
211 | #endif | 197 | #endif |
212 | ) | 198 | ) |
213 | || hdr->target_id != TARGET_ID | 199 | || hdr->target_id != TARGET_ID |
200 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
214 | || hdr->load_addr != codecbuf | 201 | || hdr->load_addr != codecbuf |
215 | || hdr->end_addr > codecbuf + CODEC_SIZE) | 202 | || hdr->end_addr > codecbuf + CODEC_SIZE |
203 | #endif | ||
204 | ) | ||
216 | { | 205 | { |
217 | logf("codec header error"); | 206 | logf("codec header error"); |
207 | lc_close(handle); | ||
218 | return CODEC_ERROR; | 208 | return CODEC_ERROR; |
219 | } | 209 | } |
220 | 210 | ||
221 | codec_size = hdr->end_addr - codecbuf; | ||
222 | |||
223 | #elif (CONFIG_PLATFORM & PLATFORM_HOSTED) | ||
224 | void *pd; | ||
225 | |||
226 | hdr = sim_codec_load_ram(codecbuf, size, &pd); | ||
227 | |||
228 | if (pd == NULL) | ||
229 | return CODEC_ERROR; | ||
230 | |||
231 | if (hdr == NULL | ||
232 | || (hdr->magic != CODEC_MAGIC | ||
233 | #ifdef HAVE_RECORDING | ||
234 | && hdr->magic != CODEC_ENC_MAGIC | ||
235 | #endif | ||
236 | ) | ||
237 | || hdr->target_id != TARGET_ID) { | ||
238 | sim_codec_close(pd); | ||
239 | return CODEC_ERROR; | ||
240 | } | ||
241 | |||
242 | codec_size = codecbuf - codecbuf; | ||
243 | |||
244 | #endif /* CONFIG_PLATFORM */ | ||
245 | if (hdr->api_version > CODEC_API_VERSION | 211 | if (hdr->api_version > CODEC_API_VERSION |
246 | || hdr->api_version < CODEC_MIN_API_VERSION) { | 212 | || hdr->api_version < CODEC_MIN_API_VERSION) { |
247 | sim_codec_close(pd); | 213 | logf("codec api version error"); |
214 | lc_close(handle); | ||
248 | return CODEC_ERROR; | 215 | return CODEC_ERROR; |
249 | } | 216 | } |
250 | 217 | ||
218 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
219 | codec_size = hdr->end_addr - codecbuf; | ||
220 | #else | ||
221 | codec_size = 0; | ||
222 | #endif | ||
223 | |||
251 | *(hdr->api) = api; | 224 | *(hdr->api) = api; |
252 | cpucache_invalidate(); | ||
253 | status = hdr->entry_point(); | 225 | status = hdr->entry_point(); |
254 | 226 | ||
255 | sim_codec_close(pd); | 227 | lc_close(handle); |
256 | 228 | ||
257 | return status; | 229 | return status; |
258 | } | 230 | } |
@@ -260,36 +232,37 @@ static int codec_load_ram(int size, struct codec_api *api) | |||
260 | int codec_load_buf(unsigned int hid, struct codec_api *api) | 232 | int codec_load_buf(unsigned int hid, struct codec_api *api) |
261 | { | 233 | { |
262 | int rc; | 234 | int rc; |
235 | void *handle; | ||
263 | rc = bufread(hid, CODEC_SIZE, codecbuf); | 236 | rc = bufread(hid, CODEC_SIZE, codecbuf); |
264 | if (rc < 0) { | 237 | if (rc < 0) { |
265 | logf("error loading codec"); | 238 | logf("error loading codec"); |
266 | return CODEC_ERROR; | 239 | return CODEC_ERROR; |
267 | } | 240 | } |
241 | handle = lc_open_from_mem(codecbuf, rc); | ||
242 | if (handle == NULL) | ||
243 | { | ||
244 | logf("error loading codec"); | ||
245 | return CODEC_ERROR; | ||
246 | } | ||
247 | |||
268 | api->discard_codec(); | 248 | api->discard_codec(); |
269 | return codec_load_ram(rc, api); | 249 | return codec_load_ram(handle, api); |
270 | } | 250 | } |
271 | 251 | ||
272 | int codec_load_file(const char *plugin, struct codec_api *api) | 252 | int codec_load_file(const char *plugin, struct codec_api *api) |
273 | { | 253 | { |
274 | char path[MAX_PATH]; | 254 | char path[MAX_PATH]; |
275 | int fd; | 255 | void *handle; |
276 | int rc; | ||
277 | 256 | ||
278 | codec_get_full_path(path, plugin); | 257 | codec_get_full_path(path, plugin); |
279 | 258 | ||
280 | fd = open(path, O_RDONLY); | 259 | handle = lc_open(path, codecbuf, CODEC_SIZE); |
281 | if (fd < 0) { | 260 | |
282 | logf("Codec load error:%d", fd); | 261 | if (handle == NULL) { |
262 | logf("Codec load error"); | ||
283 | splashf(HZ*2, "Couldn't load codec: %s", path); | 263 | splashf(HZ*2, "Couldn't load codec: %s", path); |
284 | return fd; | ||
285 | } | ||
286 | |||
287 | rc = read(fd, &codecbuf[0], CODEC_SIZE); | ||
288 | close(fd); | ||
289 | if (rc <= 0) { | ||
290 | logf("Codec read error"); | ||
291 | return CODEC_ERROR; | 264 | return CODEC_ERROR; |
292 | } | 265 | } |
293 | 266 | ||
294 | return codec_load_ram((size_t)rc, api); | 267 | return codec_load_ram(handle, api); |
295 | } | 268 | } |