windows-xp/Source/XPSP1/NT/drivers/tpg/hwx/volcano/dll/jaws.c

#include <stdlib.h>
#include "common.h"
#include "score.h"
#include "runnet.h"
#include "jaws.h"
#include "fugu.h"
#include "sole.h"
#include "nnet.h"

extern LOCRUN_INFO		g_locRunInfo;

// validates the header of the Jaws net
BOOL CheckJawsNetHeader (void *pData)
{
	NNET_HEADER		*pHeader	=	(NNET_HEADER *)pData;

	// wrong magic number
	ASSERT (pHeader->dwFileType == JAWS_FILE_TYPE);

	if (pHeader->dwFileType != JAWS_FILE_TYPE)
	{
		return FALSE;
	}

	// check version
	ASSERT(pHeader->iFileVer >= JAWS_OLD_FILE_VERSION);
    ASSERT(pHeader->iMinCodeVer <= JAWS_CUR_FILE_VERSION);

	ASSERT	(	!memcmp (	pHeader->adwSignature, 
							g_locRunInfo.adwSignature, 
							sizeof (pHeader->adwSignature)
						)
			);

	ASSERT (pHeader->cSpace == 1);

    if	(	pHeader->iFileVer >= JAWS_OLD_FILE_VERSION &&
			pHeader->iMinCodeVer <= JAWS_CUR_FILE_VERSION &&
			!memcmp (	pHeader->adwSignature, 
						g_locRunInfo.adwSignature, 
						sizeof (pHeader->adwSignature)
					) &&
			pHeader->cSpace == 1
		)
    {
        return TRUE;
    }
	else
	{
		return FALSE;
	}
}

BOOL JawsLoadPointer(JAWS_LOAD_INFO *pJaws)
{
    NNET_SPACE_HEADER	*pSpaceHeader;

	if (!CheckJawsNetHeader (pJaws->info.pbMapping))
		return FALSE;

	// point to the one and only space header
	pSpaceHeader = (NNET_SPACE_HEADER *)(pJaws->info.pbMapping + sizeof (NNET_HEADER));

    if	(	restoreLocalConnectNet	(	pJaws->info.pbMapping + pSpaceHeader->iDataOffset, 
										0, &pJaws->net
									) == NULL
		)
    {
        return FALSE;
    }

    pJaws->iNetSize = 
		getRunTimeNetMemoryRequirements (pJaws->info.pbMapping + pSpaceHeader->iDataOffset);

    if (pJaws->iNetSize <= 0)
    {
        return FALSE;
    }

    return TRUE;
}

///////////////////////////////////////
//
// JawsLoadFile
//
// Load otter/fugu/sole combiner from file
//
// Parameters:
//      pInfo: [out] Information about the mapped file
//      wszPath: [in] Path to load from
//
// Return values:
//      TRUE on successful, FALSE otherwise.
//
//////////////////////////////////////
BOOL JawsLoadFile(JAWS_LOAD_INFO *pJaws, wchar_t *wszPath)
{
	wchar_t	wszFile[_MAX_PATH];

	// Generate path to file.
	FormatPath(wszFile, wszPath, (wchar_t *)0, (wchar_t *)0, (wchar_t *)0, L"jaws.bin");

    if (!DoOpenFile(&pJaws->info, wszFile)) 
    {
        return FALSE;
    }
    return JawsLoadPointer(pJaws);
}

///////////////////////////////////////
//
// JawsUnloadFile
//
// Load otter/fugu/sole combiner from file
//
// Parameters:
//      pInfo: [out] File to unmap
//
// Return values:
//      TRUE on successful, FALSE otherwise.
//
//////////////////////////////////////
BOOL JawsUnloadFile(JAWS_LOAD_INFO *pJaws)
{
    return DoCloseFile(&pJaws->info);
}

BOOL JawsLoadRes(JAWS_LOAD_INFO *pJaws, HINSTANCE hInst, int nResID, int nType)
{
    if (DoLoadResource(&pJaws->info, hInst, nResID, nType) == NULL)
    {
        return FALSE;
    }
    return JawsLoadPointer(pJaws);
}

