void db_select1(int32_t* value) {
if (debug) {
fprintf(stderr, "db_select1()\n");
}
PGresult* res = PQexecPrepared(conn,
STMT_ID_SELECT1,
0,
NULL,
NULL,
NULL,
1);
CHECK_RESULT(res);
*value = -1;
if (PQntuples(res) == 0) {
fprintf(stderr, "db_select1() return no rows\n");
if (exit_on_error) {
exit(EXIT_FAILURE);
}
PQclear(res);
} else {
*value = ntohl(*(int32_t *) PQgetvalue(res, 0, 0));
if (debug) {
fprintf(stderr, "db_select1() return %d\n", *value);
}
}
PQclear(res);
}
/**
* \brief Check for interrupt without wait
* \param port a GPPort
* \param data a pointer to an allocated buffer
* \param size the number of bytes that should be read
*
* Reads a specified number of bytes from the inerrupt endpoint
* into the supplied buffer.
* Function waits 50 miliseconds for data on interrupt endpoint.
*
* \return a gphoto2 error code
**/
int
gp_port_check_int_fast (GPPort *port, char *data, int size)
{
int retval;
gp_log (GP_LOG_DATA, __func__, "Reading %i = 0x%x bytes from interrupt endpoint...", size, size);
C_PARAMS (port);
CHECK_INIT (port);
/* Check if we read as many bytes as expected */
CHECK_SUPP (port, "check_int", port->pc->ops->check_int);
retval = port->pc->ops->check_int (port, data, size, FAST_TIMEOUT);
CHECK_RESULT (retval);
#ifdef IGNORE_EMPTY_INTR_READS
/* For Canon cameras, we will make lots of
reads that will return zero length. Don't
bother to log them as errors. */
if (retval != 0 )
#endif
LOG_DATA (data, retval, size, "Read ", "from interrupt endpoint (fast):");
return (retval);
}
void db_select(int32_t id, int32_t* value) {
if (debug) {
fprintf(stderr, "db_select(%d)\n", id);
}
int32_t _id = htonl(id);
const char* paramValues[] = {
(const char*) &_id,
};
PGresult* res = PQexecPrepared(conn,
STMT_ID_SELECT,
1,
paramValues,
paramLengths,
paramFormats,
1);
CHECK_RESULT(res);
*value = -1;
if (PQntuples(res) == 0) {
fprintf(stderr, "db_select(%d) return no rows\n", id);
if (exit_on_error) {
exit(EXIT_FAILURE);
}
PQclear(res);
} else {
*value = ntohl(*(int32_t *) PQgetvalue(res, 0, 0));
if (debug) {
fprintf(stderr, "db_select(%d) return %d\n", id, *value);
}
}
PQclear(res);
}
void Java_org_fmod_playsound_Example_cPlaySound(JNIEnv *env, jobject thiz, int id)
{
FMOD_RESULT result = FMOD_OK;
result = FMOD_System_PlaySound(gSystem, FMOD_CHANNEL_FREE, gSound[id], 0, &gChannel);
CHECK_RESULT(result);
}
GPResult gpiAuthBuddyRequest
(
GPConnection * connection,
GPProfile profile
)
{
GPIProfile * pProfile;
GPIConnection * iconnection = (GPIConnection*)*connection;
// Get the profile object.
//////////////////////////
if(!gpiGetProfile(connection, profile, &pProfile))
Error(connection, GP_PARAMETER_ERROR, "Invalid profile.");
// Check for a valid sig.
/////////////////////////
if(!pProfile->authSig)
Error(connection, GP_PARAMETER_ERROR, "Invalid profile.");
// Send the request.
////////////////////
CHECK_RESULT(gpiSendAuthBuddyRequest(connection, pProfile));
// freeclear the sig if no more requests.
////////////////////////////////////
pProfile->requestCount--;
if(!iconnection->infoCaching && (pProfile->requestCount <= 0))
{
freeclear(pProfile->authSig);
if(gpiCanFreeProfile(pProfile))
gpiRemoveProfile(connection, pProfile);
}
return GP_NO_ERROR;
}
void Java_org_fmod_playsound_Example_cUpdate(JNIEnv *env, jobject thiz)
{
FMOD_RESULT result = FMOD_OK;
result = FMOD_System_Update(gSystem);
CHECK_RESULT(result);
}
void Begin()
{
FMOD_RESULT result = FMOD_OK;
result = FMOD_System_Create(&gSystem);
CHECK_RESULT(result);
result = FMOD_System_Init(gSystem, 32, FMOD_INIT_NORMAL, 0);
CHECK_RESULT(result);
result = FMOD_System_CreateSound(gSystem, "/sdcard/fmod/wave.mp3", FMOD_DEFAULT | FMOD_LOOP_NORMAL, 0, &gSound);
CHECK_RESULT(result);
result = FMOD_System_PlaySound(gSystem, FMOD_CHANNEL_FREE, gSound, 0, &gChannel);
CHECK_RESULT(result);
}
/**
* \brief Send a USB control message with input data
*
* \param port a GPPort
* \param request control request code
* \param value control value
* \param index control index
* \param bytes pointer to data
* \param size size of the data
*
* Sends a specific USB interface control command and read associated data.
*
* \return a gphoto2 error code
*/
int
gp_port_usb_msg_read (GPPort *port, int request, int value, int index,
char *bytes, int size)
{
int retval;
gp_log (GP_LOG_DEBUG, "gphoto2-port", _("Reading message "
"(request=0x%x value=0x%x index=0x%x size=%i=0x%x)..."),
request, value, index, size, size);
CHECK_NULL (port);
CHECK_INIT (port);
CHECK_SUPP (port, "msg_read", port->pc->ops->msg_read);
retval = port->pc->ops->msg_read (port, request, value, index, bytes, size);
CHECK_RESULT (retval);
if (retval != size)
gp_log (GP_LOG_DEBUG, "gphoto2-port", ngettext(
"Could only read %i out of %i byte",
"Could only read %i out of %i bytes",
size
), retval, size);
gp_log_data ("gphoto2-port", bytes, retval);
return (retval);
}
static PyObject* wsql_result_fetch_row_async(wsql_result *self)
{
PyObject *row = NULL, *result = NULL;
MYSQL_ROW mysql_row;
net_async_status status;
CHECK_RESULT(self, NULL);
status = mysql_fetch_row_nonblocking(self->result, &mysql_row);
if (status == NET_ASYNC_NOT_READY)
{
row = Py_None;
Py_INCREF(row);
}
else
{
row = wsql_result_convert_row(self, mysql_row);
}
if (row)
{
result = Py_BuildValue("(iO)", status, row);
Py_DECREF(row);
return result;
}
return NULL;
}
int marshal_record(record *data, unsigned char **_out, size_t *_size) {
int _result;
_result = marshal_key(&(*data).k, _out, _size);
CHECK_RESULT();
_result = marshal_unsigned_int(&(*data).data.count, _out, _size);
CHECK_RESULT();
if ((*data).data.count > 1024) return -1;
{
size_t i;
for (i = 0; i < (*data).data.count; i++) {
_result = marshal_opaque(&(*data).data.data[i], _out, _size);
CHECK_RESULT();
}
}
return 0;
}
void Java_org_fmod_programmerselected_Example_cEnd(JNIEnv *env, jobject thiz)
{
FMOD_RESULT result = FMOD_OK;
result = FMOD_EventSystem_Release(gEventSystem);
CHECK_RESULT(result);
}
int marshal_opaque_auth(opaque_auth *data, unsigned char **_out, size_t *_size) {
int _result;
_result = marshal_auth_flavor(&(*data).flavor, _out, _size);
CHECK_RESULT();
_result = marshal_unsigned_int(&(*data).body.count, _out, _size);
CHECK_RESULT();
if ((*data).body.count > 400) return -1;
{
size_t i;
for (i = 0; i < (*data).body.count; i++) {
_result = marshal_opaque(&(*data).body.data[i], _out, _size);
CHECK_RESULT();
}
}
return 0;
}
/**
* \brief Check for intterupt.
*
* \param port a GPPort
* \param data a pointer to an allocated buffer
* \param size the number of bytes that should be read
*
* Reads a specified number of bytes from the interrupt endpoint
* into the supplied buffer.
* Function waits port->timeout miliseconds for data on interrupt endpoint.
*
* \return a gphoto2 error code
**/
int
gp_port_check_int (GPPort *port, char *data, int size)
{
int retval;
gp_log (GP_LOG_DEBUG, "gphoto2-port",
ngettext(
"Reading %i=0x%x byte from interrupt endpoint...",
"Reading %i=0x%x bytes from interrupt endpoint...",
size), size, size);
CHECK_NULL (port);
CHECK_INIT (port);
/* Check if we read as many bytes as expected */
CHECK_SUPP (port, "check_int", port->pc->ops->check_int);
retval = port->pc->ops->check_int (port, data, size, port->timeout);
CHECK_RESULT (retval);
if (retval != size)
gp_log (GP_LOG_DEBUG, "gphoto2-port", _("Could only read %i "
"out of %i byte(s)"), retval, size);
gp_log_data ("gphoto2-port", data, retval);
return (retval);
}
GPResult
gpiCheckConnect(
GPConnection * connection
)
{
GPIConnection * iconnection = (GPIConnection*)*connection;
int state;
// Check if the connection is completed.
////////////////////////////////////////
CHECK_RESULT(gpiCheckSocketConnect(connection, iconnection->cmSocket, &state));
// Check for a failed attempt.
//////////////////////////////
if(state == GPI_DISCONNECTED)
CallbackFatalError(connection, GP_SERVER_ERROR, GP_LOGIN_CONNECTION_FAILED, "The server has refused the connection.");
// Check if not finished connecting.
////////////////////////////////////
if(state == GPI_NOT_CONNECTED)
return GP_NO_ERROR;
// We're now negotiating the connection.
////////////////////////////////////////
assert(state == GPI_CONNECTED);
iconnection->connectState = GPI_NEGOTIATING;
return GP_NO_ERROR;
}
int marshal_result(result *data, unsigned char **_out, size_t *_size) {
int _result;
_result = marshal_result_status(&(*data).status, _out, _size);
CHECK_RESULT();
_result = marshal_unsigned_int(&(*data).rec.count, _out, _size);
CHECK_RESULT();
if ((*data).rec.count > 1) return -1;
{
size_t i;
for (i = 0; i < (*data).rec.count; i++) {
_result = marshal_record(&(*data).rec.data[i], _out, _size);
CHECK_RESULT();
}
}
return 0;
}
static int
SDSC_send (GPPort *port, unsigned char command)
{
CHECK_RESULT (gp_port_write (port, (char *)&command, 1));
return (GP_OK);
}
//Destroyer
VulkanBase::~VulkanBase() {
// Wait until all operations are complete to destroy stuff
CHECK_RESULT(vkQueueWaitIdle(queue));
swapchain.clean();
//vkFreeCommandBuffers(device, commandPool, commandBuffersVector.size(), commandBuffersVector.data());
vkDestroyCommandPool(device, commandPool, nullptr);
// Destroy synchronization elements
vkDestroySemaphore(device, imageAcquiredSemaphore, nullptr);
vkDestroySemaphore(device, renderingCompletedSemaphore, nullptr);
vkDestroyFence(device, presentFence, nullptr);
// Destroy logical device
vkDestroyDevice(device, nullptr);
#ifdef _DEBUG
if (enableValidation) {
vkDebug::freeDebugCallback(instance);
}
#endif // _DEBUG
vkDestroyInstance(instance,nullptr);
}
CAMLprim
value caml_gp_camera_new(value unit_val) {
CAMLparam0();
Camera *cam;
int ret = gp_camera_new(&cam);
CHECK_RESULT(ret);
CAMLreturn(encapsulate_pointer(cam));
}
int unmarshal_record(record *data, unsigned char **_in, size_t *_size) {
int _result;
_result = unmarshal_key(&(*data).k, _in, _size);
CHECK_RESULT();
_result = unmarshal_unsigned_int(&(*data).data.count, _in, _size);
CHECK_RESULT();
if ((*data).data.count > 1024) return -1;
_result = _checked_calloc((void **)&(*data).data.data, (*data).data.count, sizeof((*data).data.data[0]));
{
size_t i;
for (i = 0; i < (*data).data.count; i++) {
_result = unmarshal_opaque(&(*data).data.data[i], _in, _size);
CHECK_RESULT();
}
}
return 0;
}
int unmarshal_result(result *data, unsigned char **_in, size_t *_size) {
int _result;
_result = unmarshal_result_status(&(*data).status, _in, _size);
CHECK_RESULT();
_result = unmarshal_unsigned_int(&(*data).rec.count, _in, _size);
CHECK_RESULT();
if ((*data).rec.count > 1) return -1;
_result = _checked_calloc((void **)&(*data).rec.data, (*data).rec.count, sizeof((*data).rec.data[0]));
{
size_t i;
for (i = 0; i < (*data).rec.count; i++) {
_result = unmarshal_record(&(*data).rec.data[i], _in, _size);
CHECK_RESULT();
}
}
return 0;
}
void CD3DGraphics::SetDrawTexture(S_CTexture tex, unsigned int slot) {
S_CD3DTexture d3dtex = std::static_pointer_cast<CD3DTexture>(tex);
if (d3dtex == nullptr) {
CHECK_RESULT(d3ddev->SetTexture(slot, NULL));
return;
}
CHECK_RESULT(d3ddev->SetTexture(slot, d3dtex->GetD3DTexture()));
D3DTEXTUREFILTERTYPE filterType = d3dtex->GetFilterType() == FilterType::LINEAR ? D3DTEXF_LINEAR : D3DTEXF_POINT;
d3ddev->SetSamplerState(slot, D3DSAMP_MAGFILTER, filterType);
d3ddev->SetSamplerState(slot, D3DSAMP_MINFILTER, filterType);
D3DTEXTUREADDRESS address = d3dtex->GetOverflowHandling() == OverflowHandling::CLAMP_TO_EDGE ? D3DTADDRESS_CLAMP : D3DTADDRESS_WRAP;
d3ddev->SetSamplerState(slot, D3DSAMP_ADDRESSU, address);
d3ddev->SetSamplerState(slot, D3DSAMP_ADDRESSV, address);
}
int unmarshal_opaque_auth(opaque_auth *data, unsigned char **_in, size_t *_size) {
int _result;
_result = unmarshal_auth_flavor(&(*data).flavor, _in, _size);
CHECK_RESULT();
_result = unmarshal_unsigned_int(&(*data).body.count, _in, _size);
CHECK_RESULT();
if ((*data).body.count > 400) return -1;
_result = _checked_calloc((void **)&(*data).body.data, (*data).body.count, sizeof((*data).body.data[0]));
{
size_t i;
for (i = 0; i < (*data).body.count; i++) {
_result = unmarshal_opaque(&(*data).body.data[i], _in, _size);
CHECK_RESULT();
}
}
return 0;
}
Status LinuxThread::Destroy() {
CHECK_ERROR(m_threadId);
BEFORE_CHECK_RESULT();
Terminate();
delete m_threadId;
m_threadId = NULL;
m_bRun = false;
m_bTerminate = false;
CHECK_RESULT(_destroyMutex(m_terminateMutex));
CHECK_RESULT(_destroyMutex(m_runMutex));
CHECK_RESULT(_destroyCond(m_cond));
AFTER_CHECK_RESULT();
}
static int deletefile_logitech_pd(GPPort *port, const char *filename)
{
unsigned char command[0x10] = { 0x11, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
memcpy(command+3, filename, 11); /* the id of the image to delete */
CHECK_RESULT(ultrapocket_command(port, 1, command, 0x10));
return GP_OK;
}
GPResult
gpiSendOrBufferStringLenToPeer(
GPConnection * connection,
GPIPeer_st peer,
const char * string,
int stringLen
)
{
GPIConnection *iconnection;
unsigned int sent;
unsigned int total;
unsigned int remaining;
assert(peer->outputBuffer.buffer != NULL);
sent = 0;
iconnection = (GPIConnection *)*connection;
remaining = (unsigned int)stringLen;
total = 0;
// Check for nothing to send.
/////////////////////////////
if(stringLen == 0)
return GP_NO_ERROR;
// Only try to send if the buffer is empty and there are no messages.
/////////////////////////////////////////////////////////////////////
if(!(peer->outputBuffer.len - peer->outputBuffer.pos) && !ArrayLength(peer->messages))
{
if ((int)remaining <= (gsUdpEngineGetPeerOutBufferFreeSpace(peer->ip, peer->port) - GS_UDP_RELIABLE_MSG_HEADER - GS_UDP_MSG_HEADER_LEN))
{
gsUdpEngineSendMessage(peer->ip, peer->port, iconnection->mHeader, (unsigned char *)string, remaining, gsi_true);
total = remaining;
remaining = 0;
}
else
{
unsigned int freeSpace = (unsigned int)gsUdpEngineGetPeerOutBufferFreeSpace(peer->ip, peer->port);
if (freeSpace > (GS_UDP_MSG_HEADER_LEN + GS_UDP_RELIABLE_MSG_HEADER))
{
sent = freeSpace - (GS_UDP_MSG_HEADER_LEN + GS_UDP_RELIABLE_MSG_HEADER);
gsUdpEngineSendMessage(peer->ip, peer->port, iconnection->mHeader, (unsigned char *)string,
sent, gsi_true);
total = sent;
remaining -= sent;
}
}
}
// Buffer what wasn't sent.
///////////////////////////
if(remaining)
CHECK_RESULT(gpiAppendStringToBufferLen(connection, &peer->outputBuffer, &string[total], (int)remaining));
return GP_NO_ERROR;
}
/*
* Only need to reset the generic camera type, AFAICT -
* the pocket digital never seems to need it.
*/
static int
ultrapocket_reset(Camera *camera)
{
GPPortInfo oldpi;
GPPort *port = camera->port;
CameraAbilities cab;
unsigned char cmdbuf[0x10];
gp_camera_get_abilities(camera, &cab);
GP_DEBUG ("First connect since camera was used - need to reset cam");
/*
* this resets the ultrapocket. Messy, but it's what the windows
* software does. We only reset if it's been plugged in since
* last reset.
*/
memset(cmdbuf, 0, 16);
cmdbuf[0] = 0x28;
cmdbuf[1] = 0x01;
CHECK_RESULT(ultrapocket_command(port, 1, cmdbuf, 0x10));
/* -------------- */
sleep(4); /* This should do - _might_ need increasing */
CHECK_RESULT(gp_port_get_info(port, &oldpi));
CHECK_RESULT(gp_port_free(port));
CHECK_RESULT(gp_port_new(&port));
CHECK_RESULT(gp_port_set_info(port, oldpi));
CHECK_RESULT(gp_port_usb_find_device(port,
cab.usb_vendor, cab.usb_product));
CHECK_RESULT(gp_port_open(port));
camera->port = port;
return GP_OK;
}
void owl_register_signal_handlers(void) {
struct sigaction sig_ignore = { .sa_handler = SIG_IGN };
struct sigaction sig_default = { .sa_handler = SIG_DFL };
sigset_t sigset;
int ret, i;
const int signals[] = { SIGABRT, SIGBUS, SIGCHLD, SIGFPE, SIGHUP, SIGILL,
SIGINT, SIGQUIT, SIGSEGV, SIGTERM, SIGWINCH };
/* Sanitize our signals; the mask and dispositions from our parent
* aren't really useful. Signal list taken from equivalent code in
* Chromium. */
CHECK_RESULT("sigemptyset", sigemptyset(&sigset));
if ((ret = pthread_sigmask(SIG_SETMASK, &sigset, NULL)) != 0) {
errno = ret;
perror("pthread_sigmask");
}
for (i = 0; i < G_N_ELEMENTS(signals); i++) {
CHECK_RESULT("sigaction", sigaction(signals[i], &sig_default, NULL));
}
/* Turn off SIGPIPE; we check the return value of write. */
CHECK_RESULT("sigaction", sigaction(SIGPIPE, &sig_ignore, NULL));
/* Register some signals with the signal thread. */
CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGWINCH));
CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGTERM));
CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGHUP));
CHECK_RESULT("sigaddset", sigaddset(&sigset, SIGINT));
owl_signal_init(&sigset, sig_handler, NULL);
}
static int mpu6050_set_delay(struct mpu6050_input_data *data)
{
int result;
int delay = 200;
if (data->enabled_sensors & MPU6050_SENSOR_ACCEL)
delay = MIN(delay, atomic_read(&data->accel_delay));
if (data->enabled_sensors & MPU6050_SENSOR_GYRO)
delay = MIN(delay, atomic_read(&data->gyro_delay));
data->current_delay = delay;
CHECK_RESULT(mpu6050_input_set_odr(data, data->current_delay));
CHECK_RESULT(mpu6050_input_set_irq(data, BIT_RAW_RDY_EN));
return result;
}
static int mpu6050_input_set_irq(struct mpu6050_input_data *data, int irq)
{
int result;
CHECK_RESULT(mpu6050_i2c_write_single_reg
(data->client, MPUREG_INT_ENABLE, irq));
return result;
}
static pt_int32_t pt_ctcap_encode_result_comp(ctcap_comp_t *comp, void *buf, pt_int32_t pos)
{
pt_int32_t tmp = pos;
/*parameter*/
pos = pt_asn1_encode_v(comp->para_len, comp->para, buf, pos);
CHECK_RESULT(pos);
/*comp id*/
pos = pt_asn1_encode_tlv(0xcf, 1, &comp->comp_id, buf, pos);
CHECK_RESULT(pos);
/*result component len&tag*/
pos = pt_asn1_encode_tl(0xea, (pt_uint16_t)(tmp - pos), buf, pos);
CHECK_RESULT(pos);
return pos;
}
