void ZXImgEnhanceRelease(int handle)
{
ZXImgEEFilter* pFilter = (ZXImgEEFilter*)handle;
if(pFilter)
{
if(pFilter->p_src)
{
free_aligned(pFilter->p_src);
pFilter->p_src = NULL;
}
if(pFilter->pGFltHandle)
{
sndaGuidedFilterRelease(pFilter->pGFltHandle);
pFilter->pGFltHandle = 0;
}
if(pFilter->pCFltHandle)
{
sndaClaheFilterRelease(pFilter->pCFltHandle);
pFilter->pCFltHandle = 0;
}
free_aligned(pFilter);
pFilter = NULL;
}
return;
}
Sample::~Sample()
{
if (oneD != nullptr) {
free_aligned(oneD[0]);
free_aligned(oneD);
}
}
void Render3D::SetTextureProcessingProperties(size_t scalingFactor, bool willDeposterize, bool willSmooth)
{
const bool isScaleValid = ( (scalingFactor == 2) || (scalingFactor == 4) );
const size_t newScalingFactor = (isScaleValid) ? scalingFactor : 1;
bool needTexCacheReset = false;
if ( willDeposterize && (this->_textureDeposterizeBuffer == NULL) )
{
// 1024x1024 texels is the largest possible texture size.
// We need two buffers, one for each deposterize stage.
const size_t bufferSize = 1024 * 1024 * 2 * sizeof(u32);
this->_textureDeposterizeBuffer = (u32 *)malloc_alignedCacheLine(bufferSize);
memset(this->_textureDeposterizeBuffer, 0, bufferSize);
needTexCacheReset = true;
}
else if ( !willDeposterize && (this->_textureDeposterizeBuffer != NULL) )
{
free_aligned(this->_textureDeposterizeBuffer);
this->_textureDeposterizeBuffer = NULL;
needTexCacheReset = true;
}
if (newScalingFactor != this->_textureScalingFactor)
{
u32 *oldTextureBuffer = this->_textureUpscaleBuffer;
u32 *newTextureBuffer = (u32 *)malloc_alignedCacheLine( (1024 * newScalingFactor) * (1024 * newScalingFactor) * sizeof(u32) );
this->_textureScalingFactor = newScalingFactor;
this->_textureUpscaleBuffer = newTextureBuffer;
free_aligned(oldTextureBuffer);
needTexCacheReset = true;
}
if (willSmooth != this->_textureSmooth)
{
this->_textureSmooth = willSmooth;
needTexCacheReset = true;
}
if (needTexCacheReset)
{
TexCache_Reset();
}
}
void CAudBuffer::DeAlloc()
{
if (m_buffer)
free_aligned(m_buffer);
m_buffer = NULL;
m_buffer_size = 0;
m_buffer_pos = 0;
}
int32_t ZXImgEnhanceProcess(int32_t Handle,uint8_t* pData,int32_t nImgW,int32_t nImgH)
{
ZXImgEEFilter* pFilter = (ZXImgEEFilter*)Handle;
int32_t ret;
uint8_t *p_data;
//#0 check the data safty
if((nImgW&0xF)||(nImgH&7))
return ZXIMGCORE_PARA_ERR;
//#1 color convert
if(pFilter->format!=IMGEE_FORMAT_YUVNV21)
{
if(pFilter->format==IMGEE_FORMAT_S1)
ret = nImgW * nImgH * 3 / 2;
if(pFilter->size != ret)
{
if(pFilter->p_src)
{
free_aligned(pFilter->p_src);
pFilter->p_src = NULL;
}
pFilter->p_src = (uint8_t*)malloc_aligned(ret,32);
if(!pFilter->p_src)
goto _error;
}
s1format_2_yuvnv12(pData,pFilter->p_src,nImgW,nImgH);
p_data = pFilter->p_src;
}
else
p_data = pData;
//#2 Filter
if(pFilter->pGFltHandle)
{
ret = sndaGuidedFilterProcess(pFilter->pGFltHandle,p_data,p_data,nImgW,nImgH);
if(ret != GUIDED_FILTER_OK)
return ZXIMGCORE_FAILED;
}
if(pFilter->pCFltHandle)
{
ret = sndaClaheFilterProcess(pFilter->pCFltHandle,p_data,p_data,nImgW,nImgH);
if(ret != CLAHE_FILTER_OK)
return ZXIMGCORE_FAILED;
}
//#1 color convert
if(pFilter->format!=IMGEE_FORMAT_YUVNV21)
{
yuvnv12_2_s1format(p_data,pData,nImgW,nImgH);
}
return ZXIMGCORE_OK;
_error:
return ZXIMGCORE_FAILED;
}
static void avi_destroy(struct AVIFile** avi_out)
{
if(!(*avi_out))
return;
if((*avi_out)->sound_added)
{
if((*avi_out)->compressed_streams[AUDIO_STREAM])
{
if ((*avi_out)->audio_buffer_pos > 0) {
if(FAILED(AVIStreamWrite(avi_file->compressed_streams[AUDIO_STREAM],
avi_file->sound_samples, (*avi_out)->audio_buffer_pos / (*avi_out)->wave_format.nBlockAlign,
(*avi_out)->audio_buffer, (*avi_out)->audio_buffer_pos, 0, NULL, &avi_file->ByteBuffer)))
{
avi_file->valid = 0;
}
(*avi_out)->sound_samples += (*avi_out)->audio_buffer_pos / (*avi_out)->wave_format.nBlockAlign;
(*avi_out)->tBytes += avi_file->ByteBuffer;
(*avi_out)->audio_buffer_pos = 0;
}
LONG test = AVIStreamClose((*avi_out)->compressed_streams[AUDIO_STREAM]);
(*avi_out)->compressed_streams[AUDIO_STREAM] = NULL;
(*avi_out)->streams[AUDIO_STREAM] = NULL; // compressed_streams[AUDIO_STREAM] is just a copy of streams[AUDIO_STREAM]
}
}
if((*avi_out)->video_added)
{
if((*avi_out)->compressed_streams[VIDEO_STREAM])
{
AVIStreamClose((*avi_out)->compressed_streams[VIDEO_STREAM]);
(*avi_out)->compressed_streams[VIDEO_STREAM] = NULL;
}
if((*avi_out)->streams[VIDEO_STREAM])
{
AVIStreamClose((*avi_out)->streams[VIDEO_STREAM]);
(*avi_out)->streams[VIDEO_STREAM] = NULL;
}
}
if((*avi_out)->avi_file)
{
AVIFileClose((*avi_out)->avi_file);
(*avi_out)->avi_file = NULL;
}
free_aligned((*avi_out)->convert_buffer);
free(*avi_out);
*avi_out = NULL;
}
/*
Checks if the device is a photo frame by reading the first 512 bytes and
comparing against the known string that's there
*/
int is_photoframe(int f) {
int y,res;
char id[]="SITRONIX CORP.";
char *buff;
buff=malloc_aligned(0x200);
lseek(f,0x0,SEEK_SET);
y=read(f,buff,0x200);
buff[15]=0;
// fprintf(stderr,"ID=%s\n",buff);
res=strcmp(buff,id)==0?1:0;
free_aligned(buff,0x200);
return res;
}
void CAudBuffer::ReAlloc(const size_t size)
{
uint8_t* buffer = (uint8_t*)malloc_aligned(size, 16);
if (m_buffer) {
size_t copy = std::min(size, m_buffer_size);
memcpy(buffer, m_buffer, copy);
free_aligned(m_buffer);
}
m_buffer = buffer;
m_buffer_size = size;
m_buffer_pos = std::min(m_buffer_pos, m_buffer_size);
}
void free_image(image_t* image)
{
if (image == 0)
{
LOG_ERROR("Invalid image!");
return;
}
stop_managing_memchunk(image->image);
free_aligned(image->image);
image->image = 0;
}
FragmentAttributesBuffer::~FragmentAttributesBuffer()
{
free_aligned(depth);
free_aligned(opaquePolyID);
free_aligned(translucentPolyID);
free_aligned(stencil);
free_aligned(isFogged);
free_aligned(isTranslucentPoly);
}
/*-------------------------------------------------------------------*/
DLL_EXPORT int hthread_destroy_rwlock( RWLOCK* plk, const char* location )
{
int rc;
ILOCK* ilk;
UNREFERENCED( location );
ilk = (ILOCK*) plk->ilk;
rc = hthread_rwlock_destroy( &ilk->rwlock );
LockLocksList();
RemoveListEntry( &ilk->locklink );
lockcount--;
UnlockLocksList();
free_aligned( ilk );
plk->ilk = NULL;
return rc;
}
OMX_ERRORTYPE COMXCoreComponent::FreeOutputBuffers()
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle)
return OMX_ErrorUndefined;
if(m_omx_output_buffers.empty())
return OMX_ErrorNone;
m_flush_output = true;
pthread_mutex_lock(&m_omx_output_mutex);
pthread_cond_broadcast(&m_output_buffer_cond);
omx_err = DisablePort(m_output_port, false);
for (size_t i = 0; i < m_omx_output_buffers.size(); i++) {
uint8_t *buf = m_omx_output_buffers[i]->pBuffer;
omx_err = OMX_FreeBuffer(m_handle, m_output_port, m_omx_output_buffers[i]);
if(m_omx_output_use_buffers && buf)
free_aligned(buf);
if(omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::FreeOutputBuffers error deallocate omx output buffer on component %s omx_err(0x%08x)", m_componentName.c_str(), omx_err);
}
}
WaitForCommand(OMX_CommandPortDisable, m_output_port);
m_omx_output_buffers.clear();
while (!m_omx_output_available.empty())
m_omx_output_available.pop();
m_output_alignment = 0;
m_output_buffer_size = 0;
m_output_buffer_count = 0;
pthread_mutex_unlock(&m_omx_output_mutex);
return omx_err;
}
static void
matrix_teardown (gpointer data_)
{
MatrixBench *data = data_;
free_aligned (data->a);
free_aligned (data->b);
free_aligned (data->c);
free_aligned (data->pa);
free_aligned (data->qa);
free_aligned (data->ra);
g_free (data);
}
Render3DError Render3D::SetFramebufferSize(size_t w, size_t h)
{
if (w < GPU_FRAMEBUFFER_NATIVE_WIDTH || h < GPU_FRAMEBUFFER_NATIVE_HEIGHT)
{
return RENDER3DERROR_NOERR;
}
const size_t newFramebufferColorSizeBytes = w * h * sizeof(FragmentColor);
FragmentColor *oldFramebufferColor = this->_framebufferColor;
FragmentColor *newFramebufferColor = (FragmentColor *)malloc_alignedCacheLine(newFramebufferColorSizeBytes);
this->_framebufferWidth = w;
this->_framebufferHeight = h;
this->_framebufferColorSizeBytes = newFramebufferColorSizeBytes;
this->_framebufferColor = newFramebufferColor;
free_aligned(oldFramebufferColor);
return RENDER3DERROR_NOERR;
}
int run()
{
std::cout << std::endl << "Polynomials of degree " << degree << " with " << modulus << " bit coefficients and " << sizeof(T) * 8 << " bit limbs" << std::endl;
std::cout << "======================================================================" << std::endl;
using poly_t = nfl::poly_from_modulus<T, degree, modulus>;
static_assert(sizeof(poly_t) % 32 == 0, "sizeof(poly_t) must be 32-bytes aligned");
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();
// Polynomial arrays to do the tests
start = std::chrono::steady_clock::now();
/* AG: on my system, this gives pointers non aligned on 32-bytes!
poly_t *resa = new poly_t[REPETITIONS],
*resb = new poly_t[REPETITIONS],
*resc = new poly_t[REPETITIONS],
*resd = new poly_t[REPETITIONS];
*/
poly_t *resa = alloc_aligned<poly_t, 32>(REPETITIONS),
*resb = alloc_aligned<poly_t, 32>(REPETITIONS),
*resc = alloc_aligned<poly_t, 32>(REPETITIONS),
*resd = alloc_aligned<poly_t, 32>(REPETITIONS);
if ((((uintptr_t)resa % 32) != 0) ||
(((uintptr_t)resb % 32) != 0) ||
(((uintptr_t)resc % 32) != 0) ||
(((uintptr_t)resd % 32) != 0)) {
printf("fatal error: pointer unaligned!\n");
exit(1);
}
std::fill(resa, resa + REPETITIONS, 0);
std::fill(resb, resb + REPETITIONS, 0);
std::fill(resc, resc + REPETITIONS, 0);
std::fill(resd, resd + REPETITIONS, 0);
#ifdef TEST_ADDITIONS_INPLACE
std::fill(resa, resa + REPETITIONS, nfl::uniform());
std::fill(resb, resb + REPETITIONS, nfl::uniform());
start = std::chrono::steady_clock::now();
for (unsigned i = 0; i < REPETITIONS ; i++)
{
nfl::add(resa[i], resa[i], resb[i]);
}
end = std::chrono::steady_clock::now();
std::cout << "Time per polynomial in-place addition a+=b: " << get_time_us(start, end, REPETITIONS) << " us" << std::endl;
#endif
#ifdef TEST_ADDITIONS
std::fill(resa, resa + REPETITIONS, nfl::uniform());
std::fill(resb, resb + REPETITIONS, nfl::uniform());
start = std::chrono::steady_clock::now();
for (unsigned i = 0; i < REPETITIONS ; i++)
{
nfl::add(resc[i], resa[i], resb[i]);
}
end = std::chrono::steady_clock::now();
std::cout << "Time per polynomial addition c=a+b: " << get_time_us(start, end, REPETITIONS) << " us" << std::endl;
#endif
#ifdef TEST_SUBTRACTIONS
std::fill(resa, resa + REPETITIONS, nfl::uniform());
std::fill(resb, resb + REPETITIONS, nfl::uniform());
start = std::chrono::steady_clock::now();
for (unsigned i = 0; i < REPETITIONS ; i++)
{
nfl::sub(resc[i], resa[i], resb[i]);
}
end = std::chrono::steady_clock::now();
std::cout << "Time per polynomial subtraction c=a-b: " << get_time_us(start, end, REPETITIONS) << " us" << std::endl;
#endif
#ifdef TEST_MULTIPLICATIONS
std::fill(resa, resa + REPETITIONS, nfl::uniform());
std::fill(resb, resb + REPETITIONS, nfl::uniform());
start = std::chrono::steady_clock::now();
for (unsigned i = 0; i < REPETITIONS ; i++)
{
nfl::mul(resc[i], resa[i], resb[i]);
}
end = std::chrono::steady_clock::now();
std::cout << "Time per polynomial multiplication (NTT form) c=a*b: " << get_time_us(start, end, REPETITIONS) << " us" << std::endl;
#endif
// Cleaning
free_aligned(REPETITIONS, resa);
free_aligned(REPETITIONS, resb);
free_aligned(REPETITIONS, resc);
free_aligned(REPETITIONS, resd);
return 0;
}
int ZXImgEnhanceInit(int* p_handle,int format,int nMode)
{
ZXImgEEFilter* pFilter = NULL;
int32_t ret = ZXIMGCORE_OK, eps0_y, eps1_y, eps0_uv, eps1_uv;
float_t fSaturation, fContrast;
double_t lumda0_y, lumda1_y, lumda0_uv, lumda1_uv;
//#0 check the nMode parameter
*p_handle = 0;
if(!IMGEE_IS_VALID(nMode))
return ZXIMGCORE_PARA_ERR;
if(((nMode&IMGEE_MODE_AUTO)==0)&&
((nMode&IMGEE_MODE_HDR)==0)&&
((nMode&IMGEE_MODE_BEAUTY)==0)&&
((nMode&IMGEE_MODE_SHARPEN)==0)&&
((nMode&IMGEE_MODE_DENOISE)==0)&&
((nMode&IMGEE_MODE_SHARPEN_EX)==0))
return ZXIMGCORE_PARA_ERR;
//#1 malloc memory space
pFilter = (ZXImgEEFilter*)malloc_aligned(sizeof(ZXImgEEFilter),4);
if(pFilter==NULL)
{
ret = ZXIMGCOER_MEM_ERR;
goto _error;
}
memset(pFilter,0,sizeof(ZXImgEEFilter));
//#1.1 malloc memory space for CLAHE
if((nMode&IMGEE_MODE_AUTO)||(nMode&IMGEE_MODE_HDR)||(nMode&IMGEE_MODE_BEAUTY))
{
switch(IMGEE_GET_MODE(nMode))
{
case IMGEE_MODE_AUTO:
fSaturation = 1.6f;
fContrast = 1.7f;
break;
case IMGEE_MODE_HDR:
fSaturation = 1.6f;
fContrast = 2.5f;
break;
case IMGEE_MODE_BEAUTY:
fSaturation = 1.5f;
fContrast = 1.7f;
break;
default:
fSaturation = 1.6f;
fContrast = 1.7f;
break;
};
ret = sndaClaheFilterInit(&pFilter->pCFltHandle,4,4,256,
fSaturation, fContrast,1);
if(ret!=CLAHE_FILTER_OK)
{
ret = ZXIMGCORE_INITCLAHE_ERR;
goto _error;
}
}
//1.2 malloc memory for Guided Filter
if(!(IMGEE_IS_FAST(nMode)))
{
switch(IMGEE_GET_MODE(nMode))
{
case IMGEE_MODE_AUTO:
eps0_y = 8; lumda0_y = 1.00;
eps1_y = 8192; lumda1_y = 1.65;
eps0_uv = 64; lumda0_uv = 0.25;
eps1_uv = 8192; lumda1_uv = 1.00;
break;
case IMGEE_MODE_HDR:
eps0_y = 32; lumda0_y = 0.50;
eps1_y = 8192; lumda1_y = 1.50;
eps0_uv = 64; lumda0_uv = 0.25;
eps1_uv = 8192; lumda1_uv = 1.00;
break;
case IMGEE_MODE_BEAUTY:
eps0_y = 128; lumda0_y = 0.50;
eps1_y = 8192; lumda1_y = 1.75; //1.75
eps0_uv = 128; lumda0_uv = 0.00;
eps1_uv = 8192; lumda1_uv = 1.50; //1.5
break;
default: // same as auto
eps0_y = 8; lumda0_y = 1.00;
eps1_y = 8192; lumda1_y = 1.50;
eps0_uv = 64; lumda0_uv = 0.25;
eps1_uv = 8192; lumda1_uv = 1.00;
break;
}
ret = sndaGuidedFilterInit(&pFilter->pGFltHandle,eps0_y,eps1_y,eps0_uv, eps1_uv,
(float_t)lumda0_y,(float_t)lumda1_y,(float_t)lumda0_uv,(float_t)lumda1_uv,2);
if(ret != GUIDED_FILTER_OK)
{
ret = ZXIMGCORE_INITGUIDED_ERR;
goto _error;
}
}
pFilter->format = format;
*p_handle = (int32_t)pFilter;
return ZXIMGCORE_OK;
_error:
if(pFilter)
{
if(pFilter->pGFltHandle)
{
sndaGuidedFilterRelease(pFilter->pGFltHandle);
pFilter->pGFltHandle = 0;
}
if(pFilter->pCFltHandle)
{
sndaClaheFilterRelease(pFilter->pCFltHandle);
pFilter->pCFltHandle = 0;
}
free_aligned(pFilter);
pFilter = NULL;
}
return ret;
}
~aligned_storage_ptr(void)
{
if (managed && ptr)
free_aligned(ptr);
}
void reset(T * p = 0)
{
if (managed && ptr)
free_aligned(ptr);
ptr = p;
}
void free_request(struct ata_ioc_request *rq)
{
free_aligned();
free(rq);
}
Render3D::~Render3D()
{
free_aligned(_framebufferColor);
}
~aligned_array(void)
{
for (int i = 0; i != N; ++i)
elems[i].~T();
free_aligned(elems);
}
void operator()(T* block)
{
free_aligned(block);
}
OMX_ERRORTYPE COMXCoreComponent::AllocOutputBuffers(bool use_buffers /* = false */)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle)
return OMX_ErrorUndefined;
m_omx_output_use_buffers = use_buffers;
OMX_PARAM_PORTDEFINITIONTYPE portFormat;
OMX_INIT_STRUCTURE(portFormat);
portFormat.nPortIndex = m_output_port;
omx_err = OMX_GetParameter(m_handle, OMX_IndexParamPortDefinition, &portFormat);
if(omx_err != OMX_ErrorNone)
return omx_err;
if(GetState() != OMX_StateIdle) {
if(GetState() != OMX_StateLoaded)
SetStateForComponent(OMX_StateLoaded);
SetStateForComponent(OMX_StateIdle);
}
omx_err = EnablePort(m_output_port, false);
if(omx_err != OMX_ErrorNone)
return omx_err;
m_output_alignment = portFormat.nBufferAlignment;
m_output_buffer_count = portFormat.nBufferCountActual;
m_output_buffer_size = portFormat.nBufferSize;
Logger::LogOut(LOG_LEVEL_DEBUG, "COMXCoreComponent::AllocOutputBuffers component(%s) - port(%d), nBufferCountMin(%u), nBufferCountActual(%u), nBufferSize(%u) nBufferAlignmen(%u)",
m_componentName.c_str(), m_output_port, portFormat.nBufferCountMin,
portFormat.nBufferCountActual, portFormat.nBufferSize, portFormat.nBufferAlignment);
for (size_t i = 0; i < portFormat.nBufferCountActual; i++) {
OMX_BUFFERHEADERTYPE *buffer = NULL;
OMX_U8* data = NULL;
if(m_omx_output_use_buffers) {
data = (OMX_U8*)malloc_aligned(portFormat.nBufferSize, m_output_alignment);
omx_err = OMX_UseBuffer(m_handle, &buffer, m_output_port, NULL, portFormat.nBufferSize, data);
}
else {
omx_err = OMX_AllocateBuffer(m_handle, &buffer, m_output_port, NULL, portFormat.nBufferSize);
}
if(omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::AllocOutputBuffers component(%s) - OMX_UseBuffer failed with omx_err(0x%x)",
m_componentName.c_str(), omx_err);
if(m_omx_output_use_buffers && data)
free_aligned(data);
return omx_err;
}
buffer->nOutputPortIndex = m_output_port;
buffer->nFilledLen = 0;
buffer->nOffset = 0;
buffer->pAppPrivate = (void*)i;
m_omx_output_buffers.push_back(buffer);
m_omx_output_available.push(buffer);
}
omx_err = WaitForCommand(OMX_CommandPortEnable, m_output_port);
m_flush_output = false;
return omx_err;
}
void Render3D::operator delete(void *ptr)
{
free_aligned(ptr);
}
