PInvoke void * parameter - C# Discussion Boards

14-Mar-09 5:32

Here is the unmanged definition:

//============================================================================
// DcamCapture()
// Start to acquire one image from the camera.
// ---------------------------------------------------------------------------
// [Argument]
// pImageBuff : /O: Specify the start address in the buffer where image
// data is to be stored.
// nBuffSize :I/ : Specify the buffer size (number of bytes).
// [Return values]
// If the function succeeds the return value is TRUE (1).
// If the function fails the return value is FALSE (0).
// To obtain detailed error information, use the DcamGetLastError function.
// [Note]
// 1. This function issues an instruction to start image acquisition.
// Since image acquisition is not complete even when this function ends,
// use the DcamWait function to check whether image acquisition is complete.
// 2. The necessary buffer size can be obtained with the DcamGetFrameBytes function.
//============================================================================
_DCAMLIBEXPORT BOOL _DCAMLIBSTDCALL DcamCapture( LPVOID pImageBuff, INT nBuffSize );

Here is my C# code which does not work:

class DCamLIB
{
private IntPtr ImageBuffer;

public DCamLIB()
{
ImageBuffer = new IntPtr( 0 );
}

[DllImport( "DCamLIB.dll" )]
private static extern bool DcamCapture( out IntPtr imageBuffer, Int32 bufferSize );

public void Capture( Int32 bufferSize )
{
if ( !DcamCapture( out ImageBuffer, bufferSize ) )
{
throw new DCamLIBException( this );
}
}
}

No matter what ImageBuffer = 0.

Ideas?

Luc Pattyn14-Mar-09 5:56

14-Mar-09 5:56

Hi Jason,

I doubt the first parameter is an output parameter.
To me LPVOID is the same as "void* ", i.e. pointer to something however I will not tell you what.

So it expects the address of an existing buffer, which is quite good actually, that way you can have the managed world allocate a buffer, pass it to the native camera code to get it filled, then use its content in the managed world.

There are basically two ways to allocate a buffer and pass its address:
1. using the fixed keyword
2. using the GCHandle class (get a handle, get a pointer, use, release)

1. is easier, 2. has more functionality (which one would need if the pointer needs to remain valid after the native function returns, e.g. when doing asynchronous stuff).

So I suggest you read up on "fixed" and drop the "out" from your native function's prototype.

Smile | :)

Luc Pattyn [Forum Guidelines] [My Articles]

- before you ask a question here, search CodeProject, then Google
- the quality and detail of your question reflects on the effectiveness of the help you are likely to get
- use the code block button (PRE tags) to preserve formatting when showing multi-line code snippets

modified on Saturday, March 14, 2009 12:44 PM

Jason McPeak14-Mar-09 7:02

14-Mar-09 7:02

So...

[DllImport( "DCamLIB.dll" )]
private unsafe static extern bool DcamCapture( int* imageBuffer, Int32 bufferSize );

public unsafe void Capture( Int32 bufferSize )
{
fixed ( int* ImageBuffer = new int[ bufferSize ] )
{
if ( !DcamCaptureReverseX( ImageBuffer, bufferSize ) )
{
throw new DCamLIBException( this );
}
}
}

If I needed to save the image to disk I would need to do so inside the fixed statement?
I need to do this so the garbage collector is not relocating a movable variable? The variable is essentially "pinned" during the fixed statement?

Luc Pattyn14-Mar-09 7:30

14-Mar-09 7:30

Hi,

1.
yes "fixed" is one way to pin down something, for as long as you are inside its code block.

2.
it is strange to see a Capture() method without any outputs. You should either provide a "string filename" parameter if you want it to save to disk, or return something "... int[] Capture(...)" if you want your app to work on it.
I would suggest something along these lines (note the use of "code block" button resulting in PRE tags which gives a monospaced font and preserves formatting):

public unsafe int[] Capture( Int32 bufferSize ) {
    int[] buf = new int[ bufferSize ];
    fixed ( int* ImageBuffer = buf ) {
        if ( !DcamCaptureReverseX( ImageBuffer, bufferSize ) ) throw new DCamLIBException( this );
    }
    return buf;
}

3.
Once the native world is done with your buffer, it does not need the pinning; and the managed code can operate on it without restrictions, e.g. save it to disk.

4.
remarks:
- it is unusual, and probably not so good, to have exceptions without a string argument, passing some message in.
- there would be no need to zero out the buffer, managed arrays are always zero-filled automatically upon creation; the CLR designers have chosen to do so, in order to eliminate random behavior when you forget to fill it up and start using whatever happens to be there.

5.
are you sure int[] is right? that indicates 32 bit per pixel; would be fine for color images, and probably overkill (and memory waste) for grayscale. Some native C/C++ systems have 16-bit int, in managed languages int is 32-bit.

Smile | :)

Luc Pattyn [Forum Guidelines] [My Articles]

