| /* |
| * 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 picokpdf.c |
| * |
| * knowledge handling for pdf |
| * |
| * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland |
| * All rights reserved. |
| * |
| * History: |
| * - 2009-04-20 -- initial version |
| * |
| */ |
| |
| #include "picoos.h" |
| #include "picodbg.h" |
| #include "picoknow.h" |
| #include "picokpdf.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| #if 0 |
| } |
| #endif |
| |
| |
| /* ************************************************************/ |
| /* pdf */ |
| /* ************************************************************/ |
| |
| /* |
| * @addtogroup picokpdf |
| * |
| overview: format of knowledge base pdf file |
| |
| This is the format for the dur pdf file: |
| - Numframes: 1 uint16 |
| - Vecsize: 1 uint8 |
| - sampperframe: 1 uint8 |
| - Phonquantlen: 1 uint8 |
| - Phonquant: Phonquantlen uint8 |
| - Statequantlen: 1 uint8 |
| - Statequantlen: Statequantlen uint8 |
| - And then numframes x vecsize uint8 |
| |
| This is the format for mul (mgc and lfz) pdf files: |
| - numframes: 1 uint16 |
| - vecsize: 1 uint8 |
| - numstates: 1 uint8 |
| - numframesperstate: numstates uint16 |
| - ceporder: 1 uint8 |
| - numvuv 1 uint8 |
| - numdeltas: 1 uint8 |
| - scmeanpow: 1 uint8 |
| - maxbigpow: 1 uint8 |
| - scmeanpowum KPDF_NUMSTREAMS * ceporder uint8 |
| - scivarpow KPDF_NUMSTREAMS * ceporder uint8 |
| |
| And then numframes x vecsize uint8 |
| |
| */ |
| |
| |
| /* ************************************************************/ |
| /* pdf data defines */ |
| /* may not be changed with current implementation */ |
| /* ************************************************************/ |
| |
| |
| #define KPDF_NUMSTREAMS 3 /* coeff, delta, deltadelta */ |
| |
| |
| /* ************************************************************/ |
| /* pdf loading */ |
| /* ************************************************************/ |
| |
| static pico_status_t kpdfDURInitialize(register picoknow_KnowledgeBase this, |
| picoos_Common common) { |
| picokpdf_pdfdur_t *pdfdur; |
| picoos_uint16 pos; |
| |
| if (NULL == this || NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING, |
| NULL, NULL); |
| } |
| pdfdur = (picokpdf_pdfdur_t *)this->subObj; |
| |
| pos = 0; |
| |
| pdfdur->numframes = ((picoos_uint16)(this->base[pos+1])) << 8 | |
| this->base[pos]; |
| pos += 2; |
| pdfdur->vecsize = this->base[pos++]; |
| pdfdur->sampperframe = this->base[pos++]; |
| pdfdur->phonquantlen = this->base[pos++]; |
| pdfdur->phonquant = &(this->base[pos]); |
| pos += pdfdur->phonquantlen; |
| pdfdur->statequantlen = this->base[pos++]; |
| pdfdur->statequant = &(this->base[pos]); |
| pos += pdfdur->statequantlen; |
| pdfdur->content = &(this->base[pos]); |
| PICODBG_DEBUG(("numframes %d, vecsize %d, phonquantlen %d, " |
| "statequantlen %d", pdfdur->numframes, pdfdur->vecsize, |
| pdfdur->phonquantlen, pdfdur->statequantlen)); |
| if ((picoos_uint32)(pos + (pdfdur->numframes * pdfdur->vecsize)) != this->size) { |
| PICODBG_DEBUG(("header-spec size %d, kb-size %d", |
| pos + (pdfdur->numframes * pdfdur->vecsize), |
| this->size)); |
| return picoos_emRaiseException(common->em, PICO_EXC_FILE_CORRUPT, |
| NULL, NULL); |
| } |
| PICODBG_DEBUG(("dur pdf initialized")); |
| return PICO_OK; |
| } |
| |
| static picoos_uint8 convScaleFactorToBig(picoos_uint8 pow, picoos_uint8 bigpow) |
| { |
| if (pow > 0x0F) { |
| pow = bigpow + (0xFF - pow + 1); /* take 2's complement of negative pow */ |
| } else if (bigpow >= pow) { |
| pow = bigpow - pow; |
| } else { |
| /* error: bigpow is smaller than input pow */ |
| return 0; |
| } |
| return pow; |
| } |
| |
| static pico_status_t kpdfMULInitialize(register picoknow_KnowledgeBase this, |
| picoos_Common common) { |
| picokpdf_pdfmul_t *pdfmul; |
| picoos_uint16 pos; |
| picoos_uint8 scmeanpow, maxbigpow, nummean; |
| picoos_uint8 i; |
| |
| if (NULL == this || NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING, |
| NULL, NULL); |
| } |
| pdfmul = (picokpdf_pdfmul_t *)this->subObj; |
| |
| pos = 0; |
| |
| pdfmul->numframes = ((picoos_uint16)(this->base[pos+1])) << 8 | |
| this->base[pos]; |
| pos += 2; |
| pdfmul->vecsize = this->base[pos++]; |
| pdfmul->numstates = this->base[pos++]; |
| { |
| pdfmul->stateoffset[0] = (picoos_uint16) 0; |
| for (i=1; i<pdfmul->numstates; i++) { |
| pdfmul->stateoffset[i] = pdfmul->stateoffset[i-1] + (this->base[pos] | ((picoos_uint16) this->base[pos+1] << 8)); |
| pos += 2; |
| } |
| pos += 2; /* we don't need the last number if we only need the offset (i.e. how to get to the vector start) */ |
| } |
| |
| pdfmul->ceporder = this->base[pos++]; |
| pdfmul->numvuv = this->base[pos++]; |
| pdfmul->numdeltas = this->base[pos++]; |
| scmeanpow = this->base[pos++]; |
| maxbigpow = this->base[pos++]; |
| if (maxbigpow < PICOKPDF_BIG_POW) { |
| PICODBG_ERROR(("bigpow %i is larger than maxbigpow %i defined in pdf lingware", PICOKPDF_BIG_POW, maxbigpow)); |
| return picoos_emRaiseException(common->em, PICO_EXC_MAX_NUM_EXCEED,NULL,NULL); |
| } |
| pdfmul->bigpow = PICOKPDF_BIG_POW; /* what we have to use is the smaller number! */ |
| |
| pdfmul->amplif = this->base[pos++]; |
| |
| /* bigpow corrected by scmeanpow, multiply means by 2^meanpow to obtain fixed point representation */ |
| pdfmul->meanpow = convScaleFactorToBig(scmeanpow, pdfmul->bigpow); |
| if (0 == pdfmul->meanpow) { |
| PICODBG_ERROR(("error in convScaleFactorToBig")); |
| return picoos_emRaiseException(common->em, PICO_EXC_MAX_NUM_EXCEED,NULL,NULL); |
| } |
| nummean = 3*pdfmul->ceporder; |
| |
| pdfmul->meanpowUm = picoos_allocate(common->mm,nummean*sizeof(picoos_uint8)); |
| pdfmul->ivarpow = picoos_allocate(common->mm,nummean*sizeof(picoos_uint8)); |
| if ((NULL == pdfmul->meanpowUm) || (NULL == pdfmul->ivarpow)) { |
| picoos_deallocate(common->mm,(void *) &(pdfmul->meanpowUm)); |
| picoos_deallocate(common->mm,(void *) &(pdfmul->ivarpow)); |
| return picoos_emRaiseException(common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL); |
| } |
| |
| /* read meanpowUm and convert on the fly */ |
| /* meaning of meanpowUm becomes: multiply means from pdf stream by 2^meanpowUm |
| * to achieve fixed point scaling by big |
| */ |
| for (i=0; i<nummean; i++) { |
| pdfmul->meanpowUm[i] = convScaleFactorToBig(this->base[pos++], pdfmul->bigpow); |
| } |
| |
| /*read ivarpow and convert on the fly */ |
| for (i=0; i<nummean; i++) { |
| pdfmul->ivarpow[i] = convScaleFactorToBig(this->base[pos++], pdfmul->bigpow); |
| } |
| |
| /* check numdeltas */ |
| if ((pdfmul->numdeltas == 0xFF) && (pdfmul->vecsize != (pdfmul->numvuv + pdfmul->ceporder * 3 * (2+1)))) { |
| PICODBG_ERROR(("header has inconsistent values for vecsize, ceporder, numvuv, and numdeltas")); |
| return picoos_emRaiseException(common->em,PICO_EXC_FILE_CORRUPT,NULL,NULL); |
| } |
| |
| /* vecsize: 1 uint8 for vuv |
| + ceporder short for static means |
| + numdeltas uint8 and short for sparse delta means |
| + ceporder*3 uint8 for static and delta inverse variances |
| */ |
| if ((pdfmul->numdeltas != 0xFF) && (pdfmul->vecsize != pdfmul->numvuv+pdfmul->ceporder*2+pdfmul->numdeltas*3+pdfmul->ceporder*3)) { |
| PICODBG_ERROR(("header has inconsistent values for vecsize, ceporder, numvuv, and numdeltas\n" |
| "vecsize = %i while numvuv+ceporder*2 + numdeltas*3 + ceporder*3 = %i", |
| pdfmul->vecsize, pdfmul->numvuv + pdfmul->ceporder*2 + pdfmul->numdeltas * 3 + pdfmul->ceporder * 3)); |
| return picoos_emRaiseException(common->em,PICO_EXC_FILE_CORRUPT,NULL,NULL); |
| } |
| pdfmul->content = &(this->base[pos]); |
| PICODBG_DEBUG(("numframes %d, vecsize %d, numstates %d, ceporder %d, " |
| "numvuv %d, numdeltas %d, meanpow %d, bigpow %d", |
| pdfmul->numframes, pdfmul->vecsize, pdfmul->numstates, |
| pdfmul->ceporder, pdfmul->numvuv, pdfmul->numdeltas, |
| pdfmul->meanpow, pdfmul->bigpow)); |
| if ((picoos_uint32)(pos + (pdfmul->numframes * pdfmul->vecsize)) != this->size) { |
| PICODBG_DEBUG(("header-spec size %d, kb-size %d", |
| pos + (pdfmul->numframes * pdfmul->vecsize), |
| this->size)); |
| return picoos_emRaiseException(common->em, PICO_EXC_FILE_CORRUPT, |
| NULL, NULL); |
| } |
| PICODBG_DEBUG(("mul pdf initialized")); |
| return PICO_OK; |
| } |
| |
| static pico_status_t kpdfPHSInitialize(register picoknow_KnowledgeBase this, |
| picoos_Common common) { |
| picokpdf_pdfphs_t *pdfphs; |
| picoos_uint16 pos; |
| |
| if (NULL == this || NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING, |
| NULL, NULL); |
| } |
| pdfphs = (picokpdf_pdfphs_t *)this->subObj; |
| |
| pos = 0; |
| |
| pdfphs->numvectors = ((picoos_uint16)(this->base[pos+1])) << 8 | |
| this->base[pos]; |
| pos += 2; |
| pdfphs->indexBase = &(this->base[pos]); |
| pdfphs->contentBase = pdfphs->indexBase + pdfphs->numvectors * sizeof(picoos_uint32); |
| PICODBG_DEBUG(("phs pdf initialized")); |
| return PICO_OK; |
| } |
| |
| |
| |
| static pico_status_t kpdfMULSubObjDeallocate(register picoknow_KnowledgeBase this, |
| picoos_MemoryManager mm) { |
| |
| |
| picokpdf_pdfmul_t *pdfmul; |
| |
| if ((NULL != this) && (NULL != this->subObj)) { |
| pdfmul = (picokpdf_pdfmul_t *)this->subObj; |
| picoos_deallocate(mm,(void *) &(pdfmul->meanpowUm)); |
| picoos_deallocate(mm,(void *) &(pdfmul->ivarpow)); |
| picoos_deallocate(mm, (void *) &(this->subObj)); |
| } |
| return PICO_OK; |
| } |
| |
| static pico_status_t kpdfDURSubObjDeallocate(register picoknow_KnowledgeBase this, |
| picoos_MemoryManager mm) { |
| if (NULL != this) { |
| picoos_deallocate(mm, (void *) &this->subObj); |
| } |
| return PICO_OK; |
| } |
| |
| static pico_status_t kpdfPHSSubObjDeallocate(register picoknow_KnowledgeBase this, |
| picoos_MemoryManager mm) { |
| if (NULL != this) { |
| picoos_deallocate(mm, (void *) &this->subObj); |
| } |
| return PICO_OK; |
| } |
| |
| /* we don't offer a specialized constructor for a *KnowledgeBase but |
| * instead a "specializer" of an allready existing generic |
| * picoknow_KnowledgeBase */ |
| |
| pico_status_t picokpdf_specializePdfKnowledgeBase(picoknow_KnowledgeBase this, |
| picoos_Common common, |
| const picokpdf_kpdftype_t kpdftype) { |
| pico_status_t status; |
| |
| if (NULL == this) { |
| return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING, |
| NULL, NULL); |
| } |
| switch (kpdftype) { |
| case PICOKPDF_KPDFTYPE_DUR: |
| this->subDeallocate = kpdfDURSubObjDeallocate; |
| this->subObj = picoos_allocate(common->mm,sizeof(picokpdf_pdfdur_t)); |
| if (NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, |
| NULL, NULL); |
| } |
| status = kpdfDURInitialize(this, common); |
| break; |
| case PICOKPDF_KPDFTYPE_MUL: |
| this->subDeallocate = kpdfMULSubObjDeallocate; |
| this->subObj = picoos_allocate(common->mm,sizeof(picokpdf_pdfmul_t)); |
| if (NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, |
| NULL, NULL); |
| } |
| status = kpdfMULInitialize(this, common); |
| break; |
| case PICOKPDF_KPDFTYPE_PHS: |
| this->subDeallocate = kpdfPHSSubObjDeallocate; |
| this->subObj = picoos_allocate(common->mm,sizeof(picokpdf_pdfphs_t)); |
| if (NULL == this->subObj) { |
| return picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, |
| NULL, NULL); |
| } |
| status = kpdfPHSInitialize(this, common); |
| break; |
| |
| default: |
| return picoos_emRaiseException(common->em, PICO_ERR_OTHER, |
| NULL, NULL); |
| } |
| |
| if (status != PICO_OK) { |
| picoos_deallocate(common->mm, (void *) &this->subObj); |
| return picoos_emRaiseException(common->em, status, NULL, NULL); |
| } |
| return PICO_OK; |
| } |
| |
| |
| /* ************************************************************/ |
| /* pdf getPdf* */ |
| /* ************************************************************/ |
| |
| picokpdf_PdfDUR picokpdf_getPdfDUR(picoknow_KnowledgeBase this) { |
| return ((NULL == this) ? NULL : ((picokpdf_PdfDUR) this->subObj)); |
| } |
| |
| picokpdf_PdfMUL picokpdf_getPdfMUL(picoknow_KnowledgeBase this) { |
| return ((NULL == this) ? NULL : ((picokpdf_PdfMUL) this->subObj)); |
| } |
| |
| picokpdf_PdfPHS picokpdf_getPdfPHS(picoknow_KnowledgeBase this) { |
| return ((NULL == this) ? NULL : ((picokpdf_PdfPHS) this->subObj)); |
| } |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| /* end */ |
