/* * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland * Modifications copyright (C) 2019-2020 Paolo Jovon * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @file picoos.c * * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland * Modifications copyright (C) 2019-2020 Paolo Jovon * All rights reserved. * * History: * - 2009-04-20 -- initial version * - 2020-04-14 -- 64-bit compatibility fixes * */ #include #include "picodefs.h" #include "picopal.h" #include "picoos.h" #include "picodbg.h" #ifdef __cplusplus extern "C" { #endif #if 0 } #endif #define picoos_SVOXFileHeader (picoos_char *)" (C) SVOX AG " /* ********************************************** * default error and warning messages * **********************************************/ #define PICOOS_MSG_EXC_NUMBER_FORMAT (picoos_char *) "wrong number format" #define PICOOS_MSG_EXC_MAX_NUM_EXCEED (picoos_char *) "number exceeded" #define PICOOS_MSG_EXC_NAME_CONFLICT (picoos_char *) "name conflict" #define PICOOS_MSG_EXC_NAME_UNDEFINED (picoos_char *) "name undefined" #define PICOOS_MSG_EXC_NAME_ILLEGAL (picoos_char *) "illegal name" /* buffer interaction */ #define PICOOS_MSG_EXC_BUF_OVERFLOW (picoos_char *) "buffer overflow" #define PICOOS_MSG_EXC_BUF_UNDERFLOW (picoos_char *) "buffer underflow" #define PICOOS_MSG_EXC_BUF_IGNORE (picoos_char *) "buffer error" /* memory allocation */ #define PICOOS_MSG_EXC_OUT_OF_MEM (picoos_char *) "out of memory" /* files */ #define PICOOS_MSG_EXC_CANT_OPEN_FILE (picoos_char *) "cannot open file" #define PICOOS_MSG_EXC_UNEXPECTED_FILE_TYPE (picoos_char *) "unexpected file type" #define PICOOS_MSG_EXC_FILE_CORRUPT (picoos_char *) "corrupt file" #define PICOOS_MSG_EXC_FILE_NOT_FOUND (picoos_char *) "file not found" /* resources */ #define PICOOS_MSG_EXC_RESOURCE_BUSY (picoos_char *) "resource is busy" #define PICOOS_MSG_EXC_RESOURCE_MISSING (picoos_char *) "cannot find resource" /* knowledge bases */ #define PICOOS_MSG_EXC_KB_MISSING (picoos_char *) "knowledge base missing" /* runtime exceptions (programming problems, usually a bug. E.g. trying to access null pointer) */ #define PICOOS_MSG_ERR_NULLPTR_ACCESS (picoos_char *) "access violation" #define PICOOS_MSG_ERR_INVALID_HANDLE (picoos_char *) "invalid handle value" #define PICOOS_MSG_ERR_INVALID_ARGUMENT (picoos_char *) "invalid argument supplied" #define PICOOS_MSG_ERR_INDEX_OUT_OF_RANGE (picoos_char *) "index out of range" /* errors ("external" errors, e.g. hardware failure. Usually cannot be dealt with from inside pico.) */ #define PICOOS_MSG_ERR_OTHER (picoos_char *) "other error" #define PICOOS_MSG_ERR_PU (picoos_char *) "error in processing unit" /* WARNINGS */ /* general */ #define PICOOS_MSG_WARN_INCOMPLETE (picoos_char *) "incomplete output" #define PICOOS_MSG_WARN_FALLBACK (picoos_char *) "using fall-back" #define PICOOS_MSG_WARN_OTHER (picoos_char *) "other warning" /* resources */ #define PICOOS_MSG_WARN_KB_OVERWRITE (picoos_char *) "overwriting knowledge base" #define PICOOS_MSG_WARN_RESOURCE_DOUBLE_LOAD (picoos_char *) "resource already loaded" /* decision trees */ #define PICOOS_MSG_WARN_INVECTOR (picoos_char *) "input vector not constructed" #define PICOOS_MSG_WARN_CLASSIFICATION (picoos_char *) "output not classified" #define PICOOS_MSG_WARN_OUTVECTOR (picoos_char *) "output vector not decomposed" /* processing units */ #define PICOOS_MSG_WARN_PU_IRREG_ITEM (picoos_char *) "irregular item in processing unit" #define PICOOS_MSG_WARN_PU_DISCARD_BUF (picoos_char *) "discarding processing unit buffer" /* ********************************************** * wrappers for picopal functions * **********************************************/ picoos_int32 picoos_atoi(const picoos_char *s) { return (picoos_int32)picopal_atoi((const picoos_char *)s); } picoos_int8 picoos_strcmp(const picoos_char *a, const picoos_char *b) { picopal_int32 res = picopal_strcmp((const picopal_char *)a, (const picopal_char *)b); return (picoos_int8) ((res < 0) ? -1 : (res > 0) ? 1 : 0); } picoos_int8 picoos_strncmp(const picoos_char *a, const picoos_char *b, picoos_objsize_t siz) { picopal_int32 res = picopal_strncmp((const picopal_char *)a, (const picopal_char *)b, siz); return (picoos_int8) ((res < 0) ? -1 : (res > 0) ? 1 : 0); } picoos_uint32 picoos_strlen(const picoos_char *s) { return (picoos_uint32)picopal_strlen((const picopal_char *)s); } picoos_char *picoos_strchr(const picoos_char *s, picoos_char c) { return (picoos_char *)picopal_strchr((const picopal_char *)s, (picopal_char)c); } picoos_char *picoos_strstr(const picoos_char *s, const picoos_char * substr) { return (picoos_char *)picopal_strstr((const picopal_char *)s, (const picopal_char *)substr); } picoos_int16 picoos_slprintf(picoos_char * b, picoos_uint32 bsize, const picoos_char *f, ...) { picopal_int16 i; va_list args; va_start(args, (char *)f); i = (picoos_int16)picopal_vslprintf((picoos_char *) b, bsize, (const picoos_char *)f, args); va_end(args); return i; } picoos_char *picoos_strcpy(picoos_char *d, const picoos_char *s) { return (picoos_char *)picopal_strcpy((picopal_char *)d, (const picopal_char *)s); } picoos_char *picoos_strcat(picoos_char *d, const picoos_char *s) { return (picoos_char *)picopal_strcat((picopal_char *)d, (const picopal_char *)s); } picoos_objsize_t picoos_strlcpy(picoos_char *dst, const picoos_char *src, picoos_objsize_t siz) { return (picoos_objsize_t) picopal_strlcpy((picopal_char *) dst, (const picopal_char *) src, (picopal_objsize_t) siz); } /* copies 'length' bytes from 'src' to 'dest'. (regions may be overlapping) no error checks! */ void * picoos_mem_copy(const void * src, void * dst, picoos_objsize_t length) { return picopal_mem_copy(src,dst,(picopal_objsize_t) length); } /* sets 'length' bytes starting at dest[0] to 'byte_val' */ void * picoos_mem_set(void * dest, picoos_uint8 byte_val, picoos_objsize_t length) { return picopal_mem_set(dest,(picopal_uint8)byte_val, (picopal_objsize_t)length); } picoos_double picoos_cos (const picoos_double cos_arg) { return (picoos_double) picopal_cos ((picopal_double) cos_arg); } picoos_double picoos_sin (const picoos_double sin_arg) { return (picoos_double) picopal_sin((picopal_double) sin_arg); } picoos_double picoos_fabs (const picoos_double fabs_arg) { return (picoos_double) picopal_fabs((picopal_double) fabs_arg); } picoos_double picoos_quick_exp(const picoos_double y) { return (picoos_double) picopal_quick_exp ((picopal_double)y); } /* *****************************************************************/ /* "Common" */ /* *****************************************************************/ /* picoos_common is a collection of basic functionalities that must be globally * accessible from every "big" function. It includes pointers to the MemoryManasger, * ExceptionManager and a system-wide list of open files. */ picoos_Common picoos_newCommon(picoos_MemoryManager mm) { picoos_Common this = (picoos_Common) picoos_allocate(mm,sizeof(*this)); if (NULL != this) { /* initialize */ this->em = NULL; this->mm = NULL; this->fileList = NULL; } return this; } void picoos_disposeCommon(picoos_MemoryManager mm, picoos_Common * this) { if (NULL != (*this)) { /* terminate */ picoos_deallocate(mm,(void *)this); } } /* *****************************************************************/ /* Memory Management */ /* *****************************************************************/ typedef struct mem_block_hdr * MemBlockHdr; typedef struct mem_block_hdr { MemBlockHdr next; byte_ptr_t data; picoos_objsize_t size; } mem_block_hdr_t; typedef struct mem_cell_hdr * MemCellHdr; typedef struct mem_cell_hdr { /* size may be <0 if used */ picoos_ptrdiff_t size; MemCellHdr leftCell; MemCellHdr prevFree, nextFree; } mem_cell_hdr_t; typedef struct memory_manager { MemBlockHdr firstBlock, lastBlock; /* memory blockList */ MemCellHdr freeCells, lastFree; /* free memory cells (first/last sentinel */ /* "constants" */ picoos_objsize_t fullCellHdrSize; /* aligned size of full cell header, including free-links */ picoos_objsize_t usedCellHdrSize; /* aligned size of header part without free-links */ picoos_objsize_t minContSize; /* minimum requestable application content size for allocation; must hold free-list info; = fullCellHdrSize-usedCellHdrSize */ picoos_objsize_t minCellSize; /* minimum remaining cell size when a free cell is split */ picoos_bool protMem; /* true if memory protection is enabled */ picoos_ptrdiff_t usedSize; picoos_ptrdiff_t prevUsedSize; picoos_ptrdiff_t maxUsedSize; } memory_manager_t; /** allocates 'alloc_size' bytes at start of raw memory block ('raw_mem',raw_mem_size) * and returns pointer to allocated region. Returns remaining (correctly aligned) raw memory block * in ('rest_mem','rest_mem_size'). * The allocated memory is not subject to memory management, so that it can never be freed again! * */ void * picoos_raw_malloc(byte_ptr_t raw_mem, picoos_objsize_t raw_mem_size, picoos_objsize_t alloc_size, byte_ptr_t * rest_mem, picoos_objsize_t * rest_mem_size) { picoos_ptrdiff_t rest; if (raw_mem == NULL) { return NULL; } else { if (alloc_size < 1) { alloc_size = 1; } alloc_size = ((alloc_size + PICOOS_ALIGN_SIZE - 1) / PICOOS_ALIGN_SIZE) * PICOOS_ALIGN_SIZE; rest = raw_mem_size - alloc_size; if (rest < 0) { return NULL; } else { *rest_mem_size = rest; *rest_mem = raw_mem + alloc_size; return (void *) raw_mem; } } } /** initializes the last block of mm */ static int os_init_mem_block(picoos_MemoryManager this) { int isFirstBlock; void * newBlockAddr; picoos_objsize_t size; MemCellHdr cbeg, cmid, cend; isFirstBlock = (this->freeCells == NULL); newBlockAddr = (void *) this->lastBlock->data; size = this->lastBlock->size; cbeg = (MemCellHdr) newBlockAddr; cmid = (MemCellHdr)((picoos_uintptr_t)newBlockAddr + this->fullCellHdrSize); cend = (MemCellHdr)((picoos_uintptr_t)newBlockAddr + size - this->fullCellHdrSize); cbeg->size = 0; cbeg->leftCell = NULL; cmid->size = size - 2 * this->fullCellHdrSize; cmid->leftCell = cbeg; cend->size = 0; cend->leftCell = cmid; if (isFirstBlock) { cbeg->nextFree = cmid; cbeg->prevFree = NULL; cmid->nextFree = cend; cmid->prevFree = cbeg; cend->nextFree = NULL; cend->prevFree = cmid; this->freeCells = cbeg; this->lastFree = cend; } else { /* add cmid to free cell list */ cbeg->nextFree = NULL; cbeg->prevFree = NULL; cmid->nextFree = this->freeCells->nextFree; cmid->prevFree = this->freeCells; cmid->nextFree->prevFree = cmid; cmid->prevFree->nextFree = cmid; cend->nextFree = NULL; cbeg->prevFree = NULL; } return PICO_OK; } picoos_MemoryManager picoos_newMemoryManager( void *raw_memory, picoos_objsize_t size, picoos_bool enableMemProt) { byte_ptr_t rest_mem; picoos_objsize_t rest_mem_size; picoos_MemoryManager this; picoos_objsize_t size2; mem_cell_hdr_t test_cell; this = picoos_raw_malloc(raw_memory, size, sizeof(memory_manager_t), &rest_mem, &rest_mem_size); if (this == NULL) { return NULL; } /* test if memory protection functionality is available on the current platform (if not, picopal_mpr_alloc() always returns NULL) */ if (enableMemProt) { void *addr = picopal_mpr_alloc(100); if (addr == NULL) { enableMemProt = FALSE; } else { picopal_mpr_free(&addr); } } this->firstBlock = NULL; this->lastBlock = NULL; this->freeCells = NULL; this->lastFree = NULL; this->protMem = enableMemProt; this->usedSize = 0; this->prevUsedSize = 0; this->maxUsedSize = 0; /* get aligned full header size */ this->fullCellHdrSize = ((sizeof(mem_cell_hdr_t) + PICOOS_ALIGN_SIZE - 1) / PICOOS_ALIGN_SIZE) * PICOOS_ALIGN_SIZE; /* get aligned size of header without free-list fields; the result may be compiler-dependent; the size is therefore computed by inspecting the end addresses of the fields 'size' and 'leftCell'; the higher of the ending addresses is used to get the (aligned) starting address of the application contents (NOTE: patched for 64-bit support!) */ this->usedCellHdrSize = (picoos_uintptr_t)(&test_cell.size) - (picoos_uintptr_t)(&test_cell) + sizeof(picoos_objsize_t); size2 = (picoos_uintptr_t)(&test_cell.leftCell) - (picoos_uintptr_t)(&test_cell) + sizeof(MemCellHdr); if (size2 > this->usedCellHdrSize) { this->usedCellHdrSize = size2; } /* get minimum application-usable size; must be large enough to hold remainder of cell header (free-list links) when in free-list */ this->minContSize = this->fullCellHdrSize - this->usedCellHdrSize; /* get minimum required size of a cell remaining after a cell split */ this->minCellSize = this->fullCellHdrSize + PICOOS_ALIGN_SIZE; /* install remainder of raw memory block as first block */ raw_memory = rest_mem; size = rest_mem_size; this->firstBlock = this->lastBlock = picoos_raw_malloc(raw_memory, size, sizeof(mem_block_hdr_t), &rest_mem, &rest_mem_size); if (this->lastBlock == NULL) { return NULL; } this->lastBlock->next = NULL; this->lastBlock->data = rest_mem; this->lastBlock->size = rest_mem_size; os_init_mem_block(this); return this; } void picoos_disposeMemoryManager(picoos_MemoryManager * mm) { *mm = NULL; } /* the following memory manager routines are for testing and debugging purposes */ void *picoos_allocProtMem(picoos_MemoryManager mm, picoos_objsize_t byteSize) { if (mm->protMem) { return picopal_mpr_alloc(byteSize); } else { return picoos_allocate(mm, byteSize); } } void picoos_deallocProtMem(picoos_MemoryManager mm, void **addr) { if (mm->protMem) { picopal_mpr_free(addr); } else { picoos_deallocate(mm, addr); } } void picoos_protectMem( picoos_MemoryManager mm, void *addr, picoos_objsize_t len, picoos_bool enable) { if (mm->protMem) { int prot = PICOPAL_PROT_READ; if (!enable) { prot |= PICOPAL_PROT_WRITE; } picopal_mpr_protect(addr, len, prot); } else { /* memory protection disabled; nothing to do */ } } #define PICOPAL_PROT_NONE 0 /* the memory cannot be accessed at all */ #define PICOPAL_PROT_READ 1 /* the memory can be read */ #define PICOPAL_PROT_WRITE 2 /* the memory can be written to */ void picoos_getMemUsage( picoos_MemoryManager this, picoos_bool resetIncremental, picoos_int32 *usedBytes, picoos_int32 *incrUsedBytes, picoos_int32 *maxUsedBytes) { *usedBytes = (picoos_int32) this->usedSize; *incrUsedBytes = (picoos_int32) (this->usedSize - this->prevUsedSize); *maxUsedBytes = (picoos_int32) this->maxUsedSize; if (resetIncremental) { this->prevUsedSize = this->usedSize; } } void picoos_showMemUsage(picoos_MemoryManager this, picoos_bool incremental, picoos_bool resetIncremental) { picoos_int32 usedBytes, incrUsedBytes, maxUsedBytes; picoos_getMemUsage(this, resetIncremental, &usedBytes, &incrUsedBytes, &maxUsedBytes); if (incremental) { PICODBG_DEBUG(("additional memory used: %d", incrUsedBytes)); } else { PICODBG_DEBUG(("memory used: %d, maximally used: %d", usedBytes, maxUsedBytes)); } } void * picoos_allocate(picoos_MemoryManager this, picoos_objsize_t byteSize) { picoos_objsize_t cellSize; MemCellHdr c, c2, c2r; void * adr; if (byteSize < this->minContSize) { byteSize = this->minContSize; } byteSize = ((byteSize + PICOOS_ALIGN_SIZE - 1) / PICOOS_ALIGN_SIZE) * PICOOS_ALIGN_SIZE; cellSize = byteSize + this->usedCellHdrSize; /*PICODBG_TRACE(("allocating %d", cellSize));*/ c = this->freeCells->nextFree; while ( (c != NULL) && (c->size != (picoos_ptrdiff_t) cellSize) && (c->size < (picoos_ptrdiff_t)(cellSize+ this->minCellSize))) { c = c->nextFree; } if (c == NULL) { return NULL; } if ((c->size == (picoos_ptrdiff_t) cellSize)) { c->prevFree->nextFree = c->nextFree; c->nextFree->prevFree = c->prevFree; } else { c2 = (MemCellHdr)((picoos_uintptr_t)c + cellSize); c2->size = c->size - cellSize; c->size = cellSize; c2->leftCell = c; c2r = (MemCellHdr)((picoos_uintptr_t)c2 + c2->size); c2r->leftCell = c2; c2->nextFree = c->nextFree; c2->nextFree->prevFree = c2; c2->prevFree = c->prevFree; c2->prevFree->nextFree = c2; } /* statistics */ this->usedSize += cellSize; if (this->usedSize > this->maxUsedSize) { this->maxUsedSize = this->usedSize; } c->size = -(c->size); adr = (void *)((picoos_uintptr_t)c + this->usedCellHdrSize); return adr; } void picoos_deallocate(picoos_MemoryManager this, void * * adr) { MemCellHdr c; MemCellHdr cr; MemCellHdr cl; MemCellHdr crr; if ((*adr) != NULL) { c = (MemCellHdr)((picoos_uintptr_t)(*adr) - this->usedCellHdrSize); c->size = -(c->size); // HACK: This ensures that the size never goes beyond the 31st bit on 64-bit // platforms (solving a crash-on-exit issue) c->size &= 0xFFFFFFFF; /*PICODBG_TRACE(("deallocating %d", c->size));*/ /* statistics */ this->usedSize -= c->size; cr = (MemCellHdr)((picoos_uintptr_t)c + c->size); cl = c->leftCell; if (cl->size > 0) { if (cr->size > 0) { crr = (MemCellHdr)((picoos_uintptr_t)cr + cr->size); crr->leftCell = cl; cl->size = ((cl->size + c->size) + cr->size); cr->nextFree->prevFree = cr->prevFree; cr->prevFree->nextFree = cr->nextFree; } else { cl->size = (cl->size + c->size); cr->leftCell = cl; } } else { if ((cr->size > 0)) { crr = (MemCellHdr)((picoos_uintptr_t)cr + cr->size); crr->leftCell = c; c->size = (c->size + cr->size); c->nextFree = cr->nextFree; c->prevFree = cr->prevFree; c->nextFree->prevFree = c; c->prevFree->nextFree = c; } else { c->nextFree = this->freeCells->nextFree; c->prevFree = this->freeCells; c->nextFree->prevFree = c; c->prevFree->nextFree = c; } } } *adr = NULL; } /* *****************************************************************/ /* Exception Management */ /* *****************************************************************/ /** object : exceptionManager * shortcut : em * */ typedef picoos_char picoos_exc_msg[PICOOS_MAX_EXC_MSG_LEN]; typedef picoos_char picoos_warn_msg[PICOOS_MAX_WARN_MSG_LEN]; typedef struct picoos_exception_manager { picoos_int32 curExceptionCode; picoos_exc_msg curExceptionMessage; picoos_uint8 curNumWarnings; picoos_int32 curWarningCode[PICOOS_MAX_NUM_WARNINGS]; picoos_warn_msg curWarningMessage[PICOOS_MAX_NUM_WARNINGS]; } picoos_exception_manager_t; void picoos_emReset(picoos_ExceptionManager this) { this->curExceptionCode = PICO_OK; this->curExceptionMessage[0] = '\0'; this->curNumWarnings = 0; } picoos_ExceptionManager picoos_newExceptionManager(picoos_MemoryManager mm) { picoos_ExceptionManager this = (picoos_ExceptionManager) picoos_allocate( mm, sizeof(*this)); if (NULL != this) { /* initialize */ picoos_emReset(this); } return this; } void picoos_disposeExceptionManager(picoos_MemoryManager mm, picoos_ExceptionManager * this) { if (NULL != (*this)) { /* terminate */ picoos_deallocate(mm, (void *)this); } } static void picoos_vSetErrorMsg(picoos_char * dst, picoos_objsize_t siz, picoos_int16 code, picoos_char * base, const picoos_char *fmt, va_list args) { picoos_uint16 bsize; if (NULL == base) { switch (code) { case PICO_EXC_NUMBER_FORMAT: base = PICOOS_MSG_EXC_NUMBER_FORMAT; break; case PICO_EXC_MAX_NUM_EXCEED: base = PICOOS_MSG_EXC_MAX_NUM_EXCEED; break; case PICO_EXC_NAME_CONFLICT: base = PICOOS_MSG_EXC_NAME_CONFLICT; break; case PICO_EXC_NAME_UNDEFINED: base = PICOOS_MSG_EXC_NAME_UNDEFINED; break; case PICO_EXC_NAME_ILLEGAL: base = PICOOS_MSG_EXC_NAME_ILLEGAL; break; /* buffer interaction */ case PICO_EXC_BUF_OVERFLOW: base = PICOOS_MSG_EXC_BUF_OVERFLOW; break; case PICO_EXC_BUF_UNDERFLOW: base = PICOOS_MSG_EXC_BUF_UNDERFLOW; break; case PICO_EXC_BUF_IGNORE: base = PICOOS_MSG_EXC_BUF_IGNORE; break; /* memory allocation */ case PICO_EXC_OUT_OF_MEM: base = PICOOS_MSG_EXC_OUT_OF_MEM; break; /* files */ case PICO_EXC_CANT_OPEN_FILE: base = PICOOS_MSG_EXC_CANT_OPEN_FILE; break; case PICO_EXC_UNEXPECTED_FILE_TYPE: base = PICOOS_MSG_EXC_UNEXPECTED_FILE_TYPE; break; case PICO_EXC_FILE_CORRUPT: base = PICOOS_MSG_EXC_FILE_CORRUPT; break; case PICO_EXC_FILE_NOT_FOUND: base = PICOOS_MSG_EXC_FILE_NOT_FOUND; break; /* resources */ case PICO_EXC_RESOURCE_BUSY: base = PICOOS_MSG_EXC_RESOURCE_BUSY; break; case PICO_EXC_RESOURCE_MISSING: base = PICOOS_MSG_EXC_RESOURCE_MISSING; break; /* knowledge bases */ case PICO_EXC_KB_MISSING: fmt = PICOOS_MSG_EXC_KB_MISSING; break; /* runtime exceptions (programming problems, usually a bug. E.g. trying to access null pointer) */ case PICO_ERR_NULLPTR_ACCESS: base = PICOOS_MSG_ERR_NULLPTR_ACCESS; break; case PICO_ERR_INVALID_HANDLE: base = PICOOS_MSG_ERR_INVALID_HANDLE; break; case PICO_ERR_INVALID_ARGUMENT: base = PICOOS_MSG_ERR_INVALID_ARGUMENT; break; case PICO_ERR_INDEX_OUT_OF_RANGE: base = PICOOS_MSG_ERR_INDEX_OUT_OF_RANGE; break; /* errors ("external" errors, e.g. hardware failure. Usually cannot be dealt with from inside pico.) */ case PICO_ERR_OTHER: base = PICOOS_MSG_ERR_OTHER; break; /* other error inside pu */ case PICO_STEP_ERROR: base = PICOOS_MSG_ERR_PU; break; /* WARNINGS */ /* general */ case PICO_WARN_INCOMPLETE: base = PICOOS_MSG_WARN_INCOMPLETE; break; case PICO_WARN_FALLBACK: base = PICOOS_MSG_WARN_FALLBACK; break; case PICO_WARN_OTHER: base = PICOOS_MSG_WARN_OTHER; break; /* resources */ case PICO_WARN_KB_OVERWRITE: base = PICOOS_MSG_WARN_KB_OVERWRITE; break; case PICO_WARN_RESOURCE_DOUBLE_LOAD: base = PICOOS_MSG_WARN_RESOURCE_DOUBLE_LOAD; break; /* decision trees */ case PICO_WARN_INVECTOR: base = PICOOS_MSG_WARN_INVECTOR; break; case PICO_WARN_CLASSIFICATION: base = PICOOS_MSG_WARN_CLASSIFICATION; break; case PICO_WARN_OUTVECTOR: base = PICOOS_MSG_WARN_OUTVECTOR; break; /* processing units */ case PICO_WARN_PU_IRREG_ITEM: base = PICOOS_MSG_WARN_PU_IRREG_ITEM; break; case PICO_WARN_PU_DISCARD_BUF: base = PICOOS_MSG_WARN_PU_DISCARD_BUF; break; default: base = (picoos_char *) "unknown error"; break; } } bsize = picoos_strlcpy(dst,base,siz); if ((NULL != fmt) && (bsize < siz)) { /* there is something to add and more space to add it */ if (bsize > 0) { dst += bsize; siz -= bsize; bsize = picoos_strlcpy(dst,(picoos_char *)": ",siz); } if (bsize < siz) { picopal_vslprintf((picopal_char *) dst + bsize, siz - bsize, (picopal_char *)fmt, args); } } } void picoos_setErrorMsg(picoos_char * dst, picoos_objsize_t siz, picoos_int16 code, picoos_char * base, const picoos_char *fmt, ...) { va_list args; va_start(args, (char *)fmt); picoos_vSetErrorMsg(dst,siz, code, base, fmt,args); va_end(args); } /* For convenience, this function returns the resulting current exception code. The return value therefore is NOT the status of raising * the error! */ pico_status_t picoos_emRaiseException(picoos_ExceptionManager this, pico_status_t exceptionCode, picoos_char * baseMessage, picoos_char * fmt, ...) { va_list args; if (PICO_OK == this->curExceptionCode && PICO_OK != exceptionCode) { this->curExceptionCode = exceptionCode; va_start(args, (char *)fmt); picoos_vSetErrorMsg(this->curExceptionMessage,PICOOS_MAX_EXC_MSG_LEN, exceptionCode, baseMessage, fmt,args); PICODBG_DEBUG(( "exit with exception code=%i, exception message='%s'", this->curExceptionCode, this->curExceptionMessage)); va_end(args); } return this->curExceptionCode; } pico_status_t picoos_emGetExceptionCode(picoos_ExceptionManager this) { return this->curExceptionCode; } void picoos_emGetExceptionMessage(picoos_ExceptionManager this, picoos_char * msg, picoos_uint16 maxsize) { picoos_strlcpy(msg,this->curExceptionMessage,maxsize); } void picoos_emRaiseWarning(picoos_ExceptionManager this, pico_status_t warningCode, picoos_char * baseMessage, picoos_char * fmt, ...) { va_list args; if ((this->curNumWarnings < PICOOS_MAX_NUM_WARNINGS) && (PICO_OK != warningCode)) { if (PICOOS_MAX_NUM_WARNINGS-1 == this->curNumWarnings) { this->curWarningCode[this->curNumWarnings] = PICO_EXC_MAX_NUM_EXCEED; picoos_strlcpy(this->curWarningMessage[this->curNumWarnings],(picoos_char *) "too many warnings",PICOOS_MAX_WARN_MSG_LEN); } else { this->curWarningCode[this->curNumWarnings] = warningCode; va_start(args, (char *)fmt); picoos_vSetErrorMsg(this->curWarningMessage[this->curNumWarnings],PICOOS_MAX_WARN_MSG_LEN, warningCode, baseMessage, fmt,args); va_end(args); } this->curNumWarnings++; } PICODBG_DEBUG(( "exit with code=%i and message='%s', resulting in #warnings=%i", this->curWarningCode[this->curNumWarnings-1], this->curWarningMessage[this->curNumWarnings-1], this->curNumWarnings)); } picoos_uint8 picoos_emGetNumOfWarnings(picoos_ExceptionManager this) { return this->curNumWarnings; } pico_status_t picoos_emGetWarningCode(picoos_ExceptionManager this, picoos_uint8 index) { if (index < this->curNumWarnings) { return this->curWarningCode[index]; } else { return PICO_OK; } } void picoos_emGetWarningMessage(picoos_ExceptionManager this, picoos_uint8 index, picoos_char * msg, picoos_uint16 maxsize) { if (index < this->curNumWarnings) { picoos_strlcpy(msg,this->curWarningMessage[index],maxsize); } else { msg[0] = NULLC; } } /* *****************************************************************/ /* File Access */ /* *****************************************************************/ #define picoos_MagicNumber 192837465 #define picoos_MaxBufSize 1000000 #define picoos_MaxNrOfBuffers 1000000 #define picoos_MaxBufLen 8192 #define picoos_HashFuncId0 0 #define picoos_HashTableSize0 101 #define picoos_HashTableSize1 1731 #define picoos_MaxHashTableSize HashTableSize1 #define cardinal_ptr_t picoos_uint32 * typedef struct picoos_buffer { picoos_char * data; int start; /* denotes the file position of the buffer beginning */ int len; /* denotes the length of the buffer; -1 means invalid buffer */ int pos; /* denotes the position in the buffer */ } picoos_buffer_t; typedef picoos_buffer_t picoos_buffer_array_t[picoos_MaxNrOfBuffers]; typedef picoos_int32 picoos_buffer_index_array_t[picoos_MaxNrOfBuffers]; /** object : File * shortcut : f * */ typedef struct picoos_file { picoos_FileName name; picoos_uint8 binary; picoos_uint8 write; picopal_File nf; picoos_uint32 lFileLen; picoos_uint32 lPos; picoos_File next; picoos_File prev; } picoos_file_t; picoos_File picoos_newFile(picoos_MemoryManager mm) { picoos_File this = (picoos_File) picoos_allocate(mm, sizeof(*this)); if (NULL != this) { /* initialize */ } return this; } void picoos_disposeFile(picoos_MemoryManager mm, picoos_File * this) { if (NULL != (*this)) { /* terminate */ picoos_deallocate(mm, (void *)this); } } /* ************************************************************ * low-level file operations **************************************************************/ static picoos_int32 os_min(const picoos_int32 x, const picoos_int32 y) { return (x < y) ? x : y; } /* static picoos_uint8 LReadChar (picoos_File f, picoos_char * ch); static picoos_uint8 LSetPos (picoos_File f, unsigned int pos); static picoos_uint8 LGetPos (picoos_File f, picoos_uint32 * pos); static picoos_uint8 LEof (picoos_File f); */ static picoos_bool LOpen(picoos_Common g, picoos_File * f, picoos_char fileName[], picopal_access_mode mode) { picoos_bool done = TRUE; *f = picoos_newFile(g->mm); picopal_strcpy((*f)->name, fileName); (*f)->write = ((mode == PICOPAL_TEXT_WRITE) || (mode == PICOPAL_BINARY_WRITE)); (*f)->binary = (mode == PICOPAL_BINARY_WRITE); (*f)->next = NULL; (*f)->prev = NULL; (*f)->nf = picopal_get_fnil(); (*f)->lFileLen = 0; (*f)->lPos = 0; if (picopal_strlen((*f)->name)) { (*f)->nf = picopal_fopen((*f)->name, mode); done = !(picopal_is_fnil((*f)->nf)); if (done) { (*f)->lFileLen = picopal_flength((*f)->nf); } } if (done) { (*f)->next = g->fileList; if (g->fileList != NULL) { g->fileList->prev = (*f); } g->fileList = (*f); } else { picoos_disposeFile(g->mm, f); (*f) = NULL; } return done; } static picoos_bool LClose(picoos_Common g, picoos_File * f) { picoos_bool done; if (((*f) != NULL)) { done = (PICO_OK == picopal_fclose((*f)->nf)); if (((*f)->next != NULL)) { (*f)->next->prev = (*f)->prev; } if (((*f)->prev != NULL)) { (*f)->prev->next = (*f)->next; } else { g->fileList = (*f)->next; } picoos_disposeFile(g->mm, f); done = TRUE; } else { done = FALSE; } return done; } /* caller must ensure that bytes[] has at least len allocated bytes */ static picoos_bool LReadBytes(picoos_File f, picoos_uint8 bytes[], picoos_uint32 * len) { picoos_bool done; picoos_int32 res; PICODBG_TRACE(("trying to read %i bytes",*len)); if ((f != NULL)) { res = picopal_fread_bytes(f->nf, (void *) &bytes[(0)], 1, (*len)); PICODBG_TRACE(("res = %i",res)); if (res < 0) { /* non-ansi */ (*len) = 0; done = FALSE; } else if (((picoos_uint32)res != (*len))) { (*len) = res; done = FALSE; } else { done = TRUE; } f->lPos = (f->lPos + (*len)); } else { (*len) = 0; done = FALSE; } return done; } static picoos_bool LWriteBytes(picoos_File f, const picoos_char bytes[], int * len) { picoos_bool done; int res; /*int n; void * bptr; */ if (f != NULL) { res = picopal_fwrite_bytes(f->nf, (void *) bytes, 1, *len); if ((res < 0)) { (*len) = 0; done = FALSE; } else if ((res != (*len))) { (*len) = res; done = FALSE; } else { done = TRUE; } f->lPos = (f->lPos + (unsigned int) (*len)); if ((f->lPos > f->lFileLen)) { f->lFileLen = f->lPos; } } else { (*len) = 0; done = FALSE; } return done; } static picoos_bool LSetPos(picoos_File f, unsigned int pos) { picoos_bool done; if ((f != NULL)) { if ((pos == f->lPos)) { done = TRUE; } else { done = (PICO_OK == picopal_fseek(f->nf, pos, PICOPAL_SEEK_SET)); if (done) { f->lPos = pos; } } } else { done = FALSE; } return done; } static picoos_bool LGetPos(picoos_File f, picoos_uint32 * pos) { picoos_bool done = TRUE; if ((f != NULL)) { (*pos) = f->lPos; } else { done = FALSE; (*pos) = 0; } return done; } static picoos_bool LEof(picoos_File f) { picoos_bool isEof; if ((f != NULL)) { isEof = picopal_feof(f->nf); } else { isEof = TRUE; } return isEof; } /* **************************************************************************************/ /* read a given string 'str' from file. If no match was found, the read position is advanced until and including the first * non-matching character */ static picoos_bool picoos_StrRead (picoos_File f, picoos_char str[]) { picoos_uint32 i = 0; picoos_bool done = TRUE; picoos_char b; while (done && (str[i] != NULLC)) { done = done && picoos_ReadByte(f,(picoos_char *)&b); done = done && (b == str[i]); i++; } return done; } /* write 'str' to file */ static picoos_bool picoos_WriteStr (picoos_File f, picoos_char str[]) { picoos_uint32 i = 0; picoos_bool done = TRUE; while (done && (str[i] != NULLC)) { done = done && picoos_WriteByte(f,str[i]); i++; } return done; } /* **** Sequential binary file access ******/ /* Remark: 'ReadByte', 'ReadBytes' and 'ReadVar' may be mixed; 'WriteByte', 'WriteBytes' and 'WriteVar' may be mixed. */ /* Open existing binary file for read access. Reading is buffered * with 'nrOfBufs' buffers of size 'bufSize'. If 'nrOfBufs' or * 'bufSize' is 0 reading is not buffered. * If 'key' is not empty, the file is decrypted with 'key'. * If the opened file is in an encrypted archive file, it */ picoos_uint8 picoos_OpenBinary(picoos_Common g, picoos_File * f, picoos_char fileName[]) { return LOpen(g, f, fileName, PICOPAL_BINARY_READ); } /* Read next byte from file 'f'. */ picoos_bool picoos_ReadByte(picoos_File f, picoos_uint8 * by) { picoos_uint32 n = 1; return picoos_ReadBytes(f, by, &n) && (n == 1); } /* Read next 'len' bytes from 'f' into 'bytes'; 'len' returns the number of bytes actually read (may be smaller than requested length if at end of file). bytes[] must be big enough to hold at least len bytes. */ picoos_bool picoos_ReadBytes(picoos_File f, picoos_uint8 bytes[], picoos_uint32 * len) { picoos_bool done = TRUE; /* unsigned int origPos; */ if ((f != NULL)) { done = LReadBytes(f, bytes, len); /*if ((f->keyLen > 0)) { DecryptBytes(f->key,picoos_MaxKeyLen,f->keyLen,origPos,bytes,(*len)); }*/ } return done; } /* Create new binary file. If 'key' is not empty, the file is encrypted with 'key'. */ picoos_bool picoos_CreateBinary(picoos_Common g, picoos_File * f, picoos_char fileName[]) { return LOpen(g, f, fileName, PICOPAL_BINARY_WRITE); } picoos_uint8 picoos_WriteByte(picoos_File f, picoos_char by) { int n = 1; return picoos_WriteBytes(f, (picoos_char *) &by, &n); } /* Writes 'len' bytes from 'bytes' onto file 'f'; 'len' returns the number of bytes actually written. */ picoos_bool picoos_WriteBytes(picoos_File f, const picoos_char bytes[], picoos_int32 * len) { picoos_bool done = FALSE; if (f != NULL) { done = LWriteBytes(f, bytes, len); } return done; } /* Close previously opened binary file. */ picoos_uint8 picoos_CloseBinary(picoos_Common g, picoos_File * f) { return LClose(g, f); } /* **************************************************************************************/ /* *** general routines *****/ /* Returns whether end of file was encountered in previous read operation. */ picoos_bool picoos_Eof(picoos_File f) { if ((NULL != f)) { return LEof(f); } else { return TRUE; } } /* sets the file pointer to 'pos' bytes from beginning (first byte = byte 0). This routine should only be used for binary files. */ picoos_bool picoos_SetPos(picoos_File f, picoos_int32 pos) { picoos_bool done = TRUE; if ((NULL != f)) { done = LSetPos(f, pos); } else { done = FALSE; } return done; } /* Get position from file 'f'. */ picoos_bool picoos_GetPos(picoos_File f, picoos_uint32 * pos) { if (NULL != f) { /* if (f->bFile) { (*pos) = BGetPos(f); } else { */ (*pos) = LGetPos(f, pos); /* } */ return TRUE; } else { (*pos) = 0; return FALSE; } } /* Returns the length of the file in bytes. */ picoos_bool picoos_FileLength(picoos_File f, picoos_uint32 * len) { if (NULL != f) { *len = f->lFileLen; return TRUE; } else { *len = 0; return FALSE; } } /* Return full name of file 'f'. maxsize is the size of 'name[]' in bytes */ picoos_bool picoos_Name(picoos_File f, picoos_char name[], picoos_uint32 maxsize) { picoos_bool done = TRUE; if (NULL != f) { done = (picoos_strlcpy(name, f->name,maxsize) < maxsize); } else { name[0] = (picoos_char)NULLC; done = FALSE; } return done; } /* Returns whether file 'name' exists or not. */ picoos_bool picoos_FileExists(picoos_Common g, picoos_char name[]) { picoos_File f; if (picoos_OpenBinary(g, & f,name)) { picoos_CloseBinary(g, & f); return TRUE; } else { return FALSE; } } /* ******************************************************************/ /* Array conversion operations: all procedures convert 'nrElems' values from 'src' starting with index 'srcStartInd' into corresponding (possibly rounded) values in 'dst' starting at 'dstStartInd'. */ /* taking pi to be le, these are just the array versions of read_mem_pi_*int16 */ typedef picoos_uint8 two_byte_t[2]; static void arr_conv_le_int16 (picoos_uint8 src[], picoos_uint32 srcShortStartInd, picoos_uint32 nrElems, picoos_int16 dst[], picoos_uint32 dstStartInd) { two_byte_t * src_p = (two_byte_t *) (src + (srcShortStartInd * 2)); picoos_int16 * dst_p = dst + dstStartInd; picoos_uint32 i; for (i=0; i>8); dst_p++; } } /* *****************************************************************/ /* Sampled Data Files */ /* *****************************************************************/ #define PICOOS_SDF_BUF_LEN 1024 #define PICOOS_INT16_MIN -32768 #define PICOOS_INT16_MAX 32767 #define PICOOS_UINT16_MAX 0xffff #define PICOOS_INT32_MIN -2147483648 #define PICOOS_INT32_MAX 2147483647 #define PICOOS_UINT32_MAX 0xffffffff /** object : SDFile * shortcut : sdf * */ /* typedef struct picoos_sd_file * picoos_SDFile */ typedef struct picoos_sd_file { picoos_uint32 sf; wave_file_type_t fileType; /* (acoustic) wav, au, raw, other */ picoos_uint32 hdrSize; picoos_encoding_t enc; picoos_File file; picoos_uint32 nrFileSamples; picoos_int16 buf[PICOOS_SDF_BUF_LEN]; picoos_int32 bufPos; picoos_uint8 bBuf[2*PICOOS_SDF_BUF_LEN]; picoos_bool aborted; } picoos_sd_file_t; /* Tries to read wav header at beginning of file 'f'; returns sampling rate 'sf', encoding type 'enc', nr of samples in file 'nrSamples', header size 'hdrSize', and byte order 'bOrder'; returns whether a supported wav header and format was found. */ static picoos_bool picoos_readWavHeader(picoos_File f, picoos_uint32 * sf, picoos_encoding_t * enc, picoos_uint32 * nrSamples, picoos_uint32 * hdrSize) { picoos_uint16 n16; picoos_uint32 n32; picoos_uint16 formatTag; picoos_uint32 sampleRate; picoos_uint32 bytesPerSec; picoos_uint16 blockAlign; picoos_uint16 sampleSize; picoos_uint32 dataLength; picoos_uint32 fileLen; picoos_uint32 nrFileSamples; picoos_bool done; picoos_SetPos(f, 0); picoos_FileLength(f, &fileLen); done = picoos_StrRead(f, (picoos_char *) "RIFF"); done = done && (PICO_OK == picoos_read_le_uint32(f, &n32)); /* length of riff chunk, unused */ done = done && picoos_StrRead(f, (picoos_char *) "WAVE"); done = done && picoos_StrRead(f, (picoos_char *) "fmt "); done = done && (PICO_OK == picoos_read_le_uint32(f, &n32)); /* length of fmt chunk in bytes; must be 16 */ done = done && (n32 == 16); done = done && (PICO_OK == picoos_read_le_uint16(f, &formatTag)); done = done && (PICO_OK == picoos_read_le_uint16(f, &n16)); /* number of channels; must be mono */ done = done && (n16 == 1); done = done && (PICO_OK == picoos_read_le_uint32(f, &sampleRate)); done = done && (PICO_OK == picoos_read_le_uint32(f, &bytesPerSec)); done = done && (PICO_OK == picoos_read_le_uint16(f, &blockAlign)); done = done && (PICO_OK == picoos_read_le_uint16(f, &sampleSize)); done = done && picoos_StrRead(f, (picoos_char *) "data"); done = done && (PICO_OK == picoos_read_le_uint32(f, &dataLength)); /* length of data chunk in bytes */ (*hdrSize) = 44; if (done) { (*sf) = sampleRate; (*nrSamples) = 0; switch (formatTag) { case FORMAT_TAG_LIN: (*enc) = PICOOS_ENC_LIN; done = ((blockAlign == 2) && (sampleSize == 16)); (*nrSamples) = (dataLength / 2); nrFileSamples = ((fileLen - (*hdrSize)) / 2); break; case FORMAT_TAG_ULAW: (*enc) = PICOOS_ENC_ULAW; done = ((blockAlign == 1) && (sampleSize == 8)); (*nrSamples) = dataLength; nrFileSamples = (fileLen - (*hdrSize)); break; case FORMAT_TAG_ALAW: (*enc) = PICOOS_ENC_ALAW; done = ((blockAlign == 1) && (sampleSize == 8)); (*nrSamples) = dataLength; nrFileSamples = (fileLen - (*hdrSize)); break; default: done = FALSE; break; } if (!done) { /* communicate "unsupported format" */ PICODBG_WARN(("unsupported wav format")); } else { if (nrFileSamples != (*nrSamples)) { /* warn "inconsistent number of samples" */ PICODBG_WARN(("inconsistent number of samples in wav file: %d vs. %d",nrFileSamples,(*nrSamples))); (*nrSamples) = nrFileSamples; } } } return done; } extern picoos_bool picoos_sdfOpenIn(picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], picoos_uint32 * sf, picoos_encoding_t * enc, picoos_uint32 * numSamples) { picoos_bool done = FALSE; picoos_sd_file_t * sdf = NULL; wave_file_type_t fileType = FILE_TYPE_OTHER; (*sf) = 0; (*numSamples) = 0; (*enc) = PICOOS_ENC_LIN; (*sdFile) = NULL; sdf = picoos_allocate(g->mm,sizeof(picoos_sd_file_t)); if (NULL == sdf) { picoos_emRaiseWarning(g->em,PICO_EXC_OUT_OF_MEM,NULL,NULL); return FALSE; } /* buffered access not supported, yet */ if (picoos_OpenBinary(g,&(sdf->file),fileName)) { if (picoos_has_extension(fileName,(picoos_char *) ".wav")) { fileType = FILE_TYPE_WAV; done = picoos_readWavHeader(sdf->file,&(sdf->sf),&(sdf->enc),&(sdf->nrFileSamples),&(sdf->hdrSize)); } else { /* we prefer not to treat other formats, rather than treat it as raw */ /* fileType = FILE_TYPE_RAW; */ fileType = FILE_TYPE_OTHER; done = FALSE; } if (FILE_TYPE_OTHER == fileType) { picoos_emRaiseWarning(g->em,PICO_EXC_UNEXPECTED_FILE_TYPE,(picoos_char *)"unsupported filename suffix",NULL); } else if (!done) { picoos_emRaiseWarning(g->em,PICO_EXC_UNEXPECTED_FILE_TYPE,(picoos_char *)"non-conforming header",NULL); } else { (*numSamples) = sdf->nrFileSamples; (*sf) = sdf->sf; (*enc) = sdf->enc; /* check whether sd file properties are supported */ if (PICOOS_ENC_LIN != sdf->enc) { done = FALSE; picoos_emRaiseWarning(g->em,PICO_EXC_UNEXPECTED_FILE_TYPE,NULL,(picoos_char *)"encoding not supported"); } if (SAMPLE_FREQ_16KHZ != sdf->sf) { done = FALSE; picoos_emRaiseWarning(g->em,PICO_EXC_UNEXPECTED_FILE_TYPE,NULL,(picoos_char *)"sample frequency not supported"); } (*sdFile) = sdf; } if (!done){ picoos_CloseBinary(g,&(sdf->file)); } } else { picoos_emRaiseException(g->em,PICO_EXC_CANT_OPEN_FILE,NULL,NULL); } if (!done) { picoos_deallocate(g->mm,(void *)&sdf); (*sdFile) = NULL; } return done; } static void picoos_sdfLoadSamples(picoos_SDFile sdFile, picoos_uint32 * nrSamples) { picoos_uint32 len; picoos_sd_file_t * sdf = sdFile; switch (sdFile->enc) { case PICOOS_ENC_LIN: if ((*nrSamples) > PICOOS_SDF_BUF_LEN) { (*nrSamples) = PICOOS_SDF_BUF_LEN; } len = 2 * (*nrSamples); picoos_ReadBytes(sdf->file, sdf->bBuf, &len); (*nrSamples) = len / 2; arr_conv_le_int16(sdf->bBuf, 0, (*nrSamples), sdf->buf, 0); break; /* @todo : may be useful */ case PICOOS_ENC_ULAW: case PICOOS_ENC_ALAW: default: (*nrSamples) = 0; } } extern picoos_bool picoos_sdfGetSamples ( picoos_SDFile sdFile, picoos_uint32 start, picoos_uint32 * nrSamples, picoos_int16 samples[]) { picoos_uint32 b; picoos_uint32 rem; picoos_uint32 n; picoos_uint32 i; picoos_uint32 j; picoos_bool done = FALSE; if (NULL == sdFile) { (*nrSamples) = 0; } else { if (start >= sdFile->nrFileSamples) { if (start > sdFile->nrFileSamples) { PICODBG_WARN(("start has to be <= sdFile->nrFileSamples")); } (*nrSamples) = 0; } else { if (((start + (*nrSamples)) > sdFile->nrFileSamples)) { (*nrSamples) = (sdFile->nrFileSamples - start); } if ((sdFile->enc == PICOOS_ENC_LIN)) { b = 2; } else { b = 1; } picoos_SetPos(sdFile->file,(sdFile->hdrSize + (b * start))); j = 0; rem = (*nrSamples); n = rem; while ((rem > 0) && (n > 0)) { /* set n=min(rem,buffer_length) and try loading next n samples */ n = (rem < PICOOS_SDF_BUF_LEN) ? rem : PICOOS_SDF_BUF_LEN; picoos_sdfLoadSamples(sdFile, &n); /* n may be smaller now */ for (i = 0; i < n; i++) { samples[j] = sdFile->buf[i]; j++; } rem -= n; start += n; } (*nrSamples) = j; done = ((*nrSamples) > 0); } } return done; } extern picoos_bool picoos_sdfCloseIn (picoos_Common g, picoos_SDFile * sdFile) { if (NULL != (*sdFile)) { picoos_CloseBinary(g,&((*sdFile)->file)); picoos_deallocate(g->mm,(void *)sdFile); } return TRUE; } static picoos_bool picoos_writeWavHeader(picoos_File f, picoos_uint32 sf, picoos_encoding_t enc, picoos_uint32 nrSamples, picoos_uint32 * hdrSize) { picoos_uint16 formatTag = FORMAT_TAG_LIN; picoos_uint32 sampleRate; picoos_uint32 bytesPerSec; picoos_uint32 bytesPerSample = 2; picoos_uint16 blockAlign; picoos_uint16 sampleSize = 16; picoos_uint32 dataLength; picoos_bool done = TRUE; picoos_SetPos(f, 0); switch (enc) { case PICOOS_ENC_LIN: formatTag = FORMAT_TAG_LIN; bytesPerSample = 2; sampleSize = 16; break; case PICOOS_ENC_ULAW: formatTag = FORMAT_TAG_ULAW; bytesPerSample = 1; sampleSize = 8; break; case PICOOS_ENC_ALAW: formatTag = FORMAT_TAG_ALAW; bytesPerSample = 1; sampleSize = 8; break; default: done = FALSE; break; } bytesPerSec = (sf * bytesPerSample); blockAlign = bytesPerSample; sampleRate = sf; dataLength = (bytesPerSample * nrSamples); done = done && picoos_WriteStr(f,(picoos_char *)"RIFF"); done = done && picoos_write_le_uint32(f,dataLength + 36); done = done && picoos_WriteStr(f,(picoos_char *)"WAVE"); done = done && picoos_WriteStr(f,(picoos_char *)"fmt "); done = done && picoos_write_le_uint32(f,16); done = done && picoos_write_le_uint16(f,formatTag); done = done && picoos_write_le_uint16(f,1); done = done && picoos_write_le_uint32(f,sampleRate); done = done && picoos_write_le_uint32(f,bytesPerSec); done = done && picoos_write_le_uint16(f,blockAlign); done = done && picoos_write_le_uint16(f,sampleSize); done = done && picoos_WriteStr(f,(picoos_char *)"data"); done = done && picoos_write_le_uint32(f,dataLength); (*hdrSize) = 44; return done; } #define DummyLen 100000000 extern picoos_bool picoos_sdfOpenOut(picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], int sf, picoos_encoding_t enc) { picoos_bool done = TRUE; picoos_sd_file_t * sdf = NULL; (*sdFile) = NULL; sdf = picoos_allocate(g->mm, sizeof(picoos_sd_file_t)); if (NULL == sdf) { picoos_emRaiseWarning(g->em, PICO_EXC_OUT_OF_MEM, NULL, NULL); return FALSE; } sdf->sf = sf; sdf->enc = enc; /* check whether sd file properties are supported */ if (PICOOS_ENC_LIN != sdf->enc) { done = FALSE; picoos_emRaiseWarning(g->em, PICO_EXC_UNEXPECTED_FILE_TYPE, NULL, (picoos_char *) "encoding not supported"); } if (SAMPLE_FREQ_16KHZ != sdf->sf) { done = FALSE; picoos_emRaiseWarning(g->em, PICO_EXC_UNEXPECTED_FILE_TYPE, NULL, (picoos_char *) "sample frequency not supported"); } if (done) { sdf->nrFileSamples = 0; sdf->bufPos = 0; sdf->aborted = FALSE; if (picoos_CreateBinary(g, &(sdf->file), fileName)) { if (picoos_has_extension(fileName, (picoos_char *) ".wav")) { sdf->fileType = FILE_TYPE_WAV; done = picoos_writeWavHeader(sdf->file, sdf->sf, sdf->enc, DummyLen, &(sdf->hdrSize)); } else { /* we prefer not to treat other formats, rather than treat it as raw */ /* fileType = FILE_TYPE_RAW; */ sdf->fileType = FILE_TYPE_OTHER; done = FALSE; } if (FILE_TYPE_OTHER == sdf->fileType) { picoos_emRaiseWarning(g->em, PICO_EXC_UNEXPECTED_FILE_TYPE, (picoos_char *) "unsupported filename suffix", NULL); } else if (!done) { picoos_emRaiseWarning(g->em, PICO_EXC_UNEXPECTED_FILE_TYPE, (picoos_char *) "non-conforming header", NULL); } else { (*sdFile) = sdf; } if (!done) { picoos_CloseBinary(g, &(sdf->file)); } } else { picoos_emRaiseException(g->em, PICO_EXC_CANT_OPEN_FILE, NULL, NULL); } } if (!done) { picoos_deallocate(g->mm, (void *) &sdf); (*sdFile) = NULL; } return done; } static picoos_bool picoos_sdfFlushOutBuf(picoos_SDFile sdFile) { picoos_bool done = FALSE; picoos_int32 len; picoos_int32 nrSamples; if (!(sdFile->aborted)) { nrSamples = sdFile->bufPos; switch (sdFile->enc) { case PICOOS_ENC_LIN: arr_conv_int16_le(sdFile->buf, 0, nrSamples, sdFile->bBuf, 0); len = (nrSamples * 2); done = picoos_WriteBytes(sdFile->file, sdFile->bBuf, &len) && ((nrSamples * 2) == len); break; case PICOOS_ENC_ULAW: case PICOOS_ENC_ALAW: default: nrSamples = 0; break; } sdFile->nrFileSamples = (sdFile->nrFileSamples + nrSamples); } sdFile->bufPos = 0; return done; } extern picoos_bool picoos_sdfFlushOutput(picoos_SDFile sdFile) { if ((sdFile != NULL) && !(sdFile->aborted) && (sdFile->bufPos > 0)) { return picoos_sdfFlushOutBuf(sdFile); } return TRUE; } extern picoos_bool picoos_sdfPutSamples (picoos_SDFile sdFile, picoos_uint32 nrSamples, picoos_int16 samples[]) { picoos_uint32 i; picoos_int32 s; picoos_bool done = FALSE; if ((sdFile != NULL) && !(sdFile->aborted)) { done = TRUE; for (i = 0; i < nrSamples; i++) { s = samples[i]; if ((s > PICOOS_INT16_MAX)) { s = PICOOS_INT16_MAX; } else if (s < PICOOS_INT16_MIN) { s = PICOOS_INT16_MIN; } sdFile->buf[sdFile->bufPos++] = s; if (sdFile->bufPos >= PICOOS_SDF_BUF_LEN) { done = picoos_sdfFlushOutBuf(sdFile); } } } else { done = FALSE; } return done; } extern picoos_bool picoos_sdfCloseOut (picoos_Common g, picoos_SDFile * sdFile) { picoos_bool done = TRUE; picoos_uint32 hdrSize; if (NULL != (*sdFile)) { if (!((*sdFile)->aborted) && ((*sdFile)->bufPos > 0)) { done = picoos_sdfFlushOutBuf(*sdFile); } if (FILE_TYPE_WAV == (*sdFile)->fileType) { done = picoos_writeWavHeader((*sdFile)->file, (*sdFile)->sf, (*sdFile)->enc, (*sdFile)->nrFileSamples, &hdrSize); } done = picoos_CloseBinary(g, &((*sdFile)->file)); picoos_deallocate(g->mm, (void *) sdFile); } return done; } /* *****************************************************************/ /* FileHeader */ /* *****************************************************************/ pico_status_t picoos_clearHeader(picoos_FileHeader header) { picoos_uint8 i; for (i=0; i < PICOOS_MAX_NUM_HEADER_FIELDS; i++) { header->field[i].key[0] = NULLC; header->field[i].value[0] = NULLC; header->field[i].op = PICOOS_FIELD_IGNORE; } header->numFields = 0; return PICO_OK; } pico_status_t picoos_setHeaderField(picoos_FileHeader header, picoos_uint8 index, picoos_char * key, picoos_char * value, picoos_compare_op_t op) { if (index >= header->numFields) { return PICO_ERR_INDEX_OUT_OF_RANGE; } header->field[index].op = op; if ((picoos_strlcpy(header->field[index].key, key, PICOOS_MAX_FIELD_STRING_LEN) < PICOOS_MAX_FIELD_STRING_LEN) && (picoos_strlcpy(header->field[index].value, value, PICOOS_MAX_FIELD_STRING_LEN)) < PICOOS_MAX_FIELD_STRING_LEN) { return PICO_OK; } else { return PICO_ERR_INDEX_OUT_OF_RANGE; } } /* caller has to make sure allocated space at key and value are large enough to hold a picoos_field_string */ pico_status_t picoos_getHeaderField(picoos_FileHeader header, picoos_uint8 index, picoos_field_string_t key, picoos_field_string_t value, picoos_compare_op_t * op) { if (index >= header->numFields) { return PICO_ERR_INDEX_OUT_OF_RANGE; } *op = header->field[index].op; if ((picoos_strlcpy(key,header->field[index].key, PICOOS_MAX_FIELD_STRING_LEN) < PICOOS_MAX_FIELD_STRING_LEN) && (picoos_strlcpy(value,header->field[index].value, PICOOS_MAX_FIELD_STRING_LEN)) < PICOOS_MAX_FIELD_STRING_LEN) { return PICO_OK; } else { return PICO_ERR_INDEX_OUT_OF_RANGE; } return PICO_OK; } /* check whether 'str' of length strlen matches contents in circular buffer buf, located in the first strlen bytes and ending * position bufpos. */ static picoos_uint8 os_matched( picoos_char * str, picoos_uint32 strlen, picoos_char * buf, picoos_int32 bufpos) { picoos_int32 i = strlen-1; while (i >= 0 && buf[bufpos] == str[i]) { i--; bufpos--; if (bufpos < 0) { bufpos = strlen-1; } } return (i<0); } pico_status_t picoos_getSVOXHeaderString(picoos_char * str, picoos_uint8 * len, picoos_uint32 maxlen) { picoos_char * ch; *len = picoos_strlcpy(str,picoos_SVOXFileHeader,maxlen); if (*len < maxlen) { ch = str; /* SVOX header is made less readable */ while (*ch) { *ch -= ' '; ch++; } return PICO_OK; } else { return PICO_ERR_OTHER; } } pico_status_t picoos_readPicoHeader(picoos_File f, picoos_uint32 * headerlen) { picoos_char str[32]; picoos_char buf[32]; picoos_uint8 strlen, bufpos; picoos_uint32 n; picoos_uint8 done; picoos_getSVOXHeaderString(str,&strlen,32); /* search for svox header somewhere near the file start. This allows for initial * non-svox-header bytes for a customer-specific header and/or filling bytes for alignment */ *headerlen = 0; /* read in initial chunk of length strlen */ n = strlen; done = picoos_ReadBytes(f,(picoos_uint8 *)buf,&n) && (n == strlen); if (done) { *headerlen = n; bufpos = strlen-1; /* last legal buf position */ done = os_matched(str,strlen,buf,bufpos); while (!done && *headerlen < PICO_MAX_FOREIGN_HEADER_LEN) { n = 1; bufpos = (bufpos + 1) % strlen; done = picoos_ReadBytes(f,(picoos_uint8 *)buf+bufpos,&n) && 1 == n; done = done && os_matched(str,strlen,buf,bufpos); headerlen++; } } if (done) { return PICO_OK; } else { return PICO_EXC_UNEXPECTED_FILE_TYPE; } } picoos_uint8 picoos_get_str (picoos_char * fromStr, picoos_uint32 * pos, picoos_char * toStr, picoos_objsize_t maxsize) { picoos_uint8 i = 0; /* skip non-printables */ while ((fromStr[*pos] != NULLC) && (fromStr[*pos] <= ' ')) { (*pos)++; } /* copy printable portion */ while ((fromStr[*pos] != NULLC) && (fromStr[*pos] > ' ') && (i < maxsize-1)) { toStr[i++] = fromStr[(*pos)++]; } toStr[i] = NULLC; return (i > 0) && (fromStr[*pos] <= ' '); } pico_status_t picoos_hdrParseHeader(picoos_FileHeader header, picoos_header_string_t str) { picoos_uint32 curpos = 0; picoos_uint8 i, numFields; /* read number of fields */ numFields = str[curpos++]; numFields = os_min(numFields,PICOOS_MAX_NUM_HEADER_FIELDS); /* read in all field pairs */ PICODBG_DEBUG(("number of fields = %i", numFields)); for (i = 0; i < numFields; i++) { picoos_get_str(str,&curpos,header->field[i].key,PICOOS_MAX_FIELD_STRING_LEN); picoos_get_str(str,&curpos,header->field[i].value,PICOOS_MAX_FIELD_STRING_LEN); } return PICO_OK; } /* **************************************************************************/ /* Read little-endian / platform-independent integers from file or memory */ /* **************************************************************************/ /* read little-endian */ pico_status_t picoos_read_le_uint16 (picoos_File file, picoos_uint16 * val) { picoos_uint8 by[2]; picoos_uint32 n = 2; if (picoos_ReadBytes(file, by, &n) && 2 == n) { /* little-endian */ *val = (picoos_uint16) by[1] << 8 | (picoos_uint16) by[0]; return PICO_OK; } else { *val = 0; return PICO_ERR_OTHER; } } pico_status_t picoos_read_le_int16 (picoos_File file, picoos_int16 * val) { return picoos_read_le_uint16(file, (picoos_uint16 *)val); } pico_status_t picoos_read_le_uint32 (picoos_File file, picoos_uint32 * val) { picoos_uint8 by[4]; picoos_uint32 n = 4; if (picoos_ReadBytes(file, by, &n) && (4 == n)) { /* little-endian */ PICODBG_TRACE(("reading uint 32: %i %i %i %i", by[0], by[1], by[2], by[3])); *val = (((picoos_uint32) by[3] << 8 | (picoos_uint32) by[2]) << 8 | (picoos_uint32) by[1]) << 8 | (picoos_uint32) by[0]; PICODBG_TRACE(("uint 32: %i %i %i %i corresponds %i", by[0], by[1], by[2], by[3], *val)); return PICO_OK; } else { *val = 0; return PICO_ERR_OTHER; } } /* platform-independent */ /* our convention is that pi is little-endian. */ /** @todo : direct implementation if too slow */ pico_status_t picoos_read_pi_uint16 (picoos_File file, picoos_uint16 * val) { return picoos_read_le_uint16(file,val); } pico_status_t picoos_read_pi_uint32 (picoos_File file, picoos_uint32 * val) { return picoos_read_le_uint32(file, val); } pico_status_t picoos_read_pi_int32 (picoos_File file, picoos_int32 * val) { return picoos_read_le_uint32(file, (picoos_uint32 *)val); } /* read pi from memory */ pico_status_t picoos_read_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 * val) { picoos_uint8 * by = data + *pos; /* little-endian */ *val = (picoos_uint16) by[1] << 8 | (picoos_uint16) by[0]; (*pos) += 2; return PICO_OK; } pico_status_t picoos_read_mem_pi_uint32 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint32 * val) { picoos_uint8 * by = data + *pos; /* little-endian */ *val = (((picoos_uint32) by[3] << 8 | (picoos_uint32) by[2]) << 8 | (picoos_uint32) by[1]) << 8 | (picoos_uint32) by[0]; (*pos) += 4; return PICO_OK; } /* **************************************************************************/ /* Write little-endian / platform-independent integers into file or memory */ /* **************************************************************************/ /* write little-endian */ pico_status_t picoos_write_le_uint16 (picoos_File file, picoos_uint16 val) { picoos_int32 len = 2; picoos_uint8 by[2]; by[0] = (picoos_uint8)((val) & 0x00FF); by[1] = (picoos_uint8)(((val) & 0xFF00)>>8); return (picoos_WriteBytes(file,by,&len) && (2 == len)); } pico_status_t picoos_write_le_uint32 (picoos_File file, picoos_uint32 val) { picoos_int32 len = 4; picoos_uint8 by[4]; by[0] = (picoos_uint8)(val & 0x000000FF); by[1] = (picoos_uint8)((val & 0x0000FF00)>>8); by[2] = (picoos_uint8)((val & 0x00FF0000)>>16); by[3] = (picoos_uint8)((val & 0xFF000000)>>24); return (picoos_WriteBytes(file,by,&len) && (4 == len)); } /* write pi to mem */ pico_status_t picoos_write_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 val) { picoos_uint8 * by = data + *pos; /* little-endian */ by[0] = (picoos_uint8)((val) & 0x00FF); by[1] = (picoos_uint8)(((val) & 0xFF00)>>8); (*pos) += 2; return PICO_OK; } /* *****************************************************************/ /* String search and compare operations */ /* *****************************************************************/ /* this function is case-sensitive */ picoos_uint8 picoos_has_extension(const picoos_char *str, const picoos_char *suf) { picoos_int32 istr = picoos_strlen(str)-1; picoos_int32 isuf = picoos_strlen(suf)-1; while ((istr >= 0) && (isuf >=0) && (str[istr] == suf[isuf])) { istr--; isuf--; } return (isuf < 0); } /* *****************************************************************/ /* String/Number Conversions (may be moved to picopal) */ /* *****************************************************************/ pico_status_t picoos_string_to_int32(picoos_char str[], picoos_int32 * res) { /* syntax: [+|-] dig {dig} */ int i; int neg; int val; int err; err = 0; i = 0; while ((str[i] <= ' ') && (str[i] != '\0')) { i++; } neg = 0; if (str[i] == '-') { neg = 1; i++; } else if (str[i] == '+') { i++; } val = 0; if ((str[i] < '0') || (str[i]> '9')) { err = 1; } while ((str[i] >= '0') && (str[i] <= '9')) { val = val * 10 + (str[i] - '0'); i++; } while ((str[i] <= ' ') && (str[i] != '\0')) { i++; } if (neg == 1) { val = -val; } if ((err == 0) && (str[i] == '\0')) { (*res) = val; return PICO_OK; } else { (*res) = 0; return PICO_EXC_NUMBER_FORMAT; } } pico_status_t picoos_string_to_uint32(picoos_char str[], picoos_uint32 * res) { /* syntax: [+] dig {dig} */ int i; int val; int err; err = 0; i = 0; while ((str[i] <= ' ') && (str[i] != '\0')) { i++; } if (str[i] == '+') { i++; } val = 0; if ((str[i] < '0') || (str[i]> '9')) { err = 1; } while ((str[i] >= '0') && (str[i] <= '9')) { val = val * 10 + (str[i] - '0'); i++; } while ((str[i] <= ' ') && (str[i] != '\0')) { i++; } if ((err == 0) && (str[i] == '\0')) { (*res) = val; return PICO_OK; } else { (*res) = 0; return PICO_EXC_NUMBER_FORMAT; } } /* 'stringlen' is the part of input string to be considered, * possibly not containing NULLC (e.g. result of strlen). * 'maxsize' is the maximal size of 'part' including a byte * for the terminating NULLC! */ void picoos_get_sep_part_str(picoos_char string[], picoos_int32 stringlen, picoos_int32 * ind, picoos_char sepCh, picoos_char part[], picoos_int32 maxsize, picoos_uint8 * done) { picoos_int32 j; picoos_uint8 done1; if (((*ind) >= stringlen)) { (*done) = 0; part[0] = (picoos_char) NULLC; } else { done1 = 1; j = 0; while ((((*ind) < stringlen) && (string[(*ind)] != sepCh)) && (string[((*ind))] != (picoos_char)NULLC)) { if ((j < maxsize-1)) { part[(j)] = string[(*ind)]; j++; } else { done1 = 0; } (*ind)++; } part[j] = (picoos_char)NULLC; if ((*ind) < stringlen) { if ((string[(*ind)] == sepCh)) { (*ind)++; /* skip separator character */ } else if (string[(*ind)] == (picoos_char)NULLC) { /* reached end of input; set ind to stringlen so that no more (empty) partial strings will be found */ (*ind) = stringlen; } } (*done) = done1; } } /* *****************************************************************/ /* timer function */ /* *****************************************************************/ extern void picoos_get_timer(picopal_uint32 * sec, picopal_uint32 * usec) { picopal_get_timer(sec, usec); } #ifdef __cplusplus } #endif /* end */