slutil.c

彩信MMS的全部代码

/*
 * Copyright (C) Obigo AB, 2002-2005.
 * All rights reserved.
 *
 * This software is covered by the license agreement between
 * the end user and Obigo AB, and may be 
 * used and copied only in accordance with the terms of the 
 * said agreement.
 *
 * Obigo AB assumes no responsibility or 
 * liability for any errors or inaccuracies in this software, 
 * or any consequential, incidental or indirect damage arising
 * out of the use of the software.
 *
 */

















#include "cansilib.h"   
#include "cmnconf.h"    
#include "cmntypes.h"   

#include "aapicmn.h"    
#include "gmem.h"       

#include "mmstypes.h"   
#include "mmsconf.h"    
#include "mmem.h"       

#include "slutil.h"   




static char *sluCopyStringData(const char *src);
static CMN_BOOL sluCopyMetaInfo(const SmilHead *head, SmilHead *destHead);
static CMN_BOOL sluCopyRegion(const SmilHead *head, SmilHead *destHead);
static CMN_BOOL sluCopyRootLayout(const SmilHead *head, SmilHead *destHead);











static char *sluCopyStringData(const char *src)
{
    char *dest = NULL;
    unsigned int size;
    
    if (src)
    {
        size = strlen(src);
        dest = (char *)M_ALLOC(sizeof(char) * size + 1);
        strcpy(dest, src);
    }
    else
    {
        dest = NULL;
    } 

    return dest;
}








SmilPar* sluCopyPar(const SmilPar *par)
{
    SmilPar *newPar = NULL;
    
    SmilMediaObject *newMobj = NULL;
    SmilMediaObject *pOriginalMobj;
    SmilMediaObject *pTmpMobjPrev = NULL;
    
    if ( !par)
    {
        return NULL;
    }
    
    newPar = (SmilPar *)M_ALLOC(sizeof(SmilPar));
    
    newPar->dur = sluCopyStringData(par->dur);
    newPar->mobj = NULL;
    
    
    pOriginalMobj = par->mobj;
    while (pOriginalMobj)
    {
        newMobj = (SmilMediaObject *)M_ALLOC(sizeof(SmilMediaObject));
        newMobj->next = NULL;
        
        if (! newPar->mobj)
        {
            
            newPar->mobj = newMobj;
        }
        
        newMobj->mediaObjectElement = pOriginalMobj->mediaObjectElement;
        newMobj->src    = sluCopyStringData(pOriginalMobj->src);
        newMobj->region = sluCopyStringData(pOriginalMobj->region);
        newMobj->alt    = sluCopyStringData(pOriginalMobj->alt);
        newMobj->begin  = sluCopyStringData(pOriginalMobj->begin);
        newMobj->end    = sluCopyStringData(pOriginalMobj->end);
        newMobj->textBgColor = pOriginalMobj->textBgColor;
        newMobj->textFgColor = pOriginalMobj->textFgColor;
        
        if (pTmpMobjPrev)
        {
            
            pTmpMobjPrev->next = newMobj;
        }   
        pTmpMobjPrev = newMobj;
        
        
        pOriginalMobj = pOriginalMobj->next;
    } 
    
    return newPar;
}









SmilHead* sluCopyHead(const SmilHead *head)
{
    SmilHead *newHead;
    
    if ( !head)
    {
        return NULL;
    }

    
    newHead = (SmilHead *)M_CALLOC(sizeof(SmilHead));

    if (! newHead)
    {
        
        return NULL;
    }

    if (! sluCopyMetaInfo(head, newHead))
    {
        M_FREE(newHead);
        return NULL;
    }
    else if (! sluCopyRegion(head, newHead))
    {
        sluFreeMeta(newHead->metaInfo);
        M_FREE(newHead);
        return NULL;
    }
    else if (! sluCopyRootLayout(head, newHead))
    {
        sluFreeMeta(newHead->metaInfo);
        sluFreeRegion(newHead->region);
        M_FREE(newHead);
        return NULL;
    }
    else
    {
        
        return newHead;
    }
}











static CMN_BOOL sluCopyMetaInfo(const SmilHead *head, SmilHead *destHead)
{
    SmilMetaInfo *newMetaInfo = NULL;
    SmilMetaInfo *pOriginalMeta;
    SmilMetaInfo *pTmpMetaPrev = NULL;
    SmilMetaInfo *ret = NULL;

    pOriginalMeta = head->metaInfo;

    while (pOriginalMeta)
    {
        newMetaInfo = (SmilMetaInfo *)M_ALLOC(sizeof(SmilMetaInfo));

        if (! ret)
        {
            
            ret = newMetaInfo;
        }
   
        
        if (! newMetaInfo)
        {
            
            sluFreeMeta(ret);
            return FALSE;
        }

        newMetaInfo->next = NULL;
        
        newMetaInfo->name    = sluCopyStringData(pOriginalMeta->name);
        newMetaInfo->content = sluCopyStringData(pOriginalMeta->content);

        if (pTmpMetaPrev)
        {
            
            pTmpMetaPrev->next = newMetaInfo;
        }
        
        pTmpMetaPrev = newMetaInfo;
        
        
        pOriginalMeta = pOriginalMeta->next;
    }  

    destHead->metaInfo = ret;
    return TRUE;
}











