mmires_img.cpp

Resource editor base speadrum Chinese mobile

// MMIRes_Img.cpp: implementation of the CMMIRes class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resourceeditor.h"
#include "MMIRes.h"

#include "mmi_image_def.h"

CString CMMIRes::MakeImgID(LPCTSTR pszFileName)
{
    _ASSERTE( pszFileName != NULL );

    LPCTSTR pFind = _tcsrchr(pszFileName, _T('\\'));
    if( NULL == pFind )
        pFind = pszFileName;
    else
        pFind++;

    CString strFileName = pFind;
    int nLeft = strFileName.ReverseFind(_T('.'));
    if( nLeft > 0 )
        strFileName = strFileName.Left(nLeft);

    strFileName.MakeUpper();

    return strFileName;    
}

BOOL CMMIRes::AddImg( LPCTSTR pszID, LPCTSTR pszFileName, BOOL bCompressed)
{
    _ASSERTE( pszID != NULL && !ImgIsExist(pszID) );
    _ASSERTE( pszFileName != NULL );

    LPBYTE pBmp = NULL;
	int nSize;
    BOOL bRet = m_bmpProcessor.LoadBmpFile(pszFileName, &pBmp, &nSize);
    if( bRet )
    {
        PIMGINFO pImgInfo = new IMG_INFO_T;
        if( pImgInfo == NULL )
        {
            _tcscpy(m_szErrMsg, _T("memory no enough!"));
            free(pBmp);
            return FALSE;
        }
        pImgInfo->pOriginal  = pBmp;
		//@hongliang.xin 2006-9-25
		//不压缩时，pRoccedssed 与 pOriginal相同
		if(!bCompressed)   //不压缩
		{
			pImgInfo->pProcessed = new BYTE[nSize];
			memcpy(pImgInfo->pProcessed,pBmp,nSize);
			//m_bmpProcessor.ConvertToBigEndian(pImgInfo->pProcessed,nSize,FALSE);
			
			//pImgInfo->pProcessed = pBmp;
			pImgInfo->nProcSize = nSize;
			
			m_mapImg.SetAt(pszID, pImgInfo);
			m_mapFileName.SetAt(pszID, pszFileName);
			
			m_Resource.ToolUsedInfo.nUsedSize += ( sizeof(IMG_FLAG_T) + sizeof(uint8 *) + 													   pImgInfo->nProcSize );

			m_mapImgCompress.SetAt(pszID,bCompressed);
			
		}
		else    //压缩
		{
			if( m_bmpProcessor.CompressBmp( pBmp, pImgInfo->pProcessed, pImgInfo->nProcSize ) )
			{
				m_mapImg.SetAt(pszID, pImgInfo);
				m_mapFileName.SetAt(pszID, pszFileName);

				m_Resource.ToolUsedInfo.nUsedSize += ( sizeof(IMG_FLAG_T) + sizeof(uint8 *) + 
													   pImgInfo->nProcSize );
				m_mapImgCompress.SetAt(pszID,bCompressed);
			}
			else
			{
				_tcscpy(m_szErrMsg, _T("Compress bitmap stream fail!"));
         
				m_bmpProcessor.ReleaseCompressedStream( pImgInfo->pProcessed );

				free(pBmp);
				delete pImgInfo;
				return FALSE;
			}
		}
    }   
   
    _tcscpy(m_szErrMsg, m_bmpProcessor.GetErrMsg());

    return  bRet;
}

HBITMAP CMMIRes::GetImg( LPCTSTR pszID )
{
    _ASSERTE( pszID != NULL );
    
    ReleaseImg();

    PIMGINFO pImgInfo = NULL;
    VERIFY( m_mapImg.Lookup(pszID, pImgInfo) );
   
    m_hBmp = m_bmpProcessor.CreateBitmap(pImgInfo->pOriginal);
    
    return m_hBmp;
}

