コード例 #1
0
ファイル: LotteryDlg.cpp プロジェクト: u-stone/code-database
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;
}
コード例 #2
0
ファイル: EnBitmap.cpp プロジェクト: rusingineer/EmulePlus
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
}
コード例 #3
0
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;
}
コード例 #4
0
ファイル: FileStorage.cpp プロジェクト: johndpope/Medusa
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;
}
コード例 #5
0
	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);
	}
コード例 #6
0
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;
}
コード例 #7
0
ファイル: deltup.cpp プロジェクト: jjwhitney/Deltup
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);
}
コード例 #8
0
ファイル: WavDest.cpp プロジェクト: Gongong/mpc-hc
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;
}
コード例 #9
0
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;
}
コード例 #10
0
ファイル: gxl.file.cpp プロジェクト: Reynmar/pocketheroes
	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;
	}
コード例 #11
0
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;
}
コード例 #12
0
ファイル: PicStatic.cpp プロジェクト: Halry/ZTE-windows
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;     
	}   
}
コード例 #13
0
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));
	}
}
コード例 #14
0
ファイル: picviewer.cpp プロジェクト: idandan/DrawLaneDemo
//-----------------------------------------------------------------------------
// 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);
}
コード例 #15
0
ファイル: duiimage.cpp プロジェクト: Johnny-Martin/ComBase
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;
}
コード例 #16
0
ファイル: system.cpp プロジェクト: AlloyTeam/webtop
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;
}
コード例 #17
0
ファイル: gxl.file.cpp プロジェクト: Reynmar/pocketheroes
	// 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;	
	}
コード例 #18
0
// 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;
}
コード例 #19
0
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;
}
コード例 #20
0
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;
}
コード例 #21
0
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);
        }
    }
}
コード例 #22
0
// 从内存中加载图片文件
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;
}
コード例 #23
0
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;
}
コード例 #24
0
ファイル: IStream.cpp プロジェクト: fjz13/Medusa
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;
}
コード例 #25
0
ファイル: Main.cpp プロジェクト: xmoeproject/X-moe
	/**
	 * 音声入力コールバック
	 * @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;
		}
	}
コード例 #26
0
ファイル: SSkinGif.cpp プロジェクト: 3rdexp/soui
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;
}
コード例 #27
0
ファイル: ScanImage.cpp プロジェクト: PlutoLuna/TiebaManager
// 从内存加载图片
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();
}
コード例 #28
0
// ****************************************************************************
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);

	}
}
コード例 #29
0
ファイル: img.cpp プロジェクト: pgmsoul/GitLib
	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;
	}
コード例 #30
0
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;
}