pico/lib/picodata.c

/*
 * 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 r_mode) {
    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 */