BOOL CMMIRes::ExportImg( LPCTSTR pszID, LPCTSTR pszFileName )
{
	_ASSERTE( pszID != NULL );
	_ASSERTE( pszFileName != NULL );


	CString strFile = pszFileName;
	CString strExtend = strFile.Right(4);
	if(strExtend.Compare(_T(".bmp"))!=0)
	{
		CString strFileName = pszID;
		strFileName+=".bmp";
		strFile+=strFileName;
	}

    PIMGINFO pImgInfo = NULL;
    VERIFY( m_mapImg.Lookup(pszID, pImgInfo) );
    LPBYTE pBmpStream = pImgInfo->pOriginal;

    PBITMAPFILEHEADER pbfh = (PBITMAPFILEHEADER)pBmpStream;
    
    PBITMAPINFO pbi = (PBITMAPINFO)(pbfh + 1);
    
    pBmpStream += pbfh->bfOffBits;

    LPBYTE pBits = NULL;
   
    // 注意文件中数据的内容长度可能大于实际数据的长度
    int nSize = ((pbi->bmiHeader.biWidth * pbi->bmiHeader.biBitCount + 31) &~31) / 8;
    nSize *= pbi->bmiHeader.biHeight;

    DWORD dwWritten=0;
    HANDLE fh;
	fh = CreateFile(strFile, GENERIC_WRITE,0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL); 

	if (fh == INVALID_HANDLE_VALUE) 
		return FALSE;

	if(pbi->bmiHeader.biCompression == BI_BITFIELDS)
	    WriteFile(fh, pImgInfo->pOriginal, nSize+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+3*sizeof(DWORD), &dwWritten, NULL); //three DWORD color masks 
	else if(pbi->bmiHeader.biCompression == BI_RGB)
		WriteFile(fh, pImgInfo->pOriginal, nSize+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER), &dwWritten, NULL); 
	else
	{
	   CloseHandle(fh);
	   return FALSE;
	}

	CloseHandle(fh); 
	
	return TRUE;	

}

void CMMIRes::ReleaseImg(void)
{
    if( NULL != m_hBmp )
        m_bmpProcessor.DeleteBitmap(m_hBmp);

    m_hBmp = NULL;    
}

BOOL CMMIRes::DeleteImg( LPCTSTR pszID )
{
    _ASSERTE( pszID != NULL );

    PIMGINFO pImgInfo = NULL;
	int nCompress = 1;
    BOOL bLook = m_mapImg.Lookup(pszID, pImgInfo);
	bLook = m_mapImgCompress.Lookup(pszID, nCompress);
    if( bLook )
    {
        m_Resource.ToolUsedInfo.nUsedSize -= ( sizeof(IMG_FLAG_T) + sizeof(uint8 *) +
                                               pImgInfo->nProcSize );
        delete []pImgInfo->pOriginal;

		if(nCompress == 1)
			m_bmpProcessor.ReleaseCompressedStream( pImgInfo->pProcessed );
		else
			pImgInfo->pProcessed = NULL;
		
        delete pImgInfo;

        m_mapImg.RemoveKey( pszID );
		//@hongliang.xin 2006-9-26 删除图片压缩标志
		m_mapImgCompress.RemoveKey( pszID );
    }

    return bLook;
}

