summaryrefslogtreecommitdiffstats
path: root/lib/picoapi.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/picoapi.c')
-rw-r--r--lib/picoapi.c801
1 files changed, 801 insertions, 0 deletions
diff --git a/lib/picoapi.c b/lib/picoapi.c
new file mode 100644
index 0000000..c4ef8bf
--- /dev/null
+++ b/lib/picoapi.c
@@ -0,0 +1,801 @@
+/*
+ * 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 picoapi.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"
+#include "picorsrc.h"
+#include "picoctrl.h"
+#include "picoapi.h"
+#include "picoapid.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ****************************************************************************/
+/* System-level API functions */
+/* ****************************************************************************/
+
+#define MAGIC_MASK 0x5069636F /* Pico */
+
+#define SET_MAGIC_NUMBER(sys) \
+ (sys)->magic = ((picoos_uint32) (sys)) ^ MAGIC_MASK
+
+#define CHECK_MAGIC_NUMBER(sys) \
+ ((sys)->magic == (((picoos_uint32) (sys)) ^ MAGIC_MASK))
+
+
+
+/* *** Auxiliary routines (may also be called from picoextapi.c) **************/
+
+
+int is_valid_system_handle(pico_System system)
+{
+ return (system != NULL) && CHECK_MAGIC_NUMBER(system);
+}
+
+
+picoos_Common pico_sysGetCommon(pico_System this)
+{
+ if (this != NULL) {
+ return this->common;
+ } else {
+ return NULL;
+ }
+}
+
+
+
+/* *** System initialization and termination functions ************************/
+pico_Status pico_initialize_priv(
+ void *memory,
+ const pico_Uint32 size,
+ pico_Int16 enableMemProt,
+ pico_System *system
+ )
+{
+ pico_Status status = PICO_OK;
+
+ PICODBG_INITIALIZE(PICODBG_LOG_LEVEL_INFO);
+ PICODBG_ENABLE_COLORS(0);
+ /*PICODBG_SET_OUTPUT_FORMAT((PICODBG_SHOW_LEVEL | PICODBG_SHOW_SRCNAME));*/
+
+ if (memory == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (size == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else if (system == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ byte_ptr_t rest_mem;
+ picoos_uint32 rest_mem_size;
+ pico_System sys;
+ picoos_MemoryManager sysMM;
+ picoos_ExceptionManager sysEM;
+
+ sys = (pico_System) picoos_raw_malloc(memory, size, sizeof(pico_system_t),
+ &rest_mem, &rest_mem_size);
+ if (sys != NULL) {
+ sysMM = picoos_newMemoryManager(rest_mem, rest_mem_size, enableMemProt ? TRUE : FALSE);
+ if (sysMM != NULL) {
+ sysEM = picoos_newExceptionManager(sysMM);
+ sys->common = picoos_newCommon(sysMM);
+ sys->rm = picorsrc_newResourceManager(sysMM, sys->common);
+ if ((sysEM != NULL) && (sys->common != NULL) && (sys->rm != NULL)) {
+ sys->common->em = sysEM;
+ sys->common->mm = sysMM;
+ sys->engine = NULL;
+
+ picorsrc_createDefaultResource(sys->rm /*,&defaultResource */);
+
+ SET_MAGIC_NUMBER(sys);
+ status = PICO_OK;
+ } else {
+ status = PICO_EXC_OUT_OF_MEM;
+ }
+ } else {
+ status = PICO_EXC_OUT_OF_MEM;
+ }
+ } else {
+ status = PICO_EXC_OUT_OF_MEM;
+ }
+ *system = sys;
+ }
+
+ if (status != PICO_OK) {
+ if (system != NULL) {
+ *system = NULL;
+ }
+ PICODBG_TERMINATE();
+ }
+
+ return status;
+}
+/**
+ * pico_initialize : initializes the pico system private memory
+ * @param memory : pointer to a free and already allocated memory area
+ * @param size : size of the memory area
+ * @param system : pointer to a pico_System struct
+ * @return PICO_OK : successful init, !PICO_OK : error on allocating private memory
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_initialize(
+ void *memory,
+ const pico_Uint32 size,
+ pico_System *system
+ )
+{
+ return pico_initialize_priv(memory, size, /*enableMemProt*/ FALSE, system);
+}
+
+/**
+ * pico_terminate : deallocates the pico system private memory
+ * @param system : pointer to a pico_System struct
+ * @return PICO_OK : successful de-init, !PICO_OK : error on de-allocating private memory
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_terminate(
+ pico_System *system
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if ((system == NULL) || !is_valid_system_handle(*system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else {
+ pico_System sys = *system;
+
+ /* close engine(s) */
+ picoctrl_disposeEngine(sys->common->mm, sys->rm, &sys->engine);
+
+ /* close all resources */
+ picorsrc_disposeResourceManager(sys->common->mm, &sys->rm);
+
+ sys->magic ^= 0xFFFEFDFC;
+ *system = NULL;
+ }
+
+ PICODBG_TERMINATE();
+
+ return status;
+}
+
+
+
+/* *** System status and error/warning message retrieval function *************/
+
+/**
+ * pico_getSystemStatusMessage : Returns a description of the system status or errors
+ * @param system : pointer to a pico_System struct
+ * @param errCode : pico_System error code
+ * @param outMessage : memory area where to return a string
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getSystemStatusMessage(
+ pico_System system,
+ pico_Status errCode,
+ pico_Retstring outMessage
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outMessage != NULL) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "'system' not initialized", PICO_RETSTRINGSIZE);
+ }
+ } else if (outMessage == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ if (picoos_emGetExceptionCode(system->common->em) == PICO_OK) {
+ if (errCode == PICO_OK) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "system ok", PICO_RETSTRINGSIZE);
+ } else {
+ /* exceptionManager was not informed yet; produce default message */
+ picoos_setErrorMsg((picoos_char *) outMessage, PICO_RETSTRINGSIZE, errCode, NULL, NULL, NULL);
+ }
+ } else {
+ picoos_emGetExceptionMessage(system->common->em, (picoos_char *) outMessage, PICO_RETSTRINGSIZE);
+ }
+ }
+
+ return status;
+}
+
+/**
+ * pico_getSystemStatusMessage : Returns the number of warnings
+ * @param system : pointer to a pico_System struct
+ * @param *outNrOfWarnings : pointer to location to receive number of warnings
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getNrSystemWarnings(
+ pico_System system,
+ pico_Int32 *outNrOfWarnings
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outNrOfWarnings != NULL) {
+ *outNrOfWarnings = 0;
+ }
+ } else if (outNrOfWarnings == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ *outNrOfWarnings = picoos_emGetNumOfWarnings(system->common->em);
+ }
+
+ return status;
+}
+
+/**
+ * pico_getSystemWarning : Returns a description of a warning
+ * @param system : pointer to a pico_System struct
+ * @param warningIndex : warning index
+ * @param *outCode : pointer to receive the warning code
+ * @param outMessage : pointer to receive the output message
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getSystemWarning(
+ pico_System system,
+ const pico_Int32 warningIndex,
+ pico_Status *outCode,
+ pico_Retstring outMessage
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outMessage != NULL) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "'system' not initialized", PICO_RETSTRINGSIZE);
+ }
+ } else if (warningIndex < 0) {
+ status = PICO_ERR_INDEX_OUT_OF_RANGE;
+ } else if ((outCode == NULL) || (outMessage == NULL)) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ *outCode = picoos_emGetWarningCode(system->common->em, warningIndex);
+ picoos_emGetWarningMessage(system->common->em, warningIndex, (picoos_char *) outMessage, (picoos_uint16) PICO_RETSTRINGSIZE);
+ }
+
+ return status;
+}
+
+
+
+/* *** Resource loading and unloading functions *******************************/
+
+/**
+ * pico_loadResource : Loads a resource file into the Pico system
+ * @param system : pointer to a pico_System struct
+ * @param *lingwareFileName : lingware resource file name
+ * @param *outLingware : pointer to receive the loaded lingware resource memory area address
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_loadResource(
+ pico_System system,
+ const pico_Char *lingwareFileName,
+ pico_Resource *outLingware
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if ((lingwareFileName == NULL) || (outLingware == NULL)) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ PICODBG_DEBUG(("memory usage before resource loading"));
+ picoos_showMemUsage(system->common->mm, FALSE, TRUE);
+ picoos_emReset(system->common->em);
+ status = picorsrc_loadResource(system->rm, (picoos_char *) lingwareFileName, (picorsrc_Resource *) outLingware);
+ PICODBG_DEBUG(("memory used to load resource %s", lingwareFileName));
+ picoos_showMemUsage(system->common->mm, TRUE, FALSE);
+ }
+
+ return status;
+}
+
+/**
+ * pico_unloadResource : unLoads a resource file from the Pico system
+ * @param system : pointer to a pico_System struct
+ * @param *inoutLingware : pointer to the loaded lingware resource memory area address
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_unloadResource(
+ pico_System system,
+ pico_Resource *inoutLingware
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (inoutLingware == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (!picoctrl_isValidResourceHandle(*((picorsrc_Resource *) inoutLingware))) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else {
+ PICODBG_DEBUG(("memory usage before resource unloading"));
+ picoos_showMemUsage(system->common->mm, FALSE, TRUE);
+ picoos_emReset(system->common->em);
+ status = picorsrc_unloadResource(system->rm, (picorsrc_Resource *) inoutLingware);
+ PICODBG_DEBUG(("memory released by resource unloading"));
+ picoos_showMemUsage(system->common->mm, TRUE, FALSE);
+ }
+
+ return status;
+}
+
+/* *** Resource inspection functions *******************************/
+/**
+ * pico_getResourceName : Gets a resource name
+ * @param system : pointer to a pico_System struct
+ * @param resource : pointer to the loaded resource memory area address
+ * @param outName : pointer to the area to receuive the resource name
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getResourceName(
+ pico_System system,
+ pico_Resource resource,
+ pico_Retstring outName) {
+
+ if (!is_valid_system_handle(system)) {
+ return PICO_ERR_INVALID_HANDLE;
+ } else if (NULL == outName) {
+ return PICO_ERR_NULLPTR_ACCESS;
+ }
+ return picorsrc_rsrcGetName((picorsrc_Resource)resource, (picoos_char *) outName, PICO_RETSTRINGSIZE);
+}
+
+
+/* *** Voice definition functions *********************************************/
+
+/**
+ * pico_createVoiceDefinition : Creates a voice definition
+ * @param system : pointer to a pico_System struct
+ * @param *voiceName : pointer to the area to receive the voice definition
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_createVoiceDefinition(
+ pico_System system,
+ const pico_Char *voiceName
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (voiceName == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (picoos_strlen((picoos_char *) voiceName) == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else {
+ picoos_emReset(system->common->em);
+ status = picorsrc_createVoiceDefinition(system->rm, (picoos_char *) voiceName);
+ }
+
+ return status;
+}
+
+/**
+ * pico_addResourceToVoiceDefinition : Adds a mapping pair to a voice definition
+ * @param system : pointer to a pico_System struct
+ * @param *voiceName : pointer to the area containing the voice definition
+ * @param *resourceName : pointer to the area containing the resource name
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_addResourceToVoiceDefinition(
+ pico_System system,
+ const pico_Char *voiceName,
+ const pico_Char *resourceName
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (voiceName == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (picoos_strlen((picoos_char *) voiceName) == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else if (resourceName == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (picoos_strlen((picoos_char *) resourceName) == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else {
+ picoos_emReset(system->common->em);
+ status = picorsrc_addResourceToVoiceDefinition(system->rm, (picoos_char *) voiceName, (picoos_char *) resourceName);
+ }
+
+ return status;
+}
+
+/**
+ * pico_releaseVoiceDefinition : Releases a voice definition
+ * @param system : pointer to a pico_System struct
+ * @param *voiceName : pointer to the area containing the voice definition
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_releaseVoiceDefinition(
+ pico_System system,
+ const pico_Char *voiceName
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (voiceName == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (picoos_strlen((picoos_char *) voiceName) == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else {
+ picoos_emReset(system->common->em);
+ status = picorsrc_releaseVoiceDefinition(system->rm, (picoos_char *) voiceName);
+ }
+
+ return status;
+}
+
+
+
+/* *** Engine creation and deletion functions *********************************/
+
+/**
+ * pico_newEngine : Creates and initializes a new Pico engine
+ * @param system : pointer to a pico_System struct
+ * @param *voiceName : pointer to the area containing the voice definition
+ * @param *outEngine : pointer to the Pico engine handle
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_newEngine(
+ pico_System system,
+ const pico_Char *voiceName,
+ pico_Engine *outEngine
+ )
+{
+ pico_Status status = PICO_OK;
+
+ PICODBG_DEBUG(("creating engine for voice '%s'", (picoos_char *) voiceName));
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (voiceName == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (picoos_strlen((picoos_char *) voiceName) == 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else if (outEngine == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ picoos_emReset(system->common->em);
+ if (system->engine == NULL) {
+ *outEngine = (pico_Engine) picoctrl_newEngine(system->common->mm, system->rm, voiceName);
+ if (*outEngine != NULL) {
+ system->engine = (picoctrl_Engine) *outEngine;
+ } else {
+ status = picoos_emRaiseException(system->common->em, PICO_EXC_OUT_OF_MEM,
+ (picoos_char *) "out of memory creating new engine", NULL);
+ }
+ } else {
+ status = picoos_emRaiseException(system->common->em, PICO_EXC_MAX_NUM_EXCEED,
+ NULL, (picoos_char *) "no more than %i engines", 1);
+ }
+ }
+
+ return status;
+}
+
+/**
+ * pico_disposeEngine : Disposes a Pico engine
+ * @param system : pointer to a pico_System struct
+ * @param *inoutEngine : pointer to the Pico engine handle
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_disposeEngine(
+ pico_System system,
+ pico_Engine *inoutEngine
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!is_valid_system_handle(system)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (inoutEngine == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (!picoctrl_isValidEngineHandle(*((picoctrl_Engine *) inoutEngine))) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else {
+ picoos_emReset(system->common->em);
+ picoctrl_disposeEngine(system->common->mm, system->rm, (picoctrl_Engine *) inoutEngine);
+ system->engine = NULL;
+ status = picoos_emGetExceptionCode(system->common->em);
+ }
+
+ return status;
+}
+
+
+
+/* ****************************************************************************/
+/* Engine-level API functions */
+/* ****************************************************************************/
+
+/**
+ * pico_putTextUtf8 : Puts UTF8 text into Pico text input buffer
+ * @param engine : pointer to a Pico engine handle
+ * @param *text : pointer to the text buffer
+ * @param textSize : text buffer size
+ * @param *bytesPut : pointer to variable to receive the number of bytes put
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+ */
+PICO_FUNC pico_putTextUtf8(
+ pico_Engine engine,
+ const pico_Char *text,
+ const pico_Int16 textSize,
+ pico_Int16 *bytesPut)
+{
+ pico_Status status = PICO_OK;
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else if (text == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else if (textSize < 0) {
+ status = PICO_ERR_INVALID_ARGUMENT;
+ } else if (bytesPut == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ picoctrl_engResetExceptionManager((picoctrl_Engine) engine);
+ status = picoctrl_engFeedText((picoctrl_Engine) engine, (picoos_char *)text, textSize, bytesPut);
+ }
+
+ return status;
+}
+
+/**
+ * pico_getData : Gets speech data from the engine.
+ * @param engine : pointer to a Pico engine handle
+ * @param *buffer : pointer to output buffer
+ * @param bufferSize : out buffer size
+ * @param *bytesReceived : pointer to a variable to receive the number of bytes received
+ * @param *outDataType : pointer to a variable to receive the type of buffer received
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getData(
+ pico_Engine engine,
+ void *buffer,
+ const pico_Int16 bufferSize,
+ pico_Int16 *bytesReceived,
+ pico_Int16 *outDataType
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_STEP_ERROR;
+ } else if (buffer == NULL) {
+ status = PICO_STEP_ERROR;
+ } else if (bufferSize < 0) {
+ status = PICO_STEP_ERROR;
+ } else if (bytesReceived == NULL) {
+ status = PICO_STEP_ERROR;
+ } else {
+ picoctrl_engResetExceptionManager((picoctrl_Engine) engine);
+ status = picoctrl_engFetchOutputItemBytes((picoctrl_Engine) engine, (picoos_char *)buffer, bufferSize, bytesReceived);
+ if ((status != PICO_STEP_IDLE) && (status != PICO_STEP_BUSY)) {
+ status = PICO_STEP_ERROR;
+ }
+ }
+
+ *outDataType = PICO_DATA_PCM_16BIT;
+ return status;
+}
+
+/**
+ * pico_resetEngine : Resets the engine
+ * @param engine : pointer to a Pico engine handle
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_resetEngine(
+ pico_Engine engine)
+{
+ pico_Status status = PICO_OK;
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ } else {
+ picoctrl_engResetExceptionManager((picoctrl_Engine) engine);
+ status = picoctrl_engReset((picoctrl_Engine) engine);
+ }
+
+ return status;
+}
+
+/**
+ * pico_getEngineStatusMessage : Returns the engine status or error description
+ * @param engine : pointer to a Pico engine handle
+ * @param errCode : error code
+ * @param outMessage : pointer to a memory area to receive the output message
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getEngineStatusMessage(
+ pico_Engine engine,
+ pico_Status errCode,
+ pico_Retstring outMessage
+ )
+{
+ pico_Status status = PICO_OK;
+
+ PICODBG_DEBUG(("got error code %i", errCode));
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outMessage != NULL) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "'engine' not initialized", PICO_RETSTRINGSIZE);
+ }
+ } else if (outMessage == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ picoos_Common common = picoctrl_engGetCommon((picoctrl_Engine) engine);
+ if (picoos_emGetExceptionCode(common->em) == PICO_OK) {
+ if (errCode == PICO_OK) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "engine ok", PICO_RETSTRINGSIZE);
+ } else {
+ /* exceptionManager was not informed yet; produce default message */
+ picoos_setErrorMsg((picoos_char *) outMessage, PICO_RETSTRINGSIZE, errCode, NULL, NULL, NULL);
+ }
+ } else {
+ picoos_emGetExceptionMessage(common->em, (picoos_char *) outMessage, PICO_RETSTRINGSIZE);
+ }
+ }
+
+ return status;
+}
+
+/**
+ * pico_getNrEngineWarnings : Returns the number of warnings
+ * @param engine : pointer to a Pico engine handle
+ * @param *outNrOfWarnings: pointer to a variable to receive the number of warnings
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getNrEngineWarnings(
+ pico_Engine engine,
+ pico_Int32 *outNrOfWarnings
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outNrOfWarnings != NULL) {
+ *outNrOfWarnings = 0;
+ }
+ } else if (outNrOfWarnings == NULL) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ picoos_Common common = picoctrl_engGetCommon((picoctrl_Engine) engine);
+ *outNrOfWarnings = picoos_emGetNumOfWarnings(common->em);
+ }
+
+ return status;
+}
+
+/**
+ * pico_getEngineWarning : Returns a description of a warning
+ * @param engine : pointer to a Pico engine handle
+ * @param warningIndex : warning index
+ * @param *outCode: pointer to a variable to receive the warning code
+ * @param outMessage: pointer to a memory area to receive the warning description
+ * @return PICO_OK : successful
+ * @return PICO_ERR_INVALID_HANDLE, PICO_ERR_NULLPTR_ACCESS : errors
+ * @callgraph
+ * @callergraph
+*/
+PICO_FUNC pico_getEngineWarning(
+ pico_Engine engine,
+ const pico_Int32 warningIndex,
+ pico_Status *outCode,
+ pico_Retstring outMessage
+ )
+{
+ pico_Status status = PICO_OK;
+
+ if (!picoctrl_isValidEngineHandle((picoctrl_Engine) engine)) {
+ status = PICO_ERR_INVALID_HANDLE;
+ if (outMessage != NULL) {
+ picoos_strlcpy((picoos_char *) outMessage, (picoos_char *) "'engine' not initialized", PICO_RETSTRINGSIZE);
+ }
+ } else if (warningIndex < 0) {
+ status = PICO_ERR_INDEX_OUT_OF_RANGE;
+ } else if ((outCode == NULL) || (outMessage == NULL)) {
+ status = PICO_ERR_NULLPTR_ACCESS;
+ } else {
+ picoos_Common common = picoctrl_engGetCommon((picoctrl_Engine) engine);
+ *outCode = picoos_emGetWarningCode(common->em, warningIndex);
+ picoos_emGetWarningMessage(common->em, warningIndex, (picoos_char *) outMessage, (picoos_uint16) PICO_RETSTRINGSIZE);
+ }
+
+ return status;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* end */
generated by cgit v1.1 at 2025-05-19 19:03:22 +0000