INT UEyeCamDriver::setExtTriggerMode() {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
if (!extTriggerModeActive()) {
setStandbyMode(); // No need to check for success
if ((is_err = is_EnableEvent(cam_handle_, IS_SET_EVENT_FRAME)) != IS_SUCCESS) {
std::cerr << "Could not enable frame event for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_SetExternalTrigger(cam_handle_, IS_SET_TRIGGER_HI_LO)) != IS_SUCCESS) {
std::cerr << "Could not enable falling-edge external trigger mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_CaptureVideo(cam_handle_, IS_DONT_WAIT)) != IS_SUCCESS) {
std::cerr << "Could not start external trigger live video mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
std::cout << "Started falling-edge external trigger live video mode on UEye camera '" + cam_name_ + "'"
<< std::endl;
}
return is_err;
}
INT UEyeCamDriver::setSensorScaling(double& rate, bool reallocate_buffer) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
// Stop capture to prevent access to memory buffer
setStandbyMode();
SENSORSCALERINFO sensorScalerInfo;
is_err = is_GetSensorScalerInfo(cam_handle_, &sensorScalerInfo,
sizeof(sensorScalerInfo));
if (is_err == IS_NOT_SUPPORTED) {
std::cerr << "Internal image scaling is not supported by camera" << std::endl;
rate = 1.0;
cam_sensor_scaling_rate_ = 1.0;
return IS_SUCCESS;
} else if (is_err != IS_SUCCESS) {
std::cerr << "Could not obtain supported internal image scaling information ("
<< err2str(is_err) << ")" << std::endl;
rate = 1.0;
cam_sensor_scaling_rate_ = 1.0;
return is_err;
} else {
if (rate < sensorScalerInfo.dblMinFactor || rate
> sensorScalerInfo.dblMaxFactor) {
std::cerr << "Requested internal image scaling rate of " << rate
<< " is not within supported bounds of ["
<< sensorScalerInfo.dblMinFactor << ", "
<< sensorScalerInfo.dblMaxFactor
<< "]; not updating current rate of "
<< sensorScalerInfo.dblCurrFactor << std::endl;
rate = sensorScalerInfo.dblCurrFactor;
return IS_SUCCESS;
}
}
if ((is_err = is_SetSensorScaler(cam_handle_, IS_ENABLE_SENSOR_SCALER, rate))
!= IS_SUCCESS) {
std::cerr << "Could not set internal image scaling rate to " << rate
<< "X (" << err2str(is_err) << "); resetting to 1X"
<< std::endl;
rate = 1.0;
if ((is_err = is_SetSensorScaler(cam_handle_, IS_ENABLE_SENSOR_SCALER, rate))
!= IS_SUCCESS) {
std::cerr << "Could not set internal image scaling rate to 1X ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
}
std::cout << "Updated internal image scaling rate to " << rate << "X" << std::endl;
cam_sensor_scaling_rate_ = rate;
return (reallocate_buffer ? reallocateCamBuffer() : IS_SUCCESS);
}
INT UEyeCamDriver::connectCam(int new_cam_ID) {
INT is_err = IS_SUCCESS;
int numCameras;
// Terminate any existing opened cameras
setStandbyMode();
// Updates camera ID if specified.
if (new_cam_ID >= 0) {
cam_id_ = new_cam_ID;
}
// Query for number of connected cameras
if ((is_err = is_GetNumberOfCameras(&numCameras)) != IS_SUCCESS) {
std::cerr << "Failed query for number of connected UEye cameras ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
} else if (numCameras < 1) {
std::cerr << "No UEye cameras are connected" << std::endl;
return IS_NO_SUCCESS;
} // NOTE: previously checked if ID < numCameras, but turns out that ID can be arbitrary
// Attempt to open camera handle, and handle case where camera requires a
// mandatory firmware upload
cam_handle_ = (HIDS) cam_id_;
if ((is_err = is_InitCamera(&cam_handle_, NULL)) == IS_STARTER_FW_UPLOAD_NEEDED) {
INT uploadTimeMSEC = 25000;
is_GetDuration(cam_handle_, IS_STARTER_FW_UPLOAD, &uploadTimeMSEC);
std::cout << "Uploading new firmware to UEye camera '" << cam_name_
<< "'; please wait for about " << uploadTimeMSEC / 1000.0
<< " seconds" << std::endl;
// Attempt to re-open camera handle while triggering automatic firmware upload
cam_handle_ = (HIDS) (((INT) cam_handle_) | IS_ALLOW_STARTER_FW_UPLOAD);
is_err = is_InitCamera(&cam_handle_, NULL); // Will block for N seconds
}
if (is_err != IS_SUCCESS) {
std::cerr << "Could not open UEye camera ID " << cam_id_ << " ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
// Set display mode to Device Independent Bitmap (DIB)
is_err = is_SetDisplayMode(cam_handle_, IS_SET_DM_DIB);
// Fetch sensor parameters
is_err = is_GetSensorInfo(cam_handle_, &cam_sensor_info_);
// Initialize local camera frame buffer
reallocateCamBuffer();
return is_err;
}
void setup_shared_buffer_format(COMPONENT_T *decodeComponent, int decodePort,
COMPONENT_T *renderComponent, int renderPort)
{
OMX_PARAM_PORTDEFINITIONTYPE portdef, rportdef;
;
int ret;
OMX_ERRORTYPE err;
// need to setup the input for the render with the output of the
// decoder
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decodePort;
OMX_GetParameter(ilclient_get_handle(decodeComponent),
OMX_IndexParamPortDefinition, &portdef);
// Get default values of render
rportdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
rportdef.nVersion.nVersion = OMX_VERSION;
rportdef.nPortIndex = renderPort;
// rportdef.nBufferSize = portdef.nBufferSize;
// nBufferSize = portdef.nBufferSize;
err = OMX_GetParameter(ilclient_get_handle(renderComponent),
OMX_IndexParamPortDefinition, &rportdef);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error getting render port params %s\n", err2str(err));
exit(1);
}
// tell render input what the decoder output will be providing
//Copy some
rportdef.format.video.nFrameWidth = portdef.format.image.nFrameWidth;
rportdef.format.video.nFrameHeight = portdef.format.image.nFrameHeight;
rportdef.format.video.nStride = portdef.format.image.nStride;
rportdef.format.video.nSliceHeight = portdef.format.image.nSliceHeight;
err = OMX_SetParameter(ilclient_get_handle(renderComponent),
OMX_IndexParamPortDefinition, &rportdef);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting render port params %s\n", err2str(err));
exit(1);
}
else
{
printf("Render port params set up ok\n");
}
}
static void set_video_decoder_input_format(COMPONENT_T *component)
{
int err;
// set input video format
printf("Setting video decoder format\n");
OMX_VIDEO_PARAM_PORTFORMATTYPE videoPortFormat;
//setHeader(&videoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
memset(&videoPortFormat, 0, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
videoPortFormat.nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE);
videoPortFormat.nVersion.nVersion = OMX_VERSION;
videoPortFormat.nPortIndex = 130;
videoPortFormat.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
// videoPortFormat.eCompressionFormat = OMX_VIDEO_CodingAVC;
err = OMX_SetParameter(ilclient_get_handle(component),
OMX_IndexParamVideoPortFormat, &videoPortFormat);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting video decoder format %s\n", err2str(err));
return; // err;
}
else
{
printf("Video decoder format set up ok\n");
}
}
OMX_ERRORTYPE read_into_buffer_and_empty(FILE *fp,
COMPONENT_T *component,
OMX_BUFFERHEADERTYPE *buff_header,
int *toread)
{
OMX_ERRORTYPE r;
int buff_size = buff_header->nAllocLen;
int nread = fread(buff_header->pBuffer, 1, buff_size, fp);
buff_header->nFilledLen = nread;
*toread -= nread;
printf("Read %d, %d still left\n", nread, *toread);
if (*toread <= 0)
{
printf("Setting EOS on input\n");
buff_header->nFlags |= OMX_BUFFERFLAG_EOS;
}
r = OMX_EmptyThisBuffer(ilclient_get_handle(component),
buff_header);
if (r != OMX_ErrorNone)
{
fprintf(stderr, "Empty buffer error %s\n",
err2str(r));
}
return r;
}
void
merkle_getkeyrange::getkeys_cb (ref<getkeys_arg> arg, ref<getkeys_res> res,
clnt_stat err)
{
if (err) {
warn << "GETKEYS: rpc error " << err << "\n";
delete this;
return;
} else if (res->status != MERKLE_OK) {
warn << "GETKEYS: protocol error " << err2str (res->status) << "\n";
delete this;
return;
}
// Assuming keys are sent back in increasing clockwise order
vec<chordID> rkeys;
for (u_int i = 0; i < res->resok->keys.size (); i++)
rkeys.push_back (res->resok->keys[i]);
chordID sentmax = rngmax;
if (res->resok->keys.size () > 0)
sentmax = res->resok->keys.back ();
compare_keylists (lkeys, rkeys, current, sentmax, missing);
current = incID (sentmax);
if (!res->resok->morekeys)
current = incID (rngmax); // set done
go ();
}
void
merkle_syncer::sendnode_cb (ptr<bool> deleted,
ref<sendnode_arg> arg, ref<sendnode_res> res,
clnt_stat err)
{
if (*deleted)
return;
if (err) {
error (strbuf () << "SENDNODE: rpc error " << err);
return;
} else if (res->status != MERKLE_OK) {
error (strbuf () << "SENDNODE: protocol error " << err2str (res->status));
return;
}
merkle_rpc_node *rnode = &res->resok->node;
merkle_node *lnode = ltree->lookup_exact (rnode->depth, rnode->prefix);
if (!lnode) {
fatal << "lookup failed: " << rnode->prefix << " at " << rnode->depth << "\n";
}
compare_nodes (ltree, local_rngmin, local_rngmax, lnode, rnode,
vnode, ctype, missingfnc, rpcfnc);
if (!lnode->isleaf () && !rnode->isleaf) {
trace << "I vs I\n";
st.push_back (pair<merkle_rpc_node, int> (*rnode, 0));
}
ltree->lookup_release(lnode);
next ();
}
static void stats_print(struct stats_record *rec,
struct stats_record *prev,
bool err_only)
{
int i = 0;
if (err_only)
i = REDIR_ERROR;
for (; i < REDIR_RES_MAX; i++) {
struct record *r = &rec->xdp_redir[i];
struct record *p = &prev->xdp_redir[i];
__u64 period = 0;
__u64 packets = 0;
double pps = 0;
double period_ = 0;
if (p->timestamp) {
packets = r->counter - p->counter;
period = r->timestamp - p->timestamp;
if (period > 0) {
period_ = ((double) period / NANOSEC_PER_SEC);
pps = packets / period_;
}
}
printf("%-14s %-10.0f %'-18.0f %f\n",
err2str(i), pps, pps, period_);
}
}
void CWedApp::WinHelp(DWORD dwData, UINT nCmd)
{
static int help_in;
if(help_in)
return;
help_in = TRUE;
message("Opening Help");
HINSTANCE hi =
ShellExecute(
AfxGetMainWnd()->m_hWnd,
"open",
"wed.html",
"",
approot,
SW_SHOW);
if((long)hi <= 32)
{
CString num;
num.Format("Cannot show help. %s", err2str((long)hi));
AfxMessageBox(num);
}
help_in = FALSE;
// Do not call
//CWinApp::WinHelp(dwData, nCmd);
}
int
renderImage(OPENMAX_JPEG_DECODER * decoder) {
int ret;
printf("Rendering image\n");
printState(decoder->imageDecoder->handle);
// setup render buffer
decoder->ppRenderInputBufferHeader[0]->nFilledLen =
decoder->pOutputBufferHeader->nFilledLen;
decoder->ppRenderInputBufferHeader[0]->nFlags = OMX_BUFFERFLAG_EOS;
printf("Render buffer has %d\n",
decoder->ppRenderInputBufferHeader[0]->nFilledLen);
ret = OMX_EmptyThisBuffer(decoder->imageRender->handle,
decoder->ppRenderInputBufferHeader[0]);
if (ret != OMX_ErrorNone) {
perror("Emptying render input buffer");
fprintf(stderr, "Error code %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
} else {
printf("Called to empty render input buffer\n");
}
return OMXJPEG_OK;
}
void setParamImageFormat(COMPONENT_T *image_encode, enum formatType formatType)
{
printf("in setParamImageFormat\n");
OMX_ERRORTYPE OMXstatus;
//image format stucture */
OMX_IMAGE_PARAM_PORTFORMATTYPE image_format;
memset(&image_format, 0, sizeof(image_format));
image_format.nVersion.nVersion = OMX_VERSION;
image_format.nSize = sizeof(image_format);
image_format.nPortIndex = 341;
if(formatType == JPEG_HIGH_FORMAT || formatType == JPEG_MEDIUM_FORMAT || formatType == JPEG_LOW_FORMAT)
{
image_format.eCompressionFormat = OMX_IMAGE_CodingJPEG;
OMX_IMAGE_PARAM_QFACTORTYPE compression_format;
memset(&compression_format, 0, sizeof(compression_format));
compression_format.nVersion.nVersion = OMX_VERSION;
compression_format.nSize = sizeof(compression_format);
compression_format.nPortIndex = 341;
if(formatType == JPEG_HIGH_FORMAT)
compression_format.nQFactor = 100;
else if (formatType == JPEG_MEDIUM_FORMAT)
compression_format.nQFactor = 60;
else if (formatType == JPEG_LOW_FORMAT)
compression_format.nQFactor = 10;
OMXstatus = OMX_SetParameter(ilclient_get_handle(image_encode), OMX_IndexParamQFactor, &compression_format);
if(OMXstatus != OMX_ErrorNone)
printf("Error Setting Paramter Error = %s\n", err2str(OMXstatus));
}
OMXstatus = OMX_SetParameter(ilclient_get_handle(image_encode), OMX_IndexParamImagePortFormat, &image_format);
if(OMXstatus != OMX_ErrorNone)
printf("Error Setting Paramter Error = %s\n", err2str(OMXstatus));
// print the resultant format
OMXstatus = OMX_GetParameter(ilclient_get_handle(image_encode), OMX_IndexParamImagePortFormat, &image_format);
if(OMXstatus != OMX_ErrorNone)
printf("Error Getting Paramter Error = %s\n", err2str(OMXstatus));
print_OMX_IMAGE_PARAM_PORTFORMATTYPE(image_format);
}
INT UEyeCamDriver::loadCamConfig(string filename) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
// Convert filename to unicode, as requested by UEye API
const wstring filenameU(filename.begin(), filename.end());
if ((is_err = is_ParameterSet(cam_handle_, IS_PARAMETERSET_CMD_LOAD_FILE,
(void*) filenameU.c_str(), 0))
!= IS_SUCCESS) {
std::cerr << "Could not load UEye camera '" << cam_name_
<< "' sensor parameters file " << filename << " ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
} else {
// Update the AOI and bits per pixel
if ((is_err = is_AOI(cam_handle_, IS_AOI_IMAGE_GET_AOI,
(void*) &cam_aoi_, sizeof(cam_aoi_)))
!= IS_SUCCESS) {
std::cerr
<< "Could not retrieve Area Of Interest from UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
INT colorMode = is_SetColorMode(cam_handle_, IS_GET_COLOR_MODE);
if (colorMode == IS_CM_BGR8_PACKED || colorMode == IS_CM_RGB8_PACKED) {
bits_per_pixel_ = 24;
} else if (colorMode == IS_CM_MONO8 || colorMode == IS_CM_SENSOR_RAW8) {
bits_per_pixel_ = 8;
} else {
std::cerr
<< "Current camera color mode is not supported by this wrapper;"
<< "supported modes: {MONO8 | RGB8 | BAYER_RGGB8}; switching to RGB8 (24-bit)"
<< std::endl;
if ((is_err = setColorMode("rgb8", false)) != IS_SUCCESS)
return is_err;
}
reallocateCamBuffer();
std::cout << "Successfully loaded UEye camera '" << cam_name_
<< "'s sensor parameter file: " << filename << std::endl;
}
return is_err;
}
//sets the capture resolution of the camera (any camera)
void setCaptureRes2(COMPONENT_T *camera, int width, int height)
{
//needs to check width and height to see if compatible with rpi
printf("in setCapture\n");
OMX_PARAM_PORTDEFINITIONTYPE port_params;
OMX_ERRORTYPE OMXstatus;
memset(&port_params, 0, sizeof(port_params));
port_params.nVersion.nVersion = OMX_VERSION;
port_params.nSize = sizeof(port_params);
port_params.nPortIndex = 341;
OMXstatus = OMX_GetParameter(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if(OMXstatus != OMX_ErrorNone)
printf("Error Getting Parameter In setCaptureRes. Error = %s\n", err2str(OMXstatus));
//change needed params
//port_params.nBufferCountActual = 1;
//port_params.nBufferCountMin = 1;
port_params.format.image.nFrameWidth = width;
port_params.format.image.nFrameHeight = height;
port_params.format.image.nStride = 0; //width + (width % 16); //needed! set to 0 to recalculate
port_params.format.image.nSliceHeight = 0; // height + (height % 16); //notneeded?
port_params.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
//set changes
OMXstatus = OMX_SetParameter(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if(OMXstatus != OMX_ErrorNone)
printf("Error Setting Parameter In setCaptureRes. Error = %s\n", err2str(OMXstatus));
//print current config
memset(&port_params, 0, sizeof(port_params));
port_params.nVersion.nVersion = OMX_VERSION;
port_params.nSize = sizeof(port_params);
port_params.nPortIndex = 341;
OMXstatus = OMX_GetConfig(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if (OMXstatus != OMX_ErrorNone)
printf("Error Getting Parameter (2) In setCaptureRes. Error = %s\n", err2str(OMXstatus));
print_OMX_PARAM_PORTDEFINITIONTYPE(port_params);
}
INT UEyeCamDriver::setFlashParams(INT& delay_us, UINT& duration_us) {
INT is_err = IS_SUCCESS;
// Make sure parameters are within range supported by camera
IO_FLASH_PARAMS minFlashParams, maxFlashParams, newFlashParams;
if ((is_err = is_IO(cam_handle_, IS_IO_CMD_FLASH_GET_PARAMS_MIN,
(void*) &minFlashParams, sizeof(IO_FLASH_PARAMS)))
!= IS_SUCCESS) {
std::cerr << "Could not retrieve flash parameter info (min) for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_IO(cam_handle_, IS_IO_CMD_FLASH_GET_PARAMS_MAX,
(void*) &maxFlashParams, sizeof(IO_FLASH_PARAMS)))
!= IS_SUCCESS) {
std::cerr << "Could not retrieve flash parameter info (max) for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
delay_us =
(delay_us < minFlashParams.s32Delay) ?
minFlashParams.s32Delay :
((delay_us > maxFlashParams.s32Delay) ?
maxFlashParams.s32Delay : delay_us);
duration_us =
(duration_us < minFlashParams.u32Duration && duration_us != 0) ?
minFlashParams.u32Duration :
((duration_us > maxFlashParams.u32Duration) ?
maxFlashParams.u32Duration : duration_us);
newFlashParams.s32Delay = delay_us;
newFlashParams.u32Duration = duration_us;
// WARNING: Setting s32Duration to 0, according to documentation, means
// setting duration to total exposure time. If non-ext-triggered
// camera is operating at fastest grab rate, then the resulting
// flash signal will APPEAR as active LO when set to active HIGH,
// and vice versa. This is why the duration is set manually.
if ((is_err = is_IO(cam_handle_, IS_IO_CMD_FLASH_SET_PARAMS,
(void*) &newFlashParams, sizeof(IO_FLASH_PARAMS)))
!= IS_SUCCESS) {
std::cerr << "Could not set flash parameter info for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
return is_err;
}
//sets the preview res of the camera
void setPreviewRes(COMPONENT_T *camera, int width, int height, int framerate)
{
//needs to check width and height to see if compatible with rpi
printf("in setPreviewRes\n");
OMX_PARAM_PORTDEFINITIONTYPE port_params;
OMX_ERRORTYPE OMXstatus;
memset(&port_params, 0, sizeof(port_params));
port_params.nVersion.nVersion = OMX_VERSION;
port_params.nSize = sizeof(port_params);
port_params.nPortIndex = 70;
//prepopulate structure
OMXstatus = OMX_GetConfig(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if (OMXstatus != OMX_ErrorNone)
printf("Error Getting Parameter In setPreviewRes. Error = %s\n", err2str(OMXstatus));
//change needed params
port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
port_params.format.video.nFrameWidth = width;
port_params.format.video.nFrameHeight = height;
port_params.format.video.nStride = width;
port_params.format.video.nSliceHeight = height;
port_params.format.video.xFramerate = framerate << 16;
//set changes
OMXstatus = OMX_SetConfig(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if (OMXstatus != OMX_ErrorNone)
printf("Error Setting Parameter In setPreviewRes. Error = %s\n", err2str(OMXstatus));
//print current config
memset(&port_params, 0, sizeof(port_params));
port_params.nVersion.nVersion = OMX_VERSION;
port_params.nSize = sizeof(port_params);
port_params.nPortIndex = 70;
OMXstatus = OMX_GetConfig(ilclient_get_handle(camera), OMX_IndexParamPortDefinition, &port_params);
if (OMXstatus != OMX_ErrorNone)
printf("Error Getting Parameter (2) In setPreviewRes. Error = %s\n", err2str(OMXstatus));
print_OMX_PARAM_PORTDEFINITIONTYPE(port_params);
}
INT UEyeCamDriver::setStandbyMode() {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
if (extTriggerModeActive()) {
if ((is_err = is_DisableEvent(cam_handle_, IS_SET_EVENT_FRAME)) != IS_SUCCESS) {
std::cerr << "Could not disable frame event for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_SetExternalTrigger(cam_handle_, IS_SET_TRIGGER_OFF)) != IS_SUCCESS) {
std::cerr
<< "Could not disable external trigger mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
is_SetExternalTrigger(cam_handle_, IS_GET_TRIGGER_STATUS); // documentation seems to suggest that this is needed to disable external trigger mode (to go into free-run mode)
if ((is_err = is_StopLiveVideo(cam_handle_, IS_WAIT)) != IS_SUCCESS) {
std::cerr << "Could not stop live video mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
std::cout << "Stopped external trigger mode on UEye camera '" + cam_name_ + "'"
<< std::endl;
} else if (freeRunModeActive()) {
UINT nMode = IO_FLASH_MODE_OFF;
if ((is_err = is_IO(cam_handle_, IS_IO_CMD_FLASH_SET_MODE,
(void*) &nMode, sizeof(nMode)))
!= IS_SUCCESS) {
std::cerr << "Could not disable flash output for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_DisableEvent(cam_handle_, IS_SET_EVENT_FRAME)) != IS_SUCCESS) {
std::cerr << "Could not disable frame event for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_StopLiveVideo(cam_handle_, IS_WAIT)) != IS_SUCCESS) {
std::cerr << "Could not stop live video mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
std::cout << "Stopped free-run live video mode on UEye camera '" + cam_name_ + "'"
<< std::endl;
}
if ((is_err = is_CameraStatus(cam_handle_, IS_STANDBY, IS_GET_STATUS)) != IS_SUCCESS) {
std::cerr << "Could not set standby mode for UEye camera '" << cam_name_
<< "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
return is_err;
}
INT UEyeCamDriver::setExposure(bool& auto_exposure, double& exposure_ms) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
double minExposure, maxExposure;
// Set auto exposure
double pval1 = auto_exposure, pval2 = 0;
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_SHUTTER,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SHUTTER,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Auto exposure mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
auto_exposure = false;
}
}
// Set manual exposure timing
if (!auto_exposure) {
// Make sure that user-requested exposure rate is achievable
if (((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
(void*) &minExposure, sizeof(minExposure)))
!= IS_SUCCESS) ||
((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
(void*) &maxExposure, sizeof(maxExposure)))
!= IS_SUCCESS)) {
std::cerr << "Failed to query valid exposure range from UEye camera '"
<< cam_name_ << "'" << std::endl;
return is_err;
}
CAP(exposure_ms, minExposure, maxExposure);
// Update exposure
if ((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_SET_EXPOSURE,
(void*) &(exposure_ms), sizeof(exposure_ms)))
!= IS_SUCCESS) {
std::cerr << "Failed to set exposure to " << exposure_ms
<< " ms for UEye camera '" << cam_name_ << "'" << std::endl;
return is_err;
}
}
std::cout << "Updated exposure: "
<< ((auto_exposure) ? "auto" : to_string(exposure_ms))
<< " ms" << std::endl;
return is_err;
}
INT UEyeCamDriver::setColorMode(string mode, bool reallocate_buffer) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
// Stop capture to prevent access to memory buffer
setStandbyMode();
// Set to specified color mode
if (mode == "rgb8") {
if ((is_err = is_SetColorMode(cam_handle_, IS_CM_RGB8_PACKED)) != IS_SUCCESS) {
std::cerr << "Could not set color mode to RGB8 (" << err2str(is_err)
<< ")" << std::endl;
return is_err;
}
bits_per_pixel_ = 24;
} else if (mode == "bayer_rggb8") {
if ((is_err = is_SetColorMode(cam_handle_, IS_CM_SENSOR_RAW8)) != IS_SUCCESS) {
std::cerr << "Could not set color mode to BAYER_RGGB8 ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
bits_per_pixel_ = 8;
} else { // Default to MONO8
if ((is_err = is_SetColorMode(cam_handle_, IS_CM_MONO8)) != IS_SUCCESS) {
std::cerr << "Could not set color mode to MONO8 ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
bits_per_pixel_ = 8;
}
std::cout << "Updated color mode to " << mode << std::endl;
return (reallocate_buffer ? reallocateCamBuffer() : IS_SUCCESS);
}
INT UEyeCamDriver::setFreeRunMode() {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
if (!freeRunModeActive()) {
setStandbyMode(); // No need to check for success
// Set the flash to a high active pulse for each image in the trigger mode
INT flash_delay = 0;
UINT flash_duration = 1000;
setFlashParams(flash_delay, flash_duration);
UINT nMode = IO_FLASH_MODE_FREERUN_HI_ACTIVE;
if ((is_err = is_IO(cam_handle_, IS_IO_CMD_FLASH_SET_MODE,
(void*) &nMode, sizeof(nMode)))
!= IS_SUCCESS) {
std::cerr << "Could not set free-run active-low flash output for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_EnableEvent(cam_handle_, IS_SET_EVENT_FRAME)) != IS_SUCCESS) {
std::cerr << "Could not enable frame event for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
if ((is_err = is_CaptureVideo(cam_handle_, IS_WAIT)) != IS_SUCCESS) {
std::cerr << "Could not start free-run live video mode on UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
return is_err;
}
std::cout << "Started live video mode on UEye camera '" + cam_name_ + "'" << std::endl;
}
return is_err;
}
const char* UEyeCamDriver::processNextFrame(INT timeout_ms) {
if (!freeRunModeActive() && !extTriggerModeActive())
return NULL;
INT is_err = IS_SUCCESS;
// Wait for frame event
if ((is_err = is_WaitEvent(cam_handle_, IS_SET_EVENT_FRAME, timeout_ms)) != IS_SUCCESS) {
std::cerr << "Failed to acquire image from UEye camera '" << cam_name_
<< "' (" << err2str(is_err) << ")" << std::endl;
return NULL;
}
return cam_buffer_;
}
INT UEyeCamDriver::setWhiteBalance(bool& auto_white_balance, INT& red_offset,
INT& blue_offset) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
CAP(red_offset, -50, 50);
CAP(blue_offset, -50, 50);
// Set auto white balance mode and parameters
double pval1 = auto_white_balance, pval2 = 0;
// TODO: 9 bug: enabling auto white balance does not seem to have an effect; in ueyedemo it seems to change R/G/B gains automatically
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_WHITEBALANCE,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_AUTO_WB_ONCE,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Auto white balance mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
auto_white_balance = false;
}
}
if (auto_white_balance) {
pval1 = red_offset;
pval2 = blue_offset;
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_AUTO_WB_OFFSET,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Failed to set white balance red/blue offsets to "
<< red_offset << " / " << blue_offset
<< " for UEye camera '" << cam_name_ << "'" << std::endl;
}
}
std::cout << "Updated white balance: "
<< ((auto_white_balance) ? "auto" : "manual")
<< "\n - red offset: " << red_offset << "\n - blue offset: "
<< blue_offset << std::endl;
return is_err;
}
uInt
map64to32(uLong a64)
{
uInt idx;
Map *map;
if (g_map == NULL)
growbufs(64);
idx = lookup64(a64);
map = &g_map[g_map64[idx]];
if (idx >= g_num || a64 < map->a64 || a64 >= map->a64 + BLOCK_SIZE)
{
/* create a mapping, allocating a 32-bit address block */
uInt loc = g_num;
uLong block = a64 & BLOCK_MASK;
Retcode ret = growbufs(g_num + 1);
if (ret != NO_ERROR)
{
cprintf(g_e, "map64to32: %s\n", err2str(ret));
return 0;
}
/* allocate the new map the end, which sorts it by 32-bit addr */
g_map[loc].a32 = g_alloc32;
g_map[loc].a64 = block;
g_alloc32 += BLOCK_SIZE;
g_num++;
/* move the elements to make room for the new one */
if (idx < loc && a64 >= map->a64 + BLOCK_SIZE)
idx++;
memmove(g_map64 + idx, g_map64 + idx + 1, g_num - idx);
g_map64[idx] = loc;
map = &g_map[loc];
}
return map->a32 + (uInt)(a64 - map->a64);
}
static void setup_deinterlace(COMPONENT_T *component)
{
int err;
// add extra buffers for Advanced Deinterlace
printf("Setting deinterlace\n");
OMX_PARAM_U32TYPE extra_buffers;
memset(&extra_buffers, 0, sizeof(OMX_PARAM_U32TYPE));
extra_buffers.nSize = sizeof(OMX_PARAM_U32TYPE);
extra_buffers.nVersion.nVersion = OMX_VERSION;
extra_buffers.nU32 = 3;
err = OMX_SetParameter(ilclient_get_handle(component),
OMX_IndexParamBrcmExtraBuffers, &extra_buffers);
OMX_CONFIG_IMAGEFILTERPARAMSTYPE image_filter;
memset(&image_filter, 0, sizeof(OMX_CONFIG_IMAGEFILTERPARAMSTYPE));
image_filter.nSize = sizeof(OMX_CONFIG_IMAGEFILTERPARAMSTYPE);
image_filter.nVersion.nVersion = OMX_VERSION;
image_filter.nPortIndex = 191;
image_filter.nNumParams = 1;
image_filter.nParams[0] = 3;
image_filter.eImageFilter = OMX_ImageFilterDeInterlaceAdvanced;
if (err == OMX_ErrorNone)
err = OMX_SetConfig(ilclient_get_handle(component),
OMX_IndexConfigCommonImageFilterParameters, &image_filter);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting deinterlace %s\n", err2str(err));
return; // err;
}
else
{
printf("Deinterlace set up ok\n");
}
}
static unsigned int
call_syscall(struct syscall_desc *scall, char *argv[])
{
struct stat64 sb;
struct utimbuf ut;
long long flags;
unsigned int i;
char *endp;
int rval;
int more;
union {
char *str;
long long num;
} args[MAX_ARGS];
more = 0;
/*
* Verify correctness of the arguments.
*/
for (i = 0; i < sizeof(args)/sizeof(args[0]); i++) {
if (scall->sd_args[i] == TYPE_NONE) {
if (argv[i] == NULL || strcmp(argv[i], ":") == 0)
break;
fprintf(stderr, "too many arguments [%s]\n", argv[i]);
exit(1);
} else {
if (argv[i] == NULL || strcmp(argv[i], ":") == 0) {
if (scall->sd_args[i] & TYPE_OPTIONAL) {
args[i].str = NULL;
break;
}
fprintf(stderr, "too few arguments\n");
exit(1);
}
if ((scall->sd_args[i] & TYPE_MASK) == TYPE_STRING) {
if (strcmp(argv[i], "NULL") == 0)
args[i].str = NULL;
else if (strcmp(argv[i], "DEADCODE") == 0)
args[i].str = (void *)0xdeadc0de;
else
args[i].str = argv[i];
} else if ((scall->sd_args[i] & TYPE_MASK)
== TYPE_NUMBER) {
args[i].num = strtoll(argv[i], &endp, 0);
if (*endp != '\0' && !isspace((unsigned char)*endp)) {
fprintf(stderr, "invalid argument %u, number expected [%s]\n", i, endp);
exit(1);
}
} else if ((scall->sd_args[i] & TYPE_MASK) ==
TYPE_DESCRIPTOR) {
if (strcmp(argv[i], "AT_FDCWD") == 0) {
args[i].num = AT_FDCWD;
} else if (strcmp(argv[i], "BADFD") == 0) {
/* In case AT_FDCWD is -1 on some systems... */
if (AT_FDCWD == -1)
args[i].num = -2;
else
args[i].num = -1;
} else {
int pos;
pos = strtoll(argv[i], &endp, 0);
if (*endp != '\0' &&
!isspace((unsigned char)*endp)) {
fprintf(stderr,
"invalid argument %u, number expected [%s]\n",
i, endp);
exit(1);
}
args[i].num = descriptor_get(pos);
}
}
}
}
/*
* Call the given syscall.
*/
#define NUM(n) (args[(n)].num)
#define STR(n) (args[(n)].str)
switch (scall->sd_action) {
case ACTION_OPEN:
flags = str2flags(open_flags, STR(1));
if (flags & O_CREAT) {
if (i == 2) {
fprintf(stderr, "too few arguments\n");
exit(1);
}
rval = open(STR(0), flags, (mode_t)NUM(2));
} else {
if (i == 3) {
fprintf(stderr, "too many arguments\n");
exit(1);
}
rval = open(STR(0), flags);
}
if (rval >= 0) {
more = argv[i] && !strcmp(argv[i], ":");
descriptor_add(rval);
}
break;
case ACTION_CREATE:
rval = open(STR(0), O_CREAT | O_EXCL, NUM(1));
if (rval >= 0) {
more = argv[i] && !strcmp(argv[i], ":");
descriptor_add(rval);
}
break;
case ACTION_UNLINK:
rval = unlink(STR(0));
break;
case ACTION_MKDIR:
rval = mkdir(STR(0), NUM(1));
break;
case ACTION_RMDIR:
rval = rmdir(STR(0));
break;
case ACTION_LINK:
rval = link(STR(0), STR(1));
break;
case ACTION_SYMLINK:
rval = symlink(STR(0), STR(1));
break;
case ACTION_RENAME:
rval = rename(STR(0), STR(1));
break;
case ACTION_MKFIFO:
rval = mkfifo(STR(0), NUM(1));
break;
case ACTION_CHMOD:
rval = chmod(STR(0), NUM(1));
break;
#ifdef HAS_LCHMOD
case ACTION_LCHMOD:
rval = lchmod(STR(0), NUM(1));
break;
#endif
case ACTION_CHOWN:
rval = chown(STR(0), NUM(1), NUM(2));
break;
case ACTION_LCHOWN:
rval = lchown(STR(0), NUM(1), NUM(2));
break;
#ifdef HAS_CHFLAGS
case ACTION_CHFLAGS:
rval = chflags(STR(0), str2flags(chflags_flags, STR(1)));
break;
#endif
#ifdef HAS_LCHFLAGS
case ACTION_LCHFLAGS:
rval = lchflags(STR(0), str2flags(chflags_flags, STR(1)));
break;
#endif
case ACTION_TRUNCATE:
rval = truncate64(STR(0), NUM(1));
break;
case ACTION_FTRUNCATE:
rval = ftruncate64(NUM(0), NUM(1));
break;
case ACTION_STAT:
rval = stat64(STR(0), &sb);
if (rval == 0) {
show_stats(&sb, STR(1));
return (i);
}
break;
case ACTION_LSTAT:
rval = lstat64(STR(0), &sb);
if (rval == 0) {
show_stats(&sb, STR(1));
return (i);
}
break;
case ACTION_UTIME :
switch (i) {
case 1 :
rval = utime(STR(0), (struct utimbuf*)NULL);
break;
case 3:
ut.actime = NUM(1);
ut.modtime = NUM(2);
rval = utime(STR(0), &ut);
break;
default :
fprintf(stderr,"utime() requires 1 or 3 arguments\n");
exit(1);
}
break;
case ACTION_BIND:
{
struct sockaddr_un sunx;
sunx.sun_family = AF_UNIX;
strncpy(sunx.sun_path, STR(0), sizeof(sunx.sun_path) - 1);
sunx.sun_path[sizeof(sunx.sun_path) - 1] = '\0';
rval = socket(AF_UNIX, SOCK_STREAM, 0);
if (rval < 0)
break;
rval = bind(rval, (struct sockaddr *)&sunx, sizeof(sunx));
break;
}
case ACTION_MKNOD:
case ACTION_MKNODAT:
{
mode_t ntype;
dev_t dev;
int fa;
switch (scall->sd_action) {
case ACTION_MKNOD:
fa = 0;
break;
case ACTION_MKNODAT:
fa = 1;
break;
default:
abort();
}
dev = makedev(NUM(fa + 3), NUM(fa + 4));
if (strcmp(STR(fa + 1), "c") == 0) /* character device */
ntype = S_IFCHR;
else if (strcmp(STR(fa + 1), "b") == 0) /* block device */
ntype = S_IFBLK;
else if (strcmp(STR(fa + 1), "f") == 0) /* fifo special */
ntype = S_IFIFO;
else if (strcmp(STR(fa + 1), "d") == 0) /* directory */
ntype = S_IFDIR;
else if (strcmp(STR(fa + 1), "o") == 0) /* regular file */
ntype = S_IFREG;
else {
fprintf(stderr, "wrong argument 1\n");
exit(1);
}
switch (scall->sd_action) {
case ACTION_MKNOD:
rval = mknod(STR(0), ntype | NUM(2), dev);
break;
case ACTION_MKNODAT:
rval = mknodat(NUM(0), STR(1), ntype | NUM(3), dev);
break;
default:
abort();
}
break;
}
#ifdef HAS_ACL
case ACTION_GETFACL :
rval = do_getfacl(STR(0), STR(1));
if (rval == 0)
return (i);
break;
case ACTION_SETFACL :
rval = do_setfacl(STR(0), STR(1), STR(2));
break;
#endif
default:
fprintf(stderr, "unsupported syscall\n");
exit(1);
}
#undef STR
#undef NUM
if (rval < 0) {
const char *serrno;
serrno = err2str(errno);
fprintf(stderr, "%s returned %d\n", scall->sd_name, rval);
printf("%s\n", serrno);
exit(1);
}
/* Do not output a "0" when more syscalls to come */
if (!more)
printf("0\n");
return (i);
}
static unsigned int
call_syscall(struct syscall_desc *scall, char *argv[])
{
struct stat64 sb;
long long flags;
unsigned int i;
char *endp;
int rval;
union {
char *str;
long long num;
} args[MAX_ARGS];
/*
* Verify correctness of the arguments.
*/
for (i = 0; i < sizeof(args)/sizeof(args[0]); i++) {
if (scall->sd_args[i] == TYPE_NONE) {
if (argv[i] == NULL || strcmp(argv[i], ":") == 0)
break;
fprintf(stderr, "too many arguments [%s]\n", argv[i]);
exit(1);
} else {
if (argv[i] == NULL || strcmp(argv[i], ":") == 0) {
if (scall->sd_args[i] & TYPE_OPTIONAL)
break;
fprintf(stderr, "too few arguments\n");
exit(1);
}
if (scall->sd_args[i] & TYPE_STRING) {
if (strcmp(argv[i], "NULL") == 0)
args[i].str = NULL;
else if (strcmp(argv[i], "DEADCODE") == 0)
args[i].str = (void *)0xdeadc0de;
else
args[i].str = argv[i];
} else if (scall->sd_args[i] & TYPE_NUMBER) {
args[i].num = strtoll(argv[i], &endp, 0);
if (*endp != '\0' && !isspace((unsigned char)*endp)) {
fprintf(stderr, "invalid argument %u, number expected [%s]\n", i, endp);
exit(1);
}
}
}
}
/*
* Call the given syscall.
*/
#define NUM(n) (args[(n)].num)
#define STR(n) (args[(n)].str)
switch (scall->sd_action) {
case ACTION_OPEN:
flags = str2flags(open_flags, STR(1));
if (flags & O_CREAT) {
if (i == 2) {
fprintf(stderr, "too few arguments\n");
exit(1);
}
rval = open(STR(0), flags, (mode_t)NUM(2));
} else {
if (i == 3) {
fprintf(stderr, "too many arguments\n");
exit(1);
}
rval = open(STR(0), flags);
}
break;
case ACTION_CREATE:
rval = open(STR(0), O_CREAT | O_EXCL, NUM(1));
if (rval >= 0)
close(rval);
break;
case ACTION_UNLINK:
rval = unlink(STR(0));
break;
case ACTION_MKDIR:
rval = mkdir(STR(0), NUM(1));
break;
case ACTION_RMDIR:
rval = rmdir(STR(0));
break;
case ACTION_LINK:
rval = link(STR(0), STR(1));
break;
case ACTION_SYMLINK:
rval = symlink(STR(0), STR(1));
break;
case ACTION_RENAME:
rval = rename(STR(0), STR(1));
break;
case ACTION_MKFIFO:
rval = mkfifo(STR(0), NUM(1));
break;
case ACTION_CHMOD:
rval = chmod(STR(0), NUM(1));
break;
#ifdef HAS_LCHMOD
case ACTION_LCHMOD:
rval = lchmod(STR(0), NUM(1));
break;
#endif
case ACTION_CHOWN:
rval = chown(STR(0), NUM(1), NUM(2));
break;
case ACTION_LCHOWN:
rval = lchown(STR(0), NUM(1), NUM(2));
break;
#ifdef HAS_CHFLAGS
case ACTION_CHFLAGS:
rval = chflags(STR(0), str2flags(chflags_flags, STR(1)));
break;
#endif
#ifdef HAS_LCHFLAGS
case ACTION_LCHFLAGS:
rval = lchflags(STR(0), str2flags(chflags_flags, STR(1)));
break;
#endif
case ACTION_TRUNCATE:
rval = truncate64(STR(0), NUM(1));
break;
case ACTION_STAT:
rval = stat64(STR(0), &sb);
if (rval == 0) {
show_stats(&sb, STR(1));
return (i);
}
break;
case ACTION_LSTAT:
rval = lstat64(STR(0), &sb);
if (rval == 0) {
show_stats(&sb, STR(1));
return (i);
}
break;
case ACTION_READDIR:
rval = readdir_loop(STR(0));
break;
default:
fprintf(stderr, "unsupported syscall\n");
exit(1);
}
#undef STR
#undef NUM
if (rval < 0) {
const char *serrno;
serrno = err2str(errno);
fprintf(stderr, "%s returned %d\n", scall->sd_name, rval);
printf("%s\n", serrno);
exit(1);
}
printf("0\n");
return (i);
}
int
portSettingsChanged(OPENMAX_JPEG_DECODER * decoder)
{
OMX_PARAM_PORTDEFINITIONTYPE portdef, rportdef;;
int ret;
// CLEANUP
printf("Pport settings changed\n");
// need to setup the input for the render with the output of the
// decoder
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decoder->imageDecoder->outPort;
OMX_GetParameter(decoder->imageDecoder->handle,
OMX_IndexParamPortDefinition, &portdef);
// Get default values of render
rportdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
rportdef.nVersion.nVersion = OMX_VERSION;
rportdef.nPortIndex = decoder->imageRender->inPort;
rportdef.nBufferSize = portdef.nBufferSize;
ret = OMX_GetParameter(decoder->imageRender->handle,
OMX_IndexParamPortDefinition, &rportdef);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Error getting render port params %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
// tell render input what the decoder output will be providing
//Copy some
rportdef.format.video.nFrameWidth = portdef.format.image.nFrameWidth;
rportdef.format.video.nFrameHeight = portdef.format.image.nFrameHeight;
rportdef.format.video.nStride = portdef.format.image.nStride;
rportdef.format.video.nSliceHeight = portdef.format.image.nSliceHeight;
ret = OMX_SetParameter(decoder->imageRender->handle,
OMX_IndexParamPortDefinition, &rportdef);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Error setting render port params %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
} else {
printf("Render port params set up ok\n");
}
unsigned int uWidth =
(unsigned int) portdef.format.image.nFrameWidth;
unsigned int uHeight =
(unsigned int) portdef.format.image.nFrameHeight;
printf
("Getting format Compression 0x%x Color Format: 0x%x\n",
(unsigned int) portdef.format.image.eCompressionFormat,
(unsigned int) portdef.format.image.eColorFormat);
printColorFormat(portdef.format.image.eColorFormat);
// enable ports
OMX_SendCommand(decoder->imageDecoder->handle,
OMX_CommandPortEnable,
decoder->imageDecoder->outPort, NULL);
// once the state changes, both ports should become enabled and the
// render
// output should generate a settings changed event
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageDecoder->outPort, 1, 0,
TIMEOUT_MS);
printf("Decoder output port enabled\n");
OMX_SendCommand(decoder->imageRender->handle,
OMX_CommandPortEnable,
decoder->imageRender->inPort, NULL);
// once the state changes, both ports should become enabled and the
// render
// output should generate a settings changed event
ilclient_wait_for_event(decoder->imageRender->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageRender->inPort, 1, 0,
TIMEOUT_MS);
printf("Render input port enabled\n");
ret = OMX_AllocateBuffer(decoder->imageDecoder->handle,
&decoder->pOutputBufferHeader,
decoder->imageDecoder->
outPort,
NULL,
portdef.nBufferSize);
printf("Output port buffer allocated\n");
if (ret != OMX_ErrorNone) {
perror("Eror allocating buffer");
return OMXJPEG_ERROR_MEMORY;
}
// and share it with the renderer
// which has 3 default buffers, 2 minimum
decoder->ppRenderInputBufferHeader =
(OMX_BUFFERHEADERTYPE **) malloc(sizeof(void) *
decoder->renderInputBufferHeaderCount);
printState(decoder->imageRender->handle);
decoder->imageRender->inPort,
ret = OMX_UseBuffer(decoder->imageRender->handle,
&decoder->ppRenderInputBufferHeader[0],
decoder->imageRender->inPort,
NULL,
rportdef.nBufferSize,
decoder->pOutputBufferHeader->pBuffer);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Eror sharing buffer %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
decoder->ppRenderInputBufferHeader[0]->nAllocLen =
decoder->pOutputBufferHeader->nAllocLen;
int n;
for (n = 1; n < decoder->renderInputBufferHeaderCount; n++) {
printState(decoder->imageRender->handle);
ret = OMX_UseBuffer(decoder->imageRender->handle,
&decoder->ppRenderInputBufferHeader[n],
decoder->imageRender->inPort,
NULL,
0,
NULL);
if (ret != OMX_ErrorNone) {
fprintf(stderr, "Eror sharing null buffer %s\n", err2str(ret));
return OMXJPEG_ERROR_MEMORY;
}
}
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete,
OMX_CommandPortEnable, 1,
decoder->imageDecoder->outPort, 1, 0,
TIMEOUT_MS);
printf("Decoder output port rnabled\n");
return OMXJPEG_OK;
}
INT UEyeCamDriver::setBinning(int& rate, bool reallocate_buffer) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
// Stop capture to prevent access to memory buffer
setStandbyMode();
INT rate_flag;
INT supportedRates;
supportedRates = is_SetBinning(cam_handle_, IS_GET_SUPPORTED_BINNING);
switch (rate) {
case 1:
rate_flag = IS_BINNING_DISABLE;
break;
case 2:
rate_flag = IS_BINNING_2X;
break;
case 4:
rate_flag = IS_BINNING_4X;
break;
case 8:
rate_flag = IS_BINNING_8X;
break;
case 16:
rate_flag = IS_BINNING_16X;
break;
default:
std::cerr << "Invalid or unsupported binning rate: " << rate
<< ", resetting to 1X" << std::endl;
rate = 1;
rate_flag = IS_BINNING_DISABLE;
break;
}
if ((supportedRates & rate_flag) == rate_flag) {
if ((is_err = is_SetBinning(cam_handle_, rate_flag)) != IS_SUCCESS) {
std::cerr << "Could not set binning rate to " << rate << "X ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
} else {
std::cerr << "Camera does not support requested binning rate of "
<< rate << std::endl;
// Query current rate
INT currRate = is_SetBinning(cam_handle_, IS_GET_BINNING);
if (currRate == IS_BINNING_DISABLE) {
rate = 1;
} else if (currRate == IS_BINNING_2X) {
rate = 2;
} else if (currRate == IS_BINNING_4X) {
rate = 4;
} else if (currRate == IS_BINNING_8X) {
rate = 8;
} else if (currRate == IS_BINNING_16X) {
rate = 16;
} else {
std::cerr << "ColorCamera.has unsupported binning rate (" << currRate
<< "), resetting to 1X" << std::endl;
if ((is_err = is_SetBinning(cam_handle_, IS_BINNING_DISABLE)) != IS_SUCCESS) {
std::cerr << "Could not set binning rate to 1X ("
<< err2str(is_err) << ")" << std::endl;
return is_err;
}
}
return IS_SUCCESS;
}
std::cout << "Updated binning rate to " << rate << "X" << std::endl;
cam_binning_rate_ = rate;
return (reallocate_buffer ? reallocateCamBuffer() : IS_SUCCESS);
}
INT UEyeCamDriver::setFrameRate(bool& auto_frame_rate, double& frame_rate_hz) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
double pval1 = 0, pval2 = 0;
double minFrameTime, maxFrameTime, intervalFrameTime, newFrameRate;
// Make sure that auto shutter is enabled before enabling auto frame rate
bool autoShutterOn = false;
is_SetAutoParameter(cam_handle_, IS_GET_ENABLE_AUTO_SENSOR_SHUTTER, &pval1, &pval2);
autoShutterOn |= (pval1 != 0);
is_SetAutoParameter(cam_handle_, IS_GET_ENABLE_AUTO_SHUTTER, &pval1, &pval2);
autoShutterOn |= (pval1 != 0);
if (!autoShutterOn) {
auto_frame_rate = false;
}
// Set frame rate / auto
pval1 = auto_frame_rate;
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_FRAMERATE,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_FRAMERATE,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Auto frame rate mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")"
<< std::endl;
auto_frame_rate = false;
}
}
if (!auto_frame_rate) {
// Make sure that user-requested frame rate is achievable
if ((is_err = is_GetFrameTimeRange(cam_handle_, &minFrameTime,
&maxFrameTime, &intervalFrameTime))
!= IS_SUCCESS) {
std::cerr << "Failed to query valid frame rate range from UEye camera '"
<< cam_name_ << "'" << std::endl;
return is_err;
}
CAP(frame_rate_hz, 1.0 / maxFrameTime, 1.0 / minFrameTime);
// Update frame rate
if ((is_err = is_SetFrameRate(cam_handle_, frame_rate_hz, &newFrameRate))
!= IS_SUCCESS) {
std::cerr << "Failed to set frame rate to " << frame_rate_hz
<< " MHz for UEye camera '" << cam_name_ << "'" << std::endl;
return is_err;
} else if (frame_rate_hz != newFrameRate) {
frame_rate_hz = newFrameRate;
}
}
std::cout << "Updated frame rate: "
<< ((auto_frame_rate) ? "auto" : to_string(frame_rate_hz))
<< " Hz" << std::endl;
return is_err;
}
INT UEyeCamDriver::setGain(bool& auto_gain, INT& master_gain_prc,
INT& red_gain_prc, INT& green_gain_prc,
INT& blue_gain_prc, bool& gain_boost) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
// Validate arguments
CAP(master_gain_prc, 0, 100);
CAP(red_gain_prc, 0, 100);
CAP(green_gain_prc, 0, 100);
CAP(blue_gain_prc, 0, 100);
double pval1 = 0, pval2 = 0;
if (auto_gain) {
// Set auto gain
pval1 = 1;
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_GAIN,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_GAIN,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Auto gain mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
auto_gain = false;
}
}
} else {
// Disable auto gain
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_GAIN,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_GAIN,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cout << "Auto gain mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
}
}
// Set gain boost
if (is_SetGainBoost(cam_handle_, IS_GET_SUPPORTED_GAINBOOST)
!= IS_SET_GAINBOOST_ON) {
gain_boost = false;
} else {
if ((is_err = is_SetGainBoost( cam_handle_, (gain_boost) ?
IS_SET_GAINBOOST_ON : IS_SET_GAINBOOST_OFF))
!= IS_SUCCESS) {
std::cerr << "Failed to "
<< ((gain_boost) ? "enable" : "disable")
<< " gain boost for UEye camera '" + cam_name_ + "'" << std::endl;
}
}
// Set manual gain parameters
if ((is_err = is_SetHardwareGain(cam_handle_, master_gain_prc,
red_gain_prc, green_gain_prc, blue_gain_prc))
!= IS_SUCCESS) {
std::cerr << "Failed to set manual gains (master: "
<< master_gain_prc << "; red: " << red_gain_prc
<< "; green: " << green_gain_prc << "; blue: " << blue_gain_prc
<< ") for UEye camera '" + cam_name_ + "'" << std::endl;
}
}
if (auto_gain) {
std::cout << "Updated gain: auto" << std::endl;
} else {
std::cout << "Updated gain: manual" << "\n - master gain: "
<< master_gain_prc << "\n - red gain: " << red_gain_prc
<< "\n - green gain: " << green_gain_prc
<< "\n - blue gain: " << blue_gain_prc
<< "\n - gain boost: " << gain_boost << std::endl;
}
return is_err;
}