Jason McPeak14-Mar-09 8:16

14-Mar-09 8:16

[DllImport( "DCamLIB.dll" )]
private unsafe static extern bool DcamCapture( int* imageBuffer, Int32 bufferSize );

public unsafe void CaptureReverseX( Int32 bufferSize )
{
	fixed ( int* buf = new int[ bufferSize ] )
	{
		if ( !DcamCapture( buf, bufferSize ) )
		{
			throw new DCamLIBException( this );
		}
		// Here the pointer buf is defined, but the value is still 0
		// It's like the DcamCapture() method does not populate buf
	}
}

I am consuming an existing unmanaged 3rd party dll. I have the doc on it, I have all other functions implemented and working except for this one.

The following is the complete example code:

void CC9266SmpDlg::OnBtnCapture() 
{
	DWORD	dwRetStatus = DCAM_WAITSTATUS_UNCOMPLETED;
	WORD*	pDataBuff   = NULL;
	int		nWidth, nHeight, nImageSize;

	nWidth = nHeight = nImageSize = 0;

	DcamInitialize();										// Initialize DLL
	DcamOpen();												// Open the device
	DcamSetDriveMode( DCAM_CCDDRVMODE_OPERATION, 3000 );	// Connect the CCD

	DcamSetGain( 1 );										// Set the gain 1
	DcamSetOffset( 10 );									// Set the offset 10
	DcamSetBinning( DCAM_BINNING_1X1 );						// Set the binning 1x1
	DcamSetCCDType( DCAM_CCD_TYPE0 );						// Set the CCD type S8981
	DcamSetTriggerPolarity( DCAM_TRIGPOL_NEGATIVE );		// Set the trigger polarity negative
	DcamSetTriggerMode( DCAM_TRIGMODE_EXT_LEVEL1 );			// Set the trigger mode "External Mode 2"

	DcamGetImageSize( &nWidth, &nHeight );					// Get the image size
	nImageSize = nWidth * nHeight;

	pDataBuff = new WORD[ nImageSize ];

	if( pDataBuff != NULL )
	{
		memset( pDataBuff, '\0', nImageSize );

		// Acquire the image data
		DcamCaptureReverseX( pDataBuff, nImageSize * 2 );

		while( TRUE )
		{
			// Wait to complete the image acquisition
			DcamWait( &dwRetStatus, 0 );

			if( dwRetStatus == DCAM_WAITSTATUS_COMPLETED )
			{
				break;
			}
		}
	}
	else
	{
		DcamClose();
		DcamUninitialize();
		return ;
	}

	// Save data in TIFF form ... Using DCamImg.dll
	DcamImgTiffSave( "c9266.tif", pDataBuff, nWidth, nHeight, 16, 12 );
	
	delete [] pDataBuff;

	DcamStop();											// Stop acquisition
	DcamClose();										// Close the device
	DcamUninitialize();									// Uninitialize DLL
}

Luc Pattyn14-Mar-09 9:10

14-Mar-09 9:10

Hi Jason,

The C demo code is interesting, here are some facts:
1. the image buffer needs to be allocated by the caller of the library, we got that right.
2. DcamGetImageSize is used to obtain the image sizes in pixels, and nImageSize is counting pixels, not bytes.
3. the demo code shows a big wait loop polling with DcamWait, so DcamCaptureReverseX is only starting the image capture, not waiting for it to get integrated, scanned, converted and presented in the array, hence the buffer is still untouched at that point in time.

and one strong suspicion:
1. Not sure what the second parameter of DcamCaptureReverseX is meant to be, they have 2*nImageSize, so that probably means size of the buffer in bytes, where each pixel takes 2 bytes (that fits the fact they have a WORD array, WORD=16-bit; however it is in contradiction with the memset where they clear only one byte per pixel); and your C# code does not match up, since you don't have the 2* at all.

my suggestions:
1. I would switch from int pixels to ushort pixels, allowing for 16-bit unsigned values. I now think your camera is a grayscale CCD with at best 16 bits of resolution. If less than 16 bits, the unsigned wouldn't matter at all. Don't forget the factor 2 in the DcamCaptureReverseX call.
2. you need to include a wait scheme; it needs to be inside the fixed block, since the buffer should not be unpinned for as long as the library is using it or going to use it.

Smile | :)

Luc Pattyn [Forum Guidelines] [My Articles]

Jason McPeak14-Mar-09 14:10

14-Mar-09 14:10

I got it working, needed to change a setting - set the trigger mode to internal. Using fixed worked great.

Thank you!

Luc Pattyn14-Mar-09 16:01

14-Mar-09 16:01

Well done.

BTW: I did not get an email notification this time, because you replied to one of your own messages...

Smile | :)

Luc Pattyn [Forum Guidelines] [My Articles]

Jason McPeak14-Mar-09 7:12