fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
allwinner_a64/android/external/svox/pico/lib/picodata.c
August 71b83c22f1 upload android base code part2
2018-08-08 16:14:42 +08:00

1152 lines
38 KiB
C
Raw Blame History

/*
* 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 picodata.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 "picotrns.h"
#include "picodata.h"
#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif
/* we output coefficients as fixed point values */
#define PICOCEP_OUT_DATA_FORMAT PICODATA_ITEMINFO1_FRAME_PAR_DATA_FORMAT_FIXED
/* ***************************************************************
* CharBuffer *
*****************************************************************/
/*
* method signatures
*/
typedef pico_status_t (* picodata_cbPutItemMethod) (register picodata_CharBuffer this,
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen);
typedef pico_status_t (* picodata_cbGetItemMethod) (register picodata_CharBuffer this,
picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen, const picoos_uint8 issd);
typedef pico_status_t (* picodata_cbSubResetMethod) (register picodata_CharBuffer this);
typedef pico_status_t (* picodata_cbSubDeallocateMethod) (register picodata_CharBuffer this, picoos_MemoryManager mm);
typedef struct picodata_char_buffer
{
picoos_char *buf;
picoos_uint16 rear; /* next free position to write */
picoos_uint16 front; /* next position to read */
picoos_uint16 len; /* empty: len = 0, full: len = size */
picoos_uint16 size;
picoos_Common common;
picodata_cbGetItemMethod getItem;
picodata_cbPutItemMethod putItem;
picodata_cbSubResetMethod subReset;
picodata_cbSubDeallocateMethod subDeallocate;
void * subObj;
} char_buffer_t;
static pico_status_t data_cbPutItem(register picodata_CharBuffer this,
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen);
static pico_status_t data_cbGetItem(register picodata_CharBuffer this,
picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen, const picoos_uint8 issd);
pico_status_t picodata_cbReset(register picodata_CharBuffer this)
{
this->rear = 0;
this->front = 0;
this->len = 0;
if (NULL != this->subObj) {
return this->subReset(this);
} else {
return PICO_OK;
}
}
/* CharBuffer constructor */
picodata_CharBuffer picodata_newCharBuffer(picoos_MemoryManager mm,
picoos_Common common,
picoos_objsize_t size)
{
picodata_CharBuffer this;
this = (picodata_CharBuffer) picoos_allocate(mm, sizeof(*this));
PICODBG_DEBUG(("new character buffer, size=%i", size));
if (NULL == this) {
return NULL;
}
this->buf = picoos_allocate(mm, size);
if (NULL == this->buf) {
picoos_deallocate(mm, (void*) &this);
return NULL;
}
this->size = size;
this->common = common;
this->getItem = data_cbGetItem;
this->putItem = data_cbPutItem;
this->subReset = NULL;
this->subDeallocate = NULL;
this->subObj = NULL;
picodata_cbReset(this);
return this;
}
void picodata_disposeCharBuffer(picoos_MemoryManager mm,
picodata_CharBuffer *this)
{
if (NULL != (*this)) {
/* terminate */
if (NULL != (*this)->subObj) {
(*this)->subDeallocate(*this,mm);
}
picoos_deallocate(mm,(void*)&(*this)->buf);
picoos_deallocate(mm,(void*)this);
}
}
pico_status_t picodata_cbPutCh(register picodata_CharBuffer this,
picoos_char ch)
{
if (this->len < this->size) {
this->buf[this->rear++] = ch;
this->rear %= this->size;
this->len++;
return PICO_OK;
} else {
return PICO_EXC_BUF_OVERFLOW;
}
}
picoos_int16 picodata_cbGetCh(register picodata_CharBuffer this)
{
picoos_char ch;
if (this->len > 0) {
ch = this->buf[this->front++];
this->front %= this->size;
this->len--;
return ch;
} else {
return PICO_EOF;
}
}
/* ***************************************************************
* items: CharBuffer functions *
*****************************************************************/
static pico_status_t data_cbGetItem(register picodata_CharBuffer this,
picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen, const picoos_uint8 issd)
{
picoos_uint16 i;
if (this->len < PICODATA_ITEM_HEADSIZE) { /* item not in cb? */
*blen = 0;
if (this->len == 0) { /* is cb empty? */
PICODBG_DEBUG(("no item to get"));
return PICO_EOF;
} else { /* cb not empty, but not a valid item */
PICODBG_WARN(("problem getting item, incomplete head, underflow"));
}
return PICO_EXC_BUF_UNDERFLOW;
}
*blen = PICODATA_ITEM_HEADSIZE + (picoos_uint8)(this->buf[((this->front) +
PICODATA_ITEMIND_LEN) % this->size]);
/* if getting speech data in item */
if (issd) {
/* check item type */
if (this->buf[this->front] != PICODATA_ITEM_FRAME) {
PICODBG_WARN(("item type mismatch for speech data: %c",
this->buf[this->front]));
for (i=0; i<*blen; i++) {
this->front++;
this->front %= this->size;
this->len--;
}
*blen = 0;
return PICO_OK;
}
}
if (*blen > this->len) { /* item in cb not complete? */
PICODBG_WARN(("problem getting item, incomplete content, underflow; "
"blen=%d, len=%d", *blen, this->len));
*blen = 0;
return PICO_EXC_BUF_UNDERFLOW;
}
if (blenmax < *blen) { /* buf not large enough? */
PICODBG_WARN(("problem getting item, overflow"));
*blen = 0;
return PICO_EXC_BUF_OVERFLOW;
}
/* if getting speech data in item */
if (issd) {
/* skip item header */
for (i = 0; i < PICODATA_ITEM_HEADSIZE; i++) {
this->front++;
this->front %= this->size;
this->len--;
}
*blen -= PICODATA_ITEM_HEADSIZE;
}
/* all ok, now get item (or speech data only) */
for (i = 0; i < *blen; i++) {
buf[i] = (picoos_uint8)(this->buf[this->front++]);
this->front %= this->size;
this->len--;
}
#if defined(PICO_DEBUG)
if (issd) {
PICODBG_DEBUG(("got speech data: %d samples", *blen));
} else {
PICODBG_DEBUG(("got item: %c|%d|%d|%d||", buf[PICODATA_ITEMIND_TYPE],
buf[PICODATA_ITEMIND_INFO1], buf[PICODATA_ITEMIND_INFO2],
buf[PICODATA_ITEMIND_LEN]));
for (i=PICODATA_ITEM_HEADSIZE; i<*blen; i++) {
if (buf[PICODATA_ITEMIND_TYPE] == PICODATA_ITEM_WORDGRAPH) {
PICODBG_DEBUG(("%c", buf[i]));
} else {
PICODBG_DEBUG((" %d", buf[i]));
}
}
}
#endif
return PICO_OK;
}
static pico_status_t data_cbPutItem(register picodata_CharBuffer this,
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen)
{
picoos_uint16 i;
if (blenmax < PICODATA_ITEM_HEADSIZE) { /* itemlen not accessible? */
PICODBG_WARN(("problem putting item, underflow"));
*blen = 0;
return PICO_EXC_BUF_UNDERFLOW;
}
*blen = buf[PICODATA_ITEMIND_LEN] + PICODATA_ITEM_HEADSIZE;
if (*blen > (this->size - this->len)) { /* cb not enough space? */
PICODBG_WARN(("problem putting item, overflow"));
*blen = 0;
return PICO_EXC_BUF_OVERFLOW;
}
if (*blen > blenmax) { /* item in buf not completely accessible? */
PICODBG_WARN(("problem putting item, underflow"));
*blen = 0;
return PICO_EXC_BUF_UNDERFLOW;
}
/* all ok, now put complete item */
#if defined(PICO_DEBUG)
PICODBG_DEBUG(("putting item: %c|%d|%d|%d||",
buf[PICODATA_ITEMIND_TYPE],
buf[PICODATA_ITEMIND_INFO1],
buf[PICODATA_ITEMIND_INFO2],
buf[PICODATA_ITEMIND_LEN]));
for (i=PICODATA_ITEM_HEADSIZE; i<*blen; i++) {
if (buf[PICODATA_ITEMIND_TYPE] == PICODATA_ITEM_WORDGRAPH) {
PICODBG_DEBUG(("%c", buf[i]));
} else {
PICODBG_DEBUG((" %d", buf[i]));
}
}
#endif
for (i = 0; i < *blen; i++) {
/* put single byte */
this->buf[this->rear++] = (picoos_char)buf[i];
this->rear %= this->size;
this->len++;
}
return PICO_OK;
}
/*----------------------------------------------------------
* Names : picodata_cbGetItem
* picodata_cbGetSpeechData
* Function: gets one item from 'this' and writes it on 'blenmax' sized 'buf'.
* gets one item from 'this' and writes the speech data to
* 'blenmax' sized 'buf'.
* Returns : PICO_OK : one item was copied
* PICO_EOF : 'this' is empty; no new items available
* PICO_BUF_UNDERFLOW : 'this' doesn't contain a full/valid item
* PICO_BUF_OVERFLOW : 'buf[blenmax]' too small to hold item
* on return, '*blen' contains the number of bytes written to 'buf'
* ---------------------------------------------------------*/
pico_status_t picodata_cbGetItem(register picodata_CharBuffer this,
picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen)
{
return this->getItem(this, buf, blenmax, blen, FALSE);
}
pico_status_t picodata_cbGetSpeechData(register picodata_CharBuffer this,
picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen)
{
return this->getItem(this, buf, blenmax, blen, TRUE);
}
pico_status_t picodata_cbPutItem(register picodata_CharBuffer this,
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picoos_uint16 *blen)
{
return this->putItem(this,buf,blenmax,blen);
}
/* unsafe, just for measuring purposes */
picoos_uint8 picodata_cbGetFrontItemType(register picodata_CharBuffer this)
{
return this->buf[this->front];
}
/* ***************************************************************
* items: support function *
*****************************************************************/
picoos_uint8 is_valid_itemtype(const picoos_uint8 ch) {
switch (ch) {
case PICODATA_ITEM_WSEQ_GRAPH:
case PICODATA_ITEM_TOKEN:
case PICODATA_ITEM_WORDGRAPH:
case PICODATA_ITEM_WORDINDEX:
case PICODATA_ITEM_WORDPHON:
case PICODATA_ITEM_SYLLPHON:
case PICODATA_ITEM_BOUND:
case PICODATA_ITEM_PUNC:
case PICODATA_ITEM_CMD:
case PICODATA_ITEM_PHONE:
case PICODATA_ITEM_FRAME:
case PICODATA_ITEM_FRAME_PAR:
return TRUE;
break;
case PICODATA_ITEM_OTHER:
default:
break;
}
PICODBG_WARN(("item type problem: %c", ch));
return FALSE;
}
picoos_uint8 picodata_is_valid_itemhead(const picodata_itemhead_t *head) {
if ((NULL != head) && is_valid_itemtype(head->type)) {
return TRUE;
} else {
PICODBG_WARN(("item header problem"));
return FALSE;
}
}
/* ***************************************************/
pico_status_t picodata_get_itemparts_nowarn(
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picodata_itemhead_t *head, picoos_uint8 *content,
const picoos_uint16 clenmax, picoos_uint16 *clen)
{
if (blenmax >= PICODATA_ITEM_HEADSIZE) {
head->type = buf[PICODATA_ITEMIND_TYPE];
head->info1 = buf[PICODATA_ITEMIND_INFO1];
head->info2 = buf[PICODATA_ITEMIND_INFO2];
head->len = buf[PICODATA_ITEMIND_LEN];
*clen = head->len;
if (blenmax >= (*clen + PICODATA_ITEM_HEADSIZE)) {
if (clenmax >= head->len) {
picoos_uint16 i;
for (i=0; i<head->len; i++) {
content[i] = buf[PICODATA_ITEM_HEADSIZE+i];
}
return PICO_OK;
}
*clen = 0;
return PICO_EXC_BUF_OVERFLOW;
}
}
*clen = 0;
return PICO_EXC_BUF_UNDERFLOW;
}
pico_status_t picodata_get_itemparts(
const picoos_uint8 *buf, const picoos_uint16 blenmax,
picodata_itemhead_t *head, picoos_uint8 *content,
const picoos_uint16 clenmax, picoos_uint16 *clen)
{
pico_status_t status = picodata_get_itemparts_nowarn(buf,blenmax,head,content,clenmax,clen);
if (PICO_EXC_BUF_OVERFLOW == status) {
PICODBG_WARN(("problem getting item, overflow"));
} else if (PICO_EXC_BUF_UNDERFLOW == status) {
PICODBG_WARN(("problem getting item, overflow"));
}
return status;
}
pico_status_t picodata_put_itemparts(const picodata_itemhead_t *head,
const picoos_uint8 *content, const picoos_uint16 clenmax,
picoos_uint8 *buf, const picoos_uint16 blenmax, picoos_uint16 *blen)
{
*blen = head->len + PICODATA_ITEM_HEADSIZE;
if (blenmax >= *blen) {
if (clenmax >= head->len) {
picoos_uint16 i;
buf[PICODATA_ITEMIND_TYPE] = head->type;
buf[PICODATA_ITEMIND_INFO1] = head->info1;
buf[PICODATA_ITEMIND_INFO2] = head->info2;
buf[PICODATA_ITEMIND_LEN] = head->len;
for (i=0; i<head->len; i++) {
buf[PICODATA_ITEM_HEADSIZE+i] = content[i];
}
return PICO_OK;
}
PICODBG_WARN(("problem putting item, underflow"));
*blen = 0;
return PICO_EXC_BUF_UNDERFLOW;
}
PICODBG_WARN(("problem putting item, overflow"));
*blen = 0;
return PICO_EXC_BUF_OVERFLOW;
}
pico_status_t picodata_get_iteminfo(
picoos_uint8 *buf, const picoos_uint16 blenmax,
picodata_itemhead_t *head, picoos_uint8 **content) {
if (blenmax >= PICODATA_ITEM_HEADSIZE) {
head->type = buf[PICODATA_ITEMIND_TYPE];
head->info1 = buf[PICODATA_ITEMIND_INFO1];
head->info2 = buf[PICODATA_ITEMIND_INFO2];
head->len = buf[PICODATA_ITEMIND_LEN];
if (head->len == 0) {
*content = NULL;
} else {
*content = &buf[PICODATA_ITEM_HEADSIZE];
}
return PICO_OK;
}
return PICO_EXC_BUF_UNDERFLOW;
}
pico_status_t picodata_copy_item(const picoos_uint8 *inbuf,
const picoos_uint16 inlenmax, picoos_uint8 *outbuf,
const picoos_uint16 outlenmax, picoos_uint16 *numb)
{
if (picodata_is_valid_item(inbuf, inlenmax)) {
*numb = PICODATA_ITEM_HEADSIZE + inbuf[PICODATA_ITEMIND_LEN];
} else {
*numb = 0;
}
if (*numb > 0) {
if (outlenmax >= inlenmax) {
picoos_uint16 i;
for (i=0; i<*numb; i++) {
outbuf[i] = inbuf[i];
}
return PICO_OK;
} else {
PICODBG_WARN(("buffer problem, out: %d > in: %d", outlenmax, inlenmax));
*numb = 0;
return PICO_EXC_BUF_OVERFLOW;
}
} else {
PICODBG_WARN(("item problem in inbuf"));
return PICO_ERR_OTHER;
}
}
pico_status_t picodata_set_iteminfo1(picoos_uint8 *buf,
const picoos_uint16 blenmax, const picoos_uint8 info) {
if (PICODATA_ITEMIND_INFO1 < blenmax) {
buf[PICODATA_ITEMIND_INFO1] = info;
return PICO_OK;
} else
return PICO_EXC_BUF_UNDERFLOW;
}
pico_status_t picodata_set_iteminfo2(picoos_uint8 *buf,
const picoos_uint16 blenmax, const picoos_uint8 info) {
if (PICODATA_ITEMIND_INFO2 < blenmax) {
buf[PICODATA_ITEMIND_INFO2] = info;
return PICO_OK;
} else
return PICO_EXC_BUF_UNDERFLOW;
}
/* sets the len field in the header contained in the item in buf;
return values:
PICO_OK <- all ok
PICO_EXC_BUF_UNDERFLOW <- underflow in buf
*/
pico_status_t picodata_set_itemlen(picoos_uint8 *buf,
const picoos_uint16 blenmax, const picoos_uint8 len) {
if (PICODATA_ITEMIND_LEN < blenmax) {
buf[PICODATA_ITEMIND_LEN] = len;
return PICO_OK;
} else
return PICO_EXC_BUF_UNDERFLOW;
}
picoos_uint8 picodata_is_valid_item(const picoos_uint8 *item,
const picoos_uint16 ilenmax)
{
if (ilenmax >= PICODATA_ITEM_HEADSIZE) {
picodata_itemhead_t head;
head.type = item[0];
head.info1 = item[1];
head.info2 = item[2];
head.len = item[3];
if ((ilenmax >= (head.len + PICODATA_ITEM_HEADSIZE)) &&
picodata_is_valid_itemhead(&head))
{
return TRUE;
}
}
return FALSE;
}
/* ***************************************************************
* ProcessingUnit *
*****************************************************************/
picoos_uint16 picodata_get_default_buf_size (picodata_putype_t puType)
{
return (PICODATA_PUTYPE_TEXT == puType) ? PICODATA_BUFSIZE_TEXT
: (PICODATA_PUTYPE_TOK == puType) ? PICODATA_BUFSIZE_TOK
: (PICODATA_PUTYPE_PR == puType) ? PICODATA_BUFSIZE_PR
: (PICODATA_PUTYPE_PR == puType) ? PICODATA_BUFSIZE_PR
: (PICODATA_PUTYPE_WA == puType) ? PICODATA_BUFSIZE_WA
: (PICODATA_PUTYPE_SA == puType) ? PICODATA_BUFSIZE_SA
: (PICODATA_PUTYPE_ACPH == puType) ? PICODATA_BUFSIZE_ACPH
: (PICODATA_PUTYPE_SPHO == puType) ? PICODATA_BUFSIZE_SPHO
: (PICODATA_PUTYPE_PAM == puType) ? PICODATA_BUFSIZE_PAM
: (PICODATA_PUTYPE_CEP == puType) ? PICODATA_BUFSIZE_CEP
: (PICODATA_PUTYPE_SIG == puType) ? PICODATA_BUFSIZE_SIG
: (PICODATA_PUTYPE_SINK == puType) ? PICODATA_BUFSIZE_SINK
: PICODATA_BUFSIZE_DEFAULT;
}
typedef struct simple_pu_data
{
picorsrc_Voice voice;
} simple_pu_data_t;
static pico_status_t puSimpleInitialize (register picodata_ProcessingUnit this, picoos_int32 resetMode) {
return PICO_OK;
}
static pico_status_t puSimpleTerminate (register picodata_ProcessingUnit this) {
return PICO_OK;
}
static picodata_step_result_t puSimpleStep (register picodata_ProcessingUnit this,
picoos_int16 mode,
picoos_uint16 * numBytesOutput) {
picoos_int16 ch;
picoos_int16 result = PICO_OK;
mode = mode; /*PP 13.10.08 : fix warning "var not used in this function"*/
*numBytesOutput = 0;
while ((result == PICO_OK) && (ch = picodata_cbGetCh(this->cbIn)) != PICO_EOF) {
result = picodata_cbPutCh(this->cbOut,(picoos_char) ch);
(*numBytesOutput)++;
}
if (PICO_OK != result) {
(*numBytesOutput)--;
}
if (PICO_OK == result) {
return PICODATA_PU_IDLE;
} else {
return PICODATA_PU_ERROR;
}
}
picodata_ProcessingUnit picodata_newProcessingUnit(
picoos_MemoryManager mm,
picoos_Common common,
picodata_CharBuffer cbIn,
picodata_CharBuffer cbOut,
picorsrc_Voice voice)
{
picodata_ProcessingUnit this = (picodata_ProcessingUnit) picoos_allocate(mm, sizeof(*this));
if (this == NULL) {
picoos_emRaiseException(common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
return NULL;
}
this->common = common;
this->cbIn = cbIn;
this->cbOut = cbOut;
this->voice = voice;
this->initialize = puSimpleInitialize;
this->terminate = puSimpleTerminate;
this->step = puSimpleStep;
this->subDeallocate = NULL;
this->subObj = NULL;
return this;
}
void picodata_disposeProcessingUnit(
picoos_MemoryManager mm,
picodata_ProcessingUnit * this)
{
if (NULL != (*this)) {
/* terminate */
if (NULL != (*this)->subObj) {
(*this)->subDeallocate(*this,mm);
}
picoos_deallocate(mm,(void *)this);
}
}
picodata_CharBuffer picodata_getCbIn(picodata_ProcessingUnit this)
{
if (NULL == this) {
picoos_emRaiseException(this->common->em,PICO_ERR_NULLPTR_ACCESS,NULL,NULL);
return NULL;
} else {
return this->cbIn;
}
}
picodata_CharBuffer picodata_getCbOut(picodata_ProcessingUnit this)
{
if (NULL == this) {
picoos_emRaiseException(this->common->em,PICO_ERR_NULLPTR_ACCESS,NULL,NULL);
return NULL;
} else {
return this->cbOut;
}
}
pico_status_t picodata_setCbIn(picodata_ProcessingUnit this, picodata_CharBuffer cbIn)
{
if (NULL == this) {
picoos_emRaiseException(this->common->em,PICO_ERR_NULLPTR_ACCESS,NULL,NULL);
return PICO_ERR_OTHER;
} else {
this->cbIn = cbIn;
return PICO_OK;
}
}
pico_status_t picodata_setCbOut(picodata_ProcessingUnit this, picodata_CharBuffer cbOut)
{
if (NULL == this) {
picoos_emRaiseException(this->common->em,PICO_ERR_NULLPTR_ACCESS,NULL,NULL);
return PICO_ERR_OTHER;
} else {
this->cbOut = cbOut;
return PICO_OK;
}
}
/* ***************************************************************
* auxiliary functions *
*****************************************************************/
static void transDurUniform(
picoos_uint8 frame_duration_exp, /* 2's exponent of frame duration in ms, e.g. 2 for 4ms, 3 for 8ms */
picoos_int8 array_length,
picoos_uint8 * inout,
picoos_int16 inputdur, /* input duration in ms */
picoos_int16 targetdur, /* target duration in ms */
picoos_int16 * restdur /* in/out, rest in ms */
)
{
picoos_int8 i;
picoos_int32 fact, rest;
/* calculate rest and factor in number of frames (in PICODATA_PICODATA_PRECISION) */
rest = (*restdur) << (PICODATA_PRECISION - frame_duration_exp);
fact = (targetdur << (PICODATA_PRECISION - frame_duration_exp)) / inputdur;
for (i = 0; i < array_length; i++) {
rest += fact * inout[i];
/* instead of rounding, we carry the rest to the next state */
inout[i] = rest >> PICODATA_PRECISION;
rest -= inout[i] << PICODATA_PRECISION;
}
(*restdur) = rest >> (PICODATA_PRECISION - frame_duration_exp);
}
static void transDurWeighted(
picoos_uint8 frame_duration_exp, /* 2's exponent of frame duration in ms, e.g. 2 for 4ms, 3 for 8ms */
picoos_int8 array_length,
picoos_uint8 * inout,
const picoos_uint16 * weight, /* integer weights */
picoos_int16 inputdur, /* input duration in ms */
picoos_int16 targetdur, /* target duration in ms */
picoos_int16 * restdur /* in/out, rest in ms */
)
{
picoos_int8 i;
picoos_int32 fact, rest, out, weighted_sum;
/* calculate rest and factor in number of frames (in PICODATA_PICODATA_PRECISION) */
rest = (*restdur) << (PICODATA_PRECISION - frame_duration_exp);
weighted_sum = 0;
for (i=0; i < array_length; i++) {
weighted_sum += inout[i] * weight[i];
}
if (0 == weighted_sum) {
transDurUniform(frame_duration_exp,array_length,inout,inputdur,targetdur,restdur);
return;
}
/* get the additive change factor in PICODATA_PRECISION: */
if (targetdur > inputdur) {
fact = ((targetdur - inputdur) << (PICODATA_PRECISION-frame_duration_exp))/ weighted_sum;
} else {
fact = -((inputdur - targetdur) << (PICODATA_PRECISION-frame_duration_exp))/ weighted_sum;
}
/* input[i] * fact * weight[i] is the additive modification in PICODATA_PRECISION */
for (i=0; i < array_length; i++) {
rest += fact * inout[i] * weight[i];
/* instead of rounding, we carry the rest to the next state */
out = inout[i] + (rest >> PICODATA_PRECISION);
if (out < 0) {
out = 0;
}
rest -= ((out-inout[i]) << PICODATA_PRECISION);
inout[i] = out;
}
(*restdur) = rest >> (PICODATA_PRECISION - frame_duration_exp);
}
void picodata_transformDurations(
picoos_uint8 frame_duration_exp,
picoos_int8 array_length,
picoos_uint8 * inout,
const picoos_uint16 * weight, /* integer weights */
picoos_int16 mintarget, /* minimum target duration in ms */
picoos_int16 maxtarget, /* maximum target duration in ms */
picoos_int16 facttarget, /* factor to be multiplied with original length to get the target
the factor is fixed-point with PICODATA_PRECISION PICODATA_PRECISION, i.e.
the factor as float would be facttarget / PICODATA_PRECISION_FACT
if factor is 0, only min/max are considered */
picoos_int16 * dur_rest /* in/out, rest in ms */
)
{
picoos_int32 inputdur, targetdur;
picoos_int8 i;
/* find the original duration in ms */
inputdur = 0;
for (i=0; i < array_length; i++) {
inputdur += inout[i];
}
PICODBG_TRACE(("######## transforming duration fact=%i, limits = [%i,%i] (input frames: %i)",facttarget,mintarget,maxtarget, inputdur));
inputdur <<= frame_duration_exp;
/* find the target duration */
if (facttarget) {
targetdur = (facttarget * inputdur + PICODATA_PREC_HALF) >> PICODATA_PRECISION;
} else {
targetdur = inputdur;
}
/* we need to modify input if there is an explicit factor or input is not in the target range */
if (facttarget || (targetdur < mintarget) || (maxtarget < targetdur)) {
/* make sure we are in the limits */
if (targetdur < mintarget) {
targetdur = mintarget;
} else if (maxtarget < targetdur) {
targetdur = maxtarget;
}
/* perform modification */
if (NULL == weight) {
transDurUniform(frame_duration_exp,array_length,inout,inputdur,targetdur,dur_rest);
} else {
transDurWeighted(frame_duration_exp,array_length,inout,weight,inputdur,targetdur,dur_rest);
}
}
}
extern picoos_uint8 picodata_getPuTypeFromExtension(picoos_uchar * filename, picoos_bool input)
{
if (input) {
if (picoos_has_extension(filename, PICODATA_PUTYPE_TOK_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_TOK;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_PR_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_PR;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_WA_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_WA;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SA_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SA;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_ACPH_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_ACPH;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SPHO_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SPHO;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_PAM_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_PAM;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_CEP_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_CEP;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SIG_INPUT_EXTENSION) ||
picoos_has_extension(filename, PICODATA_PUTYPE_WAV_INPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SIG;
}
else {
return PICODATA_ITEMINFO2_CMD_TO_UNKNOWN;
}
}
else {
if (picoos_has_extension(filename, PICODATA_PUTYPE_TOK_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_TOK;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_PR_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_PR;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_WA_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_WA;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SA_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SA;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_ACPH_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_ACPH;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SPHO_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SPHO;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_PAM_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_PAM;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_CEP_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_CEP;
}
else if (picoos_has_extension(filename, PICODATA_PUTYPE_SIG_OUTPUT_EXTENSION) ||
picoos_has_extension(filename, PICODATA_PUTYPE_WAV_OUTPUT_EXTENSION)) {
return PICODATA_ITEMINFO2_CMD_TO_SIG;
}
else {
return PICODATA_ITEMINFO2_CMD_TO_UNKNOWN;
}
}
return PICODATA_ITEMINFO2_CMD_TO_UNKNOWN;
}
/**
*
* @param transducer
* @param common
* @param xsampa_parser
* @param svoxpa_parser
* @param xsampa2svoxpa_mapper
* @param inputPhones
* @param alphabet
* @param outputPhoneIds
* @param maxOutputPhoneIds
* @return
*/
pico_status_t picodata_mapPAStrToPAIds(picotrns_SimpleTransducer transducer,
picoos_Common common, picokfst_FST xsampa_parser,
picokfst_FST svoxpa_parser, picokfst_FST xsampa2svoxpa_mapper,
picoos_uchar * inputPhones, picoos_uchar * alphabet,
picoos_uint8 * outputPhoneIds, picoos_int32 maxOutputPhoneIds)
{
pico_status_t status = PICO_OK;
if (picoos_strcmp(alphabet, PICODATA_XSAMPA) == 0) {
if ((NULL != xsampa_parser) && (NULL != xsampa2svoxpa_mapper)) {
picotrns_stInitialize(transducer);
status = picotrns_stAddWithPlane(transducer, inputPhones,
PICOKFST_PLANE_ASCII);
if (PICO_OK != status) {
picoos_emRaiseWarning(common->em, status, NULL,
(picoos_char *) "phoneme sequence too long (%s)",
inputPhones);
} else {
status = picotrns_stTransduce(transducer, xsampa_parser);
if (PICO_OK != status) {
picoos_emRaiseWarning(common->em, status, NULL,
(picoos_char *) "not recognized as xsampa (%s)",
inputPhones);
} else {
status = picotrns_stTransduce(transducer, xsampa2svoxpa_mapper);
if (PICO_OK != status) {
picoos_emRaiseWarning(common->em, status, NULL,
(picoos_char *) "illeagal phoneme sequence (%s)",
inputPhones);
} else {
status = picotrns_stGetSymSequence(transducer, outputPhoneIds,
maxOutputPhoneIds);
}
}
}
return status;
}
} else if (picoos_strcmp(alphabet, PICODATA_SVOXPA) == 0) {
if ((NULL != svoxpa_parser)) {
picotrns_stInitialize(transducer);
status = picotrns_stAddWithPlane(transducer, inputPhones,
PICOKFST_PLANE_ASCII);
if (PICO_OK == status) {
status = picotrns_stTransduce(transducer, svoxpa_parser);
}
if (PICO_OK == status) {
status = picotrns_stGetSymSequence(transducer, outputPhoneIds,
maxOutputPhoneIds);
}
return status;
}
}
picoos_strlcpy(outputPhoneIds, (picoos_char *) "", maxOutputPhoneIds);
picoos_emRaiseWarning(common->em, PICO_EXC_NAME_ILLEGAL, NULL,
(picoos_char *) "alphabet not supported (%s)", alphabet);
return PICO_EXC_NAME_ILLEGAL;
}
#if defined (PICO_DEBUG)
/* ***************************************************************
* For Debugging only *
*****************************************************************/
/* put string representation of 'itemtype' into 'str' (allocated size 'strsize')
* return 'str' */
static picoos_char * data_itemtype_to_string(const picoos_uint8 itemtype,
picoos_char * str, picoos_uint16 strsize)
{
picoos_char * tmpstr;
switch (itemtype) {
case PICODATA_ITEM_BOUND:
tmpstr = (picoos_char *)"BOUND";
break;
case PICODATA_ITEM_FRAME_PAR:
tmpstr = (picoos_char *)"FRAME_PAR";
break;
case PICODATA_ITEM_PHONE:
tmpstr = (picoos_char *)"PHONE";
break;
case PICODATA_ITEM_CMD:
tmpstr = (picoos_char *)"CMD";
break;
case PICODATA_ITEM_ERR:
tmpstr = (picoos_char *)"ERR";
break;
case PICODATA_ITEM_FRAME:
tmpstr = (picoos_char *)"FRAME";
break;
case PICODATA_ITEM_OTHER:
tmpstr = (picoos_char *)"OTHER";
break;
case PICODATA_ITEM_PUNC:
tmpstr = (picoos_char *)"PUNC";
break;
case PICODATA_ITEM_SYLLPHON:
tmpstr = (picoos_char *)"SYLLPHON";
break;
case PICODATA_ITEM_WORDGRAPH:
tmpstr = (picoos_char *)"WORDGRAPH";
break;
case PICODATA_ITEM_WORDINDEX:
tmpstr = (picoos_char *)"WORDINDEX";
break;
case PICODATA_ITEM_WORDPHON:
tmpstr = (picoos_char *)"WORDPHON";
break;
case PICODATA_ITEM_WSEQ_GRAPH:
tmpstr = (picoos_char *)"WSEQ_GRAPH";
break;
default:
tmpstr = (picoos_char *)"UNKNOWN";
break;
}
picopal_slprintf((picopal_char *) str, strsize, (picopal_char *)"%s",
tmpstr);
return str;
}
picoos_char * picodata_head_to_string(const picodata_itemhead_t *head,
picoos_char * str, picoos_uint16 strsize)
{
picoos_uint16 typelen;
if (NULL == head) {
picoos_strlcpy(str,(picoos_char *)"[head is NULL]",strsize);
} else {
data_itemtype_to_string(head->type, str, strsize);
typelen = picoos_strlen(str);
picopal_slprintf((picopal_char *) str+typelen, strsize-typelen,
(picopal_char *)"|%c|%c|%i", head->info1, head->info2,
head->len);
}
return str;
}
void picodata_info_item(const picoknow_KnowledgeBase kb,
const picoos_uint8 *pref6ch,
const picoos_uint8 *item,
const picoos_uint16 itemlenmax,
const picoos_char *filterfn)
{
#define SA_USE_PHST 1
picoos_uint16 i;
picoos_uint8 ch;
if ((itemlenmax < 4) || (item == NULL)) {
PICODBG_INFO_MSG(("invalid item\n"));
}
/* first 6 char used for prefix */
PICODBG_INFO_MSG_F(filterfn, ("%6s(", pref6ch));
/* type */
ch = item[0];
if ((32 <= ch) && (ch < 127)) {
PICODBG_INFO_MSG_F(filterfn, ("'%c',", ch));
} else {
PICODBG_INFO_MSG_F(filterfn, ("%3d,", ch));
}
/* info1 */
ch = item[1];
if ((32 <= ch) && (ch < 127))
switch (item[0]) {
case PICODATA_ITEM_PUNC:
case PICODATA_ITEM_BOUND:
case PICODATA_ITEM_CMD:
case PICODATA_ITEM_TOKEN:
case PICODATA_ITEM_FRAME_PAR:
PICODBG_INFO_MSG_F(filterfn, ("'%c',", ch));
break;
default:
PICODBG_INFO_MSG_F(filterfn, ("%3d,", ch));
}
else
PICODBG_INFO_MSG_F(filterfn, ("%3d,", ch));
/* info2 */
ch = item[2];
if ((32 <= ch) && (ch < 127))
switch (item[0]) {
case PICODATA_ITEM_PUNC:
case PICODATA_ITEM_BOUND:
case PICODATA_ITEM_CMD:
case PICODATA_ITEM_WORDPHON:
case PICODATA_ITEM_SYLLPHON:
PICODBG_INFO_MSG_F(filterfn, ("'%c',", ch));
break;
default:
PICODBG_INFO_MSG_F(filterfn, ("%3d,", ch));
}
else
PICODBG_INFO_MSG_F(filterfn, ("%3d,", ch));
/* len */
ch = item[3];
PICODBG_INFO_MSG_F(filterfn, ("%3d)", ch));
for (i = 0; i < ch; i++) {
if ((item[0] == PICODATA_ITEM_WSEQ_GRAPH) ||
(item[0] == PICODATA_ITEM_TOKEN) ||
(item[0] == PICODATA_ITEM_WORDGRAPH) ||
((item[0] == PICODATA_ITEM_CMD) && !((item[1] == PICODATA_ITEMINFO1_CMD_SPEED) ||
(item[1] == PICODATA_ITEMINFO1_CMD_PITCH) ||
(item[1] == PICODATA_ITEMINFO1_CMD_VOLUME) ||
(item[1] == PICODATA_ITEMINFO1_CMD_SPELL) ||
(item[1] == PICODATA_ITEMINFO1_CMD_SIL)))) {
PICODBG_INFO_MSG_F(filterfn, ("%c", item[4 + i]));
} else {
PICODBG_INFO_MSG_F(filterfn, ("%4d", item[4 + i]));
}
}
#if defined (SA_USE_PHST)
{
#include "picokdbg.h"
picoos_uint8 j;
picokdbg_Dbg kdbg;
kdbg = picokdbg_getDbg(kb);
if ((item[0] == PICODATA_ITEM_WORDPHON) ||
(item[0] == PICODATA_ITEM_SYLLPHON) ||
((item[0] == PICODATA_ITEM_CMD) && (item[1] == PICODATA_ITEMINFO1_CMD_PHONEME))) {
if (picokdbg_getPhoneSym(kdbg, item[4])) {
PICODBG_INFO_MSG_F(filterfn, (" "));
for (j = 0; j < item[3]; j++) {
PICODBG_INFO_MSG_F(filterfn, ("%s",
picokdbg_getPhoneSym(kdbg, item[4 + j])));
}
}
}
}
#endif
PICODBG_INFO_MSG_F(filterfn, ("\n"));
}
#endif /* PICO_DEBUG */
#ifdef __cplusplus
}
#endif
/* picodata.c end */
Reference in a new issue View git blame Copy permalink