slparhlr.c

彩信MMS的全部代码

        


        MMS_LOG_I(("SMIL SLPH: media object received but it is not part of a 'par'\n"));
        
        
        return;
    }
    
    
    
    pParList = slphInst->data.parList;
    
    
    while (pParList && pParList->par && pParList->finished)
    {
        pParList = pParList->next;
    }

    if ( !pParList || pParList->finished || !pParList->par)
    {
        
        MMS_LOG_I(("SMIL SLPH: media object received but it is not part of a 'par'\n"));
        return; 
    }
    
    pNew = (SmilMediaObject *)M_CALLOC(sizeof(SmilMediaObject));
    
    pTmp = pParList->par->mobj;
    if (pTmp)
    {
        
        while (pTmp->next != NULL)
        {
            pTmp = pTmp->next;
        }

        pTmp->next = pNew;
    }
    else
    {
        pParList->par->mobj = pNew;
    }
    
    switch (pData->element)
    {
    case SLPH_ELEMENT_AUDIO:
        pNew->mediaObjectElement = SMIL_MEDIA_OBJECT_AUDIO;
        break;
    case SLPH_ELEMENT_REF:
        pNew->mediaObjectElement = SMIL_MEDIA_OBJECT_REF;
        break;
    case SLPH_ELEMENT_TEXT:
        pNew->mediaObjectElement = SMIL_MEDIA_OBJECT_TEXT;

        

        pNew->textBgColor = SMIL_COLOR_NOT_USED;
        pNew->textFgColor = SMIL_COLOR_NOT_USED;
        break;
    case SLPH_ELEMENT_IMG:
        pNew->mediaObjectElement = SMIL_MEDIA_OBJECT_IMG;
        break;
    case SLPH_ELEMENT_VIDEO:
        pNew->mediaObjectElement = SMIL_MEDIA_OBJECT_VIDEO;
        break;
    default:
        MMS_LOG_I(("SMIL SLPH: mediaObjectStartElem unknown element, %d\n",
            pData->element));
        break;
    }
    
    
    pAttr = pData->attrs;
    for (i = 0; i < pData->numAttrs; ++i)
    {
    


        switch (pAttr[i].name)
        {
        case SLPH_ATTRIBUTE_SRC:
            copyStrAttribute(&pNew->src, &pAttr[i]);
            break;
        case SLPH_ATTRIBUTE_ALT:
            copyStrAttribute(&pNew->alt, &pAttr[i]);
            break;
        case SLPH_ATTRIBUTE_REGION:
            copyStrAttribute(&pNew->region, &pAttr[i]);
            break;
        case SLPH_ATTRIBUTE_BEGIN:
            copyStrAttribute(&pNew->begin, &pAttr[i]);
            break;
        case SLPH_ATTRIBUTE_END:
            copyStrAttribute(&pNew->end, &pAttr[i]);
            break;
        default:
            MMS_LOG_I(("SMIL SLPH: mediaObjectStartElem unknown attribute, %d\n", 
                pAttr[i].name));
            break;
        }
    }
}









static void paramStartElem(const SlphStartElem *pData)
{
    SmilMediaObject *pMobj;
    SlphParList     *pParList;
    char *nameAttr;
    char *valueAttr;

    if (! pData)
    {
        return;
    }

       
    if (! slphInst->data.parList || !slphInst->data.parList->par ||
        ! slphInst->data.parList->par->mobj)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem No par element\n"));
        return;
    }
    
    
    pParList = slphInst->data.parList;
    
    
    while (pParList && pParList->par && pParList->finished)
    {
        pParList = pParList->next;
    }
    
    if ( !pParList || pParList->finished || !pParList->par || 
         !pParList->par->mobj)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem Nowhere to add param data\n"));
        return; 
    }
    
    
    pMobj = pParList->par->mobj;
    
    
    while (pMobj->next != NULL)
    {
        pMobj = pMobj->next;
    }

    
    if (!pMobj || pMobj->mediaObjectElement != SMIL_MEDIA_OBJECT_TEXT)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem Parent is not text element\n"));
        return; 
    }

    

    if (pData->numAttrs < 2)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem Less than 2 attributes\n"));
        return; 
    }

    
    nameAttr = getStrAttr(pData, SLPH_ATTRIBUTE_NAME);
    if (!nameAttr)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem No name attribute\n"));
        return; 
    }

    
	valueAttr = getStrAttr(pData, SLPH_ATTRIBUTE_VALUE);
    if (!valueAttr)
    {
        MMS_LOG_I(("SMIL SLPH: paramStartElem No value attribute\n"));
        return; 
    }

    
    if ((cmnStrcmpNc(nameAttr, SLPH_ATTRVAL_PARAM_FG_COLOR_1) == 0) ||
        (cmnStrcmpNc(nameAttr, SLPH_ATTRVAL_PARAM_FG_COLOR_2) == 0))
    {
        
        pMobj->textFgColor = colorSTOI((const char *)valueAttr);
        MMS_LOG_I(("SMIL SLPH: paramStartElem Text foreground color parsed, %s, %d\n", 
                    valueAttr, pMobj->textFgColor));
    }

    
    if ((cmnStrcmpNc(nameAttr, SLPH_ATTRVAL_PARAM_BG_COLOR_1) == 0) ||
        (cmnStrcmpNc(nameAttr, SLPH_ATTRVAL_PARAM_BG_COLOR_2) == 0))
    {
        
        pMobj->textBgColor = colorSTOI((const char *)valueAttr);
        MMS_LOG_I(("SMIL SLPH: paramStartElem Text background color parsed, %s, %d\n",
            valueAttr, pMobj->textBgColor));
    }

} 








