int
realapp ()
{
#ifdef WITH_MYSQL
mysql_library_init(0, NULL, NULL);
#endif
os_mutex_init (&crypt_lock);
os_mutex_init (&getpwnam_lock);
os_mutex_init (&getspnam_lock);
os_mutex_init (&localtime_lock);
os_mutex_init (&writerpipe_lock);
#ifndef _WIN32_
reloadconfig (SIGHUP);
signal (SIGCHLD, kidkiller);
signal (SIGPIPE, ignorer);
signal (SIGQUIT, closeup);
signal (SIGINT, closeup);
#else
reloadconfig (0);
#endif
#ifndef _WIN32_
if (runAsDaemon)
daemonize ();
else if (log_filename) {
int fh = open (log_filename, O_CREAT|O_TRUNC|O_RDWR, 0666);
if (fh == -1) {
fprintf(stderr, "failed to open logfile %s:%s\n", log_filename, strerror(errno));
fh = open ("/dev/null", O_RDWR);
}
close (1);
close (2);
dup2 (fh, 1);
dup2 (fh, 2);
}
#endif
log_log (NULL, LOG_EVT_SERVERSTART, 0, conf);
while (TRUE) {
if (!HandleRequest ()) {
#ifdef WITH_DEBUG
DEBUG_LOG ("Couldn't handle request.");
#endif
}
}
#ifdef WITH_MYSQL
mysql_library_end();
#endif
return EXIT_SUCCESS;
}
/******************************************************************************
* Function: jpeg_queue_init
* Description: Initialize the queue.
* It checks the pointer to the entry array and allocate
* jpeg_q_t structure, and initialize queue head, tail
* and counts all to zero.
* Also initialize thread condition variable and mutex.
* Input parameters:
* p_queue - The pointer to queue object.
* Return values:
* JPEGERR_SUCCESS
* JPEGERR_EMALLOC
* JPEGERR_ENULLPTR
* (See jpegerr.h for description of error values.)
* Notes: none
*****************************************************************************/
int jpeg_queue_init(jpeg_queue_t *p_queue)
{
jpeg_q_t *p_q;
// Queue validation
if (!p_queue)
{
JPEG_DBG_ERROR("jpeg_queue_init: failed with empty queue pointer\n");
return JPEGERR_ENULLPTR;
}
// Allocate the jpeg_q_t structure
p_q = (jpeg_q_t *)JPEG_MALLOC(sizeof(jpeg_q_t));
*p_queue= (jpeg_queue_t)p_q;
if (!p_q)
{
JPEG_DBG_ERROR("jpeg_queue_init: failed with allocation queue\n");
return JPEGERR_EMALLOC;
}
// Zero out all fields
// Initialize queue head, tail and counts all to zero
STD_MEMSET(p_q, 0, sizeof(jpeg_q_t));
// Initialize thread condition variable and mutex
(void)os_mutex_init(&(p_q->mutex));
(void)os_cond_init(&(p_q->get_cond));
(void)os_cond_init(&(p_q->abort_cond));
return JPEGERR_SUCCESS;
}
static BOOL
log_connection (conn_t * conn, int event, config_t * conf)
{
switch (event) {
case LOG_EVT_SERVERSTART:
if (locksinit == FALSE)
os_mutex_init (&connection_filelock);
if (config_getConnLog (conf)) {
os_mutex_lock (&connection_filelock);
logfile = fopen (config_getConnLog (conf), "a");
os_mutex_unlock (&connection_filelock);
} else {
logfile = NULL;
}
break;
case LOG_EVT_SERVERCLOSE:
if (logfile) {
os_mutex_lock (&connection_filelock);
fclose (logfile);
logfile = NULL;
os_mutex_unlock (&connection_filelock);
}
break;
case LOG_EVT_SERVERRESTART:
log_connection (conn, LOG_EVT_SERVERCLOSE, conf);
log_connection (conn, LOG_EVT_SERVERSTART, conf);
break;
case LOG_EVT_LOG:
if (logfile)
return connection_real_log (conn);
break;
}
return TRUE;
}
/**
* Callback to initialize an adc_dev structure from the os device
* initialization callback. This sets up a stm32f4_adc_device(), so
* that subsequent lookups to this device allow us to manipulate it.
*
* @param1 os device ptr
* @param2 stm32f4 ADC device cfg ptr
* @return OS_OK on success
*/
int
stm32f4_adc_dev_init(struct os_dev *odev, void *arg)
{
struct stm32f4_adc_dev_cfg *sac;
struct adc_dev *dev;
struct adc_driver_funcs *af;
sac = (struct stm32f4_adc_dev_cfg *) arg;
assert(sac != NULL);
dev = (struct adc_dev *)odev;
os_mutex_init(&dev->ad_lock);
dev->ad_chans = (void *) sac->sac_chans;
dev->ad_chan_count = sac->sac_chan_count;
OS_DEV_SETHANDLERS(odev, stm32f4_adc_open, stm32f4_adc_close);
af = &dev->ad_funcs;
af->af_configure_channel = stm32f4_adc_configure_channel;
af->af_sample = stm32f4_adc_sample;
af->af_read_channel = stm32f4_adc_read_channel;
af->af_set_buffer = stm32f4_adc_set_buffer;
af->af_release_buffer = stm32f4_adc_release_buffer;
af->af_read_buffer = stm32f4_adc_read_buffer;
af->af_size_buffer = stm32f4_adc_size_buffer;
return (OS_OK);
}
/**
* Callback to initialize an adc_dev structure from the os device
* initialization callback. This sets up a nrf52_adc_device(), so
* that subsequent lookups to this device allow us to manipulate it.
*/
int
nrf52_adc_dev_init(struct os_dev *odev, void *arg)
{
struct adc_dev *dev;
struct adc_driver_funcs *af;
dev = (struct adc_dev *) odev;
os_mutex_init(&dev->ad_lock);
dev->ad_chans = (void *) nrf52_adc_chans;
dev->ad_chan_count = NRF_SAADC_CHANNEL_COUNT;
OS_DEV_SETHANDLERS(odev, nrf52_adc_open, nrf52_adc_close);
assert(init_adc_config == NULL || init_adc_config == arg);
init_adc_config = arg;
af = &dev->ad_funcs;
af->af_configure_channel = nrf52_adc_configure_channel;
af->af_sample = nrf52_adc_sample;
af->af_read_channel = nrf52_adc_read_channel;
af->af_set_buffer = nrf52_adc_set_buffer;
af->af_release_buffer = nrf52_adc_release_buffer;
af->af_read_buffer = nrf52_adc_read_buffer;
af->af_size_buffer = nrf52_adc_size_buffer;
NVIC_SetVector(SAADC_IRQn, (uint32_t) nrfx_saadc_irq_handler);
return (0);
}
/*
Clear structures to default values
*/
static void
config_init_config (config_t * conf)
{
int i;
os_mutex_init (&conf->lock);
conf->refcount = 1;
conf->auth = NULL;
conf->filt = NULL;
conf->intface = INADDR_ANY;
conf->maxbindwait = 60;
conf->port = 1080;
conf->maxconnsperthread = 100;
conf->usecount = 0;
conf->throttle = 0;
conf->allowlocalusers = 0;
conf->users = NULL;
conf->chains = NULL;
conf->sumlog.useConnFile = NULL;
for (i = 0; i < LOG_MAX; i++) {
conf->sumlog.useAddrFile[i] = NULL;
conf->sumlog.useUserFile[i] = NULL;
}
}
/**
* Initializes the nffs memory and data structures. This must be called before
* any nffs operations are attempted.
*
* @return 0 on success; nonzero on error.
*/
int
nffs_init(void)
{
int rc;
nffs_config_init();
nffs_cache_clear();
rc = os_mutex_init(&nffs_mutex);
if (rc != 0) {
return NFFS_EOS;
}
free(nffs_file_mem);
nffs_file_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_files, sizeof (struct nffs_file)));
if (nffs_file_mem == NULL) {
return NFFS_ENOMEM;
}
free(nffs_inode_mem);
nffs_inode_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_inodes,
sizeof (struct nffs_inode_entry)));
if (nffs_inode_mem == NULL) {
return NFFS_ENOMEM;
}
free(nffs_block_entry_mem);
nffs_block_entry_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_blocks,
sizeof (struct nffs_hash_entry)));
if (nffs_block_entry_mem == NULL) {
return NFFS_ENOMEM;
}
free(nffs_cache_inode_mem);
nffs_cache_inode_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_inodes,
sizeof (struct nffs_cache_inode)));
if (nffs_cache_inode_mem == NULL) {
return NFFS_ENOMEM;
}
free(nffs_cache_block_mem);
nffs_cache_block_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_blocks,
sizeof (struct nffs_cache_block)));
if (nffs_cache_block_mem == NULL) {
return NFFS_ENOMEM;
}
rc = nffs_misc_reset();
if (rc != 0) {
return rc;
}
return 0;
}
uint8_t kalman_init(
kalman_robot_handle_t * handle,
const robot_pos_t * initial_config)
{
// verify input
if(handle == NULL || initial_config == NULL) {
return 0;
}
// initialize mutex
os_mutex_init(&(handle->_mutex));
os_mutex_take(&(handle->_mutex));
// set initial state of robot
handle->_state._x = initial_config->x;
handle->_state._y = initial_config->y;
// assume that the robot is standing still initially
handle->_state._v_x = 0.0f;
handle->_state._v_y = 0.0f;
// set initial state covariance
handle->_state_covariance._cov_a._a = initial_config->var_x;
handle->_state_covariance._cov_a._b = initial_config->cov_xy;
handle->_state_covariance._cov_a._c = initial_config->cov_xy;
handle->_state_covariance._cov_a._d = initial_config->var_y;
handle->_state_covariance._cov_b._a = 0.0f;
handle->_state_covariance._cov_b._b = 0.0f;
handle->_state_covariance._cov_b._c = 0.0f;
handle->_state_covariance._cov_b._d = 0.0f;
handle->_state_covariance._cov_c._a = 0.0f;
handle->_state_covariance._cov_c._b = 0.0f;
handle->_state_covariance._cov_c._c = 0.0f;
handle->_state_covariance._cov_c._d = 0.0f;
handle->_state_covariance._cov_d._a = 0.0f;
handle->_state_covariance._cov_d._b = 0.0f;
handle->_state_covariance._cov_d._c = 0.0f;
handle->_state_covariance._cov_d._d = 0.0f;
// set default measurment covariance
handle->_measurement_covariance._a = MEAS_VAR_X;
handle->_measurement_covariance._b = MEAS_COV_XY;
handle->_measurement_covariance._c = MEAS_COV_XY;
handle->_measurement_covariance._d = MEAS_VAR_Y;
// default max acc of robot
handle->_max_acc = MAX_ACC;
// default proportionality constant for process noise covariance
handle->_process_noise_proportionality = PROC_NOISE_PROP;
os_mutex_release(&(handle->_mutex));
return 1;
}
void dcc_can_init(int devfd) {
os_mutex_init(&dcc_mutex);
mostacan_fd = devfd;
DccLoop_Init();
dcc_timer = os_timer_create(&dcc_timer_callback, NULL, NULL);
os_timer_start(dcc_timer, MSEC_TO_NSEC(100));
os_thread_create(NULL, "dcc_can_rx", 0, DCC_CAN_THREAD_CAN_STACK_SIZE,
dcc_can_thread, NULL);
}
static wsf_code wsf_allocate_resource(void)
{
msg_id_lock = os_mutex_init();
sess_lock = os_mutex_init( );
device_lock = os_mutex_init( );
init_req_glist();
wsf_msg_queue_init(&global_request_queue);
if ( (NULL == msg_id_lock)
|| (NULL == sess_lock)
|| (NULL == device_lock)
|| (NULL == global_request_queue)) {
wsf_os_free_resource();
return WSF_FAIL;
}
return WSF_SUCCESS;
}
int
cbmem_init(struct cbmem *cbmem, void *buf, uint32_t buf_len)
{
os_mutex_init(&cbmem->c_lock);
memset(cbmem, 0, sizeof(*cbmem));
cbmem->c_buf = buf;
cbmem->c_buf_end = buf + buf_len;
return (0);
}
FDWATCH_HANDLE fdwatch_create()
{
int index;
for(index=0; index<sizeof(array)/sizeof(array[0]); index++) {
if(!array[index].inuse) break;
}
if(index==sizeof(array)/sizeof(array[0])) return NULL;
array[index].inuse = 1;
rlist_init(&array[index].enable_list);
os_mutex_init(&array[index].list_mtx);
array[index].quit_flag = 0;
return &array[index];
}
static BOOL
log_outputLog (DSTSHashTable ** src, char *path)
{
struct stLogPath *logpath;
os_thread_t thr;
os_thread_init (&thr);
logpath = (struct stLogPath *) malloc (sizeof (stLogPath));
logpath->src = *src;
strncpy (logpath->path, path, sizeof (logpath->path));
*src = (DSTSHashTable *) malloc (sizeof (DSTSHashTable));
ds_hash_init (&(*src)->hsh, 100, DEF_PRIMEA, DEF_PRIMEB);
os_mutex_init (&(*src)->lock);
os_thread_exec (&thr, log_outputLogChildThread, logpath);
os_thread_detach (&thr);
return TRUE;
}
LOG_HANDLE log_open(const char* url)
{
int ret, type;
LOG_CTX* ctx = NULL;
for(type=0; type<sizeof(map)/sizeof(map[0]); type++) {
if(memcmp(map[type].name, url, strlen(map[type].name))==0) {
ctx = (LOG_CTX*)malloc(sizeof(LOG_CTX)+map[type].size+map[type].tbuflen);
memset(ctx, 0, sizeof(LOG_CTX)+map[type].size+map[type].tbuflen);
break;
}
}
if(ctx==NULL) return NULL;
ctx->type = type;
ctx->ptr = (void*)(ctx+1);
if(map[type].tbuflen==0) {
memset(&ctx->stream, 0, sizeof(ctx->stream));
return ctx;
}
ctx->stream.buf = (char*)ctx + sizeof(LOG_CTX) + map[type].size;
ctx->stream.cur = 0;
ctx->stream.len = 0;
ctx->stream.max = map[type].tbuflen;
os_sem_init(&ctx->stream.inque, 0);
os_sem_init(&ctx->stream.ouque, 0);
os_mutex_init(&ctx->stream.mtx);
ctx->stream.inque_size = 0;
ctx->stream.ouque_size = 0;
ret = map[ctx->type].func_open(ctx, url+strlen(map[type].name));
if(ret!=ERR_NOERROR) { free(ctx); return NULL; }
os_thread_begin(&ctx->stream.thread, log_thread, (void*)ctx);
return ctx;
}
void debug_alloc_init()
{
os_mutex_init(&g_debug_memory.lock);
g_debug_memory.log = g_debug_log_storage;
g_debug_memory.log_size = Count(g_debug_log_storage);
}
/**
* Initializes the host portion of the BLE stack.
*/
int
ble_hs_init(struct os_eventq *app_evq, struct ble_hs_cfg *cfg)
{
int rc;
ble_hs_free_mem();
if (app_evq == NULL) {
rc = BLE_HS_EINVAL;
goto err;
}
ble_hs_parent_evq = app_evq;
ble_hs_cfg_init(cfg);
log_init();
log_console_handler_init(&ble_hs_log_console_handler);
log_register("ble_hs", &ble_hs_log, &ble_hs_log_console_handler);
ble_hs_hci_cmd_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs,
HCI_CMD_BUF_SIZE));
if (ble_hs_hci_cmd_buf == NULL) {
rc = BLE_HS_ENOMEM;
goto err;
}
/* Create memory pool of command buffers */
rc = os_mempool_init(&g_hci_cmd_pool, ble_hs_cfg.max_hci_bufs,
HCI_CMD_BUF_SIZE, ble_hs_hci_cmd_buf,
"HCICmdPool");
assert(rc == 0);
ble_hs_hci_os_event_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs,
HCI_OS_EVENT_BUF_SIZE));
if (ble_hs_hci_os_event_buf == NULL) {
rc = BLE_HS_ENOMEM;
goto err;
}
/* Create memory pool of OS events */
rc = os_mempool_init(&g_hci_os_event_pool, ble_hs_cfg.max_hci_bufs,
HCI_OS_EVENT_BUF_SIZE, ble_hs_hci_os_event_buf,
"HCIOsEventPool");
assert(rc == 0);
/* Initialize eventq */
os_eventq_init(&ble_hs_evq);
/* Initialize stats. */
rc = stats_module_init();
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
ble_hci_cmd_init();
rc = ble_hs_conn_init();
if (rc != 0) {
goto err;
}
rc = ble_l2cap_init();
if (rc != 0) {
goto err;
}
rc = ble_att_init();
if (rc != 0) {
goto err;
}
rc = ble_att_svr_init();
if (rc != 0) {
goto err;
}
rc = ble_gap_init();
if (rc != 0) {
goto err;
}
rc = ble_gattc_init();
if (rc != 0) {
goto err;
}
rc = ble_gatts_init();
if (rc != 0) {
goto err;
}
os_mqueue_init(&ble_hs_rx_q, NULL);
os_mqueue_init(&ble_hs_tx_q, NULL);
rc = stats_init_and_reg(
STATS_HDR(ble_hs_stats), STATS_SIZE_INIT_PARMS(ble_hs_stats,
STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_hs_stats), "ble_hs");
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
os_callout_func_init(&ble_hs_heartbeat_timer, ble_hs_parent_evq,
ble_hs_heartbeat, NULL);
os_callout_func_init(&ble_hs_event_co, &ble_hs_evq,
ble_hs_event_handle, NULL);
rc = os_mutex_init(&ble_hs_mutex);
if (rc != 0) {
rc = BLE_HS_EOS;
goto err;
}
return 0;
err:
ble_hs_free_mem();
return rc;
}
static BOOL
log_summary (conn_t * conn, int event, config_t * conf)
{
time_t now;
int i;
struct tm *tm;
#ifdef HAVE_LOCALTIME_R
struct tm realtm;
#endif
switch (event) {
case LOG_EVT_SERVERSTART:
if (locksinit == FALSE)
os_mutex_init (&lastlog_lock);
for (i = 0; i < LOG_MAX; i++) {
if (config_getAddrLog (conf, i)) {
logAddrFilename[i] =
(char *) malloc (strlen (config_getAddrLog (conf, i)) +
1);
strcpy (logAddrFilename[i], config_getAddrLog (conf, i));
logAddr[i] =
(DSTSHashTable *) malloc (sizeof (DSTSHashTable));
ds_hash_init (&logAddr[i]->hsh, 100, DEF_PRIMEA, DEF_PRIMEB);
os_mutex_init (&logAddr[i]->lock);
} else {
logAddrFilename[i] = NULL;
logAddr[i] = NULL;
}
if (config_getUserLog (conf, i)) {
logUserFilename[i] =
(char *) malloc (strlen (config_getUserLog (conf, i)) +
1);
strcpy (logUserFilename[i], config_getUserLog (conf, i));
logUser[i] =
(DSTSHashTable *) malloc (sizeof (DSTSHashTable));
ds_hash_init (&logUser[i]->hsh, 100, DEF_PRIMEA, DEF_PRIMEB);
os_mutex_init (&logUser[i]->lock);
} else {
logUserFilename[i] = NULL;
logUser[i] = NULL;
}
}
time (&now);
os_mutex_lock (&lastlog_lock);
#ifndef HAVE_LOCALTIME_R
os_mutex_lock (&localtime_lock);
tm = localtime (&now);
#else
tm = localtime_r (&now, &realtm);
#endif
log_updatelast (tm);
#ifndef HAVE_LOCALTIME_R
os_mutex_unlock (&localtime_lock);
#endif
os_mutex_unlock (&lastlog_lock);
break;
case LOG_EVT_SERVERCLOSE:
now = (time_t) 0;
os_mutex_lock (&lastlog_lock);
#ifndef HAVE_LOCALTIME_R
os_mutex_lock (&localtime_lock);
tm = localtime (&now);
#else
tm = localtime_r (&now, &realtm);
#endif
log_updatelast (tm);
#ifndef HAVE_LOCALTIME_R
os_mutex_unlock (&localtime_lock);
#endif
os_mutex_unlock (&lastlog_lock);
log_checkForLogOutput ();
for (i = 0; i < LOG_MAX; i++) {
if (logAddr[i]) {
ds_hash_close (&logAddr[i]->hsh);
os_mutex_close (&logAddr[i]->lock);
free (logAddr[i]);
}
if (logUser[i]) {
ds_hash_close (&logUser[i]->hsh);
os_mutex_close (&logUser[i]->lock);
free (logUser[i]);
}
if (logAddrFilename[i]) {
free (logAddrFilename[i]);
logAddrFilename[i] = NULL;
}
if (logUserFilename[i]) {
free (logUserFilename[i]);
logUserFilename[i] = NULL;
}
}
break;
case LOG_EVT_LOG:
return log_summary_real (conn);
break;
}
return TRUE;
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_direct");
if (argc != 3)
UT_FATAL("usage: %s [directory] [# of pools]", argv[0]);
unsigned npools = ATOU(argv[2]);
const char *dir = argv[1];
int r;
os_mutex_init(&lock1);
os_mutex_init(&lock2);
os_cond_init(&sync_cond1);
os_cond_init(&sync_cond2);
cond1 = cond2 = 0;
PMEMobjpool **pops = MALLOC(npools * sizeof(PMEMobjpool *));
UT_ASSERTne(pops, NULL);
size_t length = strlen(dir) + MAX_PATH_LEN;
char *path = MALLOC(length);
for (unsigned i = 0; i < npools; ++i) {
int ret = snprintf(path, length, "%s"OS_DIR_SEP_STR"testfile%d",
dir, i);
if (ret < 0 || ret >= length)
UT_FATAL("!snprintf");
pops[i] = pmemobj_create(path, LAYOUT_NAME, PMEMOBJ_MIN_POOL,
S_IWUSR | S_IRUSR);
if (pops[i] == NULL)
UT_FATAL("!pmemobj_create");
}
PMEMoid *oids = MALLOC(npools * sizeof(PMEMoid));
UT_ASSERTne(oids, NULL);
PMEMoid *tmpoids = MALLOC(npools * sizeof(PMEMoid));
UT_ASSERTne(tmpoids, NULL);
oids[0] = OID_NULL;
UT_ASSERTeq(obj_direct(oids[0]), NULL);
for (unsigned i = 0; i < npools; ++i) {
oids[i] = (PMEMoid) {pops[i]->uuid_lo, 0};
UT_ASSERTeq(obj_direct(oids[i]), NULL);
uint64_t off = pops[i]->heap_offset;
oids[i] = (PMEMoid) {pops[i]->uuid_lo, off};
UT_ASSERTeq((char *)obj_direct(oids[i]) - off,
(char *)pops[i]);
r = pmemobj_alloc(pops[i], &tmpoids[i], 100, 1, NULL, NULL);
UT_ASSERTeq(r, 0);
}
r = pmemobj_alloc(pops[0], &thread_oid, 100, 2, NULL, NULL);
UT_ASSERTeq(r, 0);
UT_ASSERTne(obj_direct(thread_oid), NULL);
os_thread_t t;
PTHREAD_CREATE(&t, NULL, test_worker, NULL);
/* wait for the worker thread to perform the first check */
os_mutex_lock(&lock1);
while (!cond1)
os_cond_wait(&sync_cond1, &lock1);
os_mutex_unlock(&lock1);
for (unsigned i = 0; i < npools; ++i) {
UT_ASSERTne(obj_direct(tmpoids[i]), NULL);
pmemobj_free(&tmpoids[i]);
UT_ASSERTeq(obj_direct(tmpoids[i]), NULL);
pmemobj_close(pops[i]);
UT_ASSERTeq(obj_direct(oids[i]), NULL);
}
/* signal the worker that we're free and closed */
os_mutex_lock(&lock2);
cond2 = 1;
os_cond_signal(&sync_cond2);
os_mutex_unlock(&lock2);
PTHREAD_JOIN(&t, NULL);
os_cond_destroy(&sync_cond1);
os_cond_destroy(&sync_cond2);
os_mutex_destroy(&lock1);
os_mutex_destroy(&lock2);
FREE(pops);
FREE(tmpoids);
FREE(oids);
DONE(NULL);
}
int jpeg_encode (uint8_t * Y, uint8_t * UV, yuv_args_t * _yuv_args)
{
int rc, i;
encoder_args_t encoder_args;
memset (&encoder_args, 0, sizeof (encoder_args));
LOG_D ("=============================================================\n");
LOG_D ("Encoder start\n");
LOG_D ("=============================================================\n");
encoder_args.main.y_buf = Y;
encoder_args.main.uv_buf = UV;
encoder_args.main.quality = _yuv_args->quality;
// encoder_args.thumbnail.quality = 50;
encoder_args.main.width = _yuv_args->width;
// encoder_args.thumbnail.width = 0;
encoder_args.main.height = _yuv_args->height;
// encoder_args.thumbnail.height = 0;
encoder_args.rotation = 0;
// encoder_args.encode_thumbnail = true;
encoder_args.main.format = YCBCRLP_H2V2;
// encoder_args.thumbnail.format = YCBCRLP_H2V2;
encoder_args.preference = _yuv_args->preference;
encoder_args.back_to_back_count = 1;
#if 0
encoder_args.main_scale_cfg.enable = false;
encoder_args.main_scale_cfg.input_width = 0;
encoder_args.main_scale_cfg.input_height = 0;
encoder_args.main_scale_cfg.output_width = 0;
encoder_args.main_scale_cfg.output_height = 0;
encoder_args.main_scale_cfg.h_offset = 0;
encoder_args.main_scale_cfg.v_offset = 0;
encoder_args.tn_scale_cfg.enable = false;
encoder_args.tn_scale_cfg.input_width = 0;
encoder_args.tn_scale_cfg.input_height = 0;
encoder_args.tn_scale_cfg.output_width = 0;
encoder_args.tn_scale_cfg.output_height = 0;
encoder_args.tn_scale_cfg.h_offset = 0;
encoder_args.tn_scale_cfg.v_offset = 0;
encoder_args.target_filesize = 0;
#endif
encoder_args.abort_time = 0;
encoder_args.use_pmem = false;
// Double check all the required arguments are set
#if 0
if (!encoder_args.main.file_name || !encoder_args.output_file ||
!encoder_args.main.width ||
!encoder_args.main.height || encoder_args.main.format == 8)
{
LOG_D ("Missing required arguments.\n");
return 1;
}
if (encoder_args.encode_thumbnail &&
(!encoder_args.thumbnail.file_name ||
!encoder_args.thumbnail.width ||
!encoder_args.thumbnail.height ||
encoder_args.thumbnail.format == 8))
{
LOG_D ("Missing thumbnail arguments.\n");
return 1;
}
#endif
// Create thread control blocks
thread_ctrl_blks = (thread_ctrl_blk_t *) malloc (concurrent_cnt * sizeof (thread_ctrl_blk_t));
if (!thread_ctrl_blks)
{
LOG_D ("hw_engine_encode failed: insufficient memory in creating thread control blocks\n");
return 1;
}
memset (thread_ctrl_blks, 0, concurrent_cnt * sizeof (thread_ctrl_blk_t));
// Initialize the blocks and kick off the threads
for (i = 0; i < concurrent_cnt; i++)
{
thread_ctrl_blks[i].tid = i;
thread_ctrl_blks[i].p_args = &encoder_args;
os_mutex_init (&thread_ctrl_blks[i].output_handler_args.mutex);
os_cond_init (&thread_ctrl_blks[i].output_handler_args.cond);
if (os_thread_create(&thread_ctrl_blks[i].thread, hw_engine_encode,&thread_ctrl_blks[i]))
{
LOG_D ("hw_engine_encode: os_create failed\n");
return 1;
}
}
rc = 0;
// Join the threads
for (i = 0; i < concurrent_cnt; i++)
{
OS_THREAD_FUNC_RET_T ret;
os_thread_join (&thread_ctrl_blks[i].thread, &ret);
if (ret)
{
LOG_D ("hw_engine_encode: thread %d failed\n", i);
rc = (int) OS_THREAD_FUNC_RET_FAILED;
}
}
free (thread_ctrl_blks);
if (!rc)
LOG_D ("hw_engine_encode finished successfully\n");
LOG_D ("exit value: %d\n", rc);
return rc;
}
/**
* Initializes internal nffs memory and data structures. This must be called
* before any nffs operations are attempted.
*
* @return 0 on success; nonzero on error.
*/
int
nffs_init(void)
{
int rc;
nffs_config_init();
nffs_cache_clear();
rc = os_mutex_init(&nffs_mutex);
if (rc != 0) {
return FS_EOS;
}
free(nffs_file_mem);
nffs_file_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_files, sizeof (struct nffs_file)));
if (nffs_file_mem == NULL) {
return FS_ENOMEM;
}
free(nffs_inode_mem);
nffs_inode_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_inodes,
sizeof (struct nffs_inode_entry)));
if (nffs_inode_mem == NULL) {
return FS_ENOMEM;
}
free(nffs_block_entry_mem);
nffs_block_entry_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_blocks,
sizeof (struct nffs_hash_entry)));
if (nffs_block_entry_mem == NULL) {
return FS_ENOMEM;
}
free(nffs_cache_inode_mem);
nffs_cache_inode_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_inodes,
sizeof (struct nffs_cache_inode)));
if (nffs_cache_inode_mem == NULL) {
return FS_ENOMEM;
}
free(nffs_cache_block_mem);
nffs_cache_block_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_blocks,
sizeof (struct nffs_cache_block)));
if (nffs_cache_block_mem == NULL) {
return FS_ENOMEM;
}
free(nffs_dir_mem);
nffs_dir_mem = malloc(
OS_MEMPOOL_BYTES(nffs_config.nc_num_dirs,
sizeof (struct nffs_dir)));
if (nffs_dir_mem == NULL) {
return FS_ENOMEM;
}
log_init();
log_console_handler_init(&nffs_log_console_handler);
log_register("nffs", &nffs_log, &nffs_log_console_handler);
rc = nffs_misc_reset();
if (rc != 0) {
return rc;
}
fs_register(&nffs_ops);
return 0;
}
