/*
* 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 picorsrc.c
*
* Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
* All rights reserved.
*
* History:
* - 2009-04-20 -- initial version
*
*/
#include "picodefs.h"
#include "picoos.h"
#include "picodbg.h"
/* knowledge layer */
#include "picoknow.h"
#include "picokdt.h"
#include "picoklex.h"
#include "picokfst.h"
#include "picokpdf.h"
#include "picoktab.h"
#include "picokpr.h"
#include "picorsrc.h"
#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif
#if defined(PICO_DEBUG)
#include "picokdbg.h"
#endif
/** object : Resource
* shortcut : rsrc
*
*/
typedef struct picorsrc_resource {
picoos_uint32 magic; /* magic number used to validate handles */
/* next connects all active resources of a resource manager and the garbaged resources of the manager's free list */
picorsrc_Resource next;
picorsrc_resource_type_t type;
picorsrc_resource_name_t name;
picoos_int8 lockCount; /* count of current subscribers of this resource */
picoos_File file;
picoos_uint8 * raw_mem; /* pointer to allocated memory. NULL if preallocated. */
/* picoos_uint32 size; */
picoos_uint8 * start; /* start of content (after header) */
picoknow_KnowledgeBase kbList;
} picorsrc_resource_t;
#define MAGIC_MASK 0x7049634F /* pIcO */
#define SET_MAGIC_NUMBER(res) \
(res)->magic = ((picoos_uint32) (uintptr_t) (res)) ^ MAGIC_MASK
#define CHECK_MAGIC_NUMBER(res) \
((res)->magic == (((picoos_uint32) (uintptr_t) (res)) ^ MAGIC_MASK))
/**
* Returns non-zero if 'this' is a valid resource handle, zero otherwise.
*/
picoos_int16 picoctrl_isValidResourceHandle(picorsrc_Resource this)
{
return (this != NULL) && CHECK_MAGIC_NUMBER(this);
}
static picorsrc_Resource picorsrc_newResource(picoos_MemoryManager mm)
{
picorsrc_Resource this = picoos_allocate(mm, sizeof(*this));
if (NULL != this) {
SET_MAGIC_NUMBER(this);
/* initialize */
this->name[0] = NULLC;
/* picoos_strlcpy(this->name, name,PICORSRC_MAX_RSRC_NAME_SIZ); */
this->next = NULL;
this->type = PICORSRC_TYPE_NULL;
this->lockCount = 0;
this->file = NULL;
this->raw_mem = NULL;
this->start = NULL;
this->kbList = NULL;
/* this->size=0; */
}
return this;
}
static void picorsrc_disposeResource(picoos_MemoryManager mm, picorsrc_Resource * this)
{
if (NULL != (*this)) {
(*this)->magic ^= 0xFFFEFDFC;
/* we have to explicitly free 'raw_mem' here because in testing
scenarios (where memory protection functionality is enabled)
it might be allocated aside from normal memory */
if ((*this)->raw_mem != NULL) {
picoos_deallocProtMem(mm, (void *) &(*this)->raw_mem);
}
picoos_deallocate(mm,(void * *)this);
}
}
static void picorsrc_initializeVoice(picorsrc_Voice this)
{
picoos_uint16 i;
if (NULL != this) {
/* initialize */
for (i=0; i<PICORSRC_KB_ARRAY_SIZE; i++) {
this->kbArray[i] = NULL;
}
this->numResources = 0;
this->next = NULL;
}
}
static picorsrc_Voice picorsrc_newVoice(picoos_MemoryManager mm)
{
picorsrc_Voice this = (picorsrc_Voice) picoos_allocate(mm,sizeof(*this));
picorsrc_initializeVoice(this);
return this;
}
/*
static void picorsrc_disposeVoice(picoos_MemoryManager mm, picorsrc_Voice * this)
{
if (NULL != (*this)) {
picoos_deallocate(mm,(void *)this);
}
}
*/
/** object : VoiceDefinition
* shortcut : vdef
*
*/
typedef struct picorsrc_voice_definition * picorsrc_VoiceDefinition;
typedef struct picorsrc_voice_definition {
picoos_char voiceName[PICO_MAX_VOICE_NAME_SIZE];
picoos_uint8 numResources;
picorsrc_resource_name_t resourceName[PICO_MAX_NUM_RSRC_PER_VOICE];
picorsrc_VoiceDefinition next;
} picorsrc_voice_definition_t;
static picorsrc_VoiceDefinition picorsrc_newVoiceDefinition(picoos_MemoryManager mm)
{
/* picoos_uint8 i; */
picorsrc_VoiceDefinition this = (picorsrc_VoiceDefinition) picoos_allocate(mm,sizeof(*this));
if (NULL != this) {
/* initialize */
this->voiceName[0] = NULLC;
this->numResources = 0;
/*
for (i=0; i < PICO_MAX_NUM_RSRC_PER_VOICE; i++) {
this->resourceName[i][0] = NULLC;
}
*/
this->next = NULL;
}
return this;
}
/*
static void picorsrc_disposeVoiceDefinition(picoos_MemoryManager mm, picorsrc_VoiceDefinition * this)
{
if (NULL != (*this)) {
picoos_deallocate(mm,(void *)this);
}
}
*/
/** object : ResourceManager
* shortcut : rm
*
*/
typedef struct picorsrc_resource_manager {
picoos_Common common;
picoos_uint16 numResources;
picorsrc_Resource resources, freeResources;
picoos_uint16 numVoices;
picorsrc_Voice voices, freeVoices;
picoos_uint16 numVdefs;
picorsrc_VoiceDefinition vdefs, freeVdefs;
picoos_uint16 numKbs;
picoknow_KnowledgeBase freeKbs;
picoos_header_string_t tmpHeader;
} picorsrc_resource_manager_t;
pico_status_t picorsrc_createDefaultResource(picorsrc_ResourceManager this /*,
picorsrc_Resource * resource */);
picorsrc_ResourceManager picorsrc_newResourceManager(picoos_MemoryManager mm, picoos_Common common /* , picoos_char * configFile */)
{
picorsrc_ResourceManager this = picoos_allocate(mm,sizeof(*this));
if (NULL != this) {
/* initialize */
this->common = common;
this->numResources = 0;
this->resources = NULL;
this->freeResources = NULL;
this->numVoices = 0;
this->voices = NULL;
this->freeVoices = NULL;
this->numVdefs = 0;
this->vdefs = NULL;
this->freeVdefs = NULL;
}
return this;
}
void picorsrc_disposeResourceManager(picoos_MemoryManager mm, picorsrc_ResourceManager * this)
{
if (NULL != (*this)) {
/* terminate */
picoos_deallocate(mm,(void *)this);
}
}
/* ******* accessing resources **************************************/
static pico_status_t findResource(picorsrc_ResourceManager this, picoos_char * resourceName, picorsrc_Resource * rsrc) {
picorsrc_Resource r;
if (NULL == this) {
return PICO_ERR_NULLPTR_ACCESS;
}
r = this->resources;
while (NULL != r && (0 != picoos_strcmp(r->name,resourceName))) {
r = r->next;
}
*rsrc = r;
return PICO_OK;
}
static picoos_uint8 isResourceLoaded(picorsrc_ResourceManager this, picoos_char * resourceName) {
picorsrc_Resource res;
if (PICO_OK == findResource(this, resourceName,&res)){
return (NULL != res);
} else {
return FALSE;
}
}
static pico_status_t parse_resource_name(picoos_char * fileName)
{
PICODBG_DEBUG(("analysing file name %s",fileName));
if (picoos_has_extension(fileName,
(picoos_char *)PICO_BIN_EXTENSION)) {
return PICO_OK;
} else {
return PICO_EXC_UNEXPECTED_FILE_TYPE;
}
}
static pico_status_t readHeader(picorsrc_ResourceManager this,
picoos_FileHeader header, picoos_uint32 * headerlen, picoos_File file)
{
picoos_uint16 hdrlen1;
picoos_uint32 n;
pico_status_t status;
/* read PICO header */
status = picoos_readPicoHeader(file, headerlen);
if (PICO_OK == status) {
} else {
return picoos_emRaiseException(this->common->em,status,NULL,(picoos_char *)"problem reading file header");
}
/* read header length (excluding length itself) */
status = picoos_read_pi_uint16(file,&hdrlen1);
PICODBG_DEBUG(("got header size %d",hdrlen1));
if (PICO_OK == status) {
*headerlen += 2;
status = (hdrlen1 <= PICOOS_MAX_HEADER_STRING_LEN-1) ? PICO_OK : PICO_ERR_OTHER;
if (PICO_OK == status) {
n = hdrlen1;
if (picoos_ReadBytes(file, (picoos_uint8 *) this->tmpHeader, &n) && hdrlen1 == n) {
this->tmpHeader[hdrlen1] = NULLC;
*headerlen += hdrlen1;
PICODBG_DEBUG(("got header <%s>",this->tmpHeader));
status = PICO_OK;
} else {
status = PICO_ERR_OTHER;
}
}
if (PICO_OK == status) {
status = picoos_hdrParseHeader(header, this->tmpHeader);
}
}
return status;
}
static pico_status_t picorsrc_createKnowledgeBase(
picorsrc_ResourceManager this,
picoos_uint8 * data,
picoos_uint32 size,
picoknow_kb_id_t kbid,
picoknow_KnowledgeBase * kb)
{
(*kb) = picoknow_newKnowledgeBase(this->common->mm);
if (NULL == (*kb)) {
return PICO_EXC_OUT_OF_MEM;
}
(*kb)->base = data;
(*kb)->size = size;
(*kb)->id = kbid;
switch (kbid) {
case PICOKNOW_KBID_TPP_MAIN:
case PICOKNOW_KBID_TPP_USER_1:
case PICOKNOW_KBID_TPP_USER_2:
return picokpr_specializePreprocKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_TAB_GRAPHS:
return picoktab_specializeGraphsKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_TAB_PHONES:
return picoktab_specializePhonesKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_TAB_POS:
return picoktab_specializePosKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_FIXED_IDS:
return picoktab_specializeIdsKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_LEX_MAIN:
case PICOKNOW_KBID_LEX_USER_1:
case PICOKNOW_KBID_LEX_USER_2:
return picoklex_specializeLexKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_DT_POSP:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_POSP);
break;
case PICOKNOW_KBID_DT_POSD:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_POSD);
break;
case PICOKNOW_KBID_DT_G2P:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_G2P);
break;
case PICOKNOW_KBID_DT_PHR:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_PHR);
break;
case PICOKNOW_KBID_DT_ACC:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_ACC);
break;
case PICOKNOW_KBID_FST_SPHO_1:
case PICOKNOW_KBID_FST_SPHO_2:
case PICOKNOW_KBID_FST_SPHO_3:
case PICOKNOW_KBID_FST_SPHO_4:
case PICOKNOW_KBID_FST_SPHO_5:
case PICOKNOW_KBID_FST_SPHO_6:
case PICOKNOW_KBID_FST_SPHO_7:
case PICOKNOW_KBID_FST_SPHO_8:
case PICOKNOW_KBID_FST_SPHO_9:
case PICOKNOW_KBID_FST_SPHO_10:
case PICOKNOW_KBID_FST_WPHO_1:
case PICOKNOW_KBID_FST_WPHO_2:
case PICOKNOW_KBID_FST_WPHO_3:
case PICOKNOW_KBID_FST_WPHO_4:
case PICOKNOW_KBID_FST_WPHO_5:
case PICOKNOW_KBID_FST_SVOXPA_PARSE:
case PICOKNOW_KBID_FST_XSAMPA_PARSE:
case PICOKNOW_KBID_FST_XSAMPA2SVOXPA:
return picokfst_specializeFSTKnowledgeBase(*kb, this->common);
break;
case PICOKNOW_KBID_DT_DUR:
case PICOKNOW_KBID_DT_LFZ1:
case PICOKNOW_KBID_DT_LFZ2:
case PICOKNOW_KBID_DT_LFZ3:
case PICOKNOW_KBID_DT_LFZ4:
case PICOKNOW_KBID_DT_LFZ5:
case PICOKNOW_KBID_DT_MGC1:
case PICOKNOW_KBID_DT_MGC2:
case PICOKNOW_KBID_DT_MGC3:
case PICOKNOW_KBID_DT_MGC4:
case PICOKNOW_KBID_DT_MGC5:
return picokdt_specializeDtKnowledgeBase(*kb, this->common,
PICOKDT_KDTTYPE_PAM);
break;
case PICOKNOW_KBID_PDF_DUR:
return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
PICOKPDF_KPDFTYPE_DUR);
break;
case PICOKNOW_KBID_PDF_LFZ:
return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
PICOKPDF_KPDFTYPE_MUL);
break;
case PICOKNOW_KBID_PDF_MGC:
return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
PICOKPDF_KPDFTYPE_MUL);
break;
case PICOKNOW_KBID_PDF_PHS:
return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
PICOKPDF_KPDFTYPE_PHS);
break;
#if defined(PICO_DEBUG)
case PICOKNOW_KBID_DBG:
return picokdbg_specializeDbgKnowledgeBase(*kb, this->common);
break;
#endif
default:
break;
}
return PICO_OK;
}
static pico_status_t picorsrc_releaseKnowledgeBase(
picorsrc_ResourceManager this,
picoknow_KnowledgeBase * kb)
{
(*kb) = NULL;
return PICO_OK;
}
static pico_status_t picorsrc_getKbList(picorsrc_ResourceManager this,
picoos_uint8 * data,
picoos_uint32 datalen,
picoknow_KnowledgeBase * kbList)
{
pico_status_t status = PICO_OK;
picoos_uint32 curpos = 0, offset, size;
picoos_uint8 i, numKbs, kbid;
picoos_char str[PICOKNOW_MAX_KB_NAME_SIZ];
picoknow_KnowledgeBase kb;
*kbList = NULL;
datalen = datalen;
/* read number of fields */
numKbs = data[curpos++];
PICODBG_DEBUG(("number of kbs (unrestricted) = %i",numKbs));
status = (numKbs <= PICOKNOW_MAX_NUM_RESOURCE_KBS) ? PICO_OK : PICO_EXC_FILE_CORRUPT;
/* read in all kb names */
PICODBG_DEBUG(("number of kbs = %i",numKbs));
i = 0;
while ((PICO_OK == status) && (i++ < numKbs)) {
status = (picoos_get_str((picoos_char *)data,&curpos,str,PICOOS_MAX_FIELD_STRING_LEN)) ? PICO_OK : PICO_EXC_FILE_CORRUPT;
PICODBG_DEBUG(("contains knowledge base %s (status: %i)",str, status));
}
/* consume termination of last str */
curpos++;
i = 0;
while ((PICO_OK == status) && (i++ < numKbs)) {
kbid = data[curpos++];
PICODBG_DEBUG(("got kb id %i, curpos now %i",kbid, curpos));
status = picoos_read_mem_pi_uint32(data,&curpos,&offset);
PICODBG_DEBUG(("got kb offset %i, curpos now %i",offset, curpos));
status = picoos_read_mem_pi_uint32(data,&curpos,&size);
PICODBG_DEBUG(("got kb size %i, curpos now %i",size, curpos));
if (PICO_OK == status) {
if (0 == offset) {
/* currently we consider a kb mentioned in resource but with offset 0 (no knowledge) as
* different form a kb not mentioned at all. We might reconsider that later. */
PICODBG_DEBUG((" kb (id %i) is mentioned but empty (base:%i, size:%i)",kb->id, kb->base, kb->size));
status = picorsrc_createKnowledgeBase(this, NULL, size, (picoknow_kb_id_t)kbid, &kb);
} else {
status = picorsrc_createKnowledgeBase(this, data+offset, size, (picoknow_kb_id_t)kbid, &kb);
}
PICODBG_DEBUG(("found kb (id %i) starting at %i with size %i",kb->id, kb->base, kb->size));
if (PICO_OK == status) {
kb->next = *kbList;
*kbList = kb;
}
}
}
if (PICO_OK != status) {
kb = *kbList;
while (NULL != kb) {
picorsrc_releaseKnowledgeBase(this,&kb);
}
}
return status;
}
/* load resource file. the type of resource file etc. are in the header,
* then follows the directory, then the knowledge bases themselves (as byte streams) */
pico_status_t picorsrc_loadResource(picorsrc_ResourceManager this,
picoos_char * fileName, picorsrc_Resource * resource)
{
picorsrc_Resource res;
picoos_uint32 headerlen, len,maxlen;
picoos_file_header_t header;
picoos_uint8 rem;
pico_status_t status = PICO_OK;
if (resource == NULL) {
return PICO_ERR_NULLPTR_ACCESS;
} else {
*resource = NULL;
}
res = picorsrc_newResource(this->common->mm);
if (NULL == res) {
return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
}
if (PICO_MAX_NUM_RESOURCES <= this->numResources) {
picoos_deallocate(this->common->mm, (void *) &res);
return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources",PICO_MAX_NUM_RESOURCES);
}
/* ***************** parse file name for file type and parameters */
if (PICO_OK != parse_resource_name(fileName)) {
picoos_deallocate(this->common->mm, (void *) &res);
return PICO_EXC_UNEXPECTED_FILE_TYPE;
}
/* ***************** get header info */
/* open binary file for reading (no key, nrOfBufs, bufSize) */
PICODBG_DEBUG(("trying to open file %s",fileName));
if (!picoos_OpenBinary(this->common, &res->file, fileName)) {
/* open didn't succeed */
status = PICO_EXC_CANT_OPEN_FILE;
PICODBG_ERROR(("can't open file %s",fileName));
picoos_emRaiseException(this->common->em, PICO_EXC_CANT_OPEN_FILE,
NULL, (picoos_char *) "%s", fileName);
}
if (PICO_OK == status) {
status = readHeader(this, &header, &headerlen, res->file);
/* res->file now positioned at first pos after header */
}
/* ***************** check header values */
if (PICO_OK == status && isResourceLoaded(this, header.field[PICOOS_HEADER_NAME].value)) {
/* lingware is allready loaded, do nothing */
PICODBG_WARN((">>> lingware '%s' allready loaded",header.field[PICOOS_HEADER_NAME].value));
picoos_emRaiseWarning(this->common->em,PICO_WARN_RESOURCE_DOUBLE_LOAD,NULL,(picoos_char *)"%s",header.field[PICOOS_HEADER_NAME].value);
status = PICO_WARN_RESOURCE_DOUBLE_LOAD;
}
if (PICO_OK == status) {
/* get data length */
status = picoos_read_pi_uint32(res->file, &len);
PICODBG_DEBUG(("found net resource len of %i",len));
/* allocate memory */
if (PICO_OK == status) {
PICODBG_TRACE((">>> 2"));
maxlen = len + PICOOS_ALIGN_SIZE; /* once would be sufficient? */
res->raw_mem = picoos_allocProtMem(this->common->mm, maxlen);
/* res->size = maxlen; */
status = (NULL == res->raw_mem) ? PICO_EXC_OUT_OF_MEM : PICO_OK;
}
if (PICO_OK == status) {
rem = (uintptr_t) res->raw_mem % PICOOS_ALIGN_SIZE;
if (rem > 0) {
res->start = res->raw_mem + (PICOOS_ALIGN_SIZE - rem);
} else {
res->start = res->raw_mem;
}
/* read file contents into memory */
status = (picoos_ReadBytes(res->file, res->start, &len)) ? PICO_OK
: PICO_ERR_OTHER;
/* resources are read-only; the following write protection
has an effect in test configurations only */
picoos_protectMem(this->common->mm, res->start, len, /*enable*/TRUE);
}
/* note resource unique name */
if (PICO_OK == status) {
if (picoos_strlcpy(res->name,header.field[PICOOS_HEADER_NAME].value,PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
PICODBG_DEBUG(("assigned name %s to resource",res->name));
status = PICO_OK;
} else {
status = PICO_ERR_INDEX_OUT_OF_RANGE;
PICODBG_ERROR(("failed assigning name %s to resource",
res->name));
picoos_emRaiseException(this->common->em,
PICO_ERR_INDEX_OUT_OF_RANGE, NULL,
(picoos_char *)"resource %s",res->name);
}
}
/* get resource type */
if (PICO_OK == status) {
if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_TEXTANA)) {
res->type = PICORSRC_TYPE_TEXTANA;
} else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
res->type = PICORSRC_TYPE_SIGGEN;
} else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
res->type = PICORSRC_TYPE_USER_LEX;
} else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
res->type = PICORSRC_TYPE_USER_PREPROC;
} else {
res->type = PICORSRC_TYPE_OTHER;
}
}
if (PICO_OK == status) {
/* create kb list from resource */
status = picorsrc_getKbList(this, res->start, len, &res->kbList);
}
}
if (status == PICO_OK) {
/* add resource to rm */
res->next = this->resources;
this->resources = res;
this->numResources++;
*resource = res;
PICODBG_DEBUG(("done loading resource %s from %s", res->name, fileName));
} else {
picorsrc_disposeResource(this->common->mm, &res);
PICODBG_ERROR(("failed to load resource"));
}
if (status < 0) {
return status;
} else {
return PICO_OK;
}
}
static pico_status_t picorsrc_releaseKbList(picorsrc_ResourceManager this, picoknow_KnowledgeBase * kbList)
{
picoknow_KnowledgeBase kbprev, kb;
kb = *kbList;
while (NULL != kb) {
kbprev = kb;
kb = kb->next;
picoknow_disposeKnowledgeBase(this->common->mm,&kbprev);
}
*kbList = NULL;
return PICO_OK;
}
/* unload resource file. (if resource file is busy, warn and don't unload) */
pico_status_t picorsrc_unloadResource(picorsrc_ResourceManager this, picorsrc_Resource * resource) {
picorsrc_Resource r1, r2, rsrc;
if (resource == NULL) {
return PICO_ERR_NULLPTR_ACCESS;
} else {
rsrc = *resource;
}
if (rsrc->lockCount > 0) {
return PICO_EXC_RESOURCE_BUSY;
}
/* terminate */
if (rsrc->file != NULL) {
picoos_CloseBinary(this->common, &rsrc->file);
}
if (NULL != rsrc->raw_mem) {
picoos_deallocProtMem(this->common->mm, (void *) &rsrc->raw_mem);
PICODBG_DEBUG(("deallocated raw mem"));
}
r1 = NULL;
r2 = this->resources;
while (r2 != NULL && r2 != rsrc) {
r1 = r2;
r2 = r2->next;
}
if (NULL == r1) {
this->resources = rsrc->next;
} else if (NULL == r2) {
/* didn't find resource in rm! */
return PICO_ERR_OTHER;
} else {
r1->next = rsrc->next;
}
if (NULL != rsrc->kbList) {
picorsrc_releaseKbList(this, &rsrc->kbList);
}
picoos_deallocate(this->common->mm,(void **)resource);
this->numResources--;
return PICO_OK;
}
pico_status_t picorsrc_createDefaultResource(picorsrc_ResourceManager this
/*, picorsrc_Resource * resource */)
{
picorsrc_Resource res;
pico_status_t status = PICO_OK;
/* *resource = NULL; */
if (PICO_MAX_NUM_RESOURCES <= this->numResources) {
return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources",PICO_MAX_NUM_RESOURCES);
}
res = picorsrc_newResource(this->common->mm);
if (NULL == res) {
return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
}
if (picoos_strlcpy(res->name,PICOKNOW_DEFAULT_RESOURCE_NAME,PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
PICODBG_DEBUG(("assigned name %s to default resource",res->name));
status = PICO_OK;
} else {
PICODBG_ERROR(("failed assigning name %s to default resource",res->name));
status = PICO_ERR_INDEX_OUT_OF_RANGE;
}
status = picorsrc_createKnowledgeBase(this, NULL, 0, (picoknow_kb_id_t)PICOKNOW_KBID_FIXED_IDS, &res->kbList);
if (PICO_OK == status) {
res->next = this->resources;
this->resources = res;
this->numResources++;
/* *resource = res; */
}
return status;
}
pico_status_t picorsrc_rsrcGetName(picorsrc_Resource this,
picoos_char * name, picoos_uint32 maxlen) {
if (!picoctrl_isValidResourceHandle(this)) {
return PICO_ERR_INVALID_ARGUMENT;
}
picoos_strlcpy(name, this->name,maxlen);
return PICO_OK;
}
/* ******* accessing voice definitions **************************************/
static pico_status_t findVoiceDefinition(picorsrc_ResourceManager this,
const picoos_char * voiceName, picorsrc_VoiceDefinition * vdef)
{
picorsrc_VoiceDefinition v;
PICODBG_DEBUG(("finding voice name %s",voiceName));
if (NULL == this) {
return PICO_ERR_NULLPTR_ACCESS;
}
v = this->vdefs;
while (NULL != v && (0 != picoos_strcmp(v->voiceName,voiceName))) {
PICODBG_DEBUG(("%s doesnt match",v->voiceName));
v = v->next;
}
*vdef = v;
if (v == NULL) {
PICODBG_DEBUG(("didnt find voice name %s",voiceName));
} else {
PICODBG_DEBUG(("found voice name %s",voiceName));
}
return PICO_OK;
}
pico_status_t picorsrc_addResourceToVoiceDefinition(picorsrc_ResourceManager this,
picoos_char * voiceName, picoos_char * resourceName)
{
picorsrc_VoiceDefinition vdef;
if (NULL == this) {
PICODBG_ERROR(("this is NULL"));
return PICO_ERR_NULLPTR_ACCESS;
}
if ((PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) && (NULL != vdef)) {
if (PICO_MAX_NUM_RSRC_PER_VOICE <= vdef->numResources) {
return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources per voice",PICO_MAX_NUM_RSRC_PER_VOICE);
}
if (picoos_strlcpy(vdef->resourceName[vdef->numResources++], resourceName,
PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
PICODBG_DEBUG(("vdef added resource '%s' to voice '%s'",resourceName,voiceName));
return PICO_OK;
} else {
PICODBG_ERROR(("illegal name (%s)",resourceName));
return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_ILLEGAL,NULL,(picoos_char *)"%s",resourceName);
}
} else {
return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,NULL,(picoos_char *)"%s",voiceName);
}
}
pico_status_t picorsrc_createVoiceDefinition(picorsrc_ResourceManager this,
picoos_char * voiceName)
{
picorsrc_VoiceDefinition vdef;
if (NULL == this) {
PICODBG_ERROR(("this is NULL"));
return PICO_ERR_NULLPTR_ACCESS;
}
if ((PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) && (NULL != vdef)) {
PICODBG_ERROR(("voice %s allready defined",voiceName));
return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_CONFLICT,NULL,NULL);
}
if (PICO_MAX_NUM_VOICE_DEFINITIONS <= this->numVdefs) {
PICODBG_ERROR(("max number of vdefs exceeded (%i)",this->numVdefs));
return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i voice definitions",PICO_MAX_NUM_VOICE_DEFINITIONS);
}
if (NULL == this->freeVdefs) {
vdef = picorsrc_newVoiceDefinition(this->common->mm);
} else {
vdef = this->freeVdefs;
this->freeVdefs = vdef->next;
vdef->voiceName[0] = NULLC;
vdef->numResources = 0;
vdef->next = NULL;
}
if (NULL == vdef) {
return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
}
if (picoos_strlcpy(vdef->voiceName, voiceName,
PICO_MAX_VOICE_NAME_SIZE) < PICO_MAX_VOICE_NAME_SIZE) {
vdef->next = this->vdefs;
this->vdefs = vdef;
this->numVdefs++;
if (PICO_OK != picorsrc_addResourceToVoiceDefinition(this,voiceName,PICOKNOW_DEFAULT_RESOURCE_NAME)) {
return picoos_emRaiseException(this->common->em,PICO_ERR_OTHER,NULL,(picoos_char *)"problem loading default resource %s",voiceName);
}
PICODBG_DEBUG(("vdef created (%s)",voiceName));
return PICO_OK;
} else {
PICODBG_ERROR(("illegal name (%s)",voiceName));
return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_ILLEGAL,NULL,(picoos_char *)"%s",voiceName);
}
}
pico_status_t picorsrc_releaseVoiceDefinition(picorsrc_ResourceManager this,
picoos_char *voiceName)
{
picorsrc_VoiceDefinition v, l;
if (this == NULL) {
return PICO_ERR_NULLPTR_ACCESS;
}
l = NULL;
v = this->vdefs;
while ((v != NULL) && (picoos_strcmp(v->voiceName, voiceName) != 0)) {
l = v;
v = v->next;
}
if (v != NULL) {
/* remove v from vdefs list */
if (l != NULL) {
l->next = v->next;
} else {
this->vdefs = v->next;
}
/* insert v at head of freeVdefs list */
v->next = this->freeVdefs;
this->freeVdefs = v;
this->numVdefs--;
return PICO_OK;
} else {
/* we should rather return a warning, here */
/* return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,"%s", NULL); */
return PICO_OK;
}
}
/* ******* accessing voices **************************************/
/* create voice, given a voice name. the corresponding lock counts are incremented */
pico_status_t picorsrc_createVoice(picorsrc_ResourceManager this, const picoos_char * voiceName, picorsrc_Voice * voice) {
picorsrc_VoiceDefinition vdef;
picorsrc_Resource rsrc;
picoos_uint8 i, required;
picoknow_KnowledgeBase kb;
/* pico_status_t status = PICO_OK; */
PICODBG_DEBUG(("creating voice %s",voiceName));
if (NULL == this) {
PICODBG_ERROR(("this is NULL"));
return PICO_ERR_NULLPTR_ACCESS;
}
/* check number of voices */
if (PICORSRC_MAX_NUM_VOICES <= this->numVoices) {
PICODBG_ERROR(("PICORSRC_MAX_NUM_VOICES exceeded"));
return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i voices",PICORSRC_MAX_NUM_VOICES);
}
/* find voice definition for that name */
if (!(PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) || (NULL == vdef)) {
PICODBG_ERROR(("no voice definition for %s",voiceName));
return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,NULL,(picoos_char *)"voice definition %s",voiceName);
}
PICODBG_DEBUG(("found voice definition for %s",voiceName));
/* check that resources are loaded */
for (i = 0; i < vdef->numResources; i++) {
required = (NULLC != vdef->resourceName[i][0]);
if (required && !isResourceLoaded(this,vdef->resourceName[i])) {
PICODBG_ERROR(("resource missing"));
return picoos_emRaiseException(this->common->em,PICO_EXC_RESOURCE_MISSING,NULL,(picoos_char *)"resource %s for voice %s",vdef->resourceName[i],voiceName);
}
}
/* allocate new voice */
if (NULL == this->freeVoices) {
*voice = picorsrc_newVoice(this->common->mm);
} else {
*voice = this->freeVoices;
this->freeVoices = (*voice)->next;
picorsrc_initializeVoice(*voice);
}
if (*voice == NULL) {
return picoos_emRaiseException(this->common->em, PICO_EXC_OUT_OF_MEM, NULL, NULL);
}
this->numVoices++;
/* copy resource kb pointers into kb array of voice */
for (i = 0; i < vdef->numResources; i++) {
required = (NULLC != vdef->resourceName[i][0]);
if (required) {
findResource(this,vdef->resourceName[i],&rsrc);
(*voice)->resourceArray[(*voice)->numResources++] = rsrc;
rsrc->lockCount++;
kb = rsrc->kbList;
while (NULL != kb) {
if (NULL != (*voice)->kbArray[kb->id]) {
picoos_emRaiseWarning(this->common->em,PICO_WARN_KB_OVERWRITE,NULL, (picoos_char *)"%i", kb->id);
PICODBG_WARN(("overwriting knowledge base of id %i", kb->id));
}
PICODBG_DEBUG(("setting knowledge base of id %i", kb->id));
(*voice)->kbArray[kb->id] = kb;
kb = kb->next;
}
}
} /* for */
return PICO_OK;
}
/* dispose voice. the corresponding lock counts are decremented. */
pico_status_t picorsrc_releaseVoice(picorsrc_ResourceManager this, picorsrc_Voice * voice)
{
picoos_uint16 i;
picorsrc_Voice v = *voice;
if (NULL == this || NULL == v) {
return PICO_ERR_NULLPTR_ACCESS;
}
for (i = 0; i < v->numResources; i++) {
v->resourceArray[i]->lockCount--;
}
v->next = this->freeVoices;
this->freeVoices = v;
this->numVoices--;
return PICO_OK;
}
#ifdef __cplusplus
}
#endif
/* end picorsrc.c */