How Display bitmap data (a variable, not a file) into a Picture Box with MFC or WIN32 ?

    int h = 256
    int w = 256;
 
    BITMAPINFO bmi;
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biHeight = - h;
    bmi.bmiHeader.biWidth =  w;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 24;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biSizeImage = bmi.bmiHeader.biHeight * bmi.bmiHeader.biWidth * 4;
    
    HDC hdc2 = CreateCompatibleDC(NULL);
 
    VOID *pvbits;
 
    HBITMAP hbitmap = CreateDIBSection(NULL,&bmi,DIB_RGB_COLORS,&pvbits,NULL,0x0);
  

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

#include <atlimage.h>
#include <Gdiplusimaging.h>
//bitmap below is CBitmap
CImage image;
image.Attach(bitmap);
image.Save(_T("C:\\test.bmp"), Gdiplus::ImageFormatBMP);
                                              

1:
2:
3:
4:
5:
6:

bool CCam_confDlg::DisplayImage() 
{
	  capture_ok=false;	
 
	  if (eventsavedlgdc)
	  { 
	    	::DeleteObject(eventsavedlgdc);
	  }
 
	eventsavedlgdc = (HBITMAP)::LoadImage(NULL,"readframes01.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);//OK
 
	  CBitmap bmp;
	  bmp.Attach(eventsavedlgdc);
	  BITMAP bm;
	  bmp.GetBitmap(&bm);  
	  bmp.Detach(); 
 
	  HDC hdc=::GetDC(m_Picture.m_hWnd);
	  HDC memdc=::CreateCompatibleDC(hdc);
	  HBITMAP hBmp2=(HBITMAP)SelectObject(memdc,eventsavedlgdc);
  
 
	  SetStretchBltMode(hdc,COLORONCOLOR);  //For better quality
      StretchBlt(hdc,0,0,rectW,rectH,memdc,0,0,752,480,SRCCOPY); 
 
      DeleteDC(hdc);
      DeleteDC(memdc);
 
	  if(eventsavedlgdc)
	  {
			m_Picture.SetBitmap(hBmp2);
			DeleteDC(hMemDC);
			DeleteObject(eventsavedlgdc);
	  }
 
	  capture_ok=true;
	  return FALSE;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

Copy Code 
void CreateBMPFile(HWND hwnd, LPTSTR pszFile, PBITMAPINFO pbi, 
                  HBITMAP hBMP, HDC hDC) 
 { 
     HANDLE hf;                 // file handle  
    BITMAPFILEHEADER hdr;       // bitmap file-header  
    PBITMAPINFOHEADER pbih;     // bitmap info-header  
    LPBYTE lpBits;              // memory pointer  
    DWORD dwTotal;              // total count of bytes  
    DWORD cb;                   // incremental count of bytes  
    BYTE *hp;                   // byte pointer  
    DWORD dwTmp; 
 
    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
 
    if (!lpBits) 
         errhandler("GlobalAlloc", hwnd); 
 
    // Retrieve the color table (RGBQUAD array) and the bits  
    // (array of palette indices) from the DIB.  
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS)) 
    {
        errhandler("GetDIBits", hwnd); 
    }
 
    // Create the .BMP file.  
    hf = CreateFile(pszFile, 
                   GENERIC_READ | GENERIC_WRITE, 
                   (DWORD) 0, 
                    NULL, 
                   CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL); 
    if (hf == INVALID_HANDLE_VALUE) 
        errhandler("CreateFile", hwnd); 
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"  
    // Compute the size of the entire file.  
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
                 pbih->biSize + pbih->biClrUsed 
                 * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 
 
    // Compute the offset to the array of color indices.  
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    pbih->biSize + pbih->biClrUsed 
                    * sizeof (RGBQUAD); 
 
    // Copy the BITMAPFILEHEADER into the .BMP file.  
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)) 
    {
       errhandler("WriteFile", hwnd); 
    }
 
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file.  
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
                  + pbih->biClrUsed * sizeof (RGBQUAD), 
                  (LPDWORD) &dwTmp, ( NULL)))
        errhandler("WriteFile", hwnd); 
 
    // Copy the array of color indices into the .BMP file.  
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)) 
           errhandler("WriteFile", hwnd); 
 
    // Close the .BMP file.  
     if (!CloseHandle(hf)) 
           errhandler("CloseHandle", hwnd); 
 
    // Free memory.  
    GlobalFree((HGLOBAL)lpBits);
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:

