C++ WolframLibraryData::Message方法代码示例

EXTERN_C DLLEXPORT int GrabFrame(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	int err = LIBRARY_NO_ERROR;

	// get a pointer to the byte buffer:
	BYTE *pData;
	hr = VR.getReadBuffer(&pData);

	if (hr == MF_E_END_OF_STREAM)
	{
		libData->Message("endofstream");
		return LIBRARY_FUNCTION_ERROR;
	}

	if (FAILED(hr))
	{
		libData->Message("getdatafail");
		return LIBRARY_FUNCTION_ERROR;
	} 

	// create the rank 3 MTensor
	MTensor T0;
	mint dims[3];
	dims[0] = (mint) VR.m_imageheight;
	dims[1] = (mint) VR.m_imagewidth;
	dims[2] = 3;
	err = libData->MTensor_new(MType_Integer, 3, dims, &T0);

	// fill the MTensor from the byte buffer
	mint *mtdata;
    mtdata = libData->MTensor_getIntegerData(T0);
    int npixels = VR.m_imageheight * VR.m_imagewidth;   

    for (int i = 0; i < npixels; i++) {
		// we read B, G, R, (A) bytes and put R, G, B into the pixel buffer
		mtdata[3 * i    ] = (mint) pData[4 * i + 2]; // R
        mtdata[3 * i + 1] = (mint) pData[4 * i + 1]; // G
        mtdata[3 * i + 2] = (mint) pData[4 * i    ]; // B
	}
    
	// unlock the buffer
	hr = VR.releaseBuffer();
	if (FAILED(hr))
	{
		libData->Message("releaseBufferfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// return the MTensor to Mathematica
	MArgument_setMTensor(Res, T0);
	return err; 

} 

EXTERN_C DLLEXPORT int SendFrame(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	MTensor T0 = MArgument_getMTensor(Args[0]);
    mint len = libData->MTensor_getFlattenedLength(T0);

	// check that we have the right amount of data
	UINT32 expectedlength = VW.m_height * VW.m_width * 3;

	if (len != (mint) expectedlength)
	{
		libData->Message("dimensionsfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// get a buffer
	BYTE *pData = NULL;
	hr = VW.getWriteBuffer(&pData);
	if (FAILED(hr))
	{
		libData->Message("getwritebufferfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// fill the buffer
	mint *mtdata;
    int npixels = len / 3;
    mtdata = libData->MTensor_getIntegerData(T0);
               
    for (int i = 0; i < npixels; i++) {
		// we read R, G, B bytes and put B, G, R, A into the pixel buffer
		pData[4 * i + 2] = (BYTE) mtdata[3 * i    ]; // R
        pData[4 * i + 1] = (BYTE) mtdata[3 * i + 1]; // G
        pData[4 * i    ] = (BYTE) mtdata[3 * i + 2]; // B
        pData[4 * i + 3] = 0;						 // A
	}             
	
	// write the sample
	hr = VW.writeFrame(pData);
	if (FAILED(hr))
	{
		libData->Message("writeFramefail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// return the timestamp to Mathematica
	MArgument_setInteger(Res, VW.m_rtStart);

	return LIBRARY_NO_ERROR;
} 

EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) {
   
	// Initialize the COM library
	hr = CoInitialize(NULL);
	if (FAILED(hr))
	{
		libData->Message("cominitfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// Initialize Media Foundation.
	hr = MFStartup(MF_VERSION);
	if (FAILED(hr))
    {
		libData->Message("mfinitfail");
		return LIBRARY_FUNCTION_ERROR;    
    }

	return LIBRARY_NO_ERROR;
}

EXTERN_C DLLEXPORT int FinaliseSink(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	hr = VW.finalise();

	if (FAILED(hr))
	{
		libData->Message("finalisefail");
		return LIBRARY_FUNCTION_ERROR;
	}

	return LIBRARY_NO_ERROR;
} 

EXTERN_C DLLEXPORT int InitSinkWriter(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	// Get the arguments from MArgument
	char *videofile = MArgument_getUTF8String(Args[0]);

	// convert UTF8 filename to wide chars
	int size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, NULL, 0);
	WCHAR* videofileW = new WCHAR[size];
	size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, videofileW, size);
	
	// extract the sink parameters
	mint encoder =		MArgument_getInteger(Args[1]);
	mint width =		MArgument_getInteger(Args[2]);
	mint height =		MArgument_getInteger(Args[3]);
	mreal framerate =	MArgument_getReal(Args[4]);
	mint kbps =			MArgument_getInteger(Args[5]);

	hr = VW.setParams(encoder, width, height, framerate, kbps);
	if (FAILED(hr))
	{
		libData->Message("setsinkparamsfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// Initialise the sink writer
	hr = VW.initSinkWriter(videofileW);

	// finished with the filename now
	delete videofileW;	
	
	if (FAILED(hr))
	{
		libData->Message("initsinkfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	return LIBRARY_NO_ERROR;
} 

EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) {

	VR.~VidReader(); // destruct the class instances
	VW.~VidWriter(); 

	// Shut down media foundation and close the COM library
	hr = MFShutdown();
	if (FAILED(hr))
	{
		libData->Message("mfshutdownfail");
	} 
	CoUninitialize();
	
	return;
}

EXTERN_C DLLEXPORT int InitSourceReader(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	// Get the arguments from MArgument
	char *videofile = MArgument_getUTF8String(Args[0]);

	// convert UTF8 filename to wide chars
	int size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, NULL, 0);
	WCHAR* videofileW = new WCHAR[size];
	size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, videofileW, size);
	
	// Open the file
	hr = VR.initSourceReader(videofileW);

	// finished with the filename now
	delete videofileW;	
	
	if (FAILED(hr))
	{
		libData->Message("initsourcefail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// Return the duration and frame rate
	MTensor T0;
	mint dims[1] = {4};
	mint pos[1];
	
	libData->MTensor_new(MType_Real, 1, dims, &T0);

	pos[0] = 1;
	libData->MTensor_setReal(T0, pos, VR.m_duration);

	pos[0] = 2;
	libData->MTensor_setReal(T0, pos, VR.m_framerate);

	pos[0] = 3;
	libData->MTensor_setReal(T0, pos, VR.m_imagewidth);

	pos[0] = 4;
	libData->MTensor_setReal(T0, pos, VR.m_imageheight);

	MArgument_setMTensor(Res, T0);
	
	return LIBRARY_NO_ERROR;
}