slparhlr.c

彩信MMS的全部代码

        break;
        
    default :
        MMS_LOG_I(("SMIL SLPH: parStateHandler Unknown signal, %d\n",
            sig->type));
        break;
    } 
} 





static void parserAck(void)
{
    SmilResult res;
    
    
    if (SMIL_RESULT_OK != (res = sendDataToParser()))
    {
        
        SMILa_parserStop();        
        SMILa_parserHandlerResponse(res);
        
        
        deleteInstance();
    }
}






static void parserFoundStartElem(const MmsSignal *sig)
{
    SlphStartElem *elem;
    
    if ( !sig || !sig->p_param)
    {
        return;
    }

    elem = (SlphStartElem *)sig->p_param;
    switch (elem->element)
    {
    case SLPH_ELEMENT_SMIL:
    case SLPH_ELEMENT_HEAD:
    case SLPH_ELEMENT_LAYOUT:      
    case SLPH_ELEMENT_BODY:        
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        break;
                
    case SLPH_ELEMENT_META:
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        else
        {
            metaInfoStartElem((SlphStartElem *)sig->p_param);
        }
        break;
        
    case SLPH_ELEMENT_ROOT_LAYOUT:
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        else
        {
            rootlayoutStartElem(elem);
        }
        break;
        
    case SLPH_ELEMENT_REGION:
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        else
        {
            regionStartElem(elem);
        }
        break;
        
    case SLPH_ELEMENT_PAR:
        if (stackSearch(elem->element))
        {
            

            SMILa_parserHandlerResponse(SMIL_RESULT_NESTED_PAR);
            deleteInstance();
        }
        else
        {
            if (SMIL_RESULT_OK != stackPush(elem->element))
            {
                deleteInstance();
            }
            else
            {
                parStartElem(elem);
            }
        }      
        break;
        
    case SLPH_ELEMENT_AUDIO:
    case SLPH_ELEMENT_REF:
    case SLPH_ELEMENT_IMG:
    case SLPH_ELEMENT_TEXT:
    case SLPH_ELEMENT_VIDEO:
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        else
        {        
            mediaObjectStartElem(elem);
        }
        break;

    case SLPH_ELEMENT_PARAM:
        if (SMIL_RESULT_OK != stackPush(elem->element))
        {
            deleteInstance();
        }
        else
        {        
            paramStartElem(elem);
        }
        break;

    default:
        MMS_LOG_I(("%s(%d): unknown element %d\n", __FILE__, __LINE__,
            elem->element));
        break;
    }
} 






static void parStartElem(const SlphStartElem *pData)
{
    SmilPar *pNew;
    SlphParList *pList;
    SlphParList *pNewListEntry;
    SlphAttribute *pAttr;
    int i;
    
    
    pNew = (SmilPar *)M_CALLOC(sizeof(SmilPar));
    pNewListEntry = (SlphParList *)M_CALLOC(sizeof(SlphParList));
    
    pNewListEntry->par = pNew;
    
    
    pList = slphInst->data.parList;
    
    if (pList)
    {
        
        while (pList->next != NULL)
        {
            pList = pList->next;
        }
        pList->next = pNewListEntry;
    }
    else
    {
        slphInst->data.parList = pNewListEntry;
    }
    
    if (pData->attrs)
    {
        
        pAttr = pData->attrs;
        
        for (i = 0; i < pData->numAttrs; ++i)
        {
        


            if (SLPH_ATTRIBUTE_DUR == pAttr[i].name)
            {
                copyStrAttribute(&(pNew->dur), &pAttr[i]);
            }
        }
    }
}