#include <atlimage.h>
#include <Gdiplusimaging.h>
//here is the implamentation of the class
void Save(CBitmap& bmp)
{
  CImage image;
  image.Attach(bmp);
  image.Save("readframes01.bmp", Gdiplus::ImageFormatBMP); 
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:

//GLOBAL VARIABLES
FILE * fpWrite; 
void * buffer;    
long lSizeOfFile = -1;	
 
 
//CODE	
fpWrite=fopen("test.bmp", "rb");
// get the file size
fseek (fpWrite , 0 , SEEK_END);
lSizeOfFile = ftell (fpWrite);
rewind (fpWrite);
// allocate memory to contain the whole file.
buffer = (char*) malloc (lSizeOfFile);
// read the file into the buffer. 
fread (buffer,1,lSizeOfFile,fpWrite);    
 
 
//TEST THE CONTAIN OF BUFFER
//display contain of the buffer 
CString FullName =buffer;
m_label_buffer.SetWindowText(FullName);
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

BOOL WriteWindowToDIB( LPTSTR szFile, CWnd *pWnd )
{
	CBitmap 	bitmap;
	CWindowDC	dc(pWnd);
	CDC 		memDC;
	CRect		rect;
 
	memDC.CreateCompatibleDC(&dc);
 
	pWnd->GetWindowRect(rect);
 
	bitmap.CreateCompatibleBitmap(&dc, rect.Width(),rect.Height() );
 
	CBitmap* pOldBitmap = memDC.SelectObject(&bitmap);
	memDC.BitBlt(0, 0, rect.Width(),rect.Height(), &dc, 0, 0, SRCCOPY);
 
	// Create logical palette if device support a palette
	CPalette pal;
	if( dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE )
	{
		UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256);
		LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
		pLP->palVersion = 0x300;
 
		pLP->palNumEntries =
			GetSystemPaletteEntries( dc, 0, 255, pLP->palPalEntry );
 
		// Create the palette
		pal.CreatePalette( pLP );
 
		delete[] pLP;
	}
 
	memDC.SelectObject(pOldBitmap);
 
	// Convert the bitmap to a DIB
	HANDLE hDIB = DDBToDIB( bitmap, BI_RGB, &pal );
 
	if( hDIB == NULL )
		return FALSE;
 
	//char *buff;
	// Write it to file
	//WriteDIB( szFile, hDIB );
	WriteDIBnew( szFile, hDIB );
	// Free the memory allocated by DDBToDIB for the DIB
	GlobalFree( hDIB );
	return TRUE;
}
 
 
 
 
// WriteDIB		- Writes a DIB to file
// Returns		- TRUE on success
// szFile		- Name of file to write to
// hDIB			- Handle of the DIB
BOOL WriteDIB( LPTSTR szFile, HANDLE hDIB)
{
	BITMAPFILEHEADER	hdr;
	LPBITMAPINFOHEADER	lpbi;
 
	if (!hDIB)
		return FALSE;
 
	CFile file;
	if( !file.Open( szFile, CFile::modeWrite|CFile::modeCreate) )
		return FALSE;
 
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	int nColors = 1 << lpbi->biBitCount;
 
	// Fill in the fields of the file header 
	hdr.bfType		= ((WORD) ('M' << 8) | 'B');	// is always "BM"
	hdr.bfSize		= GlobalSize (hDIB) + sizeof( hdr );
	hdr.bfReserved1 	= 0;
	hdr.bfReserved2 	= 0;
	hdr.bfOffBits		= (DWORD) (sizeof( hdr ) + lpbi->biSize +
						nColors * sizeof(RGBQUAD));
 
	// Write the file header 
	file.Write( &hdr, sizeof(hdr) );
 
	// Write the DIB header and the bits 
	file.Write( lpbi, GlobalSize(hDIB) );
	
	file.Close(); //
	return TRUE;
}
 
 
//test new to change destination (not to a file but into memory)
BOOL WriteDIBnew( void* buf, HANDLE hDIB)
{
	BITMAPFILEHEADER	hdr;
	LPBITMAPINFOHEADER	lpbi;
 
	if (!hDIB)
		return FALSE;
 
	buf= malloc(65000);
 
	//CFile file;
	//if( !file.Open( szFile, CFile::modeWrite|CFile::modeCreate) )
	//	return FALSE;
 
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	int nColors = 1 << lpbi->biBitCount;
 
	// Fill in the fields of the file header 
	hdr.bfType		= ((WORD) ('M' << 8) | 'B');	// is always "BM"
	hdr.bfSize		= GlobalSize (hDIB) + sizeof( hdr );
	hdr.bfReserved1 	= 0;
	hdr.bfReserved2 	= 0;
	hdr.bfOffBits		= (DWORD) (sizeof( hdr ) + lpbi->biSize +
						nColors * sizeof(RGBQUAD));
 
	// Write the file header 
	//file.Write( &hdr, sizeof(hdr) );
	memcpy(buf,&hdr, sizeof(hdr));
 
	// Write the DIB header and the bits 
	//file.Write( lpbi, GlobalSize(hDIB) );
	memcpy(buf,lpbi, GlobalSize(hDIB));
 
	//used global bmp data variable to get bmp data everywhere
	memcpy(gl_buf,buf, sizeof(buf));
 
	//free(buf);
	//file.Close(); //
	return TRUE;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:

//test new add
BOOL WriteDIBnew( const char* buf, HANDLE hDIB)
{
	BITMAPFILEHEADER	hdr;
	LPBITMAPINFOHEADER	lpbi;
 
	if (!hDIB)
		return FALSE;
 
	buf= (const char*)malloc(65000);
	//CFile file;
	//if( !file.Open( szFile, CFile::modeWrite|CFile::modeCreate) )
	//return FALSE;
 
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	int nColors = 1 << lpbi->biBitCount;
 
	// Fill in the fields of the file header 
	hdr.bfType		= ((WORD) ('M' << 8) | 'B');	// is always "BM"
	hdr.bfSize		= GlobalSize (hDIB) + sizeof( hdr );
	hdr.bfReserved1 	= 0;
	hdr.bfReserved2 	= 0;
	hdr.bfOffBits	= (DWORD) (sizeof( hdr ) + lpbi->biSize +
				nColors * sizeof(RGBQUAD));
 
	// Write the file header 
	//file.Write( &hdr, sizeof(hdr) );
	//memcpy((void*)buf,&hdr, sizeof(hdr));
 
	// Write the DIB header and the bits 
	//file.Write( lpbi, GlobalSize(hDIB) );
 
//memcpy(buf,lpbi, GlobalSize(hDIB));
 
//free(buf);
//file.Close(); //
//     unsigned char *buff;
       const char *buff;
       unsigned char* pDIB = (unsigned char *)GlobalLock(hDIB); 
      BITMAPINFO pInfo;
      PBITMAPINFOHEADER pbih = (PBITMAPINFOHEADER)pDIB;
 
      memset(&pInfo,0,sizeof(BITMAPINFO));
      memcpy(&(pInfo.bmiHeader),pbih,sizeof(BITMAPINFOHEADER));
 
      DWORD  bfOffBits = pbih->biSize + pbih->biClrUsed * sizeof (RGBQUAD); 
      //buff=pDIB+bfOffBits;
     gl_buf=(const char*)pDIB+bfOffBits;
 
      GlobalUnlock(hDIB); 
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

//Global variables
HBITMAP HImagebmp; 
HBITMAP hBmp2;
RECT rectScaled;
int rectW;
int rectH;
 
 
FILE * fpWrite; 
char * buffer;    
long lSizeOfFile = -1;	
 
const char * gl_buf;
	  
	  
 
 //CODE1
void CTest_Load_BmpDlg::OnButtonLoadfrmfile() 
{
	  HImagebmp = (HBITMAP)::LoadImage(NULL,"Image300x200.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);  //BON  
 
	  HDC hdc=::GetDC(m_Picturebox.m_hWnd);
	  HDC memdc=::CreateCompatibleDC(hdc);
	  hBmp2=(HBITMAP)SelectObject(memdc,HImagebmp);
  
	 // SetStretchBltMode(hdc,COLORONCOLOR);  //For better quality
      StretchBlt(hdc,0,0,rectW,rectH,memdc,0,0,300,200,SRCCOPY); 
 
      DeleteDC(hdc);
      DeleteDC(memdc);
 
	  if(HImagebmp)
	  {
			m_Picturebox.SetBitmap(hBmp2);
			DeleteObject(HImagebmp);
	  }
}
 
 
 
//CODE2
void CTest_Load_BmpDlg::OnButtonSavetomem() 
{
 
	WriteWindowToDIB("test.bmp", /*pWnd*/ this->GetActiveWindow() ); //this->GetActiveWindow()           ==> ok
														   //this->GetDlgItem(IDC_PICTUREBOX); ==> blank ?
 
}
 
 
BOOL WriteWindowToDIB( LPTSTR szFile, CWnd *pWnd )
{
	CBitmap 	bitmap;
	CWindowDC	dc(pWnd);
	CDC 		memDC;
	CRect		rect;
 
	memDC.CreateCompatibleDC(&dc);
 
	pWnd->GetWindowRect(rect);
 
	bitmap.CreateCompatibleBitmap(&dc, rect.Width(),rect.Height() );
 
	CBitmap* pOldBitmap = memDC.SelectObject(&bitmap);
	memDC.BitBlt(0, 0, rect.Width(),rect.Height(), &dc, 0, 0, SRCCOPY);
 
	// Create logical palette if device support a palette
	CPalette pal;
	if( dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE )
	{
		UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256);
		LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
		pLP->palVersion = 0x300;
 
		pLP->palNumEntries =
			GetSystemPaletteEntries( dc, 0, 255, pLP->palPalEntry );
 
		// Create the palette
		pal.CreatePalette( pLP );
 
		delete[] pLP;
	}
	memDC.SelectObject(pOldBitmap);
	// Convert the bitmap to a DIB
	HANDLE hDIB = DDBToDIB( bitmap, BI_RGB, &pal );
 
	if( hDIB == NULL )
		return FALSE;
 
	gl_buf = (const char*)malloc (1900000);
	//char *buff;
	// Write it to file
	//WriteDIB( szFile, hDIB );
	WriteDIBnew( gl_buf, hDIB );
 
	// Free the memory allocated by DDBToDIB for the DIB
	GlobalFree( hDIB );
	return TRUE;
}
 
// DDBToDIB		- Creates a DIB from a DDB
// bitmap		- Device dependent bitmap
// dwCompression	- Type of compression - see BITMAPINFOHEADER
// pPal			- Logical palette
HANDLE DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal )
{
	BITMAP			bm;
	BITMAPINFOHEADER	bi;
	LPBITMAPINFOHEADER 	lpbi;
	DWORD			dwLen;
	HANDLE			hDIB;
	HANDLE			handle;
	HDC 			hDC;
	HPALETTE		hPal;
 
 
	ASSERT( bitmap.GetSafeHandle() );
 
	// The function has no arg for bitfields
	if( dwCompression == BI_BITFIELDS )
		return NULL;
 
	// If a palette has not been supplied use defaul palette
	hPal = (HPALETTE) pPal->GetSafeHandle();
	if (hPal==NULL)
		hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
 
	// Get bitmap information
	bitmap.GetObject(sizeof(bm),(LPSTR)&bm);
 
	// Initialize the bitmapinfoheader
	bi.biSize		= sizeof(BITMAPINFOHEADER);
	bi.biWidth		= bm.bmWidth;
	bi.biHeight 		= bm.bmHeight;
	bi.biPlanes 		= 1;
	bi.biBitCount		= bm.bmPlanes * bm.bmBitsPixel;
	bi.biCompression	= dwCompression;
	bi.biSizeImage		= 0;
	bi.biXPelsPerMeter	= 0;
	bi.biYPelsPerMeter	= 0;
	bi.biClrUsed		= 0;
	bi.biClrImportant	= 0;
 
	// Compute the size of the  infoheader and the color table
	int nColors = (1 << bi.biBitCount);
	if( nColors > 256 )
		nColors = 0;
	dwLen  = bi.biSize + nColors * sizeof(RGBQUAD);
 
	// We need a device context to get the DIB from
	hDC = GetDC(NULL);
	hPal = SelectPalette(hDC,hPal,FALSE);
	RealizePalette(hDC);
 
	// Allocate enough memory to hold bitmapinfoheader and color table
	hDIB = GlobalAlloc(GMEM_FIXED,dwLen);
 
	if (!hDIB){
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}
 
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	*lpbi = bi;
 
	// Call GetDIBits with a NULL lpBits param, so the device driver 
	// will calculate the biSizeImage field 
	GetDIBits(hDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
			(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);
 
	bi = *lpbi;
 
	// If the driver did not fill in the biSizeImage field, then compute it
	// Each scan line of the image is aligned on a DWORD (32bit) boundary
	if (bi.biSizeImage == 0){
		bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8)
						* bi.biHeight;
 
		// If a compression scheme is used the result may infact be larger
		// Increase the size to account for this.
		if (dwCompression != BI_RGB)
			bi.biSizeImage = (bi.biSizeImage * 3) / 2;
	}
 
	// Realloc the buffer so that it can hold all the bits
	dwLen += bi.biSizeImage;
	if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
		hDIB = handle;
	else{
		GlobalFree(hDIB);
 
		// Reselect the original palette
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}
 
	// Get the bitmap bits
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	// FINALLY get the DIB
	BOOL bGotBits = GetDIBits( hDC, (HBITMAP)bitmap.GetSafeHandle(),
				0L,				// Start scan line
				(DWORD)bi.biHeight,		// # of scan lines
				(LPBYTE)lpbi 			// address for bitmap bits
				+ (bi.biSize + nColors * sizeof(RGBQUAD)),
				(LPBITMAPINFO)lpbi,		// address of bitmapinfo
				(DWORD)DIB_RGB_COLORS);		// Use RGB for color table
 
	if( !bGotBits )
	{
		GlobalFree(hDIB);
 
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}
 
	SelectPalette(hDC,hPal,FALSE);
	ReleaseDC(NULL,hDC);
	return hDIB;
}
 
//test new add
BOOL WriteDIBnew( const char* buf, HANDLE hDIB)
{
	BITMAPFILEHEADER	hdr;
	LPBITMAPINFOHEADER	lpbi;
 
	if (!hDIB)
		return FALSE;
 
	buf= (const char*)malloc(65000);
 
	//CFile file;
	//if( !file.Open( szFile, CFile::modeWrite|CFile::modeCreate) )
	//	return FALSE;
 
	lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	int nColors = 1 << lpbi->biBitCount;
 
	// Fill in the fields of the file header 
	hdr.bfType		= ((WORD) ('M' << 8) | 'B');	// is always "BM"
	hdr.bfSize		= GlobalSize (hDIB) + sizeof( hdr );
	hdr.bfReserved1 	= 0;
	hdr.bfReserved2 	= 0;
	hdr.bfOffBits		= (DWORD) (sizeof( hdr ) + lpbi->biSize +
						nColors * sizeof(RGBQUAD));
 
	// Write the file header 
	//file.Write( &hdr, sizeof(hdr) );
    //memcpy((void*)buf,&hdr, sizeof(hdr));
 
	// Write the DIB header and the bits 
	//file.Write( lpbi, GlobalSize(hDIB) );
 
    //memcpy(buf,lpbi, GlobalSize(hDIB));
 
	//used global bmp data variable to get bmp data everywhere
    //memcpy(gl_buf,buf, sizeof(buf));
 
	//free(buf);
	//file.Close(); //
    //unsigned char *buff;
       const char *buff;
       unsigned char* pDIB = (unsigned char *)GlobalLock(hDIB); 
      BITMAPINFO pInfo;
      PBITMAPINFOHEADER pbih = (PBITMAPINFOHEADER)pDIB;
 
      memset(&pInfo,0,sizeof(BITMAPINFO));
      memcpy(&(pInfo.bmiHeader),pbih,sizeof(BITMAPINFOHEADER));
 
      DWORD  bfOffBits = pbih->biSize + pbih->biClrUsed * sizeof (RGBQUAD); 
      //buff=pDIB+bfOffBits;
	  gl_buf=(const char*)(pDIB+bfOffBits);
 
      GlobalUnlock(hDIB); 
 
	return TRUE;
}
 
 
 
 
 
 
//CODE3
void CTest_Load_BmpDlg::OnButtonLoadfrommem() 
{
 
		CString FullName =buffer;
		//CString FullName =gl_buf;
		m_label_buffer.SetWindowText(FullName);
 
 
/*
      HBITMAP hbitmap=(HBITMAP)::LoadImage(NULL,"test.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
      if(hbitmap==NULL)
      {
            AfxMessageBox("image not found");
            return ;
      }
*/
 
//gl_buf
 
      HBITMAP hbitmap=(HBITMAP)::LoadImage(NULL,gl_buf,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);
      if(hbitmap==NULL)
      {
            AfxMessageBox("image not found");
            return ;
      }
	
	
      BITMAPINFO OriginalInfo;
      unsigned char *OriginalBits;
      DDBToDIBnew(hbitmap, BI_RGB,&OriginalInfo,&OriginalBits );
      HDC hdc = ::GetDC(m_Picturebox.m_hWnd);
      ::StretchDIBits(hdc,0,0,OriginalInfo.bmiHeader.biWidth,OriginalInfo.bmiHeader.biHeight,0,0,OriginalInfo.bmiHeader.biWidth,OriginalInfo.bmiHeader.biHeight,OriginalBits,&OriginalInfo,DIB_RGB_COLORS,SRCCOPY);
      
	  CBitmap test;
	  test.Attach(hdc);
	   m_Picturebox.SetBitmap(test);
 
	  
}
//new test other funtion and signature
HANDLE DDBToDIBnew( HBITMAP hBitmap, DWORD dwCompression,BITMAPINFO* pInfo, unsigned char **ppBits )
{
	  BITMAP                  bm;
	  BITMAPINFOHEADER      bi;
	  LPBITMAPINFOHEADER       lpbi;
	  DWORD                  dwLen;
	  HANDLE                  hDIB;
	  HANDLE                  handle;
	  HDC                   hDC;
	  HPALETTE            hPal;
	CPalette* pPal = new CPalette(); 
 
	  ASSERT( hBitmap );
 
	  // The function has no arg for bitfields
	  if( dwCompression == BI_BITFIELDS )
			return NULL;
 
	  // If a palette has not been supplied use defaul palette
	  hPal = (HPALETTE) pPal->GetSafeHandle();
	  if (hPal==NULL)
			hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
 
	  // Get bitmap information
	  ::GetObject(hBitmap,sizeof(bm),(LPSTR)&bm);
 
	  // Initialize the bitmapinfoheader
	  bi.biSize            = sizeof(BITMAPINFOHEADER);
	  bi.biWidth            = bm.bmWidth;
	  bi.biHeight             = bm.bmHeight;
	  bi.biPlanes             = 1;
	  bi.biBitCount            = bm.bmPlanes * bm.bmBitsPixel;
	  bi.biCompression      = dwCompression;
	  bi.biSizeImage            = 0;
	  bi.biXPelsPerMeter      = 0;
	  bi.biYPelsPerMeter      = 0;
	  bi.biClrUsed            = 0;
	  bi.biClrImportant      = 0;
 
	  // Compute the size of the  infoheader and the color table
	  int nColors = (1 << bi.biBitCount);
	  if( nColors > 256 )
			nColors = 0;
	  dwLen  = bi.biSize + nColors * sizeof(RGBQUAD);
 
	  // We need a device context to get the DIB from
	  hDC = ::GetDC(NULL);
	  hPal = SelectPalette(hDC,hPal,FALSE);
	  RealizePalette(hDC);
 
	  // Allocate enough memory to hold bitmapinfoheader and color table
	  hDIB = GlobalAlloc(GMEM_FIXED,dwLen);
 
	  if (!hDIB){
			SelectPalette(hDC,hPal,FALSE);
			::ReleaseDC(NULL,hDC);
			return NULL;
	  }
 
	  lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	  *lpbi = bi;
 
	  // Call GetDIBits with a NULL lpBits param, so the device driver 
	  // will calculate the biSizeImage field 
	  GetDIBits(hDC, hBitmap, 0L, (DWORD)bi.biHeight,
				  (LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);
 
	  bi = *lpbi;
 
	  // If the driver did not fill in the biSizeImage field, then compute it
	  // Each scan line of the image is aligned on a DWORD (32bit) boundary
	  if (bi.biSizeImage == 0){
			bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8)
									* bi.biHeight;
 
			// If a compression scheme is used the result may infact be larger
			// Increase the size to account for this.
			if (dwCompression != BI_RGB)
				  bi.biSizeImage = (bi.biSizeImage * 3) / 2;
	  }
 
	  // Realloc the buffer so that it can hold all the bits
	  dwLen += bi.biSizeImage;
	  if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
			hDIB = handle;
	  else{
			GlobalFree(hDIB);
 
			// Reselect the original palette
			SelectPalette(hDC,hPal,FALSE);
			::ReleaseDC(NULL,hDC);
			return NULL;
	  }
 
	  // Get the bitmap bits
	  lpbi = (LPBITMAPINFOHEADER)hDIB;
 
	  // FINALLY get the DIB
	  BOOL bGotBits = GetDIBits( hDC, hBitmap,
						0L,                        // Start scan line
						(DWORD)bi.biHeight,            // # of scan lines
						(LPBYTE)lpbi                   // address for bitmap bits
						+ (bi.biSize + nColors * sizeof(RGBQUAD)),
						(LPBITMAPINFO)lpbi,            // address of bitmapinfo
						(DWORD)DIB_RGB_COLORS);            // Use RGB for color table
 
	  if( !bGotBits )
	  {
			GlobalFree(hDIB);
 
			SelectPalette(hDC,hPal,FALSE);
			::ReleaseDC(NULL,hDC);
			return NULL;
	  }
	*ppBits = (LPBYTE)lpbi  + (bi.biSize + nColors * sizeof(RGBQUAD)),
	  memcpy(&pInfo->bmiHeader,lpbi,sizeof(BITMAPINFOHEADER));                  
	  SelectPalette(hDC,hPal,FALSE);
	  ::ReleaseDC(NULL,hDC);
	  delete pPal;
	  return hDIB;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:

void *buffer = 0;
int buflen = 0;
 
bool CFXCAMd_ConfiguratorDlg::DisplayImage() 
{
 
	  if (eventsavedlgdc)
	  { 
	    	::DeleteObject(eventsavedlgdc);
	  }
 
	  // eventsavedlgdc = (HBITMAP)::LoadImage(NULL,"readframes01.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);  //BON
	  eventsavedlgdc = ::LoadBitmapFromMemory( Gl_buffer );
 
	  CBitmap bmp;
	  bmp.Attach(eventsavedlgdc);
	  BITMAP bm;
	  bmp.GetBitmap(&bm);  
	  bmp.Detach(); 
 
	  HDC hdc=::GetDC(m_Picture.m_hWnd);
	  HDC memdc=::CreateCompatibleDC(hdc);
	  HBITMAP hBmp2=(HBITMAP)SelectObject(memdc,eventsavedlgdc);
  
	  SetStretchBltMode(hdc,COLORONCOLOR);  //For better qualioty
      StretchBlt(hdc,0,0,rectW,rectH,memdc,0,0,752,480,SRCCOPY); //090907 sur image interne
      DeleteDC(hdc);
      DeleteDC(memdc);
 
	  if(eventsavedlgdc)
	  {
			m_Picture.SetBitmap(hBmp2);
			DeleteDC(hMemDC);
			DeleteObject(eventsavedlgdc);
	  }
 
	  return FALSE;
 
}
    
bool CFXCAMd_ConfiguratorDlg::GetCaptureImage()
{
	
        // Saves the image to the memory
	    try
		{
			//cp.image.Load("readframes01.bmp");
			cp.image.SaveToMem(&Gl_buffer, &Gl_buflen, GX_BMP); //GX_JPEG
 
		}
		catch(...)
		{
			 MessageBox("ERROR IN cp.image.SaveToMem","trycatch message");
 
		}
 
	return FALSE;
 
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

#include "Camdev.h" //this class is an wrapper class from GXImage class
 
//Globales
Camdev cp;
 
void *buffer = 0;
int buflen = 0;
 
RECT WndRect;
static HWND hWndImageRect;
static HDC	hdcDest;
 
HBITMAP eventsavedlgdc = (HBITMAP)::LoadImage(NULL,"readframes01.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
HDC           hMemDC;
RECT rectScaled;
int rectW;
int rectH;
 
 
 
 
// For time measuring
gxu64 fps_frametimems = 0;
gxu16 fps_frameix = 0;
gxu32 fps = 0;
gxu16 lastframeix = 0;	
 
// Waits for a captured frame
gxu16 status, newestframeix, nframes, nprocbufs, nusable, nlocked;
gxu64 newesttimems;
gxu16 nlockitems = 1;
FXCAM_FRAMEINFO lockitems[1];
bool CFXCAMd_ConfiguratorDlg::GetCaptureImage()
{
	try{
		while(1) {
					TRACE("While_new_frame_in");
					if(!cp.GetCaptureInfo(&status, &newestframeix, &newesttimems,
						&nframes, &nprocbufs, &nusable, &nlocked, lockitems, &nlockitems))
					{	
						gx_geterror(&ecode, ebuf, sizeof(ebuf));
						return TRUE;
					}
 
					if((status & 1) && (newestframeix != lastframeix)) {
						// OK, the frame buffer contains valid data
						break;	
					}
 
					#ifdef WIN32
					Sleep(10);
					#else
					usleep(10*1000);
					#endif
					TRACE("Not_valid_frame");
				}
		 
	}catch(...)
		{
		need_reconnect = true;
		}
		// Lock frame
		gxu64 frame;
		lastframeix = newestframeix;
		try{
 
		if(nlockitems == 0) {
			// No locked items
			frame = FXCAM_IX2FRAME(newestframeix);
			if(!cp.LockFrames(FXCAM_LOCK_RELEASE_ALL_OTHER, frame, frame)) {  //FXCAM_LOCK_ONLY_ONE_NEAREST FXCAM_LOCK_RELEASE_ALL_OTHER
				// Error occurred
				need_reconnect = true;
				return TRUE;
			}
 
		} else {
			// Found locked items
			frame = FXCAM_IX2FRAME(lockitems[0].index);
			newestframeix = lockitems[0].index;
			newesttimems = lockitems[0].timems;
			printf("\nTrigger event (timems: %llu, index: %u)\n", lockitems[0].timems, lockitems[0].index);
		}
		}catch(...)
		{
		need_reconnect = TRUE;
		}
		
		// Read frame
		gxu64 frametimems;
 		try 
		{
				DoEvents();
				if(!cp.ReadFrame(FXCAM_READFRAME_AUTOADJUST, 0, frame, NULL, &frametimems, &newestframeix, NULL, cp.image)) {
					if(nlockitems == 0) {
						// Error occurred
						need_reconnect = true;
						return TRUE;
					}
					MessageBox("cp.ReadFrame OK");
				}
		}
		catch(...)
		{	
			if(m_bStop)MessageBox("Exception From ReadFrame","Exception message"); //timer 2 generated
			need_reconnect = TRUE;
			return TRUE;
		}
 
		try 
		{	
				DoEvents();
				// Release the locked frame
				if(!cp.UnlockFrames(0, frame, frame)) {
					// Error occurred
					need_reconnect = true;
					return TRUE;
				}
			
		}
		catch(...)
		{	
			if(m_bStop)MessageBox("Exception From UnlockFrame","Exception message"); //timer 2 generated
			need_reconnect = TRUE;
			//SetTimer(1,80,0);
			return TRUE;
		}
 
				if(fps_frametimems+1000 < frametimems) {
					 fps = (gxu32)((1000*(frame-fps_frameix))/(frametimems-fps_frametimems));
					 fps_frametimems = frametimems;
					 fps_frameix = (gxu16)frame;
				}
	
		//FILE VERSION
		/*
		try{
		if(!cp.image.Save("readframes01.bmp", GX_BMP)) //Utiliser SavetoMem vers ppm (pour stream),  vers jpg (pour snapshot)
		{ 
			gx_geterror(&ecode, ebuf, sizeof(ebuf));
			MessageBox("Save image failed:.","Capture message");
			return TRUE;
		}
		}catch(...)
		{
		//MessageBox("ERROR IN cp.image.Save","trycatch message");
		need_reconnect = TRUE;
		}
		*/
 
		//MEMORY VERSION
	    try
		{
			cp.image.SaveToMem(&Gl_buffer, &Gl_buflen, GX_BMP); //GX_JPEG
		}
		catch(...)
		{
			 MessageBox("ERROR IN cp.image.SaveToMem","trycatch message");
		}
 
	return FALSE;
 
}
 
//------------------------------------------------------------------
// Load a DIB file from memory buffer.
// Return bitmap handle on success, NULL on error
//------------------------------------------------------------------
HBITMAP LoadBitmapFromMemory( void * pBmpFileData )
{
// Check parameter
ASSERT( pBmpFileData != NULL );
if ( pBmpFileData == NULL )
return NULL;
 
// Pointer to file bytes
BYTE * pFileBytes = (BYTE *)pBmpFileData;
 
// DIB bits (will be set by CreateDIBSection)
BYTE * pBits = NULL;
 
// Access the BITMAPINFOHEADER section
BITMAPINFOHEADER * pbmih = (BITMAPINFOHEADER *)(pFileBytes +
sizeof(BITMAPFILEHEADER));
 
// Create the DIB
HBITMAP hBitmap = ::CreateDIBSection(
NULL,                   // No HDC used
(BITMAPINFO *)pbmih,    // Pointer to DIB information
0,                      // Default
(void **)&pBits,        // The function will return pointer to
//   bitmap bits
NULL,                   // No file mapping
0 );                    // No file mapping
if ( hBitmap == NULL )
return NULL;
 
// Get pointer to bitmap bits in original file
// (we obtain the offset from BITMAPFILEHEADER.bfOffBits field)
BITMAPFILEHEADER * pbmfh = (BITMAPFILEHEADER *)pFileBytes;
BYTE * pSourceBitmapBits = pFileBytes + pbmfh->bfOffBits;
 
// Copy bits
memcpy(pBits, pSourceBitmapBits, pbmih->biSizeImage);
 
// Return bitmap handle
return hBitmap;
}
 
bool CFXCAMd_ConfiguratorDlg::DisplayImage() 
{
	  //FILE VERSION
/*
	  if (eventsavedlgdc)
	  { 
	    	::DeleteObject(eventsavedlgdc);
	  }
 
	  eventsavedlgdc = (HBITMAP)::LoadImage(NULL,"readframes01.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);  //BON
	  //eventsavedlgdc = ::LoadBitmapFromMemory( Gl_buffer );
 
 
	  CBitmap bmp;
	  bmp.Attach(eventsavedlgdc);
	  BITMAP bm;
	  bmp.GetBitmap(&bm);  
	  bmp.Detach(); 
 
	  HDC hdc=::GetDC(m_Picture.m_hWnd);
 
	  HDC memdc=::CreateCompatibleDC(hdc);
	  HBITMAP hBmp2=(HBITMAP)SelectObject(memdc,eventsavedlgdc);
  
	  SetStretchBltMode(hdc,COLORONCOLOR);  //For better quality
      StretchBlt(hdc,0,0,rectW,rectH,memdc,0,0,752,480,SRCCOPY); 
      DeleteDC(hdc);
      DeleteDC(memdc);
 
	  if(eventsavedlgdc)
	  {
 
			m_Picture.SetBitmap(hBmp2);
			DeleteDC(hMemDC);
			DeleteObject(eventsavedlgdc);
	  }
*/
 
 
 
      //MEMORY VERSION
	  HBITMAP hBitMap = ::LoadBitmapFromMemory( Gl_buffer );
 
	  RECT lp;
      BITMAPINFO OriginalInfo;
      unsigned char *OriginalBits;
      HDC hdc = ::GetWindowDC(m_hWnd);
      ::GetWindowRect(m_hWnd,&lp);
      HDC hdc1=::GetDC(m_hWnd);
      HDC memDC = CreateCompatibleDC ( hdc );
      hBitMap = ::CreateCompatibleBitmap(hdc,lp.right,lp.bottom);
 
      ::SelectObject ( memDC, hBitMap );  //eventsavedlgdc
      ::BitBlt(memDC,0,0,lp.right,lp.bottom,hdc,0,0,SRCCOPY);
      HGLOBAL hDIB =DDBToDIB(hBitMap, BI_RGB,&OriginalInfo,&OriginalBits );
      //WriteDIB("c:/temp.bmp",hDIB); //not to write on disk
      ::StretchDIBits(hdc1,0,40,OriginalInfo.bmiHeader.biWidth,OriginalInfo.bmiHeader.biHeight,0,0,OriginalInfo.bmiHeader.biWidth,OriginalInfo.bmiHeader.biHeight,OriginalBits,&OriginalInfo,DIB_RGB_COLORS,SRCCOPY);
      ::ReleaseDC(m_hWnd,hdc1);
      ::ReleaseDC(m_hWnd,hdc);
      ::GlobalFree(hDIB);
      ::DeleteObject(hBitMap);
 
	  return FALSE;
}
 
 
+++
 
	/** Saves an image in a specific file format to a specific memory area.
	 * @param buffer Pointer to the memory area pointer that is large enough or NULL.
	 * @param buflen Size of the memory area.
	 * @param fileformat Format of the image file (see \ref GX_IMGFILEFORMATS).
	 * @return An exception is thrown or false is returned in case of error. */
	inline bool SaveToMem(void **buffer, gxi32 *buflen, gxi32 fileformat) throw(gxError) {
		gxassert(_image);
		bool st = gx_savetomem(*this, _image, buffer, buflen, fileformat) ? true : false;
		gxcondthrow(!st);
		return st;
	}
	
/** Saves an image in a specific file format to a specific memory area.
 * @param handle Handle of the module.
 * @param pimage Pointer to the image.
 * @param buffer Pointer to the memory area pointer that is large enough or NULL.
 * @param buflen Size of the memory area.
 * @param fileformat Format of the image file (see \ref GX_IMGFILEFORMATS).
 * @return On error false is returned and the error code/string in the GX system
 *         is set appropriately ( see gx_geterror() ). */
inline gxi32 gx_savetomem(gxHANDLE handle, gxIMAGE* pimage,
					void **buffer, gxi32 *buflen, gxi32 fileformat) {
	struct GX_PARM_SAVETOMEM sm;
	assert(pimage);
	assert(buffer);
	assert(buflen);
	assert(*buflen >= 0);
	sm.pimage = pimage;
	sm.buffer = buffer;
	sm.buflen = buflen;
	sm.fileformat = fileformat;
	return gx_call(handle, GX_CALL_SAVETOMEM, (void *)&sm);
}
 
/** Calls a module process with the specified parameters.
 *
 * The functions and parameters usable inside the modules can be found in the
 * documentation of the modules. The headers given with the modules contain
 * inline functions, that make the access to the functions of the module easier.
 *
 * @see gx_openmodule() gx_closehandle() gx_direct()
 *
 * @param handle	Handle of an opened module or special system handle ( see gx_direct() ).
 * @param function	Identifier of the function (GX_CALL_xxx).
 * @param params	Parameters to give for the function (GX_PARM_xxx).
 * @return Module defined, usually non-zero on success. */
int GXAPI gx_call(struct gxHANDLE handle, int function, void *params) {
#ifdef WIN32
static gxldr_callfunc_t *gxsdldr_call = 0;
	if (!gxsdldr_call)
	{
		/* Call the init function if the gx_call() is not found */
		gxsdldr_init(&gxsdldr_call);
	}
#else
	if(!gxsdldr_call) gxsdldr_init();
#endif
	if (gxsdldr_call) return gxsdldr_call(handle, function, params);	/* GXSD library is loaded */
 
	/* GXSD library not loaded */
	switch(function) {
		case GX_CALL_GETERROR:	/* gx_geterror() function - Unicode mode */
			{
				if(params){
					struct GX_PARM_GETERROR *mp = (struct GX_PARM_GETERROR *)params;
					mp->code = ENOENT;
					if(mp->string && mp->maxlen>0) {
						gx_snwprintf(mp->string, mp->maxlen, L"gxsdldr: open error in %hs (%hs)",
							gxsdldr_modulename, gxsdldr_errstr);
						mp->string[mp->maxlen-1] = 0;
					}
				}
				return ENOENT;
			}
		case GX_CALL_GETERRORA:	/* gx_geterror() function - ASCII mode */
			{
				if(params){
					struct GX_PARM_GETERRORA *mp = (struct GX_PARM_GETERRORA *)params;
					mp->code = ENOENT;
					if(mp->string && mp->maxlen>0) {
						gx_snprintf(mp->string, mp->maxlen, "gxsdldr: open error in %s (%s)",
							gxsdldr_modulename, gxsdldr_errstr);
						mp->string[mp->maxlen-1] = 0;
					}
				}
				return ENOENT;
			}
		default:
			/* Unknown function */
			break;
	}
	
	/* Unknown function */
	errno = EINVAL;
	return 0;	
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372: