binfilefactory_anim.cpp

Resource editor base speadrum Chinese mobile

// BinFileFactory_Anim.cpp: implementation of the CBinFileFactory class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ResourceEditor.h"
#include "BinFileFactory.h"
#include "MMIRes.h"
#include "DirFileInfo.h"
#include "Converter.h"

#include "mmi_anim_def.h"

#include <memory>

void CBinFileFactory::CalcAnimInfo()
{
    _ASSERTE( m_dwAnimOffset > 0 );

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &AnimData = res.mmi_data_table[MMI_RT_ANIM];
    ANIM_MAP       &animMap  = mmires.m_mapAnim;

    DWORD dwBase    = res.ToolUsedInfo.nStartAddress;
    BOOL  bIsOffset = res.ToolUsedInfo.bAddrIsOffset;

    AnimData.pData  = (void *)CalcAddr(dwBase, m_dwAnimOffset, bIsOffset);
    // 保持4字节对齐
    _ASSERTE((uint32)AnimData.pData % sizeof(uint32) == 0);

    AnimData.uCount = animMap.GetCount();
    AnimData.uSize  = 0;

    CString   strID;
    PANIMINFO pAnimInfo = NULL;
    POSITION pos = animMap.GetStartPosition();
    while( pos != NULL )
    {
        animMap.GetNextAssoc( pos, strID, pAnimInfo );
        AnimData.uSize += ( pAnimInfo->nSize + sizeof(ANIM_FLAG_T) + sizeof(uint32 *) );
        AnimData.uSize = Addr4ByteAlign(AnimData.uSize);
    }

    if( AnimData.uCount > 0 )
    {
        AnimData.uSize += sizeof(MMI_ANIM_DATA_T);
    }

    m_dwRingOffset = m_dwAnimOffset + AnimData.uSize;
    m_dwRingOffset = Addr4ByteAlign(m_dwRingOffset);
}

