int dci_load(struct dci_state* state, struct dc_entry_t* entry)
{
if(entry->cached == 0)
{
struct str_t uri;
str_init_create(&uri, getfile_uri, 0);
const struct str_t const* uri_parts[] =
{
&slash,
&entry->_id,
};
str_concat(&uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, NULL, GET);
ci_request(&request);
str_swap(&request.response.body, &entry->cache);
ci_destroy(&request);
entry->cached = 1;
}
}
return 0;
}
void dci_get_file_list(const char *path, struct dci_state *state)
{
int is_already_path = dci_is_already_path(path, state);
if(is_already_path) return;
struct str_t uri;
str_init_create(&uri, filelist_uri, 0);
struct str_t path_param;
str_init_create(&path_param, "path=", 0);
struct str_t *path_str = str_urlencode_char(path, 0);
const struct str_t const* uri_parts[] =
{
&path_param,
path_str
};
str_concat(&uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, NULL, GET);
ci_request(&request);
json_parse_file_list(path, &request.response.body, state);
ci_destroy(&request);
}
str_destroy(&uri);
}
int dci_write(const char *path, const char *buf, size_t size, const char *fileName, struct dci_state *state)
{
struct str_t header;
struct str_t fileName_param;
struct str_t fileSize_param;
struct str_t uploadDate_param;
struct str_t deviceID_param;
struct str_t isFolder_param;
struct str_t path_param;
struct str_t data_param;
struct str_t data;
str_init_create(&header, "Content-Type: application/json", 0);
str_init_create(&fileName_param, "fileName=", 0);
str_init_create(&fileSize_param, "fileSize=", 0);
str_init_create(&uploadDate_param, "uploadDate=", 0);
str_init_create(&deviceID_param, "deviceID", 0);
str_init_create(&isFolder_param, "isFolder=", 0);
str_init_create(&path_param, "path=", 0);
str_init_create(&data_param, "data=", 0);
struct dc_entry_t* entry;
entry = (struct dc_entry_t*) malloc(sizeof(struct dc_entry_t));
memset(entry, 0, sizeof(struct dc_entry_t));
str_init_create(&entry->fileName, fileName, 0);
entry->fileSize = size;
entry->uploadDate = time(0);
str_init_create(&entry->deviceID, "binensky", 0);
entry->isFolder = 0;
str_init_create(&entry->path, path, 0);
str_init_create(&entry->cache, buf, 0);
entry->cached = 1;
struct str_t uri;
struct str_t param_uri;
str_init_create(&uri, getfile_uri, 0);
str_init(¶m_uri);
const struct str_t const* uri_parts[] =
{
&fileName_param,
fileName,
&,
&fileSize_param,
itoa(entry->fileSize),
&,
&uploadDate_param,
itoa(entry->uploadDate),
&,
&deviceID_param,
&entry->deviceID,
&,
&isFolder_param,
itoa(entry->isFolder),
&,
&path_param,
&entry->path,
&,
&data_param,
&entry->cache
};
str_concat(¶m_uri, sizeof(uri_parts)/sizeof(const struct str_t const*), uri_parts);
{
struct request_t request;
ci_init(&request, &uri, 0, NULL, param_uri.str, POST);
ci_request(&request);
str_swap(&request.response.body, &entry->_id);
ci_destroy(&request);
struct dc_entry_t *tmp = dci_last_entry(state);
tmp = entry;
}
}
int mcam_init(p_camera_context_t camera_context)
{
int status = 0;
#ifdef DEBUG_PARAM_CHECK
/* parameter check */
if (camera_context->sensor_type > CAMERA_TYPE_MAX)
return -EINVAL;
/* check the function dispatch table according to the sensor type */
if (!camera_context->camera_functions)
return -EINVAL;
if (!camera_context->camera_functions->init ||
!camera_context->camera_functions->deinit ||
!camera_context->camera_functions->set_capture_format ||
!camera_context->camera_functions->start_capture ||
!camera_context->camera_functions->stop_capture)
return -EINVAL;
#endif
/* initialize some camera used parameters */
camera_context->capture_input_width = 0;
camera_context->capture_input_height = 0;
camera_context->capture_output_width = 0;
camera_context->capture_output_height = 0;
camera_context->capture_input_format = CAMERA_IMAGE_FORMAT_MAX + 1;
camera_context->capture_output_format = CAMERA_IMAGE_FORMAT_MAX + 1;
camera_context->fifo0_transfer_size = 0;
camera_context->fifo1_transfer_size = 0;
camera_context->fifo2_transfer_size = 0;
camera_context->fifo3_transfer_size = 0;
camera_context->video_fifo0_transfer_size = 0;
camera_context->video_fifo1_transfer_size = 0;
camera_context->video_fifo2_transfer_size = 0;
camera_context->still_fifo0_transfer_size = 0;
camera_context->still_fifo1_transfer_size = 0;
camera_context->still_fifo2_transfer_size = 0;
camera_context->frame_buffer_number = 0;
camera_context->video_capture_buffer_queue.head = NULL;
camera_context->video_capture_buffer_queue.tail = NULL;
camera_context->still_capture_buffer_queue.head = NULL;
camera_context->still_capture_buffer_queue.tail = NULL;
camera_context->psu_enable = 0;
camera_context->cgu_enable = 0;
camera_context->ssu_scale = CI_SSU_SCALE_DISABLE;
camera_context->cmu_usage = CI_CMU_DISABLE;
camera_context->dma_running = 0;
/* MFP pins init */
zylonite_enable_cif_pins();
/* UTMI_SWITCH must be set to low and
* the UTMI_TEST_EN should be set to output (low)
*/
mhn_gpio_set_direction(MFP_UTMI_SWITCH, GPIO_DIR_OUT);
mhn_gpio_set_direction(MFP_UTMI_TEST_EN, GPIO_DIR_OUT);
mhn_gpio_set_level(MFP_UTMI_SWITCH, GPIO_LEVEL_LOW);
mhn_gpio_set_level(MFP_UTMI_TEST_EN, GPIO_LEVEL_HIGH);
/* set two gpio pin direction as output
* to control the power of two sensors.
*/
mhn_gpio_set_direction(MFP_CIF_HI_PWDN_GPI0, GPIO_DIR_OUT);
mhn_gpio_set_direction(MFP_CIF_LO_PWDN_GPI0, GPIO_DIR_OUT);
/* set two gpio pin output as HI to power off two sensors. */
mhn_gpio_set_level(MFP_CIF_HI_PWDN_GPI0, GPIO_LEVEL_HIGH);
mhn_gpio_set_level(MFP_CIF_LO_PWDN_GPI0, GPIO_LEVEL_HIGH);
/* capture interface init */
ci_init();
/* sensor init */
status = camera_context->camera_functions->init(camera_context);
if (status) {
goto camera_init_err;
}
/* set frame rate */
mcam_set_capture_frame_rate(camera_context);
return 0;
camera_init_err:
mcam_deinit(camera_context);
return -EIO;
}
/* copydirectory: copy all regular files in src to dst,
arg is of form 'src\0dst\0' */
static void *copydirectory(void *arg)
{
struct iofiles *iofp, *newiofp;
char *src_dir, *dst_dir;
char *src_path, *dst_path;
struct dirent *dirp;
DIR *dp;
int infd, outfd;
pthread_t tid;
struct stat statbuf;
copyinfo_t *cip, *newci;
/* get inputs */
iofp = (struct iofiles *)arg;
src_dir = iofp->source;
dst_dir = iofp->destination;
fprintf(stderr, "copydirectory got: %s %s\n", src_dir, dst_dir);
tid = 0;
if ((dp = opendir(src_dir)) == NULL) {
err_quit("Failed to opendir: %s", src_dir);
}
if (stat(dst_dir, &statbuf) == -1) {
if (mkdir(dst_dir, DIR_MODE) == -1)
err_sys("mkdir error");
}
while ((dirp = readdir(dp)) != NULL) {
if ((!strcmp(dirp->d_name, ".")) ||
(!strcmp(dirp->d_name, "..")))
continue;
src_path = buildpath(src_dir, dirp->d_name);
if (stat(src_path, &statbuf) == -1)
err_sys("stat error");
if ((infd = open(src_path, O_RDONLY)) < 0)
err_sys("failed to open %s", src_path);
dst_path = buildpath(dst_dir, dirp->d_name);
if (S_ISDIR(statbuf.st_mode)) {
newiofp = Malloc(sizeof(struct iofiles));
newiofp->source = s_dup(src_path);
newiofp->destination = s_dup(dst_path);
copydirectory((void *)newiofp);
continue;
}
if ((outfd = open(dst_path, OFLAGS, FILE_MODE)) < 0)
err_sys("failed to open %s", dst_path);
newci = ci_init(dst_path, tid);
newci->sourcefd = infd;
newci->destinationfd = outfd;
newci->next = head;
head = newci;
Pthread_create(&newci->tid, NULL, copyfilepass, (void *)newci);
for (cip = head; cip != NULL; cip = cip->next) {
(void)pthread_join(cip->tid, NULL);
}
free(src_path);
free(dst_path);
}
if (closedir(dp) < 0)
err_msg("failed to close directory");
return (void *)0;
}
