/**
* Try undo the harm done by the init function.
*
* This may leave the system in an unstable state since we might have been
* hijacking memory below 1MB that is in use by the kernel.
*/
void vmmR0TripleFaultHackTerm(void)
{
/*
* Restore overwritten memory.
*/
if ( g_pvSavedLowCore
&& g_pbLowCore)
memcpy(g_pbLowCore, g_pvSavedLowCore, PAGE_SIZE);
if (g_pbPage0)
{
g_pbPage0[0x467+0] = RT_BYTE1(g_u32SavedVector);
g_pbPage0[0x467+1] = RT_BYTE2(g_u32SavedVector);
g_pbPage0[0x467+2] = RT_BYTE3(g_u32SavedVector);
g_pbPage0[0x467+3] = RT_BYTE4(g_u32SavedVector);
g_pbPage0[0x472+0] = RT_BYTE1(g_u16SavedCadIndicator);
g_pbPage0[0x472+1] = RT_BYTE2(g_u16SavedCadIndicator);
}
/*
* Fix the CMOS.
*/
if (g_pvSavedLowCore)
{
uint32_t fSaved = ASMIntDisableFlags();
ASMOutU8(0x70, 0x0f);
ASMOutU8(0x71, 0x0a);
ASMOutU8(0x70, 0x00);
ASMInU8(0x71);
ASMReloadCR3();
ASMWriteBackAndInvalidateCaches();
ASMSetFlags(fSaved);
}
/*
* Release resources.
*/
RTMemFree(g_pvSavedLowCore);
g_pvSavedLowCore = NULL;
RTR0MemObjFree(g_hMemLowCore, true /*fFreeMappings*/);
g_hMemLowCore = NIL_RTR0MEMOBJ;
g_hMapLowCore = NIL_RTR0MEMOBJ;
g_pbLowCore = NULL;
g_HCPhysLowCore = NIL_RTHCPHYS;
RTR0MemObjFree(g_hMemPage0, true /*fFreeMappings*/);
g_hMemPage0 = NIL_RTR0MEMOBJ;
g_hMapPage0 = NIL_RTR0MEMOBJ;
g_pbPage0 = NULL;
}
void Mouse::fireMultiTouchEvent(uint8_t cContacts,
const LONG64 *paContacts,
uint32_t u32ScanTime)
{
com::SafeArray<SHORT> xPositions(cContacts);
com::SafeArray<SHORT> yPositions(cContacts);
com::SafeArray<USHORT> contactIds(cContacts);
com::SafeArray<USHORT> contactFlags(cContacts);
uint8_t i;
for (i = 0; i < cContacts; i++)
{
uint32_t u32Lo = RT_LO_U32(paContacts[i]);
uint32_t u32Hi = RT_HI_U32(paContacts[i]);
xPositions[i] = (int16_t)u32Lo;
yPositions[i] = (int16_t)(u32Lo >> 16);
contactIds[i] = RT_BYTE1(u32Hi);
contactFlags[i] = RT_BYTE2(u32Hi);
}
VBoxEventDesc evDesc;
evDesc.init(mEventSource, VBoxEventType_OnGuestMultiTouch,
cContacts, ComSafeArrayAsInParam(xPositions), ComSafeArrayAsInParam(yPositions),
ComSafeArrayAsInParam(contactIds), ComSafeArrayAsInParam(contactFlags), u32ScanTime);
evDesc.fire(0);
}
DECLHIDDEN(int) drvHostBaseReadOs(PDRVHOSTBASE pThis, uint64_t off, void *pvBuf, size_t cbRead)
{
int rc = VINF_SUCCESS;
if (pThis->Os.cbBlock)
{
/*
* Issue a READ(12) request.
*/
do
{
const uint32_t LBA = off / pThis->Os.cbBlock;
AssertReturn(!(off % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
uint32_t cbRead32 = cbRead > SCSI_MAX_BUFFER_SIZE
? SCSI_MAX_BUFFER_SIZE
: (uint32_t)cbRead;
const uint32_t cBlocks = cbRead32 / pThis->Os.cbBlock;
AssertReturn(!(cbRead % pThis->Os.cbBlock), VERR_INVALID_PARAMETER);
uint8_t abCmd[16] =
{
SCSI_READ_12, 0,
RT_BYTE4(LBA), RT_BYTE3(LBA), RT_BYTE2(LBA), RT_BYTE1(LBA),
RT_BYTE4(cBlocks), RT_BYTE3(cBlocks), RT_BYTE2(cBlocks), RT_BYTE1(cBlocks),
0, 0, 0, 0, 0
};
rc = drvHostBaseScsiCmdOs(pThis, abCmd, 12, PDMMEDIATXDIR_FROM_DEVICE, pvBuf, &cbRead32, NULL, 0, 0);
off += cbRead32;
cbRead -= cbRead32;
pvBuf = (uint8_t *)pvBuf + cbRead32;
} while ((cbRead > 0) && RT_SUCCESS(rc));
}
else
rc = VERR_MEDIA_NOT_PRESENT;
return rc;
}
RTDECL(uint32_t) ASMByteSwapU32(uint32_t u32)
{
return RT_MAKE_U32_FROM_U8(RT_BYTE4(u32), RT_BYTE3(u32), RT_BYTE2(u32), RT_BYTE1(u32));
}
/* Used by PutEventMultiTouch and PutEventMultiTouchString. */
HRESULT Mouse::putEventMultiTouch(LONG aCount,
LONG64 *paContacts,
ULONG aScanTime)
{
if (aCount >= 256)
{
return E_INVALIDARG;
}
DisplayMouseInterface *pDisplay = mParent->getDisplayMouseInterface();
ComAssertRet(pDisplay, E_FAIL);
HRESULT rc = S_OK;
uint64_t* pau64Contacts = NULL;
uint8_t cContacts = 0;
/* Deliver 0 contacts too, touch device may use this to reset the state. */
if (aCount > 0)
{
/* Create a copy with converted coords. */
pau64Contacts = (uint64_t *)RTMemTmpAlloc(aCount * sizeof(uint64_t));
if (pau64Contacts)
{
int32_t x1, y1, x2, y2;
/* Takes the display lock */
pDisplay->getFramebufferDimensions(&x1, &y1, &x2, &y2);
LONG i;
for (i = 0; i < aCount; i++)
{
uint32_t u32Lo = RT_LO_U32(paContacts[i]);
uint32_t u32Hi = RT_HI_U32(paContacts[i]);
int32_t x = (int16_t)u32Lo;
int32_t y = (int16_t)(u32Lo >> 16);
uint8_t contactId = RT_BYTE1(u32Hi);
bool fInContact = (RT_BYTE2(u32Hi) & 0x1) != 0;
bool fInRange = (RT_BYTE2(u32Hi) & 0x2) != 0;
LogRel3(("%s: [%d] %d,%d id %d, inContact %d, inRange %d\n",
__FUNCTION__, i, x, y, contactId, fInContact, fInRange));
/* Framebuffer dimensions are 0,0 width, height, that is x2,y2 are exclusive,
* while coords are inclusive.
*/
int32_t xAdj = x1 < x2 ? ((x - 1 - x1) * VMMDEV_MOUSE_RANGE)
/ (x2 - x1) : 0;
int32_t yAdj = y1 < y2 ? ((y - 1 - y1) * VMMDEV_MOUSE_RANGE)
/ (y2 - y1) : 0;
bool fValid = ( xAdj >= VMMDEV_MOUSE_RANGE_MIN
&& xAdj <= VMMDEV_MOUSE_RANGE_MAX
&& yAdj >= VMMDEV_MOUSE_RANGE_MIN
&& yAdj <= VMMDEV_MOUSE_RANGE_MAX);
if (fValid)
{
uint8_t fu8 = (fInContact? 0x01: 0x00)
| (fInRange? 0x02: 0x00);
pau64Contacts[cContacts] = RT_MAKE_U64_FROM_U16((uint16_t)xAdj,
(uint16_t)yAdj,
RT_MAKE_U16(contactId, fu8),
0);
cContacts++;
}
}
}
else
{
/* Used by PutEventMultiTouch and PutEventMultiTouchString. */
HRESULT Mouse::putEventMultiTouch(LONG aCount,
LONG64 *paContacts,
ULONG aScanTime)
{
if (aCount >= 256)
{
return E_INVALIDARG;
}
DisplayMouseInterface *pDisplay = mParent->getDisplayMouseInterface();
ComAssertRet(pDisplay, E_FAIL);
/* Touch events are mapped to the primary monitor, because the emulated USB
* touchscreen device is associated with one (normally the primary) screen in the guest.
*/
ULONG uScreenId = 0;
ULONG cWidth = 0;
ULONG cHeight = 0;
LONG xOrigin = 0;
LONG yOrigin = 0;
HRESULT rc = pDisplay->getScreenResolution(uScreenId, &cWidth, &cHeight, NULL, &xOrigin, &yOrigin);
ComAssertComRCRetRC(rc);
uint64_t* pau64Contacts = NULL;
uint8_t cContacts = 0;
/* Deliver 0 contacts too, touch device may use this to reset the state. */
if (aCount > 0)
{
/* Create a copy with converted coords. */
pau64Contacts = (uint64_t *)RTMemTmpAlloc(aCount * sizeof(uint64_t));
if (pau64Contacts)
{
int32_t x1 = xOrigin;
int32_t y1 = yOrigin;
int32_t x2 = x1 + cWidth;
int32_t y2 = y1 + cHeight;
LogRel3(("%s: screen [%d] %d,%d %d,%d\n",
__FUNCTION__, uScreenId, x1, y1, x2, y2));
LONG i;
for (i = 0; i < aCount; i++)
{
uint32_t u32Lo = RT_LO_U32(paContacts[i]);
uint32_t u32Hi = RT_HI_U32(paContacts[i]);
int32_t x = (int16_t)u32Lo;
int32_t y = (int16_t)(u32Lo >> 16);
uint8_t contactId = RT_BYTE1(u32Hi);
bool fInContact = (RT_BYTE2(u32Hi) & 0x1) != 0;
bool fInRange = (RT_BYTE2(u32Hi) & 0x2) != 0;
LogRel3(("%s: [%d] %d,%d id %d, inContact %d, inRange %d\n",
__FUNCTION__, i, x, y, contactId, fInContact, fInRange));
/* x1,y1 are inclusive and x2,y2 are exclusive,
* while x,y start from 1 and are inclusive.
*/
if (x <= x1 || x > x2 || y <= y1 || y > y2)
{
/* Out of range. Skip the contact. */
continue;
}
int32_t xAdj = x1 < x2? ((x - 1 - x1) * VMMDEV_MOUSE_RANGE) / (x2 - x1) : 0;
int32_t yAdj = y1 < y2? ((y - 1 - y1) * VMMDEV_MOUSE_RANGE) / (y2 - y1) : 0;
bool fValid = ( xAdj >= VMMDEV_MOUSE_RANGE_MIN
&& xAdj <= VMMDEV_MOUSE_RANGE_MAX
&& yAdj >= VMMDEV_MOUSE_RANGE_MIN
&& yAdj <= VMMDEV_MOUSE_RANGE_MAX);
if (fValid)
{
uint8_t fu8 = (fInContact? 0x01: 0x00)
| (fInRange? 0x02: 0x00);
pau64Contacts[cContacts] = RT_MAKE_U64_FROM_U16((uint16_t)xAdj,
(uint16_t)yAdj,
RT_MAKE_U16(contactId, fu8),
0);
cContacts++;
}
}
}
else
{
void UIVMPreviewWindow::sltRecreatePreview()
{
/* Only do this if we are visible: */
if (!isVisible())
return;
/* Remove preview if any: */
if (m_pPreviewImg)
{
delete m_pPreviewImg;
m_pPreviewImg = 0;
}
/* We are not creating preview for inaccessible VMs: */
if (m_machineState == KMachineState_Null)
return;
if (!m_machine.isNull() && m_vRect.width() > 0 && m_vRect.height() > 0)
{
QImage image(size(), QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter painter(&image);
bool fDone = false;
/* Preview enabled? */
if (m_pUpdateTimer->interval() > 0)
{
/* Use the image which may be included in the save state. */
if ( m_machineState == KMachineState_Saved
|| m_machineState == KMachineState_Restoring)
{
ULONG width = 0, height = 0;
QVector<BYTE> screenData = m_machine.ReadSavedScreenshotPNGToArray(0, width, height);
if (screenData.size() != 0)
{
QImage shot = QImage::fromData(screenData.data(), screenData.size(), "PNG").scaled(m_vRect.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
dimImage(shot);
painter.drawImage(m_vRect.x(), m_vRect.y(), shot);
fDone = true;
}
}
/* Use the current VM output. */
else if ( m_machineState == KMachineState_Running
// || m_machineState == KMachineState_Saving /* Not sure if this is valid */
|| m_machineState == KMachineState_Paused)
{
if (m_session.GetState() == KSessionState_Locked)
{
CVirtualBox vbox = vboxGlobal().virtualBox();
if (vbox.isOk())
{
const CConsole& console = m_session.GetConsole();
if (!console.isNull())
{
CDisplay display = console.GetDisplay();
/* Todo: correct aspect radio */
// ULONG w, h, bpp;
// display.GetScreenResolution(0, w, h, bpp);
// QImage shot = QImage(w, h, QImage::Format_RGB32);
// shot.fill(Qt::black);
// display.TakeScreenShot(0, shot.bits(), shot.width(), shot.height());
QVector<BYTE> screenData = display.TakeScreenShotToArray(0, m_vRect.width(), m_vRect.height());
if ( display.isOk()
&& screenData.size() != 0)
{
/* Unfortunately we have to reorder the pixel
* data, cause the VBox API returns RGBA data,
* which is not a format QImage understand.
* Todo: check for 32bit alignment, for both
* the data and the scanlines. Maybe we need to
* copy the data in any case. */
uint32_t *d = (uint32_t*)screenData.data();
for (int i = 0; i < screenData.size() / 4; ++i)
{
uint32_t e = d[i];
d[i] = RT_MAKE_U32_FROM_U8(RT_BYTE3(e), RT_BYTE2(e), RT_BYTE1(e), RT_BYTE4(e));
}
QImage shot = QImage((uchar*)d, m_vRect.width(), m_vRect.height(), QImage::Format_RGB32);
if (m_machineState == KMachineState_Paused)
dimImage(shot);
painter.drawImage(m_vRect.x(), m_vRect.y(), shot);
fDone = true;
}
}
}
}
}
}
if (fDone)
m_pPreviewImg = new QImage(image);
}
update();
}
/**
* Deals with complicated MMIO reads.
*
* Complicated means unaligned or non-dword/qword sized accesses depending on
* the MMIO region's access mode flags.
*
* @returns Strict VBox status code. Any EM scheduling status code,
* VINF_IOM_R3_MMIO_READ, VINF_IOM_R3_MMIO_READ_WRITE or
* VINF_IOM_R3_MMIO_WRITE may be returned.
*
* @param pVM The cross context VM structure.
* @param pRange The range to read from.
* @param GCPhys The physical address to start reading.
* @param pvValue Where to store the value.
* @param cbValue The size of the value to read.
*/
static VBOXSTRICTRC iomMMIODoComplicatedRead(PVM pVM, PIOMMMIORANGE pRange, RTGCPHYS GCPhys, void *pvValue, unsigned cbValue)
{
AssertReturn( (pRange->fFlags & IOMMMIO_FLAGS_READ_MODE) == IOMMMIO_FLAGS_READ_DWORD
|| (pRange->fFlags & IOMMMIO_FLAGS_READ_MODE) == IOMMMIO_FLAGS_READ_DWORD_QWORD,
VERR_IOM_MMIO_IPE_1);
AssertReturn(cbValue != 0 && cbValue <= 16, VERR_IOM_MMIO_IPE_2);
RTGCPHYS const GCPhysStart = GCPhys; NOREF(GCPhysStart);
/*
* Do debug stop if requested.
*/
int rc = VINF_SUCCESS; NOREF(pVM);
#ifdef VBOX_STRICT
if (pRange->fFlags & IOMMMIO_FLAGS_DBGSTOP_ON_COMPLICATED_READ)
{
# ifdef IN_RING3
rc = DBGFR3EventSrc(pVM, DBGFEVENT_DEV_STOP, RT_SRC_POS,
"Complicated read %#x byte at %RGp to %s\n", cbValue, GCPhys, R3STRING(pRange->pszDesc));
if (rc == VERR_DBGF_NOT_ATTACHED)
rc = VINF_SUCCESS;
# else
return VINF_IOM_R3_MMIO_READ;
# endif
}
#endif
/*
* Split and conquer.
*/
for (;;)
{
/*
* Do DWORD read from the device.
*/
uint32_t u32Value;
int rc2 = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser),
GCPhys & ~(RTGCPHYS)3, &u32Value, sizeof(u32Value));
switch (rc2)
{
case VINF_SUCCESS:
break;
case VINF_IOM_MMIO_UNUSED_FF:
u32Value = UINT32_C(0xffffffff);
break;
case VINF_IOM_MMIO_UNUSED_00:
u32Value = 0;
break;
case VINF_IOM_R3_MMIO_READ:
case VINF_IOM_R3_MMIO_READ_WRITE:
case VINF_IOM_R3_MMIO_WRITE:
/** @todo What if we've split a transfer and already read
* something? Since reads can have sideeffects we could be
* kind of screwed here... */
LogFlow(("iomMMIODoComplicatedRead: GCPhys=%RGp GCPhysStart=%RGp cbValue=%u rc=%Rrc\n", GCPhys, GCPhysStart, cbValue, rc2));
return rc2;
default:
if (RT_FAILURE(rc2))
{
Log(("iomMMIODoComplicatedRead: GCPhys=%RGp GCPhysStart=%RGp cbValue=%u rc=%Rrc\n", GCPhys, GCPhysStart, cbValue, rc2));
return rc2;
}
AssertMsgReturn(rc2 >= VINF_EM_FIRST && rc2 <= VINF_EM_LAST, ("%Rrc\n", rc2), VERR_IPE_UNEXPECTED_INFO_STATUS);
if (rc == VINF_SUCCESS || rc2 < rc)
rc = rc2;
break;
}
u32Value >>= (GCPhys & 3) * 8;
/*
* Write what we've read.
*/
unsigned cbThisPart = 4 - (GCPhys & 3);
if (cbThisPart > cbValue)
cbThisPart = cbValue;
switch (cbThisPart)
{
case 1:
*(uint8_t *)pvValue = (uint8_t)u32Value;
break;
case 2:
*(uint16_t *)pvValue = (uint16_t)u32Value;
break;
case 3:
((uint8_t *)pvValue)[0] = RT_BYTE1(u32Value);
((uint8_t *)pvValue)[1] = RT_BYTE2(u32Value);
((uint8_t *)pvValue)[2] = RT_BYTE3(u32Value);
break;
case 4:
*(uint32_t *)pvValue = u32Value;
break;
}
/*
* Advance.
*/
cbValue -= cbThisPart;
if (!cbValue)
break;
GCPhys += cbThisPart;
pvValue = (uint8_t *)pvValue + cbThisPart;
}
return rc;
}
aubio_source_apple_audio_t * new_aubio_source_apple_audio(char_t * path, uint_t samplerate, uint_t block_size)
{
aubio_source_apple_audio_t * s = AUBIO_NEW(aubio_source_apple_audio_t);
s->path = path;
s->block_size = block_size;
OSStatus err = noErr;
UInt32 propSize;
// open the resource url
CFURLRef fileURL = getURLFromPath(path);
err = ExtAudioFileOpenURL(fileURL, &s->audioFile);
if (err) { AUBIO_ERR("error when trying to access %s, in ExtAudioFileOpenURL, %d\n", s->path, (int)err); goto beach;}
// create an empty AudioStreamBasicDescription
AudioStreamBasicDescription fileFormat;
propSize = sizeof(fileFormat);
memset(&fileFormat, 0, sizeof(AudioStreamBasicDescription));
// fill it with the file description
err = ExtAudioFileGetProperty(s->audioFile,
kExtAudioFileProperty_FileDataFormat, &propSize, &fileFormat);
if (err) { AUBIO_ERROR("error in ExtAudioFileGetProperty, %d\n", (int)err); goto beach;}
if (samplerate == 0) {
samplerate = fileFormat.mSampleRate;
//AUBIO_DBG("sampling rate set to 0, automagically adjusting to %d\n", samplerate);
}
s->samplerate = samplerate;
s->source_samplerate = fileFormat.mSampleRate;
s->channels = fileFormat.mChannelsPerFrame;
AudioStreamBasicDescription clientFormat;
propSize = sizeof(clientFormat);
memset(&clientFormat, 0, sizeof(AudioStreamBasicDescription));
clientFormat.mFormatID = kAudioFormatLinearPCM;
clientFormat.mSampleRate = (Float64)(s->samplerate);
clientFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
clientFormat.mChannelsPerFrame = s->channels;
clientFormat.mBitsPerChannel = sizeof(short) * 8;
clientFormat.mFramesPerPacket = 1;
clientFormat.mBytesPerFrame = clientFormat.mBitsPerChannel * clientFormat.mChannelsPerFrame / 8;
clientFormat.mBytesPerPacket = clientFormat.mFramesPerPacket * clientFormat.mBytesPerFrame;
clientFormat.mReserved = 0;
// set the client format description
err = ExtAudioFileSetProperty(s->audioFile, kExtAudioFileProperty_ClientDataFormat,
propSize, &clientFormat);
if (err) {
AUBIO_ERROR("error in ExtAudioFileSetProperty, %d\n", (int)err);
#if 1
// print client and format descriptions
AUBIO_DBG("Opened %s\n", s->path);
AUBIO_DBG("file/client Format.mFormatID: : %3c%c%c%c / %c%c%c%c\n",
(int)RT_BYTE4(fileFormat.mFormatID), (int)RT_BYTE3(fileFormat.mFormatID), (int)RT_BYTE2(fileFormat.mFormatID), (int)RT_BYTE1(fileFormat.mFormatID),
(int)RT_BYTE4(clientFormat.mFormatID), (int)RT_BYTE3(clientFormat.mFormatID), (int)RT_BYTE2(clientFormat.mFormatID), (int)RT_BYTE1(clientFormat.mFormatID)
);
AUBIO_DBG("file/client Format.mSampleRate : %6.0f / %.0f\n", fileFormat.mSampleRate , clientFormat.mSampleRate);
AUBIO_DBG("file/client Format.mFormatFlags : %6d / %d\n", (int)fileFormat.mFormatFlags , (int)clientFormat.mFormatFlags);
AUBIO_DBG("file/client Format.mChannelsPerFrame : %6d / %d\n", (int)fileFormat.mChannelsPerFrame, (int)clientFormat.mChannelsPerFrame);
AUBIO_DBG("file/client Format.mBitsPerChannel : %6d / %d\n", (int)fileFormat.mBitsPerChannel , (int)clientFormat.mBitsPerChannel);
AUBIO_DBG("file/client Format.mFramesPerPacket : %6d / %d\n", (int)fileFormat.mFramesPerPacket , (int)clientFormat.mFramesPerPacket);
AUBIO_DBG("file/client Format.mBytesPerFrame : %6d / %d\n", (int)fileFormat.mBytesPerFrame , (int)clientFormat.mBytesPerFrame);
AUBIO_DBG("file/client Format.mBytesPerPacket : %6d / %d\n", (int)fileFormat.mBytesPerPacket , (int)clientFormat.mBytesPerPacket);
AUBIO_DBG("file/client Format.mReserved : %6d / %d\n", (int)fileFormat.mReserved , (int)clientFormat.mReserved);
#endif
goto beach;
}
// compute the size of the segments needed to read the input file
UInt32 samples = s->block_size * clientFormat.mChannelsPerFrame;
Float64 rateRatio = clientFormat.mSampleRate / fileFormat.mSampleRate;
uint_t segmentSize= (uint_t)(samples * rateRatio + .5);
if (rateRatio < 1.) {
segmentSize = (uint_t)(samples / rateRatio + .5);
} else if (rateRatio > 1.) {
AUBIO_WRN("up-sampling %s from %0.2fHz to %0.2fHz\n", s->path, fileFormat.mSampleRate, clientFormat.mSampleRate);
} else {
assert ( segmentSize == samples );
//AUBIO_DBG("not resampling, segmentSize %d, block_size %d\n", segmentSize, s->block_size);
}
// allocate the AudioBufferList
if (createAubioBufferList(&s->bufferList, s->channels, segmentSize)) err = -1;
return s;
beach:
AUBIO_FREE(s);
return NULL;
}