static char *getStrAttr(const SlphStartElem *pData, int type)
{
    int i = pData->numAttrs;    

    
    while (i--)
    {
        
        if (pData->attrs[i].name == type)
        {
            
            if (pData->attrs[i].valueType == SLPH_STRING)
            {
                
                return pData->attrs[i].value.data;
            }
        }
    }

    
    return NULL;
} 














static UINT32 colorSTOI(const char *colorStrVal)
{
      UINT32 color = 0;
      int index = 0;
      char colorVal[7];
      char red;
      char green;
      char blue;
      
      if (colorStrVal == NULL)
      {
          return SMIL_COLOR_NOT_USED;
      } 
      
      
      if (colorStrVal[0] == SMIL_HASH_MARK)
      {
          memset(colorVal, 0x00, sizeof(colorVal));
          
          if (strlen(colorStrVal) == 4)
          {
              
              colorVal[0] = colorVal[1] = colorStrVal[1];
              colorVal[2] = colorVal[3] = colorStrVal[2];
              colorVal[4] = colorVal[5] = colorStrVal[3];
          }
          else
          {
              
              strcpy(colorVal, (const char *)&colorStrVal[1]);
          }
          
          
          if (!cmnHexDecodeByte(&red, &colorVal[0]) || 
              !cmnHexDecodeByte(&green, &colorVal[2]) ||
              !cmnHexDecodeByte(&blue, &colorVal[4]))
          {
              return SMIL_COLOR_NOT_USED;
          }
          else
          {
              


              color = (unsigned char)red << 16;
              color |= (unsigned char)green << 8;
              color |= (unsigned char)blue;
          }
          
      }
      else
      {
      

          while (slphColorSet[index].colorName != NULL)
          {
              if (cmnStrcmpNc(slphColorSet[index].colorName, colorStrVal) == 0)
              {
                  return slphColorSet[index].colorValue;
              } 
              index++;
          } 
          
          
          color = SMIL_COLOR_NOT_USED;
      } 
      return color;
} 






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


            if (SLPH_ATTRIBUTE_CONTENT == pAttr[i].name)
            {
                copyStrAttribute(&(pNew->content), &pAttr[i]);
            }
            else if (SLPH_ATTRIBUTE_NAME == pAttr[i].name)
            {
                copyStrAttribute(&(pNew->name), &pAttr[i]);
            }
        }
    }
}






static void manageParser(const MmsSignal *sig)
{
    switch (sig->type)
    {
    case MMS_SIG_COMMON_TIMER_EXPIRED:
        MMS_LOG_I(("%s(%d): Received TIMER_EXPIRED\n", __FILE__, __LINE__));
        SMILa_parserHandlerResponse(SMIL_RESULT_TIMEOUT);
        deleteInstance();
        break;
    case SLPH_SIG_CANCEL:
        
        receivedCancel();
        break;
    case SLPH_SIG_PARSER_ACK_DATA:
        
        parserAck();
        break;        
    case SLPH_SIG_PARSER_START_ELEMENT:      
        
        if (! sig->p_param)
        {
            
            MMS_LOG_I(("SMIL - manageParser: signal"
                       "SLPH_SIG_PARSER_START_ELEMENT without params!\n"));
            return; 
        }
        else
        {
            parserFoundStartElem(sig);
        }
        break;
    case SLPH_SIG_PARSER_CHAR_DATA:
        


        break;
        
    default:
        break;
    }

    
}






static void headStateHandler(const MmsSignal *sig)
{
    SmilHead *head;
    SlphStartElem *elem;
    
    switch (sig->type)
    {        
    case MMS_SIG_COMMON_TIMER_EXPIRED:
    case SLPH_SIG_PARSER_ACK_DATA:
    case SLPH_SIG_CANCEL:      
    case SLPH_SIG_PARSER_CHAR_DATA:        
        manageParser(sig);
        break;

    case SLPH_SIG_PARSER_START_ELEMENT:

        if ( !sig || !sig->p_param)
        {
            return;
        }
        elem = (SlphStartElem *)sig->p_param;
        
        
        if (SLPH_ELEMENT_BODY == elem->element)
        {
            MMS_LOG_I(("SMIL SLPH headStateHandler: no head in SMIL.\n"));

            
            SMILa_parsedHead(NULL);

            
            if (SMIL_RESULT_OK != stackPush(elem->element))
            {
                deleteInstance();
            }

                       
            changeState(SLPH_STATE_WAIT_FOR_HEAD_RESPONSE);
        }
        else
        {
            manageParser(sig);
        }        
        break;
   
    case SLPH_SIG_PARSER_END_ELEMENT:
        if (SLPH_ELEMENT_HEAD == stackTop())
        {
            
            head = (SmilHead *)M_CALLOC(sizeof(SmilHead));
            head->metaInfo = slphInst->data.metaInfo;
            head->rootLayout = slphInst->data.rootLayout;
            head->region = slphInst->data.region;
            
            
            SMILa_parsedHead(head);
            
            
            sluFreeHead(head);
            
            slphInst->data.metaInfo = NULL;
            slphInst->data.rootLayout = NULL;
            slphInst->data.region = NULL;
            
            changeState(SLPH_STATE_WAIT_FOR_HEAD_RESPONSE);
        }
        
        stackPop();
        if (stackIsEmpty())
        {
            
            SMILa_parserHandlerResponse(SMIL_RESULT_MISMATCH_BEGIN_END);
            deleteInstance();
        }
        break;
        
    case SLPH_SIG_PARSER_DONE:
        if (SMIL_RESULT_OK != sig->i_param)
        {
                        
            SMILa_parserHandlerResponse(SMIL_RESULT_PARSER_REPORTED_ERROR);
            deleteInstance();
        }
        else
        {
            
            MMS_LOG_I(("SMIL SLPH: parser finished before any head or body could be built.\n"));
            
            SMILa_parserHandlerResponse(SMIL_RESULT_NO_HEAD_OR_BODY_FOUND);
            deleteInstance();
        }
        break;
        
    default :
        MMS_LOG_I(("SMIL SLPH headStateHandler: Unknown signal, %d\n", sig->type));
        break;
    } 
} 






static void headResponseStateHandler(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();
        }
        break;
        
    case SLPH_SIG_HEAD_RESPONSE:
        


        if (dataExistToDeliver())
        {
            
            sendPar();
            changeState(SLPH_STATE_PARSING_PAR);
        }
        else
        {
            
            if (slphInst->flag == SLPH_BIT_PARSER_FINISHED)
            {
                
                SMILa_parserHandlerResponse(SMIL_RESULT_NO_PAR_DATA_RECEIVED);
                deleteInstance();
            }
            else
            {
                
                changeState(SLPH_STATE_WAIT_FOR_FIRST_PAR);
            }
        }
        break;
        
    case SLPH_SIG_PARSER_DONE:
        if (SMIL_RESULT_OK != sig->i_param)
        {
            
            SMILa_parserHandlerResponse(SMIL_RESULT_PARSER_REPORTED_ERROR);
            deleteInstance();
        }
        else
        {
            
            slphInst->flag |= SLPH_BIT_PARSER_FINISHED;
        }
        break;
        
    default :
        MMS_LOG_I(("SMIL - headResponseStateHandler: Unknown signal, %d\n",
            sig->type));
        break;
    } 
} 






static void parStateHandler(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();
        }
        break;
        
    case SLPH_SIG_PAR_RESPONSE:
        


        if (dataExistToDeliver())
        {
            sendPar();            
        }
        
        else if (slphInst->flag & SLPH_BIT_PARSER_FINISHED)
        {
            if (! stackIsEmpty())
            {
                SMILa_parserHandlerResponse(SMIL_RESULT_MISMATCH_BEGIN_END);
                deleteInstance();
                return;
            }
            else if (! slphInst->data.parList)
            {
                
                SMILa_parserHandlerResponse(SMIL_RESULT_OK);
                deleteInstance();
            }
            else
            {
                MMS_LOG_I(("SMIL SLPH: parser has finished but unfinished par element(s) remains.\n"));
                SMILa_parserHandlerResponse(SMIL_RESULT_UNFINISHED_PAR_REMAINS); 
                deleteInstance();
            }
        }
        break;
        
    case SLPH_SIG_PARSER_DONE:
        if (SMIL_RESULT_OK != sig->i_param)
        {
            
            SMILa_parserHandlerResponse(SMIL_RESULT_PARSER_REPORTED_ERROR);
            deleteInstance();
        }
        else if ( !stackIsEmpty())
        {
            
            MMS_LOG_I(("SMIL SLPH: missmatch between elements' begin and end.\n"));
            
            SMILa_parserHandlerResponse(SMIL_RESULT_MISMATCH_BEGIN_END);
            deleteInstance();
        }
        else if ( !dataExistToDeliver())
        {
            


            SMILa_parserHandlerResponse(SMIL_RESULT_OK);
            deleteInstance();
        }
        else
        {
            


            slphInst->flag |= SLPH_BIT_PARSER_FINISHED;
        }