bool CLotteryDlg::_loadPic(CString strFullPath, PicInfo* picInfo) { try { HANDLE hFile = CreateFile(strFullPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) return false; DWORD dwFileSize = GetFileSize(hFile, NULL); if (-1 == dwFileSize) return false; picInfo->_hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwFileSize); if (picInfo->_hGlobal == NULL) return false; void * pImageMemory = GlobalLock(picInfo->_hGlobal); DWORD dwReadedSize;//保存实际读取的文件的大小 ReadFile(hFile, pImageMemory, dwFileSize, &dwReadedSize, NULL); GlobalUnlock(picInfo->_hGlobal); CloseHandle(hFile); IStream* pIStream;//创建一个ISTream接口指针,保存图片流 IPicture* pIPicture;//创建一个IPicture接口指针,表示图片对象 if (S_OK != CreateStreamOnHGlobal(picInfo->_hGlobal, false, &pIStream))//用全局内存初始化IStream接口指针 return false; if (S_OK != OleLoadPicture(pIStream, 0, false, IID_IPicture, (LPVOID*)&(pIPicture)))//用OleLoadPicture获得IPicture接口指针 { ::GlobalFree(picInfo->_hGlobal); pIStream->Release(); return false; } //得到IPicture COM接口对象后,就可以进行获得图片信息,显示图片等操作 pIPicture->get_Width(&picInfo->_cx); pIPicture->get_Height(&picInfo->_cy); picInfo->_iStream = pIStream; picInfo->_iPic = pIPicture; picInfo->_x = picInfo->_y = 0; picInfo->_strFilePath = strFullPath; } catch (...) { return false; } return true; }
IPicture* CEnBitmap::LoadFromBuffer(BYTE* pBuff, int nSize) { HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize); void* pData = GlobalLock(hGlobal); memcpy2(pData, pBuff, nSize); GlobalUnlock(hGlobal); IStream* pStream = NULL; IPicture* pPicture = NULL; if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK) { OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID *)&pPicture); pStream->Release(); } return pPicture; // caller releases }
HRESULT SavePropertyStoreToString(IPropertyStore *pps, PWSTR *ppszBase64) { *ppszBase64 = NULL; IStream *pstm; HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pstm); if (SUCCEEDED(hr)) { hr = SavePropertyStoreToStream(pps, pstm); if (SUCCEEDED(hr)) { IStream_Reset(pstm); hr = GetBase64StringFromStream(pstm, ppszBase64); } pstm->Release(); } return hr; }
bool FileStorage::SaveFile(FileEntry& fileEntry, const IStream& sourceStream) { IStream* stream = WriteFileHelper(fileEntry, FileOpenMode::DestoryWriteOrCreate, FileDataType::Binary); RETURN_FALSE_IF_NULL(stream); sourceStream.CopyTo(*stream); SAFE_RELEASE(stream); return true; }
inline void LoadGdiplusImage(const void *mem, size_t len, const FuncT &func) { HGLOBAL hGlobal = ::GlobalAlloc(GMEM_MOVEABLE, len); void *pData = ::GlobalLock(hGlobal); memcpy(pData, mem, len); ::GlobalUnlock(hGlobal); IStream *pStream = NULL; if( ::CreateStreamOnHGlobal(hGlobal,TRUE, &pStream) == S_OK ) { std::auto_ptr<Bitmap> bm(Bitmap::FromStream(pStream)); func(bm.get()); pStream->Release(); } ::GlobalFree(hGlobal); }
BOOL GdiPlusPicDrawer::CreateImageFromHGlobal(HGLOBAL hBuffer) { ASSERT(hBuffer != NULL); IStream* pStream = NULL; if (::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream) == S_OK) { m_pImage = Gdiplus::Bitmap::FromStream(pStream); Status lastStatus = m_pImage->GetLastStatus(); pStream->Release(); if (m_pImage != NULL && lastStatus == Ok) return TRUE; TRACE(_T("@1 GdiPlusPicDrawer::CreateImageFromHGlobal. Bitmap::FromStream failed :%d\r\n"), lastStatus); } else TRACE(_T("@1 GdiPlusPicDrawer::CreateImageFromHGlobal. CreateStreamOnHGlobal failed\r\n")); Destroy(); return FALSE; }
void applyPatchfile(string fname) { IStream *f = new IFStream(fname); Injectable_IStream f2(*f); if (((IFStream*)f)->bad()) { fprintf(stderr, "file is missing: %s\n", fname.c_str()); exit(1); } unsigned type = determine_filetype(f2); delete f; switch (type) { case GZIP: f = new GZ_IFStream(fname); break; case BZIP2: f = new BZ_IFStream(fname); break; case DTU: f = new IFStream(fname); break; case UNKNOWN_FMT: fprintf(stderr, "cannot read file %s\n", fname.c_str()); exit(1); case TARBALL : f = new IFStream(fname); unsigned zero_count; zero_count = 0; char tarheader[512]; do { f->read(tarheader, 512); if (tarheader[0]==0) ++zero_count; int size = read_ascii_octal(tarheader+124); if (size) { string fileName = getTmpFilename(); { OFStream o(fileName); copy_bytes_to_file(*f, o, size); } applyPatchfile(fileName); doneTmpFile(fileName); unsigned lastblocksize = size % 512; if (lastblocksize==0) lastblocksize=512; f->read(tarheader, 512 - lastblocksize); } } while (zero_count < 2); return; } Injectable_IStream infile(*f); type = determine_filetype(infile); if (type==DTU) patchPackage(infile); else applyPatchfile(infile); }
HRESULT CWavDestFilter::StopStreaming() { IStream* pStream; if (m_pOutput->IsConnected() == FALSE) { return E_FAIL; } IPin* pDwnstrmInputPin = m_pOutput->GetConnected(); if (!pDwnstrmInputPin) { return E_FAIL; } HRESULT hr = ((IMemInputPin*) pDwnstrmInputPin)->QueryInterface(IID_IStream, (void**)&pStream); if (SUCCEEDED(hr)) { BYTE* pb = (BYTE*)_alloca(m_cbHeader); RIFFLIST* pRiffWave = (RIFFLIST*)pb; RIFFCHUNK* pRiffFmt = (RIFFCHUNK*)(pRiffWave + 1); RIFFCHUNK* pRiffData = (RIFFCHUNK*)(((BYTE*)(pRiffFmt + 1)) + m_pInput->CurrentMediaType().FormatLength()); pRiffData->fcc = FCC('data'); pRiffData->cb = m_cbWavData; pRiffFmt->fcc = FCC('fmt '); pRiffFmt->cb = m_pInput->CurrentMediaType().FormatLength(); CopyMemory(pRiffFmt + 1, m_pInput->CurrentMediaType().Format(), pRiffFmt->cb); pRiffWave->fcc = FCC('RIFF'); pRiffWave->cb = m_cbWavData + m_cbHeader - sizeof(RIFFCHUNK); pRiffWave->fccListType = FCC('WAVE'); LARGE_INTEGER li; ZeroMemory(&li, sizeof(li)); hr = pStream->Seek(li, STREAM_SEEK_SET, 0); if (SUCCEEDED(hr)) { hr = pStream->Write(pb, m_cbHeader, 0); } pStream->Release(); } return hr; }
bool NewGUI_ExtractVistaIcon(const std::vector<BYTE>& v, Bitmap** pOutBmp) { if(pOutBmp == NULL) { ASSERT(FALSE); return false; } *pOutBmp = NULL; const size_t SizeICONDIR = 6; const size_t SizeICONDIRENTRY = 16; if(v.size() < SizeICONDIR) { ASSERT(FALSE); return false; } const size_t cImages = *(WORD *)&v[4]; for(size_t i = 0; i < cImages; ++i) { const BYTE bWidth = v[SizeICONDIR + (i * SizeICONDIRENTRY)]; const BYTE bHeight = v[SizeICONDIR + (i * SizeICONDIRENTRY) + 1]; const WORD wBitCount = *(WORD *)&v[SizeICONDIR + (i * SizeICONDIRENTRY) + 6]; if((bWidth == 0) && (bHeight == 0) && (wBitCount == 32)) { const size_t uSize = *(size_t *)&v[SizeICONDIR + (i * SizeICONDIRENTRY) + 8]; const size_t uOffset = *(size_t *)&v[SizeICONDIR + (i * SizeICONDIRENTRY) + 12]; IStream* pStream = NULL; if(FAILED(CreateStreamOnHGlobal(NULL, TRUE, &pStream))) { ASSERT(FALSE); return false; } if(pStream == NULL) { ASSERT(FALSE); return false; } VERIFY(SUCCEEDED(pStream->Write(&v[uOffset], static_cast<ULONG>(uSize), NULL))); LARGE_INTEGER liMove; ZeroMemory(&liMove, sizeof(LARGE_INTEGER)); VERIFY(SUCCEEDED(pStream->Seek(liMove, STREAM_SEEK_SET, NULL))); *pOutBmp = Bitmap::FromStream(pStream, FALSE); pStream->Release(); return (*pOutBmp != NULL); } } return false; }
uint32 GetPosition() const { check(IsOpen()); ULARGE_INTEGER ulgint; LARGE_INTEGER lgint; lgint.QuadPart = 0; HRESULT hr = m_pStream->Seek(lgint,STREAM_SEEK_CUR,&ulgint); check(hr == S_OK); return (uint32)ulgint.QuadPart; }
std::vector<BYTE> NewGUI_SaveIcon(HICON hIcon) { std::vector<BYTE> v; if(hIcon == NULL) { ASSERT(FALSE); return v; } IStream* pStream = NULL; if(FAILED(CreateStreamOnHGlobal(NULL, TRUE, &pStream))) { ASSERT(FALSE); return v; } if(pStream == NULL) { ASSERT(FALSE); return v; } PICTDESC pd; ZeroMemory(&pd, sizeof(PICTDESC)); pd.cbSizeofstruct = sizeof(PICTDESC); pd.picType = PICTYPE_ICON; pd.icon.hicon = hIcon; IPicture* pPic = NULL; LONG lSize = 0; bool bPic = SUCCEEDED(OleCreatePictureIndirect(&pd, IID_IPicture, FALSE, (LPVOID *)&pPic)); bPic &= (pPic != NULL); if(bPic) { if(SUCCEEDED(pPic->SaveAsFile(pStream, TRUE, &lSize))) { LARGE_INTEGER liMove; ZeroMemory(&liMove, sizeof(LARGE_INTEGER)); VERIFY(SUCCEEDED(pStream->Seek(liMove, STREAM_SEEK_SET, NULL))); v.resize(static_cast<size_t>(lSize)); ULONG cbRead = 0; VERIFY(SUCCEEDED(pStream->Read(&v[0], static_cast<ULONG>( lSize), &cbRead))); if(cbRead == static_cast<ULONG>(lSize)) { } // Success else { ASSERT(FALSE); v.clear(); } } pPic->Release(); } pStream->Release(); return v; }
HRESULT CPicStatic::ShowJpeg(LPVOID picData,DWORD dwFileSize,int x, int y,CDC *pDC) { IStream *pStm; IPicture *pPic; BOOL bResult; HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwFileSize); LPVOID pvData = NULL; if (hGlobal == NULL) return false; pvData = GlobalLock(hGlobal); if ( pvData == NULL) return false; memcpy(pvData,picData,dwFileSize); GlobalUnlock(hGlobal); CreateStreamOnHGlobal(hGlobal, TRUE, &pStm); bResult=OleLoadPicture(pStm,dwFileSize,TRUE,IID_IPicture,(LPVOID*)&pPic); if(FAILED(bResult)) { // CloseHandle(hFile); return false; } OLE_XSIZE_HIMETRIC hmWidth; OLE_YSIZE_HIMETRIC hmHeight; pPic->get_Width(&hmWidth); pPic->get_Height(&hmHeight); //将图形输出到屏幕上(有点像BitBlt) bResult=pPic->Render(pDC->m_hDC,0,0,x,y,0,hmHeight,hmWidth,-hmHeight,NULL); // CloseHandle(hFile); pStm->Release(); pPic->Release(); if (SUCCEEDED(bResult)) { return S_OK; } else { return E_FAIL; } }
void CInProcPlugHole::ReleasePeer() { if (m_piMarshalledPeer != NULL) { IStream* piStream = m_piMarshalledPeer; m_piMarshalledPeer = NULL; m_dwVMStarterId = 0; ::ResetEvent(m_hPeerAvailable); m_mapPeers.clear(); // Unmarshall it one last time to release it LARGE_INTEGER pos; pos.QuadPart = 0; piStream->Seek(pos, STREAM_SEEK_SET, NULL); IIPDolphinPtr piPeer; HRESULT hr = ::CoGetInterfaceAndReleaseStream(piStream, __uuidof(IIPDolphin), reinterpret_cast<void**>(&piPeer)); } }
//----------------------------------------------------------------------------- // Does: Read The Picture Data From a Source (File / Resource) // ~~~~ And Load It Into The Current IPicture Object In Use // // InPut: Buffer Of Data Source (File / Resource) And Its Size // ~~~~~ // // OutPut: Feed The IPicture Object With The Picture Data // ~~~~~~ (Use Draw Functions To Show It On a Device Context) // TRUE If Succeeded... //----------------------------------------------------------------------------- BOOL CPicViewer::LoadPictureData(BYTE *pBuffer, int nSize) //============================================================================= { BOOL bResult = FALSE; HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize); if(hGlobal == NULL) { TRACE( "Can not allocate enough memory\n" ); // HWND hWnd = AfxGetApp()->GetMainWnd()->m_hWnd; // MessageBoxEx(hWnd, "Can not allocate enough memory\t", ERROR_TITLE, MB_OK | MB_ICONSTOP, LANG_ENGLISH); return(FALSE); } void* pData = GlobalLock(hGlobal); memcpy(pData, pBuffer, nSize); GlobalUnlock(hGlobal); IStream* pStream = NULL; if(CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK) { HRESULT hr; if((hr = OleLoadPicture(pStream, nSize, FALSE, IID_IPicture, (LPVOID *)&m_IPicture)) == E_NOINTERFACE) { TRACE( "IPicture interface is not supported\n" ); // HWND hWnd = AfxGetApp()->GetMainWnd()->m_hWnd; // MessageBoxEx(hWnd, "IPicture interface is not supported\t", ERROR_TITLE, MB_OK | MB_ICONSTOP, LANG_ENGLISH); return(FALSE); } else // S_OK { pStream->Release(); pStream = NULL; bResult = TRUE; } } FreeResource(hGlobal); // 16Bit Windows Needs This (32Bit - Automatic Release) return(bResult); }
BOOL CDuiImgX::LoadFromMemory( LPVOID pBuf,DWORD dwSize ) { assert(m_pImg==NULL); HGLOBAL hMem = ::GlobalAlloc(GMEM_FIXED, dwSize); BYTE* pMem = (BYTE*)::GlobalLock(hMem); memcpy(pMem, pBuf, dwSize); IStream* pStm = NULL; ::CreateStreamOnHGlobal(hMem, TRUE, &pStm); m_pImg = Gdiplus::Image::FromStream(pStm); pStm->Release(); ::GlobalUnlock(hMem); // GlobalFree(hMem); return m_pImg!=NULL; }
Bitmap* GetImageFromBase64(string encodedImage) { int imageSize = int((encodedImage.length()/3)+1)*4; char* t=new char[imageSize]; base64_decode(encodedImage.c_str(),encodedImage.length(), t, &imageSize); // using the base64 HGLOBAL hMem = ::GlobalAlloc(GMEM_MOVEABLE, imageSize); LPVOID pImage = ::GlobalLock(hMem); memcpy(pImage, t, imageSize); IStream* pStream = NULL; ::CreateStreamOnHGlobal(hMem, FALSE, &pStream); Bitmap *img = new Bitmap(pStream); pStream->Release(); GlobalUnlock(hMem); GlobalFree(hMem); delete []t; return img; }
// iFileI interface implementation uint32 Seek(sint32 pos, SeekMode smode = FSEEK_SET) { check(IsOpen()); LARGE_INTEGER lgint; ULARGE_INTEGER newPos; lgint.QuadPart = pos; HRESULT hr = m_pStream->Seek(lgint,smode,&newPos); check(hr == S_OK); if ( hr == S_OK ) return newPos.LowPart; else return ~0UL; }
// This code was also brazenly stolen from the DX9 SDK // Pass it a file name in wszPath, and it will save the filter graph to that file. HRESULT SaveGraphFile(IGraphBuilder *pGraph, WCHAR *wszPath) { const WCHAR wszStreamName[] = L"ActiveMovieGraph"; HRESULT hr; IStorage *pStorage = NULL; // First, create a document file which will hold the GRF file hr = StgCreateDocfile( wszPath, STGM_CREATE | STGM_TRANSACTED | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStorage); if(FAILED(hr)) { return hr; } // Next, create a stream to store. IStream *pStream; hr = pStorage->CreateStream( wszStreamName, STGM_WRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream); if (FAILED(hr)) { pStorage->Release(); return hr; } // The IPersistStream converts a stream into a persistent object. IPersistStream *pPersist = NULL; pGraph->QueryInterface(IID_IPersistStream, reinterpret_cast<void**>(&pPersist)); hr = pPersist->Save(pStream, TRUE); pStream->Release(); pPersist->Release(); if (SUCCEEDED(hr)) { hr = pStorage->Commit(STGC_DEFAULT); } pStorage->Release(); return hr; }
Bitmap* BitmapFromResource(HINSTANCE hInstance, LPCTSTR strID, LPCTSTR strType /* = _T("PNG") */) { Bitmap* pResult = NULL; HRSRC hResource = FindResource(hInstance, strID, strType); if (hResource != NULL) { DWORD nSize = SizeofResource(hInstance, hResource); HANDLE hResourceMem = LoadResource(hInstance, hResource); BYTE* pData = (BYTE*)LockResource(hResourceMem); if (pData != NULL) { HGLOBAL hBuffer = GlobalAlloc(GMEM_MOVEABLE, nSize); if (hBuffer != NULL) { void* pBuffer = GlobalLock(hBuffer); if (pBuffer != NULL) { CopyMemory(pBuffer, pData, nSize); GlobalUnlock(hBuffer); IStream* pStream = NULL; if (SUCCEEDED(CreateStreamOnHGlobal(hBuffer, TRUE, &pStream))) { pResult = Bitmap::FromStream(pStream); pStream->Release(); } else GlobalFree(hBuffer); } else GlobalFree(hBuffer); } } } return pResult; }
void HostResourceLoader::loadFromPNG( BuiltFromResourcePixMap& item ) { HRSRC x = ::FindResourceA( NULL, item.resourceName, "PNG" ); ProductionAssert(x,item.resourceName); DWORD n = SizeofResource( NULL, x); Assert(n); HGLOBAL g = ::LoadResource( NULL, x ); Assert(g); const void* r=LockResource(g); Assert(r!=NULL); HGLOBAL buf = ::GlobalAlloc(GMEM_MOVEABLE, n); Assert(buf); char* png = (char*)::GlobalLock(buf); Assert(png); memcpy(png,r,n); // Following assertion check that it is a PNG resource. Assert(memcmp(png+1,"PNG",3)==0 ); IStream* s = NULL; HRESULT streamCreationStatus = CreateStreamOnHGlobal(buf,FALSE,&s); Assert( streamCreationStatus==S_OK ); Assert(s); Gdiplus::Bitmap* bitmap = Gdiplus::Bitmap::FromStream(s,FALSE); ProductionAssert(bitmap,"Gdiplus::Bitmap::FromStream returned false"); Gdiplus::Status fromStreamStatus = bitmap->GetLastStatus(); ProductionAssert(fromStreamStatus==Gdiplus::Ok,"Gdiplus::Bitmap::FromStream failed"); s->Release(); ::GlobalUnlock(buf); ::GlobalFree(buf); int w=bitmap->GetWidth(); int h=bitmap->GetHeight(); const Gdiplus::Rect rect(0,0,w,h); Gdiplus::BitmapData lockedBits; Gdiplus::Status lockStatus = bitmap->LockBits(&rect,0,PixelFormat32bppARGB,&lockedBits); Assert( lockStatus==Gdiplus::Ok); NimblePixMap map(w,h,8*sizeof(NimblePixel),lockedBits.Scan0,lockedBits.Stride); item.buildFrom(map); Gdiplus::Status unlockStatus = bitmap->UnlockBits(&lockedBits); delete bitmap; Assert(unlockStatus==Gdiplus::Ok); return; }
void Win32WebControl::_loadHTMLString(const std::string &html) const { bool flag = false; HGLOBAL htmlText = globalAllocWstringFromString(html); if (htmlText != NULL) { IStream *stream = NULL; if (SUCCEEDED(CreateStreamOnHGlobal(htmlText, FALSE, &stream))) { IPersistStreamInit *persistStreamInit = NULL; if (SUCCEEDED(_htmlDoc->QueryInterface(IID_IPersistStreamInit, (void **)&persistStreamInit))) { if (SUCCEEDED(persistStreamInit->InitNew()) && SUCCEEDED(persistStreamInit->Load(stream))) { flag = true; } persistStreamInit->Release(); } stream->Release(); } GlobalFree(htmlText); } if (flag) { if (_didFinishLoading != nullptr) { std::string str("data:text/html,"); str.append(html); _didFinishLoading(str); } } else { if (_didFailLoading != nullptr) { std::string str("data:text/html,"); str.append(html); _didFailLoading(str); } } }
// 从内存中加载图片文件 BOOL LoadImageFromMem(BYTE* pByte, DWORD dwSize, BOOL useEmbeddedColorManagement, Image*& pImg) { // 根据文件大小分配HGLOBAL内存 HGLOBAL hGlobal = GlobalAlloc( GMEM_MOVEABLE | GMEM_NODISCARD, dwSize ); if ( !hGlobal ) { TRACE( _T( "Load (file): Error allocating memory\n" ) ); pImg = NULL; return FALSE; }; char *pData = reinterpret_cast<char*>(GlobalLock(hGlobal)); if ( !pData ) { TRACE( _T( "Load (file): Error locking memory\n" ) ); GlobalFree( hGlobal ); pImg = NULL; return FALSE; }; // 将文件内容读到HGLOBAL内存中 memcpy(pData, pByte, dwSize); GlobalUnlock( hGlobal ); // 利用hGlobal内存中的数据创建stream IStream *pStream = NULL; if ( CreateStreamOnHGlobal( hGlobal, TRUE, &pStream ) != S_OK ) { pImg = NULL; return FALSE; } pImg = Gdiplus::Image::FromStream( pStream, useEmbeddedColorManagement ); // 要加上这一句,否则由GlobalAlloc得来的hGlobal内存没有被释放,导致内存泄露,由于 // CreateStreamOnHGlobal第二个参数被设置为TRUE,所以调用pStream->Release()会自动 // 将hGlobal内存(参见msdn对CreateStreamOnHGlobal的说明) pStream->Release(); return TRUE; }
int ReadStreamFunc(void* ptr, uint8_t* buf, int buf_size) { IStream* pFileStream = (IStream*)ptr; ULONG bytesRead = 0; HRESULT hr = pFileStream->Read(buf, buf_size, &bytesRead); if (FAILED(hr)) { return -1; } // If we succeed but don't have any bytes, assume end of file if (bytesRead == 0) { return AVERROR_EOF; // Let FFmpeg know that we have reached eof } return (int)bytesRead; }
size_t IStream::CopyTo(IStream& dest, size_t bufferSize/*=1024*/)const { RETURN_ZERO_IF_FALSE(CanRead() && dest.CanWrite()); size_t realBufferSize = Math::Min(LeftLength(), bufferSize); size_t count = 0; MemoryData buffer = MemoryData::Alloc(realBufferSize); do { size_t readSize = ReadDataTo(buffer, DataReadingMode::AlwaysCopy); BREAK_IF_ZERO(readSize); buffer.ForceSetSize(readSize); count += dest.WriteData(buffer); buffer.ForceSetSize(realBufferSize); } while (true); return count; }
/** * 音声入力コールバック * @param hwi 音声入力ハンドル * @param uMsg コマンド * @param dwParam1 パラメータ1 * @param dwParam1 パラメータ2 */ void waveIn(HWAVEIN hwi, UINT uMsg, DWORD dwParam1, DWORD dwParam2) { /* イベント処理 */ switch(uMsg){ case WIM_DATA: { LPWAVEHDR lpwvhdr = (LPWAVEHDR) dwParam1; ULONG s; wvout->Write(lpwvhdr->lpData, lpwvhdr->dwBufferLength, &s); } break; } }
int SSkinGif::LoadFromMemory( LPVOID pBuf,size_t dwSize ) { HGLOBAL hMem = ::GlobalAlloc(GMEM_FIXED, dwSize); BYTE* pMem = (BYTE*)::GlobalLock(hMem); memcpy(pMem, pBuf, dwSize); IStream* pStm = NULL; ::CreateStreamOnHGlobal(hMem, TRUE, &pStm); Gdiplus::Bitmap *pImg = Gdiplus::Bitmap::FromStream(pStm); if(!pImg || pImg->GetLastStatus() != Gdiplus::Ok) { pStm->Release(); ::GlobalUnlock(hMem); return 0; } LoadFromGdipImage(pImg); delete pImg; return m_nFrames; }
// 从内存加载图片 BOOL ReadImage(const BYTE* buffer, ULONG size, CImage& img) { // 创建流 HGLOBAL m_hMem = GlobalAlloc(GMEM_FIXED, size); BYTE* pmem = (BYTE*)GlobalLock(m_hMem); if (pmem == NULL) return FALSE; memcpy(pmem, buffer, size); IStream* pstm; CreateStreamOnHGlobal(m_hMem, FALSE, &pstm); // 加载到CImage if (!img.IsNull()) img.Destroy(); img.Load(pstm); // 释放流 GlobalUnlock(m_hMem); pstm->Release(); return !img.IsNull(); }
// **************************************************************************** void CStaticStringMapper::serial(IStream &f, std::vector<TSStringId> &strIdVect) throw(EStream) { std::vector<std::string> vsTmp; std::string sTmp; // Serialize class components. if (f.isReading()) { f.serialCont(vsTmp); strIdVect.resize(vsTmp.size()); for(uint i = 0; i < vsTmp.size(); ++i) strIdVect[i] = add(vsTmp[i]); } else { vsTmp.resize(strIdVect.size()); for (uint i = 0; i < vsTmp.size(); ++i) vsTmp[i] = get(strIdVect[i]); f.serialCont(vsTmp); } }
int Image::Save(Memory<char>& mem,LPCWSTR type,long quality){ if(_image==0) return 0; CLSID clsid; //未知原因,如果不用一个变量转换一下,type是一个常量字串的话,如果把 type 直接传给 GetImageEncoderClsid 会引起程序崩溃。 //wchar_t tp[256]; //这样也不行。 //cs::WcsCopy(tp,type); cs::String tp = type; if(!GetImageEncoderClsid(tp,&clsid)) return 0; if(quality>100) quality = 100; if(quality<0) quality = 0; Gdiplus::EncoderParameters eps; eps.Count = 1; eps.Parameter[0].Guid = Gdiplus::EncoderQuality; eps.Parameter[0].NumberOfValues = 1; eps.Parameter[0].Type = Gdiplus::EncoderParameterValueTypeLong; eps.Parameter[0].Value = &quality; IStream* stream; if(FAILED(CreateStreamOnHGlobal(0,1,&stream))) return 0; if(((_Image*)_image)->Save(stream,&clsid,&eps)!=0) return 0; ULONG ws = 0; LARGE_INTEGER li; ULARGE_INTEGER npos; li.QuadPart = 0; stream->Seek(li,STREAM_SEEK_END,&npos); if(mem.Length()<npos.LowPart){ mem.SetUseSysMemory(1); if(!mem.SetLength(npos.LowPart)) return 0; } stream->Seek(li,STREAM_SEEK_SET,0); HRESULT ret = stream->Read(mem.Handle(),mem.Length(),&ws); stream->Release(); if(FAILED(ret)) return 0; return ws; }
int CBaseOperation::saveToJpeg(AVFrame *pFrame, int width, int height, char *buffer, int bufferSize){ GdiplusInit gdiplusinit; CLSID imgClsid; int encoderClsid = GetGdiplusEncoderClsid(L"image/jpeg", &imgClsid); auto image = std::make_unique<Gdiplus::Bitmap>(width, height, pFrame->linesize[0], PixelFormat32bppRGB, pFrame->data[0]); if (encoderClsid != -1){ IStream *stream; CreateStreamOnHGlobal(nullptr, TRUE, static_cast<LPSTREAM*>(&stream)); if (image->Save(stream, &imgClsid) == Gdiplus::Ok){ STATSTG statstg; stream->Stat(&statstg, STATFLAG_DEFAULT); ULARGE_INTEGER streamSize = statstg.cbSize; LARGE_INTEGER zero; zero.QuadPart = 0; if (bufferSize >= streamSize.QuadPart){ stream->Seek(zero, STREAM_SEEK_SET, nullptr); stream->Read(buffer, streamSize.QuadPart, nullptr); stream->Release(); return streamSize.QuadPart; } stream->Release(); return streamSize.QuadPart*(-1); } return 3; } return 3; }