// describe the codepoint
RREAL *CodePointFlags(ALC alc, RREAL *pFeat)
{
    *(pFeat++) = ((alc & ALC_NUMERIC) ? 65535 : 0);
    *(pFeat++) = ((alc & ALC_ALPHA) ? 65535 : 0);
    *(pFeat++) = ((alc & (ALC_PUNC | ALC_NUMERIC_PUNC | ALC_OTHER)) ? 65535 : 0);
    *(pFeat++) = ((alc & (ALC_HIRAGANA | ALC_JAMO | ALC_BOPOMOFO)) ? 65535 : 0);
    *(pFeat++) = ((alc & (ALC_KATAKANA | ALC_HANGUL_ALL)) ? 65535 : 0);
    *(pFeat++) = ((alc & (ALC_KANJI_ALL)) ? 65535 : 0);
    return pFeat;
}

// Given an alt list with dense and possibly folded codes in it, run through it
// and expand the folded lists.  The unfolded alt list is returned in place.
// This function assumes that the list begins with better alternates, as those
// later in the list will get dropped if we run out of space.
static void UnfoldCodes(ALT_LIST *pAltList, LOCRUN_INFO *pLocRunInfo, CHARSET *cs)
{
	int i, cOut=0;
	ALT_LIST newAltList;	// This will be where the new alt list is constructed.

	// For each alternate in the input list and while we have space in the output list
	for (i=0; i<(int)pAltList->cAlt && (int)cOut<MAX_ALT_LIST; i++) {

		// Check if the alternate is a folded coded
		if (LocRunIsFoldedCode(pLocRunInfo,pAltList->awchList[i])) {
			int kndex;
			// If it is a folded code, look up the folding set
			wchar_t *pFoldingSet = LocRunFolded2FoldingSet(pLocRunInfo, pAltList->awchList[i]);

			// Run through the folding set, adding non-NUL items to the output list
			// (until the output list is full)
			for (kndex = 0; 
				kndex < LOCRUN_FOLD_MAX_ALTERNATES && pFoldingSet[kndex] != 0 && (int)cOut<MAX_ALT_LIST; 
				kndex++) {
				if (IsAllowedChar(pLocRunInfo, cs, pFoldingSet[kndex])) 
				{
					newAltList.awchList[cOut]=pFoldingSet[kndex];
					newAltList.aeScore[cOut]=pAltList->aeScore[i];
					cOut++;
#ifdef DISABLE_UNFOLDING
					// If unfolding is disabled, then stop after producing one unfolded code.
					// This way we don't push results later in the alt list out of the alt
					// list, while still allowing the recognizer to return unicodes for each
					// alternate.  
					break;
#endif
				}
			}
		} else {
			// Dense codes that are not folded get added directly
			newAltList.awchList[cOut]=pAltList->awchList[i];
			newAltList.aeScore[cOut]=pAltList->aeScore[i];
			cOut++;
		}
	}	
	// Store the length of the output list
	newAltList.cAlt=cOut;

	// Copy the output list over the input.
	*pAltList=newAltList;
}