BOOL CMMIRes::ReplaceImg( LPCTSTR pszID, LPCTSTR pszFileName, int bCheckLimit /* = FALSE */,
                          PUINT pOldSize /* = NULL */, PUINT pNewSize /* = NULL */, BOOL bCompressed /* = TRUE */)
{
    _ASSERTE( pszID != NULL && ImgIsExist(pszID) );
    _ASSERTE( pszFileName != NULL );
  
    LPBYTE pNewBmp = NULL;
	PIMGINFO pImgInfo = NULL;
    int    nSize       = 0;
    BOOL bRet = m_bmpProcessor.LoadBmpFile(pszFileName, &pNewBmp, &nSize);
    if( bRet )
    {
        LPBYTE pCompressed = NULL;
		UINT    nMaxSize    = 0;
		int    nCompressed = 1; //是否压缩
		if(!bCompressed)
		{
			VERIFY( m_mapImg.Lookup(pszID, pImgInfo) );	
			m_mapImgCompress.Lookup(pszID, nCompressed);

			if( bCheckLimit && m_Resource.ToolUsedInfo.nMaxLimitSize > 0 )
			{
				nMaxSize = m_Resource.ToolUsedInfo.nUsedSize;
				nMaxSize += ( pImgInfo->nProcSize - nSize );
				if( nMaxSize > m_Resource.ToolUsedInfo.nMaxLimitSize )
				{
					_stprintf(m_szErrMsg, _T("Exceed the limit size %d!"), m_Resource.ToolUsedInfo.nMaxLimitSize );
					
					m_bmpProcessor.ReleaseCompressedStream(pCompressed);
					delete []pNewBmp;
					return FALSE;
				}
			}
			m_Resource.ToolUsedInfo.nUsedSize += ( nSize - pImgInfo->nProcSize );
			
			if( pOldSize != NULL ) *pOldSize = pImgInfo->nProcSize;
			if( pNewSize != NULL ) *pNewSize = nSize;

			delete []pImgInfo->pOriginal;

			if(nCompressed == 1)
				m_bmpProcessor.ReleaseCompressedStream( pImgInfo->pProcessed );
			else
				pImgInfo->pProcessed = NULL;			

			pImgInfo->pOriginal  = pNewBmp;
			pImgInfo->pProcessed = pNewBmp;
			pImgInfo->nProcSize  = nSize;

			m_mapImgCompress.SetAt(pszID,bCompressed);
		}
		else
		{
			if( m_bmpProcessor.CompressBmp(pNewBmp, pCompressed, nSize) )
			{
				VERIFY( m_mapImg.Lookup(pszID, pImgInfo) );
				m_mapImgCompress.Lookup(pszID, nCompressed);

				if( bCheckLimit && m_Resource.ToolUsedInfo.nMaxLimitSize > 0 )
				{
					nMaxSize = m_Resource.ToolUsedInfo.nUsedSize;
					nMaxSize += ( pImgInfo->nProcSize - nSize );
					if( nMaxSize > m_Resource.ToolUsedInfo.nMaxLimitSize )
					{
						_stprintf(m_szErrMsg, _T("Exceed the limit size %d!"), m_Resource.ToolUsedInfo.nMaxLimitSize );

						m_bmpProcessor.ReleaseCompressedStream(pCompressed);
						delete []pNewBmp;
						return FALSE;
					}
				}
				m_Resource.ToolUsedInfo.nUsedSize += ( nSize - pImgInfo->nProcSize );

				if( pOldSize != NULL ) *pOldSize = pImgInfo->nProcSize;
				if( pNewSize != NULL ) *pNewSize = nSize;

				delete []pImgInfo->pOriginal;
				
				if(nCompressed == 1)
					m_bmpProcessor.ReleaseCompressedStream( pImgInfo->pProcessed );
				else
					pImgInfo->pProcessed = NULL;	
				
				pImgInfo->pOriginal  = pNewBmp;
				pImgInfo->pProcessed = pCompressed;
				pImgInfo->nProcSize  = nSize;
				
				m_mapImgCompress.SetAt(pszID,bCompressed);
				
			}
			else
			{
				_tcscpy(m_szErrMsg, _T("CompressBmp fail!") );

				m_bmpProcessor.ReleaseCompressedStream(pCompressed);
				delete []pNewBmp;
				bRet = FALSE;
			}
        }
    } 
    else
    {
        _tcscpy(m_szErrMsg, m_bmpProcessor.GetErrMsg() );
    }
    
    return  bRet;
}

BOOL CMMIRes::ImgIsExist( LPCTSTR pszID)
{
    _ASSERTE( pszID != NULL );

    PIMGINFO pImg = NULL;
    return m_mapImg.Lookup(pszID, pImg);
}

int CMMIRes::CalcImgResSize(void)
{
    int nCount = m_mapImg.GetCount();
   
    int nSize = sizeof(MMI_IMG_DATA_T);
    nSize    += sizeof(IMG_FLAG_T) * nCount;
    nSize    += sizeof(uint8 *)    * nCount;

    CString  strKey;
    PIMGINFO pImgInfo = NULL;
    POSITION pos = m_mapImg.GetStartPosition();
    while( pos != NULL )
    {
        m_mapImg.GetNextAssoc( pos, strKey, pImgInfo );
        _ASSERTE( pImgInfo != NULL );

        nSize += pImgInfo->nProcSize;
    }

    return nSize;
}