XnUInt32 XnSensorImageStream::CalculateExpectedSize()
{
XnUInt32 nExpectedImageBufferSize = GetXRes() * GetYRes();
// when cropping is turned on, actual IR size is smaller
const XnCropping* pCropping = GetCropping();
if (pCropping->bEnabled)
{
nExpectedImageBufferSize = pCropping->nXSize * pCropping->nYSize;
}
switch (m_InputFormat.GetValue())
{
case XN_IO_IMAGE_FORMAT_YUV422:
case XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422:
// in YUV each pixel is represented in 2 bytes (actually 2 pixels are represented by 4 bytes)
nExpectedImageBufferSize *= 2;
break;
case XN_IO_IMAGE_FORMAT_BAYER:
// each pixel is one byte.
break;
case XN_IO_IMAGE_FORMAT_JPEG:
// image should be in RGB now - 3 bytes a pixel
nExpectedImageBufferSize *= 3;
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DEVICE_SENSOR, "Does not know to calculate expected size for input format %d", m_InputFormat.GetValue());
}
return nExpectedImageBufferSize;
}
OniStatus LinkOniMapStream::getProperty(int propertyId, void* data, int* pDataSize)
{
XnStatus nRetVal = XN_STATUS_ERROR;
switch(propertyId)
{
case ONI_STREAM_PROPERTY_VIDEO_MODE:
EXACT_PROP_SIZE(*pDataSize, OniVideoMode);
nRetVal = GetVideoMode((OniVideoMode*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case ONI_STREAM_PROPERTY_MIRRORING:
EXACT_PROP_SIZE(*pDataSize, OniBool);
nRetVal = GetMirror((OniBool*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case ONI_STREAM_PROPERTY_CROPPING:
EXACT_PROP_SIZE(*pDataSize, OniCropping);
nRetVal = GetCropping(*(OniCropping*)data);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
break;
case LINK_PROP_PIXEL_FORMAT:
ENSURE_PROP_SIZE(*pDataSize, XnLinkPixelFormat);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, m_pInputStream->GetVideoMode().m_nPixelFormat);
break;
case LINK_PROP_COMPRESSION:
ENSURE_PROP_SIZE(*pDataSize, XnLinkCompressionType);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, m_pInputStream->GetVideoMode().m_nCompression);
break;
case PS_PROPERTY_GAIN:
{
ENSURE_PROP_SIZE(*pDataSize, XnUInt16);
XnUInt16 gain;
nRetVal = m_pInputStream->GetGain(gain);
XN_IS_STATUS_OK_RET(nRetVal, ONI_STATUS_ERROR);
ASSIGN_PROP_VALUE_INT(data, *pDataSize, gain);
}
break;
default:
{
return LinkOniStream::getProperty(propertyId, data, pDataSize);
}
}
return ONI_STATUS_OK;
}
XnStatus XnSensorIRStream::OnIsMirroredChanged()
{
XnStatus nRetVal = XN_STATUS_OK;
// if cropping is on, we need to flip it
OniCropping cropping = *GetCropping();
if (cropping.enabled)
{
nRetVal = SetCropping(&cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::SetCroppingMode(XnCroppingMode mode)
{
switch (mode)
{
case XN_CROPPING_MODE_NORMAL:
case XN_CROPPING_MODE_INCREASED_FPS:
case XN_CROPPING_MODE_SOFTWARE_ONLY:
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Bad cropping mode: %u", mode);
}
return SetCroppingImpl(GetCropping(), mode);
}
XnStatus XnPixelStream::FixCropping()
{
XnStatus nRetVal = XN_STATUS_OK;
XnCropping cropping = *GetCropping();
if (cropping.nXOffset > GetXRes() ||
cropping.nYOffset > GetYRes() ||
XnUInt32(cropping.nXOffset + cropping.nXSize) > GetXRes() ||
XnUInt32(cropping.nYOffset + cropping.nYSize) > GetYRes())
{
// disable it
cropping.bEnabled = FALSE;
nRetVal = SetCropping(&cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::FixCropping()
{
XnStatus nRetVal = XN_STATUS_OK;
OniCropping cropping = *GetCropping();
if (cropping.originX > (int)GetXRes() ||
cropping.originY > (int)GetYRes() ||
(cropping.originX + cropping.width) > (int)GetXRes() ||
(cropping.originY + cropping.height) > (int)GetYRes())
{
// disable it
cropping.enabled = FALSE;
nRetVal = SetCropping(&cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
void XnPixelStream::NewDataAvailable(OniFrame* pFrame)
{
// crop
xnOSEnterCriticalSection(GetLock());
OniCropping cropping = *GetCropping();
xnOSLeaveCriticalSection(GetLock());
if (cropping.enabled)
{
XnStatus nRetVal = CropImpl(pFrame, &cropping);
if (nRetVal != XN_STATUS_OK)
{
xnLogWarning(XN_MASK_DDK, "Failed to crop! Frame will be dropped");
return;
}
}
XnFrameStream::NewDataAvailable(pFrame);
}
void XnSensorIRGenerator::OnResChanged()
{
// we calculate the size because the IR stream actually gives out a bigger buffer, but
// we want the buffer we return to be with the right size.
XnMapOutputMode outputMode;
GetMapOutputMode(outputMode);
XnUInt32 nPixels = outputMode.nXRes * outputMode.nYRes;
XnCropping cropping;
GetCropping(cropping);
if (cropping.bEnabled)
{
nPixels = cropping.nXSize * cropping.nYSize;
}
m_nBufferSize = nPixels * sizeof(XnIRPixel);
}
XnStatus XnPixelStream::ReadImpl(XnStreamData* pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
// first read
nRetVal = XnFrameStream::ReadImpl(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
// now crop
xnOSEnterCriticalSection(GetLock());
XnCropping cropping = *GetCropping();
xnOSLeaveCriticalSection(GetLock());
if (cropping.bEnabled)
{
nRetVal = CropImpl(pStreamOutput, &cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::Mirror(XnStreamData* pStreamOutput) const
{
XnUInt32 nXRes = GetCropping()->bEnabled ? GetCropping()->nXSize : GetXRes();
return XnFormatsMirrorPixelData(GetOutputFormat(), (XnUChar*)pStreamOutput->pData, pStreamOutput->nDataSize, nXRes);
}