BOOL CBinFileFactory::WriteAnimInfo( FILE * pFile )
{
    _ASSERTE( pFile != NULL );

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &AnimData = res.mmi_data_table[MMI_RT_ANIM];
    ANIM_MAP       &animMap  = mmires.m_mapAnim;
    CDirFileInfo   * pInfo   = g_theApp.m_pAnimInfo;

    int nCount = AnimData.uCount;
    if( nCount == 0 )
        return TRUE;

    _ASSERTE(( (uint32)ftell(pFile) == ((uint32)AnimData.pData+g_theApp.prj_arm_addr) )||
		     ( (uint32)ftell(pFile) == ((uint32)AnimData.pData+g_theApp.prj_win_addr) ));

///////////////////////////////////////////////////////////////////////////////
#define WRITE_FILE(des, st, num, file)      \
    if( fwrite(des, st, num, file) != num ) \
    {                                       \
        _ASSERTE(0);                        \
        _tcscpy(m_szErrMsg, _T("Write file error!"));  \
        return FALSE;                       \
    }
///////////////////////////////////////////////////////////////////////////////

    MMI_ANIM_DATA_T mad;
    mad.pFlag     = (PANIM_FLAG_T)((LPBYTE)AnimData.pData + sizeof(MMI_ANIM_DATA_T));
    mad.pAnimData = (uint32 *)( (LPBYTE)AnimData.pData + sizeof(MMI_ANIM_DATA_T) + 
                               sizeof(ANIM_FLAG_T) * AnimData.uCount );

    const BOOL bBigEdn = res.ToolUsedInfo.bBigEndian;
    CConverter conv;
    if( bBigEdn )
	{
		mad.pFlag     = (PANIM_FLAG_T)conv.ConvEdn_INT((DWORD)mad.pFlag);
        mad.pAnimData = (uint32 *)conv.ConvEdn_INT((DWORD)mad.pAnimData);
	}
    
    WRITE_FILE(&mad, sizeof(mad), 1, pFile);

    if( bBigEdn )
	{
		mad.pFlag     = (PANIM_FLAG_T)conv.ConvEdn_INT((DWORD)mad.pFlag);
        mad.pAnimData = (uint32 *)conv.ConvEdn_INT((DWORD)mad.pAnimData);
	}

    CStringArray arrID;
    pInfo->CalcAllLeafID(arrID);
    _ASSERTE( nCount == arrID.GetSize() );
    _ASSERTE( nCount == animMap.GetCount() );

    CBmpProcessor bmpProc;

    int         i         = 0;
    ANIM_FLAG_T animFlag  = { 0 };
    PANIMINFO   pAnimInfo = NULL;
    for( i = 0; i < nCount; ++i )
    {
        VERIFY( animMap.Lookup( arrID[i], pAnimInfo ) );
        
        CSize sizeAnim     = bmpProc.GetMovieSize(pAnimInfo->pCompressed);
		if(bBigEdn)
		{
			animFlag.nWidth    = conv.LitEdnToBigEdn((uint16)sizeAnim.cx);
			animFlag.nHeight   = conv.LitEdnToBigEdn((uint16)sizeAnim.cy);
			animFlag.nSize     = conv.ConvEdn_INT(pAnimInfo->nSize);
			animFlag.nType     = conv.LitEdnToBigEdn((uint16)AT_COMPRESS_STREAM);
			animFlag.nFrameNum = conv.LitEdnToBigEdn(pAnimInfo->nFrameNum);
		}
		else
		{
			animFlag.nWidth    = (uint16)sizeAnim.cx;
			animFlag.nHeight   = (uint16)sizeAnim.cy;
			animFlag.nSize     = pAnimInfo->nSize;
			animFlag.nType     = AT_COMPRESS_STREAM;
			animFlag.nFrameNum = pAnimInfo->nFrameNum;
		}
        
        WRITE_FILE(&animFlag, sizeof(animFlag), 1, pFile);
    }

    uint32 nAddr = (uint32)mad.pAnimData + sizeof(uint32 *) * nCount;
    nAddr = Addr4ByteAlign(nAddr);
    for( i = 0; i < nCount; ++i )
    {
        if( bBigEdn ) nAddr = conv.ConvEdn_INT(nAddr);

        WRITE_FILE(&nAddr, sizeof(nAddr), 1, pFile);

        if( bBigEdn ) nAddr = conv.ConvEdn_INT(nAddr);

        VERIFY( animMap.Lookup( arrID[i], pAnimInfo ) );
        
        nAddr += pAnimInfo->nSize;     
        nAddr = Addr4ByteAlign(nAddr);
    }

    
    BYTE arrAlign[] = { 0xbd, 0xbd, 0xbd, 0xbd };
    for( i = 0; i < nCount; ++i )
    {
        VERIFY( animMap.Lookup( arrID[i], pAnimInfo ) );
        if(bBigEdn)
			bmpProc.MovieConvertToBigEndian(pAnimInfo->pCompressed,pAnimInfo->nSize);
		
        WRITE_FILE(pAnimInfo->pCompressed, pAnimInfo->nSize, 1, pFile);
		
        if(bBigEdn)
			bmpProc.MovieConvertToLitEndian(pAnimInfo->pCompressed,pAnimInfo->nSize);

        nAddr = Addr4ByteAlign(pAnimInfo->nSize);
        _ASSERTE(nAddr - pAnimInfo->nSize < 4);
        fwrite(arrAlign, nAddr - pAnimInfo->nSize, 1, pFile);
    }

    return TRUE;
}