static CMN_BOOL sluCopyRegion(const SmilHead *head, SmilHead *destHead)
{
    SmilRegion *newRegion = NULL;
    SmilRegion *pOriginalRegion;
    SmilRegion *pTmpRegionPrev = NULL;
    SmilRegion *ret = NULL;

    
    pOriginalRegion = head->region;

    while (pOriginalRegion)
    {
        newRegion = (SmilRegion *)M_ALLOC(sizeof(SmilRegion));

        if (! ret)
        {
            
            ret = newRegion;
        }

        if (! newRegion)
        {
            


            sluFreeRegion(ret);
            return FALSE;
        }
        newRegion->next = NULL;
        
        newRegion->id     = sluCopyStringData(pOriginalRegion->id);
        newRegion->left   = sluCopyStringData(pOriginalRegion->left);
        newRegion->top    = sluCopyStringData(pOriginalRegion->top);
        newRegion->height = sluCopyStringData(pOriginalRegion->height);
        newRegion->width  = sluCopyStringData(pOriginalRegion->width);
        newRegion->fit    = sluCopyStringData(pOriginalRegion->fit);
        
        if (pTmpRegionPrev)
        {
            
            pTmpRegionPrev->next = newRegion;
        }
        pTmpRegionPrev = newRegion;
        
        pOriginalRegion = pOriginalRegion->next;
    }  

    destHead->region = ret;
    return TRUE;
}











static CMN_BOOL sluCopyRootLayout(const SmilHead *head, SmilHead *destHead)
{
    SmilRootLayout *newRootLayout = NULL;

    
    if (head->rootLayout)
    {
        newRootLayout = (SmilRootLayout *)M_ALLOC(sizeof(SmilRootLayout));
        
        if (! newRootLayout)
        {
            return FALSE;
        }
        
        newRootLayout->height = sluCopyStringData(head->rootLayout->height);
        newRootLayout->width  = sluCopyStringData(head->rootLayout->width);
        newRootLayout->bgColor = head->rootLayout->bgColor;
    }

    destHead->rootLayout =  newRootLayout;
    return TRUE;
}







void sluFreeHead(SmilHead *head)
{
    if (head)
    {
        if (head->metaInfo)
        {
            sluFreeMeta(head->metaInfo);
        }
        
        if (head->rootLayout)
        {
            sluFreeRootLayout(head->rootLayout);
        }
        
        if (head->region)
        {
            sluFreeRegion(head->region);
        }

        M_FREE(head);
    }
}






static void sluFreeMediaObjects(SmilMediaObject *mobj)
{
    SmilMediaObject *tmp;
    
    while (mobj)
    {
        if (mobj->src)
        {
            
            M_FREE(mobj->src);
        }
        
        if (mobj->region)
        {
            
            M_FREE(mobj->region);
        }
        
        if (mobj->alt)
        {
            
            M_FREE(mobj->alt); 
        }
        
        if (mobj->begin)
        {
            
            M_FREE(mobj->begin);
        }
        
        if (mobj->end)
        {
            
            M_FREE(mobj->end);
        }

        tmp = mobj;
        mobj = mobj->next;
        M_FREE(tmp);
    }
}






void sluFreeMeta(SmilMetaInfo *metaInfo)
{
    SmilMetaInfo *tmp;
    
    while (metaInfo)
    {
        if (metaInfo->content)
        {
            M_FREE(metaInfo->content);
        }
        
        if (metaInfo->name)
        {
            M_FREE(metaInfo->name);
        }
        
        tmp = metaInfo;
        
        metaInfo = metaInfo->next;
        
        M_FREE(tmp);
    }
}






void sluFreeNoneNestedPar(SmilPar *par)
{
    if (par)
    {
        if (par->dur)
        {
            M_FREE(par->dur);
        }
        
        if (par->mobj)
        {
            sluFreeMediaObjects(par->mobj);
        }
        
        M_FREE(par);
    }
}






void sluFreeRegion(SmilRegion *region)
{
    SmilRegion *tmp;

    while (region)
    {
        if (region->id)
        {
            M_FREE(region->id);
        }

        if (region->top)
        {
            M_FREE(region->top);
        }

        if (region->left)
        {
            M_FREE(region->left);
        }

        if (region->width)
        {
            M_FREE(region->width);
        }

        if (region->height)
        {
            M_FREE(region->height);
        }

        if (region->fit)
        {
            M_FREE(region->fit);
        }
        
        tmp = region;
        region = region->next;
        
        M_FREE(tmp);
    }  
}






void sluFreeRootLayout(SmilRootLayout *rootLayout)
{
    if (rootLayout)
    {
        if (rootLayout->width)
        {
            M_FREE(rootLayout->width);
        }

        if (rootLayout->height)
        {
            M_FREE(rootLayout->height);
        }

        M_FREE(rootLayout);
    }
}