/* * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland * Modifications (C) 2019 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 picorsrc.c * * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland * All rights reserved. * * History: * - 2009-04-20 -- initial version * - 2019-08-28 -- x86_64 compatibility fixes */ #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_uintptr_t 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_uintptr_t) (res)) ^ MAGIC_MASK #define CHECK_MAGIC_NUMBER(res) \ ((res)->magic == (((picoos_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; ikbArray[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 = (picoos_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 */