BOOL CBinFileFactory::ReadAnimInfo( FILE * pFile, BOOL bBuildInfo /* = FALSE */ )
{
    _ASSERTE( pFile != NULL );

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &AnimData = res.mmi_data_table[MMI_RT_ANIM];
    ANIM_MAP       &animMap  = mmires.m_mapAnim;
    CDirFileInfo   * pInfo   = g_theApp.m_pAnimInfo;

    const BOOL bBigEdn = res.ToolUsedInfo.bBigEndian;
    CConverter conv;
    if( bBigEdn )
    {
        AnimData.uCount = conv.ConvEdn_INT(AnimData.uCount);
        AnimData.uSize  = conv.ConvEdn_INT(AnimData.uSize);
    }

    int nCount = AnimData.uCount;
    if( nCount == 0 )
        return TRUE;

///////////////////////////////////////////////////////////////////////////////
#define READ_FILE(des, st, num, file)      \
    if( fread(des, st, num, file) != num ) \
    {                                      \
        _ASSERTE(0);                       \
        _tcscpy(m_szErrMsg, _T("Read file(anim info) error!")); \
        return FALSE;                      \
    }
#define SEEK_FILE(pfile, st)               \
    if( fseek(pfile,st, SEEK_CUR) != 0 )   \
    {  _ASSERTE(0); return  FALSE; }
///////////////////////////////////////////////////////////////////////////////

    SEEK_FILE( pFile, sizeof(MMI_ANIM_DATA_T) );
    
    CStringArray arrID;
    pInfo->CalcAllLeafID( arrID );

    int i = 0;
    _ASSERTE( 0 == animMap.GetCount() );

    std::auto_ptr<ANIM_FLAG_T>AnimFlagBuf(new ANIM_FLAG_T[nCount]);
    
    PANIM_FLAG_T pAnimFlag = AnimFlagBuf.get();
    if( pAnimFlag == NULL )
    {
        _ASSERTE(0);
        return FALSE;
    }

    READ_FILE(pAnimFlag, sizeof(ANIM_FLAG_T) * nCount, 1, pFile);

    SEEK_FILE( pFile, sizeof(uint32) * nCount );
    
    CBmpProcessor bmpProc;

    CString   strID;
    PANIMINFO pAnimInfo = NULL;
    LPBYTE   pData    = NULL;
    int      nSize    = 0;
    int      nAlign   = 0;
    for( i = 0; i < nCount; ++i )
    {
        pAnimInfo = new ANIM_INFO_T;
        if( NULL == pAnimInfo )
            return FALSE;

        memset(pAnimInfo, 0, sizeof(ANIM_INFO_T));
        if( bBuildInfo )
        { 
            CDirFileNode * pRoot = (CDirFileNode *)pInfo->GetRoot();
            CDirFileNode * pNode = (CDirFileNode *)pInfo->MallocNode();
            if( NULL == pNode )
                return FALSE;
            
            pNode->bIsDir = TRUE;
   
            _stprintf(pNode->szID, _T("ANIM_%03d"), i);
            _stprintf(pNode->szName, _T("anim_%03d"), i);
			pNode->nWidth  = pAnimFlag[i].nWidth;
			pNode->nHeight = pAnimFlag[i].nHeight;

            
            strID = pNode->szID;
          
            pInfo->AddChild(pRoot, pNode);
        }
        else
        {
            strID = arrID[i];
        }

        animMap.SetAt( strID, pAnimInfo );

        nSize = pAnimFlag[i].nSize;
        pData = (LPBYTE)malloc( nSize );
        if( NULL == pData )
            return FALSE;

        READ_FILE(pData, nSize, 1, pFile);
        nAlign = Addr4ByteAlign(nSize);
        fseek(pFile, nAlign - nSize, SEEK_CUR);
		
//		if(bBigEdn && mmires.m_iVersion >=4 )
//			bmpProc.MovieConvertToLitEndian(pData,nSize);

        pAnimInfo->pCompressed = pData;
		
        pAnimInfo->nSize       = nSize;
        pAnimInfo->nFrameNum   = pAnimFlag[i].nFrameNum;
    }

    return TRUE;
}

