C / C++ / MFC

//----------------------------------------------------------------------------- 
// Does:   Open a File And Load It Into IPicture (Interface) 
// ~~~~    (.BMP .DIB .EMF .GIF .ICO .JPG .WMF) 
// 
// InPut:  sFilePathName - Path And FileName Target To Save 
// ~~~~~   
// 
// OutPut: TRUE If Succeeded... 
// ~~~~~~ 
//----------------------------------------------------------------------------- 
BOOL CPicture::Load(CString sFilePathName) 
//============================================================================= 
{ 
        BOOL bResult = FALSE; 
        CFile PictureFile; 
        CFileException e; 
        int nSize = 0; 
        
        if(m_IPicture != NULL) FreePictureData(); // Important - Avoid Leaks... 
        
        if(PictureFile.Open(sFilePathName, CFile::modeRead | CFile::typeBinary, &e)) 
        { 
                nSize = PictureFile.GetLength(); 
                BYTE* pBuffer = new BYTE[nSize]; 
                
                if(PictureFile.Read(pBuffer, nSize) > 0) 
                { 
                        if(LoadPictureData(pBuffer, nSize)) bResult = TRUE; 
                } 
                
                PictureFile.Close(); 
                delete [] pBuffer; 
        } 
        else // Open Failed... 
        { 
                TCHAR szCause[255]; 
                e.GetErrorMessage(szCause, 255, NULL); 
                HWND hWnd = AfxGetApp()->GetMainWnd()->m_hWnd; 
                MessageBoxEx(hWnd, szCause, ERROR_TITLE, MB_OK | MB_ICONSTOP, LANG_ENGLISH); 
                bResult = FALSE; 
        } 
        
        m_Weight = nSize; // Update Picture Size Info... 
        
        if(m_IPicture != NULL) // Do Not Try To Read From Memory That Is Not Exist... 
        {      
                m_IPicture->get_Height(&m_Height); 
                m_IPicture->get_Width(&m_Width); 
                // Calculate Its Size On a "Standard" (96 DPI) Device Context 
                m_Height = MulDiv(m_Height, 96, HIMETRIC_INCH); 
                m_Width  = MulDiv(m_Height,  96, HIMETRIC_INCH); 

        } 
        else // Picture Data Is Not a Known Picture Type 
        { 
                m_Height = 0; 
                m_Width = 0; 
                bResult = FALSE; 
        } 
        
        return(bResult); 
} 

//----------------------------------------------------------------------------- 
// Does:   Saves The Picture That Is Stored In The IPicture Object As a Bitmap 
// ~~~~    (Converts From Any Known Picture Type To a Bitmap / Icon File) 
// 
// InPut:  sFilePathName - Path And FileName Target To Save 
// ~~~~~ 
// 
// OutPut: TRUE If Succeeded... 
// ~~~~~~ 
//----------------------------------------------------------------------------- 
BOOL CPicture::SaveAsBitmap(CString sFilePathName) 
//============================================================================= 
{        
        
        
        
        BOOL bResult = FALSE; 
        ILockBytes *Buffer = 0; 
        IStorage   *pStorage = 0; 
        IStream    *FileStream = 0; 
        BYTE       *BufferBytes; 
        STATSTG     BytesStatistics; 
        DWORD       OutData; 
        long        OutStream; 
        CFile       BitmapFile; CFileException e; 
        double      SkipFloat = 0; 
        DWORD       ByteSkip = 0; 
        _ULARGE_INTEGER RealData; 
        
        CreateILockBytesOnHGlobal(NULL, TRUE, &Buffer); // Create ILockBytes Buffer 
        
        HRESULT hr = ::StgCreateDocfileOnILockBytes(Buffer, 
                STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_READWRITE, 0, &pStorage); 
        
        hr = pStorage->CreateStream(L"PICTURE", 
                STGM_SHARE_EXCLUSIVE | STGM_CREATE | STGM_READWRITE, 0, 0, &FileStream); 
        
        m_IPicture->SaveAsFile(FileStream, TRUE, &OutStream); // Copy Data Stream 
        FileStream->Release(); 
        pStorage->Release(); 
        Buffer->Flush(); 
        
        // Get Statistics For Final Size Of Byte Array 
        Buffer->Stat(&BytesStatistics, STATFLAG_NONAME); 
        
        // Cut UnNeeded Data Coming From SaveAsFile() (Leave Only "Pure" Picture Data) 
        SkipFloat = (double(OutStream) / 512); // Must Be In a 512 Blocks... 
        if(SkipFloat > DWORD(SkipFloat)) ByteSkip = (DWORD)SkipFloat + 1; 
        else ByteSkip = (DWORD)SkipFloat; 
        ByteSkip = ByteSkip * 512; // Must Be In a 512 Blocks... 
        
        // Find Difference Between The Two Values 
        ByteSkip = (DWORD)(BytesStatistics.cbSize.QuadPart - ByteSkip); 
        
        // Allocate Only The "Pure" Picture Data 
        RealData.LowPart = 0; 
        RealData.HighPart = 0; 
        RealData.QuadPart = ByteSkip; 
        BufferBytes = (BYTE*)malloc(OutStream); 
        if(BufferBytes == NULL) 
        { 
                Buffer->Release(); 
                HWND hWnd = AfxGetApp()->GetMainWnd()->m_hWnd; 
                MessageBoxEx(hWnd, "Can not allocate enough memory\t", ERROR_TITLE, MB_OK | MB_ICONSTOP, LANG_ENGLISH); 
        } 
        
        Buffer->ReadAt(RealData, BufferBytes, OutStream, &OutData); 
        
        if(BitmapFile.Open(sFilePathName, CFile::typeBinary | CFile::modeCreate | CFile::modeWrite, &e)) 
        { 
                BitmapFile.Write(BufferBytes, OutData); 
                BitmapFile.Close(); 
                bResult = TRUE; 
        } 
        else // Write File Failed... 
        { 
                TCHAR szCause[255]; 
                e.GetErrorMessage(szCause, 255, NULL); 
                HWND hWnd = AfxGetApp()->GetMainWnd()->m_hWnd; 
                MessageBoxEx(hWnd, szCause, ERROR_TITLE, MB_OK | MB_ICONSTOP, LANG_ENGLISH); 
                bResult = FALSE; 
        } 
        
        Buffer->Release(); 
        free(BufferBytes); 
        
        return(bResult); 
}