void xcam_cpf_blob_free (XCamCpfBlob *blob) { XCAM_FAIL_RETURN (blob); if (blob->data) xcam_free (blob->data); xcam_free (blob); }
X3aAnalyzerAiq::~X3aAnalyzerAiq() { if (_cpf_path) xcam_free (_cpf_path); XCAM_LOG_DEBUG ("~X3aAnalyzerAiq destructed"); }
CpfReader::~CpfReader() { if (_aiq_cpf) xcam_cpf_blob_free (_aiq_cpf); if (_name) xcam_free (_name); }
static int32_t read_cpf_file (const char *cpf_file, uint8_t **buf) { int32_t size = 0; FILE *fp = fopen (cpf_file, "rb"); XCAM_FAIL_RETURN_VAL (fp, -1); *buf = NULL; if (fseek (fp, 0, SEEK_END) < 0) goto read_error; if ((size = ftell (fp)) <= 0) goto read_error; if (fseek( fp, 0, SEEK_SET) < 0) goto read_error; *buf = (uint8_t*) xcam_new0 (size); if (fread (*buf, 1, size, fp) != size) goto read_error; fclose (fp); return size; read_error: XCAM_LOG_ERROR ("read cpf(%s) failed", cpf_file); fclose (fp); if (*buf) { xcam_free (*buf); *buf = NULL; } return -1; }
FakePollThread::~FakePollThread () { if (_raw_path) xcam_free (_raw_path); if (_raw) fclose (_raw); }
bool V4l2Device::set_device_name (const char *name) { XCAM_ASSERT (name); if (is_opened()) { XCAM_LOG_WARNING ("can't set device name since device opened"); return false; } if (_name) xcam_free (_name); _name = strndup (name, XCAM_MAX_STR_SIZE); return true; }
X3aStatsData::~X3aStatsData () { if (_data) xcam_free (_data); }
CLKernel::~CLKernel () { destroy (); if (_name) xcam_free (_name); }
V4l2Device::~V4l2Device () { close(); if (_name) xcam_free (_name); }
SmartAnalyzerLoader::~SmartAnalyzerLoader () { if (_name) xcam_free (_name); }
XCamReturn CLKernel::build_kernel (const XCamKernelInfo& info, const char* options) { KernelMap::iterator i_kernel; SmartPtr<CLKernel> single_kernel; char key_str[1024]; uint8_t body_key[8]; std::string key; XCamReturn ret = XCAM_RETURN_NO_ERROR; XCAM_FAIL_RETURN (ERROR, info.kernel_name, XCAM_RETURN_ERROR_PARAM, "build kernel failed since kernel name null"); xcam_mem_clear (body_key); get_string_key_id (info.kernel_body, info.kernel_body_len, body_key); snprintf ( key_str, sizeof(key_str), "%s#%02x%02x%02x%02x%02x%02x%02x%02x#%s", info.kernel_name, body_key[0], body_key[1], body_key[2], body_key[3], body_key[4], body_key[5], body_key[6], body_key[7], XCAM_STR(options)); key = key_str; char temp_filename[XCAM_MAX_STR_SIZE] = {0}; char cache_filename[XCAM_MAX_STR_SIZE] = {0}; FileHandle temp_file; FileHandle cache_file; size_t read_cache_size = 0; size_t write_cache_size = 0; uint8_t *kernel_cache = NULL; bool load_cache = false; struct timeval ts; std::string cache_path = _kernel_cache_path; const char *env = std::getenv ("XCAM_CL_KERNEL_CACHE_PATH"); if (env) cache_path.assign (env, strlen (env)); snprintf ( cache_filename, XCAM_MAX_STR_SIZE - 1, "%s/%s", cache_path.c_str (), key_str); { SmartLock locker (_kernel_map_mutex); i_kernel = _kernel_map.find (key); if (i_kernel == _kernel_map.end ()) { SmartPtr<CLContext> context = get_context (); single_kernel = new CLKernel (context, info.kernel_name); XCAM_ASSERT (single_kernel.ptr ()); if (access (cache_path.c_str (), F_OK) == -1) { mkdir (cache_path.c_str (), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); } ret = cache_file.open (cache_filename, "r"); if (ret == XCAM_RETURN_NO_ERROR) { cache_file.get_file_size (read_cache_size); if (read_cache_size > 0) { kernel_cache = (uint8_t*) xcam_malloc0 (sizeof (uint8_t) * (read_cache_size + 1)); if (NULL != kernel_cache) { cache_file.read_file (kernel_cache, read_cache_size); cache_file.close (); ret = single_kernel->load_from_binary (kernel_cache, read_cache_size); xcam_free (kernel_cache); kernel_cache = NULL; XCAM_FAIL_RETURN ( ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "build kernel(%s) from binary failed", key_str); load_cache = true; } } } else { XCAM_LOG_DEBUG ("open kernel cache file to read failed ret(%d)", ret); } if (load_cache == false) { ret = single_kernel->load_from_source (info.kernel_body, strlen (info.kernel_body), &kernel_cache, &write_cache_size, options); XCAM_FAIL_RETURN ( ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "build kernel(%s) from source failed", key_str); } _kernel_map.insert (std::make_pair (key, single_kernel)); //_kernel_map[key] = single_kernel; } else { single_kernel = i_kernel->second; } } if (load_cache == false && NULL != kernel_cache) { gettimeofday (&ts, NULL); snprintf ( temp_filename, XCAM_MAX_STR_SIZE - 1, "%s." XCAM_TIMESTAMP_FORMAT, cache_filename, XCAM_TIMESTAMP_ARGS (XCAM_TIMEVAL_2_USEC (ts))); ret = temp_file.open (temp_filename, "wb"); if (ret == XCAM_RETURN_NO_ERROR) { ret = temp_file.write_file (kernel_cache, write_cache_size); temp_file.close (); if (ret == XCAM_RETURN_NO_ERROR && write_cache_size > 0) { rename (temp_filename, cache_filename); } else { remove (temp_filename); } } else { XCAM_LOG_ERROR ("open kernel cache file to write failed ret(%d)", ret); } xcam_free (kernel_cache); kernel_cache = NULL; } XCAM_FAIL_RETURN ( ERROR, (single_kernel.ptr () && single_kernel->is_valid ()), XCAM_RETURN_ERROR_UNKNOWN, "build kernel(%s) failed, unknown error", key_str); ret = this->clone (single_kernel); XCAM_FAIL_RETURN ( ERROR, ret == XCAM_RETURN_NO_ERROR, ret, "load kernel(%s) from kernel failed", key_str); return ret; }
X3aAnalyzer::~X3aAnalyzer() { if (_name) xcam_free (_name); }
XCamMessage::~XCamMessage () { if (msg) xcam_free (msg); }
void free_3a_result (XCam3aResultHead *result) { xcam_free (result); }
boolean xcam_cpf_read (const char *cpf_file, XCamCpfBlob *aiq_cpf, XCamCpfBlob *hal_cpf) { uint8_t *cpf_buf; int32_t cpf_size; uint8_t *blob; int32_t blob_size; XCAM_FAIL_RETURN_VAL (cpf_file, FALSE); XCAM_FAIL_RETURN_VAL (aiq_cpf, FALSE); /* read cpf */ if ((cpf_size = read_cpf_file(cpf_file, &cpf_buf)) <= 0) { XCAM_LOG_ERROR ("read cpf_file(%s) failed.", cpf_file); return FALSE; } /* check sum */ if (tbd_validate (cpf_buf, cpf_size, tbd_tag_cpff) != tbd_err_none) { XCAM_LOG_ERROR ("tbd validate cpf file(%s) failed.", cpf_file); goto free_buf; } /* fetch AIQ */ if ( (tbd_get_record (cpf_buf, tbd_class_aiq, tbd_format_any, (void**)&blob, (size_t*)&blob_size) != tbd_err_none) || !blob || blob_size <= 0) { XCAM_LOG_ERROR ("CPF parse AIQ record failed."); goto free_buf; } aiq_cpf->data = (uint8_t*) malloc (blob_size); aiq_cpf->size = blob_size; memcpy (aiq_cpf->data, blob, blob_size); #if 0 //DRV not necessary /* fetch DRV */ if (tbd_get_record (cpf_buf, tbd_class_drv, tbd_format_any, &drv_blob.data, &drv_blob.size) != tbd_err_none) { XCAM_LOG_ERROR ("CPF parse DRV record failed."); return FALSE; } #endif /* fetch HAL */ if (hal_cpf) { if (tbd_get_record (cpf_buf, tbd_class_hal, tbd_format_any, (void**)&blob, (size_t*)&blob_size) != tbd_err_none) { XCAM_LOG_WARNING ("CPF doesn't have HAL record."); // ignore HAL, not necessary } else if (blob && blob_size > 0) { hal_cpf->data = (uint8_t*) malloc (blob_size); hal_cpf->size = blob_size; memcpy (hal_cpf->data, blob, blob_size); } } xcam_free (cpf_buf); return TRUE; free_buf: xcam_free (cpf_buf); return FALSE; }
CLImageHandler::~CLImageHandler () { if (_name) xcam_free (_name); }