BOOL CBinFileFactory::ReadAnimInfo_v5( FILE * pFile, BOOL bBuildInfo /* = FALSE */ )
{
    _ASSERTE( pFile != NULL );

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &AnimData = res.mmi_data_table[MMI_RT_ANIM];
    ANIM_MAP       &animMap  = mmires.m_mapAnim;
    CDirFileInfo   * pInfo   = g_theApp.m_pAnimInfo;

    const BOOL bBigEdn = res.ToolUsedInfo.bBigEndian;
    CConverter conv;
    if( bBigEdn )
    {
        AnimData.uCount = conv.ConvEdn_INT(AnimData.uCount);
        AnimData.uSize  = conv.ConvEdn_INT(AnimData.uSize);
    }

    int nCount = AnimData.uCount;
    if( nCount == 0 )
        return TRUE;

///////////////////////////////////////////////////////////////////////////////
#define READ_FILE(des, st, num, file)      \
    if( fread(des, st, num, file) != num ) \
    {                                      \
        _ASSERTE(0);                       \
        _tcscpy(m_szErrMsg, _T("Read file(anim info) error!")); \
        return FALSE;                      \
    }
#define SEEK_FILE(pfile, st)               \
    if( fseek(pfile,st, SEEK_CUR) != 0 )   \
    {  _ASSERTE(0); return  FALSE; }
///////////////////////////////////////////////////////////////////////////////

    SEEK_FILE( pFile, sizeof(MMI_ANIM_DATA_T) );
    
    CStringArray arrID;
    pInfo->CalcAllLeafID( arrID );

    int i = 0;
    _ASSERTE( 0 == animMap.GetCount() );

    std::auto_ptr<ANIM_FLAG_T>AnimFlagBuf(new ANIM_FLAG_T[nCount]);
    
    PANIM_FLAG_T pAnimFlag = AnimFlagBuf.get();
    if( pAnimFlag == NULL )
    {
        _ASSERTE(0);
        return FALSE;
    }

    READ_FILE(pAnimFlag, sizeof(ANIM_FLAG_T) * nCount, 1, pFile);

    SEEK_FILE( pFile, sizeof(uint32) * nCount );
    
    CBmpProcessor bmpProc;

    CString   strID;
    PANIMINFO pAnimInfo = NULL;
    LPBYTE   pData    = NULL;
    int      nSize    = 0;
    int      nAlign   = 0;
    for( i = 0; i < nCount; ++i )
    {
        pAnimInfo = new ANIM_INFO_T;
        if( NULL == pAnimInfo )
            return FALSE;
		//转换AnimFlag
		if(bBigEdn)
		{
			pAnimFlag[i].nWidth = conv.BigEdnToLitEdn(pAnimFlag[i].nWidth);
			pAnimFlag[i].nHeight = conv.BigEdnToLitEdn(pAnimFlag[i].nHeight);
			pAnimFlag[i].nType = conv.BigEdnToLitEdn(pAnimFlag[i].nType);
			pAnimFlag[i].nFrameNum = conv.BigEdnToLitEdn(pAnimFlag[i].nFrameNum);
			pAnimFlag[i].nSize = conv.ConvEdn_INT(pAnimFlag[i].nSize);			
		}

        memset(pAnimInfo, 0, sizeof(ANIM_INFO_T));
        if( bBuildInfo )
        { 
            CDirFileNode * pRoot = (CDirFileNode *)pInfo->GetRoot();
            CDirFileNode * pNode = (CDirFileNode *)pInfo->MallocNode();
            if( NULL == pNode )
                return FALSE;
            
            pNode->bIsDir = TRUE;
   
            _stprintf(pNode->szID, _T("ANIM_%03d"), i);
            _stprintf(pNode->szName, _T("anim_%03d"), i);
			pNode->nWidth  = pAnimFlag[i].nWidth;
			pNode->nHeight = pAnimFlag[i].nHeight;

            
            strID = pNode->szID;
          
            pInfo->AddChild(pRoot, pNode);
        }
        else
        {
            strID = arrID[i];
        }

        animMap.SetAt( strID, pAnimInfo );

        nSize = pAnimFlag[i].nSize;
        pData = (LPBYTE)malloc( nSize );
        if( NULL == pData )
            return FALSE;

        READ_FILE(pData, nSize, 1, pFile);
        nAlign = Addr4ByteAlign(nSize);
        fseek(pFile, nAlign - nSize, SEEK_CUR);
		
		if(bBigEdn && mmires.m_iVersion >=6 )
			bmpProc.MovieConvertToLitEndian(pData,nSize);

        pAnimInfo->pCompressed = pData;
		
        pAnimInfo->nSize       = nSize;
        pAnimInfo->nFrameNum   = pAnimFlag[i].nFrameNum;
    }

    return TRUE;
}