diff options
Diffstat (limited to 'pico/lib/picoos.h')
| -rw-r--r-- | pico/lib/picoos.h | 550 |
1 files changed, 550 insertions, 0 deletions
diff --git a/pico/lib/picoos.h b/pico/lib/picoos.h new file mode 100644 index 0000000..859e176 --- /dev/null +++ b/pico/lib/picoos.h @@ -0,0 +1,550 @@ +/* + * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland + * + * 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.h + * + * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland + * All rights reserved. + * + * History: + * - 2009-04-20 -- initial version + * + */ +/** + * @addtogroup picoos + + * <b> Operating system generalization module </b>\n + * +*/ + +#ifndef PICOOS_H_ +#define PICOOS_H_ + +#include "picodefs.h" +#include "picopal.h" + +#ifdef __cplusplus +extern "C" { +#endif +#if 0 +} +#endif + + +/* some "switch" used in picopal and in picocep ... */ +#define PICOOS_DIV_USE_INV PICOPAL_DIV_USE_INV + +/* *************************************************/ +/* types */ +/* *************************************************/ + +typedef picopal_uint8 picoos_uint8; +typedef picopal_uint16 picoos_uint16; +typedef picopal_uint32 picoos_uint32; + +typedef picopal_int8 picoos_int8; +typedef picopal_int16 picoos_int16; +typedef picopal_int32 picoos_int32; + +typedef picopal_double picoos_double; +typedef picopal_single picoos_single; + +typedef picopal_char picoos_char; +typedef picopal_uchar picoos_uchar; + +typedef picopal_uint8 picoos_bool; + +typedef picopal_objsize_t picoos_objsize_t; +typedef picopal_ptrdiff_t picoos_ptrdiff_t; + +/* *************************************************/ +/* functions */ +/* *************************************************/ + + +picoos_int32 picoos_atoi(const picoos_char *); +picoos_int8 picoos_strcmp(const picoos_char *, const picoos_char *); +picoos_int8 picoos_strncmp(const picoos_char *a, const picoos_char *b, picoos_objsize_t siz); +picoos_uint32 picoos_strlen(const picoos_char *); +picoos_char * picoos_strchr(const picoos_char *, picoos_char); +picoos_char *picoos_strstr(const picoos_char *s, const picoos_char *substr); +picoos_int16 picoos_slprintf(picoos_char * b, picoos_uint32 bsize, const picoos_char *f, ...); +picoos_char * picoos_strcpy(picoos_char *, const picoos_char *); +picoos_char * picoos_strcat(picoos_char *, const picoos_char *); + +/* 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); + +/* safe versions */ +picoos_objsize_t picoos_strlcpy(picoos_char *dst, const picoos_char *src, picoos_objsize_t siz); +void * picoos_mem_set(void * dest, picoos_uint8 byte_val, picoos_objsize_t length); + +picoos_double picoos_cos(const picoos_double cos_arg); +picoos_double picoos_sin(const picoos_double sin_arg); +picoos_double picoos_fabs(const picoos_double fabs_arg); + +picoos_double picoos_quick_exp(const picoos_double y); + + +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); +pico_status_t picoos_string_to_uint32 (picoos_char str[], picoos_uint32 * res); +pico_status_t picoos_string_to_int32 (picoos_char str[], picoos_int32 * res); + +/* *****************************************************************/ +/* "Common" */ +/* *****************************************************************/ +/* picoos_common is a collection of basic functionalities that must be globally accesible from every "big" function. + * It includes pointers to the MemoryManasger, ExceptionManager and a list of open files. */ + +typedef struct memory_manager * picoos_MemoryManager; +typedef struct picoos_exception_manager * picoos_ExceptionManager; +typedef struct picoos_file * picoos_File; + + +/** object : Common + * shortcut : common + * + */ +typedef struct picoos_common * picoos_Common; + +/* the picoos_common structure itself is exported so no access functions are needed. Handle with care! (might be changed later) */ +typedef struct picoos_common { + picoos_ExceptionManager em; + picoos_MemoryManager mm; + picoos_File fileList; +} picoos_common_t; + +picoos_Common picoos_newCommon(picoos_MemoryManager mm); + +void picoos_disposeCommon(picoos_MemoryManager mm, picoos_Common * this); + + +/* *****************************************************************/ +/* Memory Management */ +/* *****************************************************************/ + +typedef picoos_char * byte_ptr_t; + +#define PICOOS_ALIGN_SIZE 8 + + + +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); + +/** + * Creates a new memory manager object for the specified raw memory + * block. 'enableProtMem' enables or disables memory protection + * functionality; if disabled, picoos_protectMem() has no effect. + */ +picoos_MemoryManager picoos_newMemoryManager( + void *raw_memory, + picoos_objsize_t size, + picoos_bool enableMemProt); + + + +void picoos_disposeMemoryManager(picoos_MemoryManager * mm); + + +void * picoos_allocate(picoos_MemoryManager this, picoos_objsize_t byteSize); +void picoos_deallocate(picoos_MemoryManager this, void * * adr); + +/* the following memory manager routines are for testing and + debugging purposes */ + +/** + * Same as picoos_allocate, but write access to the memory block may be + * prohibited by a subsequent call to picoos_protectMem(). + */ +void *picoos_allocProtMem(picoos_MemoryManager mm, picoos_objsize_t byteSize); + +/** + * Releases a memory block previously allocated by picoos_allocProtMem(). + */ +void picoos_deallocProtMem(picoos_MemoryManager mm, void **addr); + +/** + * Enables or disables write protection of a memory block previously + * allocated by picoos_allocProtMem(). If write protection is enabled, + * any subsequent write access will cause a segmentation fault. + */ +void picoos_protectMem( + picoos_MemoryManager mm, + void *addr, + picoos_objsize_t len, + picoos_bool enable); + +void picoos_getMemUsage( + picoos_MemoryManager this, + picoos_bool resetIncremental, + picoos_int32 *usedBytes, + picoos_int32 *incrUsedBytes, + picoos_int32 *maxUsedBytes); + +void picoos_showMemUsage( + picoos_MemoryManager this, + picoos_bool incremental, + picoos_bool resetIncremental); + +/* *****************************************************************/ +/* Exception Management */ +/* *****************************************************************/ +/** object : ExceptionManager + * shortcut : em + * + */ + + +#define PICOOS_MAX_EXC_MSG_LEN 512 +#define PICOOS_MAX_WARN_MSG_LEN 64 +#define PICOOS_MAX_NUM_WARNINGS 8 + +void picoos_setErrorMsg(picoos_char * dst, picoos_objsize_t siz, + picoos_int16 code, picoos_char * base, const picoos_char *fmt, ...); + + +picoos_ExceptionManager picoos_newExceptionManager(picoos_MemoryManager mm); + +void picoos_disposeExceptionManager(picoos_MemoryManager mm, + picoos_ExceptionManager * this); + + +void picoos_emReset(picoos_ExceptionManager this); + +/* For convenience, this function returns the resulting exception code of 'this' + * (as would be returned by emGetExceptionCode). + * 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, ...); + +pico_status_t picoos_emGetExceptionCode(picoos_ExceptionManager this); + +void picoos_emGetExceptionMessage(picoos_ExceptionManager this, picoos_char * msg, picoos_uint16 maxsize); + +void picoos_emRaiseWarning(picoos_ExceptionManager this, + pico_status_t warningCode, picoos_char * baseMessage, picoos_char * fmt, ...); + +picoos_uint8 picoos_emGetNumOfWarnings(picoos_ExceptionManager this); + +pico_status_t picoos_emGetWarningCode(picoos_ExceptionManager this, picoos_uint8 warnNum); + +void picoos_emGetWarningMessage(picoos_ExceptionManager this, picoos_uint8 warnNum, picoos_char * msg, picoos_uint16 maxsize); + + + + +/* *****************************************************************/ +/* File Access */ +/* *****************************************************************/ + +#define picoos_MaxFileNameLen 512 +#define picoos_MaxKeyLen 512 +#define picoos_MaxPathLen 512 +#define picoos_MaxPathListLen 2048 + +typedef picoos_char picoos_Key[picoos_MaxKeyLen]; +typedef picoos_char picoos_FileName[picoos_MaxFileNameLen]; +typedef picoos_char picoos_Path[picoos_MaxPathLen]; +typedef picoos_char picoos_PathList[picoos_MaxPathListLen]; + + +/* ***** 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. */ +picoos_uint8 picoos_OpenBinary(picoos_Common g, picoos_File * f, picoos_char name[]); + + +/* Read next byte from file 'f'. */ +picoos_uint8 picoos_ReadByte(picoos_File f, picoos_uint8 * by); + +/* Read next 'len' bytes from 'f' into 'bytes'; 'len' returns the + number of bytes actually read (may be smaller than requested + length if 'bytes' is too small to hold all bytes or at end of file). + Remark: 'bytes' is compabtible with any variable of any size. */ +picoos_uint8 picoos_ReadBytes(picoos_File f, picoos_uint8 bytes[], + picoos_uint32 * len); + + +/* Create new binary file. + If 'key' is not empty, the file is encrypted with 'key'. */ +picoos_uint8 picoos_CreateBinary(picoos_Common g, picoos_File * f, picoos_char name[]); + +picoos_uint8 picoos_WriteByte(picoos_File f, picoos_char by); + +/* Writes 'len' bytes from 'bytes' onto file 'f'; 'len' returns + the number of bytes actually written. */ +picoos_uint8 picoos_WriteBytes(picoos_File f, const picoos_char bytes[], + picoos_int32 * len); + + +/* Close previously opened binary file. */ +picoos_uint8 picoos_CloseBinary(picoos_Common g, picoos_File * f); + + + + + + +pico_status_t picoos_read_le_int16 (picoos_File file, picoos_int16 * val); +pico_status_t picoos_read_le_uint16 (picoos_File file, picoos_uint16 * val); +pico_status_t picoos_read_le_uint32 (picoos_File file, picoos_uint32 * val); + + +pico_status_t picoos_read_pi_uint16 (picoos_File file, picoos_uint16 * val); +pico_status_t picoos_read_pi_uint32 (picoos_File file, picoos_uint32 * val); + +pico_status_t picoos_write_le_uint16 (picoos_File file, picoos_uint16 val); +pico_status_t picoos_write_le_uint32 (picoos_File file, picoos_uint32 val); + +/* +pico_status_t picoos_write_pi_uint32 (picoos_File file, const picoos_uint32 val); + +pico_status_t picoos_write_pi_uint16 (picoos_File file, const picoos_uint16 val); +*/ + + +/* **************************************************************************************/ +/* *** general file routines *****/ + +/* Returns whether end of file was encountered in previous + read operation. */ +picoos_bool picoos_Eof(picoos_File f); + +/* 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); + +/* Get position from file 'f'. */ +picoos_bool picoos_GetPos(picoos_File f, picoos_uint32 * pos); + +/* Returns the length of the file in bytes. */ +picoos_bool picoos_FileLength(picoos_File f, picoos_uint32 * len); + +/* Return full name of file 'f'. */ +picoos_bool picoos_Name(picoos_File f, picoos_char name[], picoos_uint32 maxsize); + +/* Returns whether file 'name' exists or not. */ +picoos_bool picoos_FileExists(picoos_Common g, picoos_char name[] /*, picoos_char ckey[] */); + +/* Delete a file. */ +picoos_bool picoos_Delete(picoos_char name[]); + +/* Rename a file. */ +picoos_bool picoos_Rename(picoos_char oldName[], picoos_char newName[]); + + +/* *****************************************************************/ +/* Sampled Data Files */ +/* *****************************************************************/ + +#define SAMPLE_FREQ_16KHZ (picoos_uint32) 16000 + +typedef enum { + FILE_TYPE_WAV, + FILE_TYPE_AU, + FILE_TYPE_RAW, + FILE_TYPE_OTHER +} wave_file_type_t; + +typedef enum { + FORMAT_TAG_LIN = 1, /**< linear 16-bit encoding */ + FORMAT_TAG_ALAW = 6, /**< a-law encoding, 8 bit */ + FORMAT_TAG_ULAW = 7 /**< u-law encoding, 8 bit */ + /* there are many more */ +} wave_format_tag_t; + + +typedef enum { + /* values corresponding RIFF wFormatTag */ + PICOOS_ENC_LIN = FORMAT_TAG_LIN, /**< linear 16-bit encoding; standard */ + PICOOS_ENC_ALAW = FORMAT_TAG_ALAW, /**< a-law encoding, 8 bit */ + PICOOS_ENC_ULAW = FORMAT_TAG_ULAW, /**< u-law encoding, 8 bit */ + /* values outside RIFF wFormatTag values (above 4100) */ + PICOOS_ENC_OTHER = 5000 /**< other; (treated as raw) */ + } picoos_encoding_t; + +typedef struct picoos_sd_file * picoos_SDFile; + +/* SDFile input functions */ + +/* orig. comment from SDInOut.def + Opens sampled data file 'fileName' for input and returns + the encoding 'enc' of the file, sampling rate 'sf', + nr of samples 'nrSamples', and a handle to the opened file + in 'sdFile'. + + If 'fileName' is empty, the input is taken from the direct + acoustic input using the sampling rate specified by + "SetRawDefaults". In this case, 'encoding' returns 'EncLin', + and 'nrSamples' returns 0. + + The file format is taken from the file name extension: + ".wav" --> wav file + ".au" --> au file + other extensions --> headerless files + + For wav and au files, the sampling rate and encoding are taken + from the file header and returned in 'sf' and 'enc'. For + headerless files, 'sf' and 'enc' are taken from the + most recently set default values (procedure SetRawDefaults). + + 'done' returns whether the sampled data file was successfully + opened. */ +extern picoos_bool picoos_sdfOpenIn (picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], picoos_uint32 * sf, picoos_encoding_t * enc, picoos_uint32 * nrSamples); + + +extern picoos_bool picoos_sdfGetSamples (picoos_SDFile sdFile, picoos_uint32 start, picoos_uint32 * nrSamples, picoos_int16 samples[]); + + +extern picoos_bool picoos_sdfCloseIn (picoos_Common g, picoos_SDFile * sdFile); + + +/* SDFile output functions*/ + +extern picoos_bool picoos_sdfOpenOut (picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], int sf, picoos_encoding_t enc); + + +extern picoos_bool picoos_sdfPutSamples (picoos_SDFile sdFile, picoos_uint32 nrSamples, picoos_int16 samples[]); + +/* +extern picoos_bool picoos_AbortOutput (picoos_SDFile sdFile); + + +extern picoos_bool picoos_ResumeOutput (picoos_SDFile sdFile); + + +extern picoos_bool picoos_FlushOutput (picoos_SDFile sdFile); +*/ + +extern picoos_bool picoos_sdfCloseOut (picoos_Common g, picoos_SDFile * sdFile); + + +/* *****************************************************************/ +/* File Headers */ +/* *****************************************************************/ + +#define PICOOS_MAX_FIELD_STRING_LEN 32 /* including terminating char */ + +#define PICOOS_MAX_NUM_HEADER_FIELDS 10 +#define PICOOS_NUM_BASIC_HEADER_FIELDS 5 + +#define PICOOS_HEADER_NAME 0 +#define PICOOS_HEADER_VERSION 1 +#define PICOOS_HEADER_DATE 2 +#define PICOOS_HEADER_TIME 3 +#define PICOOS_HEADER_CONTENT_TYPE 4 + +#define PICOOS_MAX_HEADER_STRING_LEN (PICOOS_MAX_NUM_HEADER_FIELDS * (2 * PICOOS_MAX_FIELD_STRING_LEN)) + +typedef picoos_char picoos_field_string_t[PICOOS_MAX_FIELD_STRING_LEN]; + +typedef picoos_char picoos_header_string_t[PICOOS_MAX_HEADER_STRING_LEN]; + +typedef enum {PICOOS_FIELD_IGNORE, PICOOS_FIELD_EQUAL, PICOOS_FIELD_COMPAT} picoos_compare_op_t; + +/* private */ +typedef struct picoos_file_header_field { + picoos_field_string_t key; + picoos_field_string_t value; + picoos_compare_op_t op; +} picoos_file_header_field_t; + +/* public */ +typedef struct picoos_file_header * picoos_FileHeader; +typedef struct picoos_file_header { + picoos_uint8 numFields; + picoos_file_header_field_t field[PICOOS_MAX_NUM_HEADER_FIELDS]; +} picoos_file_header_t; + + +pico_status_t picoos_clearHeader(picoos_FileHeader header); + +pico_status_t picoos_setHeaderField(picoos_FileHeader header, picoos_uint8 index, picoos_char * key, picoos_char * value, picoos_compare_op_t op); + +/* 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); + +/* caller has to make sure allocated space at str is large enough to hold the header in question */ +/* +pico_status_t picoos_hdrToString(picoos_FileHeader header, picoos_header_string_t str); +*/ + +pico_status_t picoos_hdrParseHeader(picoos_FileHeader header, picoos_header_string_t str); + +pico_status_t picoos_getSVOXHeaderString(picoos_char * str, picoos_uint8 * len, picoos_uint32 maxlen); + +pico_status_t picoos_readPicoHeader(picoos_File f, picoos_uint32 * headerlen); + + + +/* *****************************************************************/ +/* String search and compare operations */ +/* *****************************************************************/ + + +picoos_uint8 picoos_has_extension(const picoos_char *str, const picoos_char *suf); + +/* *****************************************************************/ +/* String/Number Manipulations (might be moved to picopal) */ +/* *****************************************************************/ + +pico_status_t picoos_string_to_int32(picoos_char str[], + picoos_int32 * res); + +pico_status_t picoos_string_to_uint32(picoos_char str[], + picoos_uint32 * res); + +/* '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); + +/* searches for the first contiguous string of printable characters (> ' ') inside fromStr, possibly skipping + * chars <= ' ') and returns it in toStr. + * fromStr is assumed to be NULLC terminated and toStr is forced to be NULLC terminated within maxsize. + * The search is started at *pos inside fromStr and at return, *pos is the position within fromStr after the + * found string, or the position after the end of fromStr, if no string was found. + * the function returns TRUE if a string was found and fitted toStr, or FALSE otherwise. */ +picoos_uint8 picoos_get_str (picoos_char * fromStr, picoos_uint32 * pos, picoos_char * toStr, picoos_objsize_t maxsize); + + +pico_status_t picoos_read_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 * val); + +pico_status_t picoos_read_mem_pi_uint32 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint32 * val); + +pico_status_t picoos_write_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 val); + + +/* *****************************************************************/ +/* timer function */ +/* *****************************************************************/ + +void picoos_get_timer(picopal_uint32 * sec, picopal_uint32 * usec); + +#ifdef __cplusplus +} +#endif + + +#endif /*PICOOS_H_*/ |