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; }