binfilefactory_ring.cpp

Resource editor base speadrum Chinese mobile

// BinFileFactory_Ring.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_ring_def.h"

void CBinFileFactory::CalcRingInfo()
{
    _ASSERTE( m_dwRingOffset > 0 );

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &RingData = res.mmi_data_table[MMI_RT_RING];
    RING_MAP       &ringMap  = mmires.m_mapRing;

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

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

    RingData.uCount = ringMap.GetCount();
    RingData.uSize  = 0;

    PAUD_RING_DATA_INFO_T pRingInfo = NULL;
    CString   strID;
    POSITION pos = ringMap.GetStartPosition();
    while( pos != NULL )
    {
        ringMap.GetNextAssoc( pos, strID, pRingInfo );
        RingData.uSize += ( pRingInfo->data_len + sizeof(MMIAUD_RING_DATA_INFO_T) );
        RingData.uSize = Addr4ByteAlign(RingData.uSize);
    }

    m_dwTextOffset = m_dwRingOffset + RingData.uSize;
    m_dwTextOffset = Addr4ByteAlign(m_dwTextOffset);
}

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

    CMMIRes        &mmires   = g_theApp.m_MMIRes;
    MMI_RESOURCE_T &res      = mmires.m_Resource;
    MMI_RES_DATA_T &RingData = res.mmi_data_table[MMI_RT_RING];
    RING_MAP       &ringMap  = mmires.m_mapRing;
    CDirFileInfo   * pInfo   = g_theApp.m_pRingInfo;
   
    int nCount = RingData.uCount;
    if( nCount == 0 )
        return TRUE;

    _ASSERTE(( (uint32)ftell(pFile) == ((uint32)RingData.pData+g_theApp.prj_arm_addr ))||
		     ( (uint32)ftell(pFile) == ((uint32)RingData.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;                       \
    }
///////////////////////////////////////////////////////////////////////////////

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

    const BOOL bBigEdn = res.ToolUsedInfo.bBigEndian;
    CConverter conv;

    int                   i         = 0;
    PAUD_RING_DATA_INFO_T pRingInfo = NULL;

    uint8 * pData = NULL;
    uint32 nAddr = (uint32)RingData.pData + nCount * sizeof(MMIAUD_RING_DATA_INFO_T);
    nAddr = Addr4ByteAlign(nAddr);
    for( i = 0; i < nCount; ++i )
    {
        VERIFY( ringMap.Lookup(arrID[i], pRingInfo) );

        pData = pRingInfo->data_ptr;
        pRingInfo->data_ptr = (uint8 *)nAddr;

        if( bBigEdn )
        {
            pRingInfo->data_ptr = (uint8 *)conv.ConvEdn_INT((DWORD)pRingInfo->data_ptr);
            pRingInfo->data_len = conv.ConvEdn_INT((DWORD)pRingInfo->data_len);
            pRingInfo->type     = (AUD_RING_TYPE_E)conv.ConvEdn_INT((DWORD)pRingInfo->type);
        }
        if( fwrite(pRingInfo, sizeof(MMIAUD_RING_DATA_INFO_T), 1, pFile) != 1 )
        {
            _ASSERTE(0);
            pRingInfo->data_ptr = pData;
            _tcscpy(m_szErrMsg, _T("Write file error!"));
            return FALSE; 
        }
        
        pRingInfo->data_ptr = pData;
        if( bBigEdn )
        {
            pRingInfo->data_len = conv.ConvEdn_INT((DWORD)pRingInfo->data_len);
            pRingInfo->type     = (AUD_RING_TYPE_E)conv.ConvEdn_INT((DWORD)pRingInfo->type);
        }

        nAddr += pRingInfo->data_len;
        nAddr = Addr4ByteAlign(nAddr);
    }

    BYTE arrAlign[] = { 0xcd, 0xcd, 0xcd, 0xcd };
    for( i = 0; i < nCount; ++i )
    {
        VERIFY( ringMap.Lookup(arrID[i], pRingInfo) );

        WRITE_FILE(pRingInfo->data_ptr, pRingInfo->data_len, 1, pFile);

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

    return TRUE;
}

BOOL CBinFileFactory::ReadRingInfo( 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 &RingData = res.mmi_data_table[MMI_RT_RING];
    RING_MAP       &ringMap  = mmires.m_mapRing;
    CDirFileInfo   * pInfo   = g_theApp.m_pRingInfo;

    const BOOL bBigEdn = res.ToolUsedInfo.bBigEndian;
    CConverter conv;
    if( bBigEdn )
    {
        RingData.uCount = conv.ConvEdn_INT(RingData.uCount);
        RingData.uSize  = conv.ConvEdn_INT(RingData.uSize);
    }
    int nCount = RingData.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(ring info) error!")); \
        return FALSE;                      \
    }
#define SEEK_FILE(pfile, st)               \
    if( fseek(pfile,st, SEEK_CUR) != 0 )   \
    {  _ASSERTE(0); return  FALSE; }
///////////////////////////////////////////////////////////////////////////////

    CStringArray arrID;
    pInfo->CalcAllLeafID( arrID );

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

    PAUD_RING_DATA_INFO_T pRingInfo = NULL;
    LPBYTE   pData    = NULL;
    int      nAlign   = 0;
    for( i = 0; i < nCount; ++i )
    {
        pRingInfo = new MMIAUD_RING_DATA_INFO_T;
        if( NULL == pRingInfo )
            return FALSE;

        READ_FILE( pRingInfo, sizeof(MMIAUD_RING_DATA_INFO_T), 1, pFile );
        if( bBigEdn )
        {
            pRingInfo->data_len = conv.ConvEdn_INT(pRingInfo->data_len);
            pRingInfo->type     = (AUD_RING_TYPE_E)conv.ConvEdn_INT(pRingInfo->type);
        }
        if( bBuildInfo )
        { 
            CDirFileNode * pRoot = (CDirFileNode *)pInfo->GetRoot();
            CDirFileNode * pNode = (CDirFileNode *)pInfo->MallocNode();
            if( NULL == pNode )
                return FALSE;
            
            _stprintf(pNode->szID,   _T("RING_%03d"), i);
            _stprintf(pNode->szName, _T("RING_%03d%s"), i, GetRingExt(pRingInfo->type));
            
            ringMap.SetAt(pNode->szID, pRingInfo );
            arrID.Add(pNode->szID);
            pInfo->AddChild(pRoot, pNode);
        }
        else
        {
            ringMap.SetAt( arrID[i], pRingInfo );
        }
    }

    for( i = 0; i < nCount; ++i )
    {
        VERIFY( ringMap.Lookup(arrID[i], pRingInfo) );
        
        pRingInfo->data_ptr = new BYTE[pRingInfo->data_len];
        if( pRingInfo->data_ptr == NULL )
            return FALSE;

        READ_FILE( pRingInfo->data_ptr, pRingInfo->data_len, 1, pFile );

        nAlign = Addr4ByteAlign(pRingInfo->data_len);
        fseek(pFile, nAlign - pRingInfo->data_len, SEEK_CUR);
    }

    return TRUE;
}

CString CBinFileFactory::GetRingExt(int nType)
{
    CString strExt = _T("");
    switch(nType)
    {
    case AUD_MIDI_RING:
        strExt = _T(".mid");
        break;
    case AUD_SMAF_RING:
        strExt = _T(".mmf");
        break;
    case AUD_WAVE_RING:
        strExt = _T(".wave");
        break;
    default:
        _ASSERTE( 0 );
    }

    return strExt;
}