static void regionStartElem(const SlphStartElem *pData)
{
    SmilRegion *pTmp, *pNew;
    SlphAttribute *pAttr;
    int i;
    
    
    pNew = (SmilRegion *)M_CALLOC(sizeof(SmilRegion));
    
    pTmp = slphInst->data.region;
    
    
    if (pTmp)
    {
        
        while (pTmp->next != NULL)
        {
            pTmp = pTmp->next;
        }
        pTmp->next = pNew;
    }
    else
    {
        slphInst->data.region = pNew;
    }
    
    if (pData->attrs)
    {
        
        pAttr = pData->attrs;
        
        for (i = 0; i < pData->numAttrs; ++i)
        {
        


            switch (pAttr[i].name)
            {
            case SLPH_ATTRIBUTE_HEIGHT:
                copyStrAttribute(&(pNew->height), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_WIDTH:
                copyStrAttribute(&(pNew->width), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_ID:
                copyStrAttribute(&(pNew->id), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_LEFT:
                copyStrAttribute(&(pNew->left), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_TOP:
                copyStrAttribute(&(pNew->top), &pAttr[i]);
                break;
                
            case SLPH_ATTRIBUTE_FIT:
                copyRegionFitString(pNew, pAttr[i].value.i);
                break;
            default:
                MMS_LOG_I(("SMIL SLPH: RegionStartElem unknown attribute, %d\n",
                    pAttr[i].name));
                break;
            }
        }
    }
}





static void receivedCancel(void)
{
    SMILa_parserHandlerResponse(SMIL_RESULT_CANCELLED_BY_USER);
    deleteInstance();
}





static void rootlayoutStartElem(const SlphStartElem *pData)
{
    SmilRootLayout *pNew;
    SlphAttribute *pAttr;
    int i;
    char *colorString;
    UINT32 colorInt;
    
    if (slphInst->data.rootLayout)
    {
         
        MMS_LOG_I(("SMIL SLPH: A root-layout already exists\n"));
        return; 
    }
    
    
    pNew = (SmilRootLayout *)M_CALLOC(sizeof(SmilRootLayout));
    
    slphInst->data.rootLayout = pNew;

    
    pNew->bgColor = SMIL_COLOR_NOT_USED;
    
    if (pData->attrs)
    {
        
        pAttr = pData->attrs;
        
        for (i = 0; i < pData->numAttrs; ++i)
        {
        

            switch (pAttr[i].name)
            {
            case SLPH_ATTRIBUTE_HEIGHT:
                copyStrAttribute(&(pNew->height), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_WIDTH:
                copyStrAttribute(&(pNew->width), &pAttr[i]);
                break;
            case SLPH_ATTRIBUTE_BGCOLOR_DEPR:
                






            case SLPH_ATTRIBUTE_BGCOLOR:
                
                if (pAttr[i].valueType == SLPH_STRING)
                {
                    
                    colorString = pAttr[i].value.data;
                    if (!colorString)
                    {
                        pNew->bgColor = SMIL_COLOR_NOT_USED;
                    }   
                    else
                    {
                        

                        colorInt = colorSTOI((const char *)colorString);
                        
                        
                        pNew->bgColor = colorInt;
                        
                        MMS_LOG_I(("SMIL SLPH rootlayoutStartElem: root-layout "
                            "background color parsed, %s, 0x%.8x\n",
                                    colorString, colorInt));
                    }
                }          
                break;           
            default:
                MMS_LOG_I(("SMIL SLPH rootlayoutStartElem unknown attribute, %d\n",
                    pAttr[i].name));
                break;
            } 
        } 
    } 
} 







static SmilResult sendDataToParser(void)
{
    int ret;
    unsigned int bufLen;
    char *buf;
    
    if (SLPH_NO_FILE == slphInst->src.data.file.id)
    {
        return SMIL_RESULT_OPEN_FILE_FAILED;
    }

    bufLen = sizeof(char) * SMIL_SPH_BUFFER_SIZE;
    buf = (char *)M_CALLOC(bufLen);
    
    ret = FILEa_read(slphInst->src.data.file.category, 
        slphInst->src.data.file.id, 
        buf, slphInst->filePos, (int)bufLen);

    if (SLPH_FILE_READ_FAILED == ret)
    {
        M_FREE(buf);
        MMS_LOG_I(("SMIL SLPH: failed to read data from file.\n"));
        return SMIL_RESULT_READ_FROM_FILE_FAILED;
    }
    else
    {
       



        slphInst->filePos += ret;
        SMILa_parserData(buf, ret, (bufLen == (unsigned int)ret));
        M_FREE(buf);
        return SMIL_RESULT_OK;
    }
}




static void sendPar(void)
{
    SlphParList *tmpListObj;
    SmilPar  *tPar = NULL;
    
    if (slphInst->data.parList)
    {
        
        tPar = slphInst->data.parList->par;
        
        
        SMILa_parsedPar(tPar);
        
        
        tmpListObj = slphInst->data.parList;
        
        slphInst->data.parList = slphInst->data.parList->next;
        
        sluFreeNoneNestedPar(tPar);
        M_FREE(tmpListObj);
    }
    else
    {
        
        MMS_LOG_I(("SMIL SLPH: missing data to par element.\n"));
        
        SMILa_parsedPar(NULL);
    }
}




void slphInit(void)
{
    slphInst = NULL;
    slphFsmBusy = FALSE;

    mSignalRegisterDst(M_FSM_SMIL_PARSE_HANDLER, slphMain);
    
    MMS_LOG_I(("SMIL - slphInit: FSM initialized\n"));
    
    slphSignalHandlers[SLPH_STATE_IDLE] = 
        idleStateHandler;
    
    slphSignalHandlers[SLPH_STATE_PARSING_HEAD] = 
        headStateHandler;
    
    slphSignalHandlers[SLPH_STATE_WAIT_FOR_HEAD_RESPONSE] = 
        headResponseStateHandler;
    
    slphSignalHandlers[SLPH_STATE_WAIT_FOR_FIRST_PAR] = 
        waitForFirstParStateHandler;
    
    slphSignalHandlers[SLPH_STATE_PARSING_PAR] =
        parStateHandler;
}






static void slphMain(MmsSignal *sig)
{   
    if (!sig)
    {
        MMS_LOG_I(("SMIL SLPH: NULL signal recevied.\n"));
        return;
    }
    
    if (SLPH_SIG_START_PARSER_HANDLER == sig->type)
    {
        
        if (slphFsmBusy)
        {
            MMS_LOG_I(("SMIL SLPH: start signal received but FSM is busy!\n"));
            
            SMILa_parserHandlerResponse(SMIL_RESULT_BUSY);
        }
        else
        {
            slphFsmBusy = TRUE;
            initInstance();        
            
            slphSignalHandlers[slphInst->state](sig);
        }   
    }
    else if ( !slphFsmBusy)            
    {
        
        MMS_LOG_I(("SMIL SLPH: signal sent to a non-existing instance!\n"));
    }
    else if ( !slphInst)
    {
        
        MMS_LOG_I(("SMIL SLPH: non-existing instance!\n"));
    }
    else
    {
        
        slphSignalHandlers[slphInst->state](sig);
    }
    
    freeSignalParam(sig);
    mSignalDelete(sig);
} 




void slphTerminate(void)
{
    if (slphInst)
    {
        if ((SLPH_STATE_IDLE != slphInst->state) &&
            (! (SLPH_BIT_PARSER_FINISHED & slphInst->state)))
        {   
            SMILa_parserStop();
        }
        
        if (slphFsmBusy)
        {
            MMS_LOG_I(("%s(%d): BUSY at close down!\n", __FILE__, __LINE__));
            
            deleteInstance();
        }
    }
    mSignalDeregister(M_FSM_SMIL_PARSE_HANDLER);
    
    MMS_LOG_I(("SMIL SLPH: FSM closed down.\n"));
}





static void stackPop(void)
{
    if (slphInst->stackTopElem > SLPH_STACK_EMPTY)
    {
        --slphInst->stackTopElem;
    }
}








static SmilResult stackPush(int val)
{
    if (slphInst->stackTopElem >= SMIL_SPH_MAX_NESTING_DEPTH)
    {
         MMS_LOG_I(("SMIL SLPH: SMIL message max nesting level reached.\n"));
        return SMIL_RESULT_MAX_NESTING_EXCEEDED;
    }
    else
    {
        slphInst->stack[++slphInst->stackTopElem] = val;
        return SMIL_RESULT_OK;
    }
}






static CMN_BOOL stackIsEmpty(void)
{
    return slphInst->stackTopElem == SLPH_STACK_EMPTY;
}








static int stackTop(void)
{
    if (slphInst->stackTopElem == SLPH_STACK_EMPTY)
    {
        return SLPH_STACK_EMPTY;
    }
    else
    {
        return slphInst->stack[slphInst->stackTopElem];
    }
}








static CMN_BOOL stackSearch(int element)
{
    int i;
    CMN_BOOL result = FALSE;

    for (i = 0; i < (slphInst->stackTopElem + 1) && result == FALSE; ++i)
    {
        result = (element == slphInst->stack[i]);
    }

    return result;
}







static void waitForFirstParStateHandler( const MmsSignal *sig)
{
    switch (sig->type)
    {
    case MMS_SIG_COMMON_TIMER_EXPIRED:
    case SLPH_SIG_PARSER_ACK_DATA:
    case SLPH_SIG_CANCEL:
    case SLPH_SIG_PARSER_START_ELEMENT:      
    case SLPH_SIG_PARSER_CHAR_DATA:        
        manageParser(sig);
        break;
        
    case SLPH_SIG_PARSER_END_ELEMENT:
        if (stackIsEmpty())
        {
            SMILa_parserHandlerResponse(SMIL_RESULT_MISMATCH_BEGIN_END);
            deleteInstance();
            return;
        }
        else
        {
            endElement();
        }
        
        
        
        


        if (dataExistToDeliver())
        {
            
            sendPar();
            changeState(SLPH_STATE_PARSING_PAR);
        }
        break;
        
    case SLPH_SIG_PARSER_DONE:
        if (SMIL_RESULT_OK != sig->i_param)
        {
                        
            MMS_LOG_I(("SMIL SLPH: parser found errors.\n"));
            SMILa_parserHandlerResponse(SMIL_RESULT_PARSER_REPORTED_ERROR);
            deleteInstance();
        }
        else
        {
            


            MMS_LOG_I(("SMIL SLPH: parser finished before the first 'par' was assembled.\n"));
            SMILa_parserHandlerResponse(SMIL_RESULT_NO_PAR_FOUND);
            deleteInstance();
        }
        break;
        
    default :
        MMS_LOG_I(("SMIL SLPH: WaitForFirstParState Unknown signal, %d\n", 
           sig->type));
        break;
    } 
}