int JawsFeaturize(FUGU_LOAD_INFO *pFugu, SOLE_LOAD_INFO *pSole, LOCRUN_INFO *pLocRunInfo, 
                  GLYPH *pGlyph, RECT *pGuide,
                  CHARSET *pCharSet, RREAL *pFeat, ALT_LIST *pAltList,
                  BOOL *pfAgree)
{
	int i;
	ALT_LIST altListFugu;
	ALT_LIST altListSole;

    wchar_t wchSoleTop1;
    float flSoleTop1;
	
    if (FuguMatch(&pFugu->fugu, &altListFugu, MAX_ALT_LIST, pGlyph, NULL, pCharSet, pLocRunInfo) < 0)
    {
        return -1;
    }

    UnfoldCodes(&altListFugu, pLocRunInfo, pCharSet);
    altListSole = altListFugu;

    if (SoleMatchRescore(pSole, &wchSoleTop1, &flSoleTop1, &altListSole, MAX_ALT_LIST, 
                         pGlyph, pGuide, pCharSet, pLocRunInfo) < 0)
    {
        return -1;
    }

    *pAltList = altListSole;

    if (altListFugu.cAlt > 0 && wchSoleTop1 == altListFugu.awchList[0])
    {
        *pfAgree = TRUE;
    }
    else
    {
        *pfAgree = FALSE;
        if (altListFugu.cAlt > JAWS_NUM_ALTERNATES)
        {
            pAltList->cAlt = JAWS_NUM_ALTERNATES;
        }
        for (i = 0; i < JAWS_NUM_ALTERNATES; i++) 
        {
            extern UNIGRAM_INFO g_unigramInfo;
            if (i < (int) altListFugu.cAlt) 
            {
                *(pFeat++) = (int) (altListFugu.aeScore[i] * 65535);
                *(pFeat++) = (int) (altListSole.aeScore[i] * 65535);
                *(pFeat++) = (int) (-UnigramCost(&g_unigramInfo, altListFugu.awchList[i]) * 100 * 256);
                pFeat = CodePointFlags(LocRun2ALC(pLocRunInfo, altListFugu.awchList[i]), pFeat);
            }
            else
            {
                *(pFeat++) = 0;
                *(pFeat++) = 0;
                *(pFeat++) = (int) (-UnigramCost(&g_unigramInfo, 0xFFFE) * 100 * 256);
                pFeat = CodePointFlags(0, pFeat);
            }
        }
        *(pFeat++) = (CframeGLYPH(pGlyph) - 1) * 65535;
    }
    return pAltList->cAlt;
}

///////////////////////////////////////
//
// JawsMatch
//
// Invoke Fugu/Otter/Sole combiner on a character.  
//
// Parameters:
//      pFugu:          [in]  Fugu database to use
//      pAltList:       [in/out] Alt list to rewrite the scores of
//      cAlt:           [in]  The maximum number of alternates to return
//      pGlyph:         [in]  The ink to recognize
//      pGuide:         [in]  Guide to scale ink to
//      pCharSet:       [in]  Filter for the characters to be returned
//      pLocRunInfo:    [in]  Pointer to the locale database
//
// Return values:
//      Returned the number of items in the alt list, or -1 if there is an error
//
//////////////////////////////////////
int JawsMatch(JAWS_LOAD_INFO *pJaws, FUGU_LOAD_INFO *pFugu, SOLE_LOAD_INFO *pSole,
              ALT_LIST *pAltList, int cAlt, GLYPH *pGlyph, RECT *pGuide, 
              CHARSET *pCharSet, LOCRUN_INFO *pLocRunInfo)
{
	int i;
    RREAL *pNetOut;
    int iWinner, cOut;
    BOOL fAgree;
    RREAL *pFeat = (RREAL *) ExternAlloc(pJaws->iNetSize * sizeof(RREAL));
    if (pFeat == NULL)
    {
        return -1;
    }

    if (JawsFeaturize(pFugu, pSole, pLocRunInfo, pGlyph, pGuide, pCharSet, pFeat, pAltList, &fAgree) < 0)
    {
        ExternFree(pFeat);
        return -1;
    }

    if (!fAgree)
    {
        pNetOut = runLocalConnectNet(&pJaws->net, pFeat, &iWinner, &cOut);
        if (cOut < (int) pAltList->cAlt)
        {
            pAltList->cAlt = cOut;
        }
        for (i = 0; i < (int) pAltList->cAlt; i++) 
        {
            pAltList->aeScore[i] = (float) *(pNetOut++) / (float) SOFT_MAX_UNITY;
        }
    }

    for (i = 0; i < (int) pAltList->cAlt; i++) 
    {
        pAltList->aeScore[i] = ((float) -ProbToScore(pAltList->aeScore[i])) / (float) 256.0;
    }

    SortAltList(pAltList);

    ExternFree(pFeat);
    return pAltList->cAlt;
}