grn_rc
grn_timeval_now(grn_ctx *ctx, grn_timeval *tv)
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec t;
if (clock_gettime(CLOCK_REALTIME, &t)) {
SERR("clock_gettime");
} else {
tv->tv_sec = t.tv_sec;
tv->tv_nsec = t.tv_nsec;
}
return ctx->rc;
#else /* HAVE_CLOCK_GETTIME */
# ifdef WIN32
time_t t;
struct _timeb tb;
time(&t);
_ftime(&tb);
tv->tv_sec = t;
tv->tv_nsec = tb.millitm * (GRN_TIME_NSEC_PER_SEC / 1000);
return GRN_SUCCESS;
# else /* WIN32 */
struct timeval t;
if (gettimeofday(&t, NULL)) {
SERR("gettimeofday");
} else {
tv->tv_sec = t.tv_sec;
tv->tv_nsec = GRN_TIME_USEC_TO_NSEC(t.tv_usec);
}
return ctx->rc;
# endif /* WIN32 */
#endif /* HAVE_CLOCK_GETTIME */
}
int32_t led_flash_rer_wait_pupil_contract(
rer_cfg_t *rer,
module_sensor_params_t *led_module_params)
{
if (rer->status == RER_WAIT_PUPIL_CONTRACT) {
/* Wait before to start the main flash after RER sequence */
long int delay;
struct timeval ts_now, ts, ts_diff;
ts = rer->last_rer_flash_ts;
gettimeofday(&ts_now, NULL);
timersub(&ts_now, &ts, &ts_diff);
delay = (ts_diff.tv_sec * 1000000) + ts_diff.tv_usec;
delay = (long int)(RER_PUPIL_CONTRACT_TIME * 1000) - delay;
if (delay > 0) {
/* Wait until Pupil contraction time RER_PUPIL_CONTRACT_TIME */
if (delay <= (RER_PUPIL_CONTRACT_TIME * 1000)) {
SLOW("Wait %ld us to reach RER_PUPIL_CONTRACT_TIME\n", delay);
usleep(delay);
} else {
/* Error - delay can not be bigger than RER_PUPIL_CONTRACT_TIME */
SERR("Error - RER delay out of range %d us\n", delay);
}
} else {
/* Delay is bigger than the requested RER_PUPIL_CONTRACT_TIME */
SERR("RER Over delay %ld us (total delay %ld us)\n",
-(long int)delay,
(long int)(RER_PUPIL_CONTRACT_TIME * 1000) - delay);
}
rer->status = RER_DONE;
}
return SENSOR_SUCCESS;
}
grn_id
grn_plugin_open(grn_ctx *ctx, const char *filename)
{
grn_id id;
grn_dl dl;
grn_plugin **plugin = NULL;
CRITICAL_SECTION_ENTER(grn_plugins_lock);
if ((id = grn_hash_get(&grn_gctx, grn_plugins, filename, PATHLEN(filename),
(void **)&plugin))) {
(*plugin)->refcount++;
goto exit;
}
if ((dl = grn_dl_open(filename))) {
if ((id = grn_hash_add(&grn_gctx, grn_plugins, filename, PATHLEN(filename),
(void **)&plugin, NULL))) {
*plugin = GRN_GMALLOCN(grn_plugin, 1);
if (*plugin) {
if (grn_plugin_initialize(ctx, *plugin, dl, id, filename)) {
GRN_GFREE(*plugin);
*plugin = NULL;
}
}
if (!*plugin) {
grn_hash_delete_by_id(&grn_gctx, grn_plugins, id, NULL);
if (grn_dl_close(dl)) {
/* Now, __FILE__ set in plugin is invalid. */
ctx->errline = 0;
ctx->errfile = NULL;
} else {
const char *label;
label = grn_dl_close_error_label();
SERR(label);
}
id = GRN_ID_NIL;
} else {
(*plugin)->refcount = 1;
}
} else {
if (!grn_dl_close(dl)) {
const char *label;
label = grn_dl_close_error_label();
SERR(label);
}
}
} else {
const char *label;
label = grn_dl_open_error_label();
SERR(label);
}
exit:
CRITICAL_SECTION_LEAVE(grn_plugins_lock);
return id;
}
grn_rc
grn_com_event_init(grn_ctx *ctx, grn_com_event *ev, int max_nevents, int data_size)
{
ev->max_nevents = max_nevents;
if ((ev->hash = grn_hash_create(ctx, NULL, sizeof(grn_sock), data_size, 0))) {
MUTEX_INIT(ev->mutex);
COND_INIT(ev->cond);
GRN_COM_QUEUE_INIT(&ev->recv_old);
ev->msg_handler = NULL;
memset(&(ev->curr_edge_id), 0, sizeof(grn_com_addr));
ev->acceptor = NULL;
ev->opaque = NULL;
#ifndef USE_SELECT
# ifdef USE_EPOLL
if ((ev->events = GRN_MALLOC(sizeof(struct epoll_event) * max_nevents))) {
if ((ev->epfd = epoll_create(max_nevents)) != -1) {
goto exit;
} else {
SERR("epoll_create");
}
GRN_FREE(ev->events);
}
# else /* USE_EPOLL */
# ifdef USE_KQUEUE
if ((ev->events = GRN_MALLOC(sizeof(struct kevent) * max_nevents))) {
if ((ev->kqfd = kqueue()) != -1) {
goto exit;
} else {
SERR("kqueue");
}
GRN_FREE(ev->events);
}
# else /* USE_KQUEUE */
if ((ev->events = GRN_MALLOC(sizeof(struct pollfd) * max_nevents))) {
goto exit;
}
# endif /* USE_KQUEUE*/
# endif /* USE_EPOLL */
grn_hash_close(ctx, ev->hash);
ev->hash = NULL;
ev->events = NULL;
#else /* USE_SELECT */
goto exit;
#endif /* USE_SELECT */
}
exit :
return ctx->rc;
}
static
void
cd_JSONRequest (struct evhttp_request* request, CDServer* server)
{
struct evbuffer* buffer = evhttp_request_get_input_buffer(request);
char* text = CD_alloc(evbuffer_get_length(buffer) + 1);
evbuffer_remove(buffer, text, evbuffer_get_length(buffer));
json_error_t error;
json_t* input = json_loads(text, 0, &error);
json_t* output = json_object();
printf("%s\n", text);
if (evhttp_request_get_command(request) != EVHTTP_REQ_POST) {
goto error;
}
if (input == NULL) {
SERR(server, "RPC.JSON: error on line %d: %s", error.line, error.text);
goto error;
}
CD_EventDispatch(server, "RPC.JSON", input, output);
done: {
char* outString = json_dumps(output, JSON_INDENT(2));
struct evbuffer* outBuffer = evbuffer_new();
evbuffer_add_printf(outBuffer, "%s", outString);
evhttp_send_reply(request, HTTP_OK, "OK", outBuffer);
evbuffer_free(outBuffer);
free(outString);
json_delete(output);
json_delete(input);
CD_free(text);
return;
}
error: {
evhttp_send_error(request, HTTP_INTERNAL, "Internal server error");
CD_free(text);
if (input) {
json_delete(input);
}
if (output) {
json_delete(output);
}
return;
}
}
grn_rc
grn_plugin_close(grn_ctx *ctx, grn_id id)
{
grn_rc rc;
grn_plugin *plugin;
if (id == GRN_ID_NIL) {
return GRN_INVALID_ARGUMENT;
}
CRITICAL_SECTION_ENTER(grn_plugins_lock);
if (!grn_hash_get_value(&grn_gctx, grn_plugins, id, &plugin)) {
rc = GRN_INVALID_ARGUMENT;
goto exit;
}
if (--plugin->refcount) {
rc = GRN_SUCCESS;
goto exit;
}
if (plugin->dl) {
grn_plugin_call_fin(ctx, id);
if (!grn_dl_close(plugin->dl)) {
const char *label;
label = grn_dl_close_error_label();
SERR("%s", label);
}
}
GRN_GFREE(plugin);
rc = grn_hash_delete_by_id(&grn_gctx, grn_plugins, id, NULL);
exit:
CRITICAL_SECTION_LEAVE(grn_plugins_lock);
return rc;
}
void *
grn_plugin_sym(grn_ctx *ctx, grn_id id, const char *symbol)
{
grn_plugin *plugin;
grn_dl_symbol func;
if (id == GRN_ID_NIL) {
return NULL;
}
CRITICAL_SECTION_ENTER(grn_plugins_lock);
if (!grn_hash_get_value(&grn_gctx, grn_plugins, id, &plugin)) {
func = NULL;
goto exit;
}
grn_dl_clear_error();
if (!(func = grn_dl_sym(plugin->dl, symbol))) {
const char *label;
label = grn_dl_sym_error_label();
SERR("%s", label);
}
exit:
CRITICAL_SECTION_LEAVE(grn_plugins_lock);
return func;
}
static int read_from_sock(server_t *srv) {
selene_t *s = srv->s;
int err;
ssize_t rv = 0;
do {
char buf[8096];
setnonblocking(srv->sock);
rv = read(srv->sock, &buf[0], sizeof(buf));
if (rv == -1) {
err = errno;
if (err != EAGAIN) {
srv->read_err = err;
break;
}
}
if (rv == 0) {
break;
}
if (rv > 0) {
SERR(selene_io_in_enc_bytes(s, buf, rv));
}
} while (rv > 0);
return 0;
}
int32_t led_flash_rer_get_chromatix(
rer_cfg_t *rer,
red_eye_reduction_type *rer_chromatix)
{
int led_flash_enable;
red_eye_reduction_type *rer_cfg = (rer_cfg_t *)rer->cfg;
if ((rer_cfg == NULL) ||
(rer_chromatix == NULL)) {
// Check input
SERR("Red Eye Reduction process Skip ->\n \
rer_cfg = 0x%08x \n \
rer_chromatix = 0x%08x \n",
(unsigned int)rer_cfg,
(unsigned int)rer_chromatix);
return SENSOR_FAILURE;
}
// Save red_eye_reduction_led_flash_enable state
led_flash_enable = rer_cfg->red_eye_reduction_led_flash_enable;
memcpy(rer_cfg, rer_chromatix, sizeof(red_eye_reduction_type));
// Restore red_eye_reduction_led_flash_enable state
rer_cfg->red_eye_reduction_led_flash_enable = led_flash_enable;
return SENSOR_SUCCESS;
}
static
void
cdsurvivalproxy_ProxyErrorCallback (struct bufferevent* event, short error, CDClient* client)
{
assert(client);
CDServer* server = client->server;
assert(server);
if (error & BEV_EVENT_CONNECTED) {
SLOG(client->server, LOG_INFO, "proxy connected :D");
}
if (!((error & BEV_EVENT_EOF) || (error & BEV_EVENT_ERROR) || (error & BEV_EVENT_TIMEOUT))) {
//not an error
return;
}
if (error & BEV_EVENT_ERROR) {
SLOG(client->server, LOG_INFO, "libevent: ip %s - %s", client->ip, evutil_socket_error_to_string(EVUTIL_SOCKET_ERROR()));
} else if (error & BEV_EVENT_TIMEOUT) {
SERR(client->server, "A bufferevent timeout?");
} else if (error & BEV_EVENT_EOF) {
SLOG(client->server, LOG_INFO, "remote EOF");
}
CD_ServerKick(client->server, client, CD_CreateStringFromCString("remote connection died"));
}
static grn_bool
grn_time_t_to_tm(grn_ctx *ctx, const time_t time, struct tm *tm)
{
grn_bool success;
const char *function_name;
#ifdef HAVE__LOCALTIME64_S
function_name = "localtime_s";
success = (localtime_s(tm, &time) == 0);
#else /* HAVE__LOCALTIME64_S */
# ifdef HAVE_LOCALTIME_R
function_name = "localtime_r";
success = (localtime_r(&time, tm) != NULL);
# else /* HAVE_LOCALTIME_R */
function_name = "localtime";
{
struct tm *local_tm;
local_tm = localtime(&time);
if (local_tm) {
success = GRN_TRUE;
memcpy(tm, local_tm, sizeof(struct tm));
} else {
success = GRN_FALSE;
}
}
# endif /* HAVE_LOCALTIME_R */
#endif /* HAVE__LOCALTIME64_S */
if (!success) {
SERR("%s: failed to convert time_t to struct tm: <%" GRN_FMT_INT64D ">",
function_name,
(int64_t)time);
}
return success;
}
mrb_value
grn_mrb_load(grn_ctx *ctx, const char *path)
{
grn_mrb_data *data = &(ctx->impl->mrb);
mrb_state *mrb = data->state;
char expanded_path[PATH_MAX];
FILE *file;
mrb_value result;
struct mrb_parser_state *parser;
if (!mrb) {
return mrb_nil_value();
}
if (!grn_mrb_expand_script_path(ctx, path, expanded_path, PATH_MAX)) {
return mrb_nil_value();
}
file = grn_fopen(expanded_path, "r");
if (!file) {
mrb_value exception;
SERR("fopen: failed to open mruby script file: <%s>",
expanded_path);
exception = mrb_exc_new(mrb, E_LOAD_ERROR,
ctx->errbuf, strlen(ctx->errbuf));
mrb->exc = mrb_obj_ptr(exception);
return mrb_nil_value();
}
{
char current_base_directory[PATH_MAX];
char *last_directory;
grn_strcpy(current_base_directory, PATH_MAX, data->base_directory);
grn_strcpy(data->base_directory, PATH_MAX, expanded_path);
last_directory = strrchr(data->base_directory, '/');
if (last_directory) {
last_directory[0] = '\0';
}
parser = mrb_parser_new(mrb);
mrb_parser_set_filename(parser, expanded_path);
parser->s = parser->send = NULL;
parser->f = file;
mrb_parser_parse(parser, NULL);
fclose(file);
{
struct RProc *proc;
proc = mrb_generate_code(mrb, parser);
result = mrb_toplevel_run(mrb, proc);
}
mrb_parser_free(parser);
grn_strcpy(data->base_directory, PATH_MAX, current_base_directory);
}
return result;
}
grn_rc
grn_com_event_add(grn_ctx *ctx, grn_com_event *ev, grn_sock fd, int events, grn_com **com)
{
grn_com *c;
/* todo : expand events */
if (!ev || *ev->hash->n_entries == ev->max_nevents) {
if (ev) {
GRN_LOG(ctx, GRN_LOG_ERROR, "too many connections (%d)", ev->max_nevents);
}
return GRN_INVALID_ARGUMENT;
}
#ifdef USE_EPOLL
{
struct epoll_event e;
memset(&e, 0, sizeof(struct epoll_event));
e.data.fd = (fd);
e.events = (uint32_t) events;
if (epoll_ctl(ev->epfd, EPOLL_CTL_ADD, (fd), &e) == -1) {
SERR("epoll_ctl");
return ctx->rc;
}
}
#endif /* USE_EPOLL*/
#ifdef USE_KQUEUE
{
struct kevent e;
/* todo: udata should have fd */
EV_SET(&e, (fd), events, EV_ADD, 0, 0, NULL);
if (kevent(ev->kqfd, &e, 1, NULL, 0, NULL) == -1) {
SERR("kevent");
return ctx->rc;
}
}
#endif /* USE_KQUEUE */
{
if (grn_hash_add(ctx, ev->hash, &fd, sizeof(grn_sock), (void **)&c, NULL)) {
c->ev = ev;
c->fd = fd;
c->events = events;
if (com) {
*com = c;
}
}
}
return ctx->rc;
}
grn_rc
grn_com_event_mod(grn_ctx *ctx, grn_com_event *ev, grn_sock fd, int events, grn_com **com)
{
grn_com *c;
if (!ev) {
return GRN_INVALID_ARGUMENT;
}
if (grn_hash_get(ctx, ev->hash, &fd, sizeof(grn_sock), (void **)&c)) {
if (c->fd != fd) {
GRN_LOG(ctx, GRN_LOG_ERROR,
"grn_com_event_mod fd unmatch "
"%" GRN_FMT_SOCKET " != %" GRN_FMT_SOCKET,
c->fd, fd);
return GRN_OBJECT_CORRUPT;
}
if (com) {
*com = c;
}
if (c->events != events) {
#ifdef USE_EPOLL
struct epoll_event e;
memset(&e, 0, sizeof(struct epoll_event));
e.data.fd = (fd);
e.events = (uint32_t) events;
if (epoll_ctl(ev->epfd, EPOLL_CTL_MOD, (fd), &e) == -1) {
SERR("epoll_ctl");
return ctx->rc;
}
#endif /* USE_EPOLL*/
#ifdef USE_KQUEUE
// experimental
struct kevent e[2];
EV_SET(&e[0], (fd), GRN_COM_POLLIN|GRN_COM_POLLOUT, EV_DELETE, 0, 0, NULL);
EV_SET(&e[1], (fd), events, EV_ADD, 0, 0, NULL);
if (kevent(ev->kqfd, e, 2, NULL, 0, NULL) == -1) {
SERR("kevent");
return ctx->rc;
}
#endif /* USE_KQUEUE */
c->events = events;
}
return GRN_SUCCESS;
}
return GRN_INVALID_ARGUMENT;
}
int32_t led_flash_sub_module_init(sensor_func_tbl_t *func_tbl)
{
if (!func_tbl) {
SERR("failed");
return SENSOR_FAILURE;
}
func_tbl->open = led_flash_open;
func_tbl->process = led_flash_process;
func_tbl->close = led_flash_close;
return SENSOR_SUCCESS;
}
grn_rc
grn_com_event_del(grn_ctx *ctx, grn_com_event *ev, grn_sock fd)
{
if (!ev) {
return GRN_INVALID_ARGUMENT;
}
{
grn_com *c;
grn_id id = grn_hash_get(ctx, ev->hash, &fd, sizeof(grn_sock), (void **)&c);
if (id) {
#ifdef USE_EPOLL
if (!c->closed) {
struct epoll_event e;
memset(&e, 0, sizeof(struct epoll_event));
e.data.fd = fd;
e.events = c->events;
if (epoll_ctl(ev->epfd, EPOLL_CTL_DEL, fd, &e) == -1) {
SERR("epoll_ctl");
return ctx->rc;
}
}
#endif /* USE_EPOLL*/
#ifdef USE_KQUEUE
struct kevent e;
EV_SET(&e, (fd), c->events, EV_DELETE, 0, 0, NULL);
if (kevent(ev->kqfd, &e, 1, NULL, 0, NULL) == -1) {
SERR("kevent");
return ctx->rc;
}
#endif /* USE_KQUEUE */
return grn_hash_delete_by_id(ctx, ev->hash, id, NULL);
} else {
GRN_LOG(ctx, GRN_LOG_ERROR,
"%04x| fd(%" GRN_FMT_SOCKET ") not found in ev(%p)",
getpid(), fd, ev);
return GRN_INVALID_ARGUMENT;
}
}
}
int32_t led_flash_get_current(
awb_update_t *awb_update,
awb_dual_led_settings_t *dual_led_setting)
{
if (!awb_update || !dual_led_setting) {
SERR("failed");
return SENSOR_FAILURE;
}
memcpy(dual_led_setting, &(awb_update->dual_led_setting),
sizeof(awb_dual_led_settings_t));
return SENSOR_SUCCESS;
}
void *
grn_plugin_sym(grn_ctx *ctx, grn_id id, const char *symbol)
{
grn_plugin *plugin;
grn_dl_symbol func;
if (!grn_hash_get_value(ctx, grn_plugins, id, &plugin)) {
return NULL;
}
grn_dl_clear_error;
if (!(func = grn_dl_sym(plugin->dl, symbol))) {
const char *label;
label = grn_dl_sym_error_label;
SERR(label);
}
return func;
}
grn_rc
grn_plugin_close(grn_ctx *ctx, grn_id id)
{
grn_plugin *plugin;
if (!grn_hash_get_value(ctx, grn_plugins, id, &plugin)) {
return GRN_INVALID_ARGUMENT;
}
if (--plugin->refcount) { return GRN_SUCCESS; }
grn_plugin_call_fin(ctx, id);
if (!grn_dl_close(plugin->dl)) {
const char *label;
label = grn_dl_close_error_label;
SERR(label);
}
GRN_GFREE(plugin);
return grn_hash_delete_by_id(ctx, grn_plugins, id, NULL);
}
grn_rc
grn_com_init(void)
{
#ifdef WIN32
WSADATA wd;
if (WSAStartup(MAKEWORD(2, 0), &wd) != 0) {
grn_ctx *ctx = &grn_gctx;
SOERR("WSAStartup");
}
#else /* WIN32 */
#ifndef USE_MSG_NOSIGNAL
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
grn_ctx *ctx = &grn_gctx;
SERR("signal");
}
#endif /* USE_MSG_NOSIGNAL */
#endif /* WIN32 */
return grn_gctx.rc;
}
grn_rc
grn_timeval2str(grn_ctx *ctx, grn_timeval *tv, char *buf)
{
struct tm *ltm;
#ifdef WIN32
time_t tvsec = (time_t) tv->tv_sec;
ltm = localtime(&tvsec);
#else /* WIN32 */
struct tm tm;
time_t t = tv->tv_sec;
ltm = localtime_r(&t, &tm);
#endif /* WIN32 */
if (!ltm) { SERR("localtime"); }
snprintf(buf, GRN_TIMEVAL_STR_SIZE - 1, GRN_TIMEVAL_STR_FORMAT,
ltm->tm_year + 1900, ltm->tm_mon + 1, ltm->tm_mday,
ltm->tm_hour, ltm->tm_min, ltm->tm_sec, (int) tv->tv_usec);
buf[GRN_TIMEVAL_STR_SIZE - 1] = '\0';
return ctx->rc;
}
grn_rc
grn_timeval_now(grn_ctx *ctx, grn_timeval *tv)
{
#ifdef WIN32
time_t t;
struct _timeb tb;
time(&t);
_ftime(&tb);
tv->tv_sec = (int32_t) t;
tv->tv_usec = tb.millitm * 1000;
return GRN_SUCCESS;
#else /* WIN32 */
struct timeval t;
if (gettimeofday(&t, NULL)) {
SERR("gettimeofday");
} else {
tv->tv_sec = (int32_t) t.tv_sec;
tv->tv_usec = t.tv_usec;
}
return ctx->rc;
#endif /* WIN32 */
}
static int32_t led_flash_close(void *led_flash_ctrl)
{
int32_t rc = SENSOR_SUCCESS;
sensor_led_flash_data_t *ctrl = (sensor_led_flash_data_t *)led_flash_ctrl;
struct msm_camera_led_cfg_t cfg;
SLOW("Enter");
cfg.cfgtype = MSM_CAMERA_LED_RELEASE;
rc = ioctl(ctrl->fd, VIDIOC_MSM_FLASH_LED_DATA_CFG, &cfg);
if (rc < 0) {
SERR("VIDIOC_MSM_FLASH_LED_DATA_CFG failed %s",
strerror(errno));
}
/* close subdev */
close(ctrl->fd);
if (ctrl->rer != NULL) {
if (ctrl->rer->cfg != NULL) {
/* Free rer->cfg */
free(ctrl->rer->cfg);
ctrl->rer->cfg = NULL;
}
/* Free rer */
free(ctrl->rer);
ctrl->rer = NULL;
}
if (ctrl->dual_led_setting != NULL) {
/* Free dual_led_setting */
free(ctrl->dual_led_setting);
ctrl->dual_led_setting = NULL;
}
free(ctrl);
SLOW("Exit");
return rc;
}
int main(int argc, char *argv[]) {
const char *host = SELENE_SERVER_DEFAULT_HOST;
int port = SELENE_SERVER_DEFAULT_PORT;
const char *cert_path = SELENE_SERVER_DEFAULT_CERT_PATH;
const char *key_path = NULL;
selene_conf_t *conf = NULL;
const char *cert = NULL;
const char *pkey = NULL;
int rv = 0;
int i;
for (i = 1; i < argc; i++) {
/* TODO: s_server compat */
if (!strcmp("-host", argv[i]) && argc > i + 1) {
host = argv[i + 1];
i++;
} else if (!strcmp("-port", argv[i]) && argc > i + 1) {
port = atoi(argv[i + 1]);
i++;
} else if (!strcmp("-listen", argv[i]) && argc > i + 1) {
char *p;
host = argv[i + 1];
if ((p = strstr(host, ":")) == NULL) {
fprintf(stderr, "no port found\n");
exit(EXIT_FAILURE);
}
*(p++) = '\0';
port = atoi(p);
i++;
} else {
fprintf(stderr, "Invalid args\n");
usage();
exit(EXIT_FAILURE);
}
}
if (host == NULL) {
fprintf(stderr, "-host must be set\n");
exit(EXIT_FAILURE);
}
if (port <= 0) {
fprintf(stderr, "-port must be set\n");
exit(EXIT_FAILURE);
}
if (key_path == NULL) {
/* assume its a pem encoded cert + key in one */
key_path = cert_path;
}
SERR(selene_conf_create(&conf));
SERR(selene_conf_use_reasonable_defaults(conf));
cert = load_cert(cert_path);
pkey = load_cert(key_path);
SERR(selene_conf_cert_chain_add(conf, cert, pkey));
rv = listen_to(conf, host, port, stdin);
selene_conf_destroy(conf);
if (cert) {
free((void *)cert);
}
if (pkey) {
free((void *)pkey);
}
return rv;
}
static int listen_to(selene_conf_t *conf, const char *host, int port,
FILE *fp) {
fd_set readers;
int rv = 0;
server_t server;
char buf[8096];
char port_str[16];
char *p = NULL;
struct addrinfo hints, *res, *res0;
selene_error_t *err = NULL;
char ip_buf[INET6_ADDRSTRLEN];
char *ip_str = NULL;
memset(&server, 0, sizeof(server));
snprintf(port_str, sizeof(port_str), "%i", port);
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
rv = getaddrinfo(host, port_str, &hints, &res0);
if (rv != 0) {
fprintf(stderr, "TCP getaddrinfo(%s:%d) failed: (%d) %s\n", host, port, rv,
gai_strerror(rv));
exit(EXIT_FAILURE);
}
server.sock = -1;
for (res = res0; res; res = res->ai_next) {
server.listen_sock =
socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (server.listen_sock < 0) {
continue;
}
ip_str = addr2str(res->ai_addr, &ip_buf[0], sizeof(ip_buf));
fprintf(stderr, "TCP bind(%s:%d)\n", ip_str, port);
rv = bind(server.listen_sock, res->ai_addr, res->ai_addrlen);
if (rv != 0) {
close(server.listen_sock);
server.listen_sock = -1;
continue;
}
rv = listen(server.listen_sock, 10);
if (rv != 0) {
close(server.listen_sock);
server.listen_sock = -1;
continue;
}
break;
}
freeaddrinfo(res0);
if (server.listen_sock == -1) {
fprintf(stderr, "TCP bind(%s:%d) failed\n", host, port);
exit(EXIT_FAILURE);
}
server.sock = -1;
while (server.write_err == 0) {
FD_ZERO(&readers);
FD_SET(server.listen_sock, &readers);
if (server.sock != -1) {
FD_SET(server.sock, &readers);
}
FD_SET(fileno(fp), &readers);
rv = select(FD_SETSIZE, &readers, NULL, NULL, NULL);
if (rv > 0) {
if (FD_ISSET(fileno(fp), &readers)) {
p = fgets(buf, sizeof(buf), fp);
if (p == NULL) {
break;
}
if (server.sock != -1) {
SERR(selene_io_in_clear_bytes(server.s, p, strlen(p)));
}
} else if (FD_ISSET(server.listen_sock, &readers)) {
/* TODO: multiple client support */
if (server.sock == -1) {
server.sock = accept(server.listen_sock, NULL, 0);
err = selene_server_create(conf, &server.s);
if (err != SELENE_SUCCESS) {
fprintf(stderr,
"Failed to create client instance: (%d) %s [%s:%d]\n",
err->err, err->msg, err->file, err->line);
exit(EXIT_FAILURE);
}
selene_subscribe(server.s, SELENE_EVENT_LOG_MSG, have_logline, NULL);
SERR(selene_subscribe(server.s, SELENE_EVENT_IO_OUT_ENC, want_pull,
&server));
SERR(selene_subscribe(server.s, SELENE_EVENT_IO_OUT_CLEAR,
have_cleartext, &server));
SERR(selene_start(server.s));
}
} else if (server.sock != -1 && FD_ISSET(server.sock, &readers)) {
read_from_sock(&server);
}
}
}
if (server.write_err != 0) {
/* TODO: client ip */
fprintf(stderr, "TCP write from %s:%d failed: (%d) %s\n", host, port,
server.write_err, strerror(server.write_err));
exit(EXIT_FAILURE);
}
if (server.read_err != 0) {
/* TODO: just disconnect client, keep listening */
fprintf(stderr, "TCP read on %s:%d failed: (%d) %s\n", host, port,
server.read_err, strerror(server.read_err));
exit(EXIT_FAILURE);
}
if (server.s) {
selene_destroy(server.s);
server.s = NULL;
}
return 0;
}
int32_t led_flash_rer_sequence_process(
rer_cfg_t *rer,
module_sensor_params_t *led_module_params)
{
int32_t rc = SENSOR_SUCCESS;
red_eye_reduction_type *rer_cfg = (rer_cfg_t *)rer->cfg;
int led_flash_enable;
int preflash_cycles;
int LED_pulse_duration_ms;
int interval_pulese_ms;
int LED_current_mA;
if ((led_module_params == NULL) ||
(rer_cfg == NULL)) {
// Check input
SERR("Red Eye Reduction process Skip ->\n \
led_module_params = 0x%08x \n \
rer_cfg = 0x%08x \n",
(unsigned int)led_module_params,
(unsigned int)rer_cfg
);
return SENSOR_FAILURE;
}
// Get chromatix RER data from rer_cfg
led_flash_enable = rer_cfg->red_eye_reduction_led_flash_enable;
preflash_cycles = rer_cfg->number_of_preflash_cycles;
LED_pulse_duration_ms = rer_cfg->preflash_LED_pulse_duration;
interval_pulese_ms = rer_cfg->preflash_interval_between_pulese;
LED_current_mA = rer_cfg->preflash_LED_current;
rer->status = RER_START;
if (led_flash_enable == 1) {
// Red eye procedure is Enabled
int rc = SENSOR_SUCCESS;
int sequence_time = ((preflash_cycles
* (LED_pulse_duration_ms + interval_pulese_ms))
+ RER_PUPIL_CONTRACT_TIME);
// Check Red Eye Tuning parameters
rc += input_check(preflash_cycles, PREFLASH_CYCLES_MIN, PREFLASH_CYCLES_MAX);
rc += input_check(LED_pulse_duration_ms, LED_ON_MS_MIN, LED_ON_MS_MAX);
rc += input_check(interval_pulese_ms, LED_OFF_MS_MIN, LED_OFF_MS_MAX);
rc += input_check(sequence_time, RER_DURATION_MS_MIN, RER_DURATION_MS_MAX);
if (rc < 0) {
SERR("Error: RER parameters out of range \n");
rer->status = RER_DONE;
return SENSOR_FAILURE;
}
// RER procedure
while (preflash_cycles) {
led_module_params->func_tbl.process(
led_module_params->sub_module_private,
LED_FLASH_SET_RER_PULSE_FLASH , &LED_current_mA);
usleep(LED_pulse_duration_ms*1000);
led_module_params->func_tbl.process(
led_module_params->sub_module_private,
LED_FLASH_SET_OFF , NULL);
if (preflash_cycles <= 1) {
/* Last flash pulse */
rer->status = RER_WAIT_PUPIL_CONTRACT;
gettimeofday(&rer->last_rer_flash_ts, NULL);
break;
} else {
/* Generate interval between the pulses */
usleep(interval_pulese_ms*1000);
}
preflash_cycles--;
}
}
if (rer->status == RER_START) {
rer->status = RER_DONE;
}
return SENSOR_SUCCESS;
}
boolean sensor_init_probe(module_sensor_ctrl_t *module_ctrl)
{
int32_t rc = 0, dev_fd = 0, sd_fd = 0;
uint32_t i = 0;
struct media_device_info mdev_info;
int32_t num_media_devices = 0;
char dev_name[32];
char subdev_name[32];
struct sensor_init_cfg_data cfg;
boolean ret = TRUE;
while (1) {
int32_t num_entities = 1;
snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
if (dev_fd < 0) {
SLOW("Done enumerating media devices");
break;
}
num_media_devices++;
rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
if (rc < 0) {
SLOW("Done enumerating media devices");
close(dev_fd);
break;
}
if (strncmp(mdev_info.model, "msm_config", sizeof(mdev_info.model) != 0)) {
close(dev_fd);
continue;
}
while (1) {
struct media_entity_desc entity;
memset(&entity, 0, sizeof(entity));
entity.id = num_entities++;
SLOW("entity id %d", entity.id);
rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
if (rc < 0) {
SLOW("Done enumerating media entities");
rc = 0;
break;
}
SLOW("entity name %s type %d group id %d",
entity.name, entity.type, entity.group_id);
if (entity.type == MEDIA_ENT_T_V4L2_SUBDEV &&
entity.group_id == MSM_CAMERA_SUBDEV_SENSOR_INIT) {
snprintf(subdev_name, sizeof(dev_name), "/dev/%s", entity.name);
break;
}
}
close(dev_fd);
}
/* Open sensor_init subdev */
sd_fd = open(subdev_name, O_RDWR);
if (sd_fd < 0) {
SHIGH("Open sensor_init subdev failed");
return FALSE;
}
/* Open sensor libraries and get init information */
for (i = 0; i < ARRAY_SIZE(sensor_libs); i++) {
ret = sensor_probe(sd_fd, sensor_libs[i]);
if (ret == FALSE) {
SERR("failed: to load %s", sensor_libs[i]);
}
}
cfg.cfgtype = CFG_SINIT_PROBE_DONE;
if (ioctl(sd_fd, VIDIOC_MSM_SENSOR_INIT_CFG, &cfg) < 0) {
SERR("failed");
ret = FALSE;
}
close(sd_fd);
return TRUE;
}
grn_id
grn_plugin_open(grn_ctx *ctx, const char *filename)
{
grn_id id = GRN_ID_NIL;
grn_dl dl;
grn_plugin **plugin = NULL;
size_t filename_size;
filename_size = GRN_PLUGIN_KEY_SIZE(filename);
CRITICAL_SECTION_ENTER(grn_plugins_lock);
if ((id = grn_hash_get(&grn_gctx, grn_plugins, filename, filename_size,
(void **)&plugin))) {
(*plugin)->refcount++;
goto exit;
}
#ifdef GRN_WITH_MRUBY
{
const char *mrb_suffix;
mrb_suffix = grn_plugin_get_ruby_suffix();
if (filename_size > strlen(mrb_suffix) &&
strcmp(filename + (strlen(filename) - strlen(mrb_suffix)),
mrb_suffix) == 0) {
id = grn_plugin_open_mrb(ctx, filename, filename_size);
goto exit;
}
}
#endif /* GRN_WITH_MRUBY */
if ((dl = grn_dl_open(filename))) {
if ((id = grn_hash_add(&grn_gctx, grn_plugins, filename, filename_size,
(void **)&plugin, NULL))) {
*plugin = GRN_GMALLOCN(grn_plugin, 1);
if (*plugin) {
grn_memcpy((*plugin)->path, filename, filename_size);
if (grn_plugin_initialize(ctx, *plugin, dl, id, filename)) {
GRN_GFREE(*plugin);
*plugin = NULL;
}
}
if (!*plugin) {
grn_hash_delete_by_id(&grn_gctx, grn_plugins, id, NULL);
if (grn_dl_close(dl)) {
/* Now, __FILE__ set in plugin is invalid. */
ctx->errline = 0;
ctx->errfile = NULL;
} else {
const char *label;
label = grn_dl_close_error_label();
SERR("%s", label);
}
id = GRN_ID_NIL;
} else {
(*plugin)->refcount = 1;
}
} else {
if (!grn_dl_close(dl)) {
const char *label;
label = grn_dl_close_error_label();
SERR("%s", label);
}
}
} else {
const char *label;
label = grn_dl_open_error_label();
SERR("%s", label);
}
exit:
CRITICAL_SECTION_LEAVE(grn_plugins_lock);
return id;
}
/** mesh_rolloff_V4_UpScaleOTPMesh_9x7to10x13:
* @MeshIn: Input Mesh 9x7
* @MeshOut: Output Mesh 13x10
* @width: Sensor width
* @height: Sensor height
* @dh: Horizontal offset of OTP grid from top-left corner of image
* @dv: Vertical offset of OTP grid from top-left corner of image
*
* This function resamples the 9x7 OTP data into the rolloff 13x10 grid
* This function assumed that 9x7 OTP data is unifrom
* This function is called by sonyimx135_format_lensshading
*
* Return:
* void
**/
void mesh_rolloff_V4_UpScaleOTPMesh_9x7to10x13(float *MeshIn, float *MeshOut,
int width, int height, int Dh, int Dv)
{
float cxm, cx0, cx1, cx2, cym, cy0, cy1, cy2;
float am, a0, a1, a2, bm, b0, b1, b2;
float tx , ty;
int ix, iy;
int i, j;
/* Initialize the roll-off mesh grid */
int level,scale, w, h, sgh, sgv, gh, gv, dh, dv;
int sign = 0;
int MESH_H = 12; /* the rolloff block number (horizontal). */
int MESH_V = 9; /* the rolloff block number (vertical). */
int Nx = 9; /* the OTP grid number (horizontal) */
int Ny = 7; /* the OTP grid number (vertical) */
int Gh, Gv;
float *Extend_Mesh;
interp_grid_optimization(width, height, &scale, &dh, &dv, &sgh, &sgv);
gh = sgh * scale;
gv = sgv * scale;
/* outer extend the mesh data 1 block by keeping the same slope */
Dh = Dh/2; /* convert into the size in per-channel image */
Dv = Dv/2;
Gh = (width/2-2*Dh)/(Nx-1); /* OTP block size (horizontal) */
Gv = (height/2-2*Dv)/(Ny-1); /* OTP block size (vertical) */
Extend_Mesh = (float*) malloc( sizeof(float) * (Nx+2)*(Ny+2));
if (Extend_Mesh == NULL) {
SERR("%s: malloc failed",__func__);
return;
}
for (i=1; i<Ny+1; i++)
for (j=1; j<Nx+1; j++)
Extend_Mesh[i*(Nx+2)+j] = MeshIn[(i-1)*Nx+j-1];
Extend_Mesh[0*(Nx+2)+0] = Extend_Mesh[1*(Nx+2)+1]*2- Extend_Mesh[2*(Nx+2)+2];
Extend_Mesh[(Ny+1)*(Nx+2)+0] =
Extend_Mesh[(Ny)*(Nx+2)+1]*2- Extend_Mesh[(Ny-1)*(Nx+2)+2];
Extend_Mesh[(Ny+1)*(Nx+2)+Nx+1] =
Extend_Mesh[(Ny)*(Nx+2)+Nx]*2- Extend_Mesh[(Ny-1)*(Nx+2)+Nx-1];
Extend_Mesh[0*(Nx+2)+Nx+1] =
Extend_Mesh[1*(Nx+2)+Nx]*2- Extend_Mesh[2*(Nx+2)+Nx-1];
for (i=1; i<Ny+1; i++){
Extend_Mesh[i*(Nx+2)+0] = Extend_Mesh[i*(Nx+2)+1]*2 -
Extend_Mesh[i*(Nx+2)+2];
Extend_Mesh[i*(Nx+2)+Nx+1] = Extend_Mesh[i*(Nx+2)+Nx]*2 -
Extend_Mesh[i*(Nx+2)+Nx-1];
}
for (j=1; j<Nx+1; j++){
Extend_Mesh[0*(Nx+2)+j] = Extend_Mesh[1*(Nx+2)+j]*2 -
Extend_Mesh[2*(Nx+2)+j];
Extend_Mesh[(Ny+1)*(Nx+2)+j] = Extend_Mesh[(Ny)*(Nx+2)+j]*2 -
Extend_Mesh[(Ny-1)*(Nx+2)+j];
}
/* resample Extended Mesh data onto the roll-off mesh grid */
for (i = 0; i < (MESH_V + 1); i++) {
for (j = 0; j < (MESH_H + 1); j++) {
tx = (float)((double)(j*gh-dh -Dh + Gh)/ (double)(Gh));
ix = floor(tx);
tx -= (double)ix;
ty = (float)((double)(i*gv-dv -Dv + Gv)/(double)(Gv));
iy = floor(ty);
ty -= (double)iy;
if (i == 0 || j == 0 || i == MESH_V|| j == MESH_H){
/* for boundary points, use bilinear interpolation */
b1 = (1 - tx)* Extend_Mesh[iy *(Nx+2) + ix] +
tx* Extend_Mesh[iy *(Nx+2) + ix+1];
b2 = (1 - tx)* Extend_Mesh[(iy+1)*(Nx+2) + ix] +
tx* Extend_Mesh[(iy+1)*(Nx+2) + ix+1];
MeshOut[(i * (MESH_H + 1)) + j] = (float)((1 - ty)*b1 + ty*b2);
} else { /* for nonboundary points, use bicubic interpolation */
/*get x direction coeff and y direction coeff*/
CUBIC_F(tx, cxm, cx0, cx1, cx2);
CUBIC_F(ty, cym, cy0, cy1, cy2);
am = Extend_Mesh[(iy-1) *(Nx+2)+ (ix-1)];
a0 = Extend_Mesh[(iy-1) *(Nx+2)+ (ix )];
a1 = Extend_Mesh[(iy-1) *(Nx+2)+ (ix+1)];
a2 = Extend_Mesh[(iy-1) *(Nx+2)+ (ix+2)];
bm = ((cxm * am) + (cx0 * a0) + (cx1 * a1) + (cx2 * a2));
am = Extend_Mesh[(iy ) *(Nx+2)+ (ix-1)];
a0 = Extend_Mesh[(iy ) *(Nx+2)+ (ix )];
a1 = Extend_Mesh[(iy ) *(Nx+2)+ (ix+1)];
a2 = Extend_Mesh[(iy ) *(Nx+2)+ (ix+2)];
b0 = ((cxm * am) + (cx0 * a0) + (cx1 * a1) + (cx2 * a2));
am = Extend_Mesh[(iy+1) *(Nx+2)+ (ix-1)];
a0 = Extend_Mesh[(iy+1) *(Nx+2)+ (ix )];
a1 = Extend_Mesh[(iy+1) *(Nx+2)+ (ix+1)];
a2 = Extend_Mesh[(iy+1) *(Nx+2)+ (ix+2)];
b1 = ((cxm * am) + (cx0 * a0) + (cx1 * a1) + (cx2 * a2));
am = Extend_Mesh[(iy+2) *(Nx+2)+ (ix-1)];
a0 = Extend_Mesh[(iy+2) *(Nx+2)+ (ix )];
a1 = Extend_Mesh[(iy+2) *(Nx+2)+ (ix+1)];
a2 = Extend_Mesh[(iy+2) *(Nx+2)+ (ix+2)];
b2 = ((cxm * am) + (cx0 * a0) + (cx1 * a1) + (cx2 * a2));
MeshOut[(i * (MESH_H + 1)) + j] = (float)
((cym * bm) + (cy0 * b0) + (cy1 * b1) + (cy2 * b2));
} /* else */
}/*for (j = 0; j < (MESH_H + 1); j++) */
}/* for (i = 0; i < (MESH_V + 1); i++) */
/* free memory */
free(Extend_Mesh);
}
static int32_t led_flash_open(void **led_flash_ctrl, const char *subdev_name)
{
int32_t rc = SENSOR_SUCCESS;
sensor_led_flash_data_t *ctrl = NULL;
struct msm_camera_led_cfg_t cfg;
char subdev_string[32];
SLOW("Enter");
if (!led_flash_ctrl || !subdev_name) {
SERR("failed sctrl %p subdev name %p",
led_flash_ctrl, subdev_name);
return SENSOR_ERROR_INVAL;
}
ctrl = malloc(sizeof(sensor_led_flash_data_t));
if (!ctrl) {
SERR("failed");
return SENSOR_FAILURE;
}
memset(ctrl, 0, sizeof(sensor_led_flash_data_t));
snprintf(subdev_string, sizeof(subdev_string), "/dev/%s", subdev_name);
SLOW("sd name %s", subdev_string);
/* Open subdev */
ctrl->fd = open(subdev_string, O_RDWR);
if (ctrl->fd < 0) {
SERR("failed");
rc = SENSOR_FAILURE;
goto ERROR1;
}
ctrl->rer = malloc(sizeof(rer_cfg_t));
if (!ctrl->rer) {
SERR("failed");
rc = SENSOR_FAILURE;
goto ERROR1;
}
memset(ctrl->rer, 0, sizeof(rer_cfg_t));
ctrl->rer->cfg = malloc(sizeof(red_eye_reduction_type));
if (!ctrl->rer->cfg) {
SERR("failed");
rc = SENSOR_FAILURE;
goto ERROR2;
}
memset(ctrl->rer->cfg, 0, sizeof(red_eye_reduction_type));
ctrl->dual_led_setting = malloc(sizeof(awb_dual_led_settings_t));
if (!ctrl->dual_led_setting) {
SERR("failed");
rc = SENSOR_FAILURE;
goto ERROR3;
}
memset(ctrl->dual_led_setting, 0, sizeof(awb_dual_led_settings_t));
cfg.cfgtype = MSM_CAMERA_LED_INIT;
rc = ioctl(ctrl->fd, VIDIOC_MSM_FLASH_LED_DATA_CFG, &cfg);
if (rc < 0) {
SERR("VIDIOC_MSM_FLASH_LED_DATA_CFG failed %s", strerror(errno));
goto ERROR4;
}
*led_flash_ctrl = (void *)ctrl;
SLOW("Exit");
return rc;
ERROR4:
free(ctrl->dual_led_setting);
ERROR3:
free(ctrl->rer->cfg);
ERROR2:
free(ctrl->rer);
ERROR1:
free(ctrl);
return rc;
}
