/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
compressedBuffer = (uint8_t*)malloc(bufferSize);
if(DALI_UNLIKELY(compressedBuffer == nullptr))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", bufferSize);
return 0u;
}
outBufferData.isBufferOwned = true;
compressedBuffer = (uint8_t*)malloc(bufferSize);
if(DALI_UNLIKELY(compressedBuffer == nullptr))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", bufferSize);
return 0u;
}
outBufferData.isBufferOwned = true;
uint8_t* __restrict__ tempBuffer = (uint8_t*)malloc(outBufferData.height * (widthByte + 1));
if(DALI_UNLIKELY(tempBuffer == nullptr))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", outBufferData.height * (widthByte + 1));
return 0u;
}
compressedBuffer = (uint8_t*)malloc(bufferSize);
if(DALI_UNLIKELY(compressedBuffer == nullptr))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", bufferSize);
free(tempBuffer);
return 0u;
}
#include <memory>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/public-api/adaptor-framework/timer.h>
using namespace Dali::Accessibility;
}
}
+void BridgeBase::CompressDefaultLabels()
+{
+ // Remove entries for objects which no longer exist
+ mDefaultLabels.remove_if([](const DefaultLabelType& label) {
+ return !label.first.GetBaseHandle(); // Check window's weak handle
+ // TODO: Once Accessible becomes a handle type, check its weak handle here as well
+ });
+}
+
void BridgeBase::RegisterDefaultLabel(Accessible* object)
{
- if(std::find(mDefaultLabels.begin(), mDefaultLabels.end(), object) == mDefaultLabels.end())
+ CompressDefaultLabels();
+
+ Dali::WeakHandle<Dali::Window> window = GetWindow(object);
+ if(!window.GetBaseHandle()) // true also if `object` is null
+ {
+ DALI_LOG_ERROR("Cannot register default label: object does not belong to any window");
+ return;
+ }
+
+ auto it = std::find_if(mDefaultLabels.begin(), mDefaultLabels.end(), [object](const DefaultLabelType& label) {
+ return object == label.second;
+ });
+
+ if(it == mDefaultLabels.end())
+ {
+ mDefaultLabels.push_back({window, object});
+ }
+ else if(it->first != window)
+ {
+ // TODO: Tentative implementation. It is yet to be specified what should happen
+ // when the same object is re-registered as a default label for another window.
+ *it = {window, object};
+ }
+ else // it->first == window && it->second == object
{
- mDefaultLabels.push_back(object);
+ // Nothing to do
}
}
void BridgeBase::UnregisterDefaultLabel(Accessible* object)
{
- auto it = std::find(mDefaultLabels.begin(), mDefaultLabels.end(), object);
- if(it != mDefaultLabels.end())
- {
- mDefaultLabels.erase(it);
- }
+ CompressDefaultLabels();
+
+ mDefaultLabels.remove_if([object](const DefaultLabelType& label) {
+ return object == label.second;
+ });
}
Accessible* BridgeBase::GetDefaultLabel(Accessible* root) const
{
- // TODO (multi-window support): Change mDefaultLabels to a collection of vectors
- // (one per window) and select the right one based on the window that 'root' belongs to.
- return mDefaultLabels.empty() ? root : mDefaultLabels.back();
+ Dali::WeakHandle<Dali::Window> window = GetWindow(root);
+ if(!window.GetBaseHandle())
+ {
+ return root;
+ }
+
+ auto it = std::find_if(mDefaultLabels.rbegin(), mDefaultLabels.rend(), [&window](const DefaultLabelType& label) {
+ return window == label.first;
+ });
+
+ return (it == mDefaultLabels.rend()) ? root : it->second;
}
std::string BridgeBase::StripPrefix(const std::string& path)
item->GetDescription(),
item->GetStates().GetRawData());
}
+
+Dali::WeakHandle<Dali::Window> BridgeBase::GetWindow(Dali::Accessibility::Accessible* accessible)
+{
+ Dali::WeakHandle<Dali::Window> windowHandle;
+ Dali::Actor actor = accessible ? accessible->GetInternalActor() : Dali::Actor();
+
+ if(actor)
+ {
+ Dali::Window window = Dali::DevelWindow::Get(actor);
+ windowHandle = {window};
+ }
+
+ return windowHandle;
+}
// EXTERNAL INCLUDES
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/dali-adaptor-version.h>
+#include <dali/public-api/object/weak-handle.h>
#include <dali/public-api/signals/connection-tracker.h>
#include <memory>
#include <tuple>
}
protected:
- mutable ApplicationAccessible mApplication;
- std::vector<Dali::Accessibility::Accessible*> mDefaultLabels;
- bool mIsScreenReaderSuppressed = false;
+ // We use a weak handle in order not to keep a window alive forever if someone forgets to UnregisterDefaultLabel()
+ using DefaultLabelType = std::pair<Dali::WeakHandle<Dali::Window>, Dali::Accessibility::Accessible*>;
+ using DefaultLabelsType = std::list<DefaultLabelType>;
+
+ mutable ApplicationAccessible mApplication;
+ DefaultLabelsType mDefaultLabels;
+ bool mIsScreenReaderSuppressed = false;
private:
/**
*/
CacheElementType CreateCacheElement(Dali::Accessibility::Accessible* item);
+ /**
+ * @brief Removes expired elements from the default label collection.
+ */
+ void CompressDefaultLabels();
+
+ /**
+ * @brief Gets the window to which this accessible belongs (or an empty handle).
+ *
+ * @param accessible The accessible
+ * @return The window
+ */
+ static Dali::WeakHandle<Dali::Window> GetWindow(Dali::Accessibility::Accessible* accessible);
+
protected:
BridgeBase();
virtual ~BridgeBase();
uint8_t* stagingBuffer = reinterpret_cast<uint8_t*>(malloc(info.srcSize));
- uint8_t* srcMemory = &reinterpret_cast<uint8_t*>(source.memorySource.memory)[info.srcOffset];
+ if(DALI_UNLIKELY(stagingBuffer == nullptr))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", info.srcSize);
+ }
+ else
+ {
+ uint8_t* srcMemory = &reinterpret_cast<uint8_t*>(source.memorySource.memory)[info.srcOffset];
- std::copy(srcMemory, srcMemory + info.srcSize, stagingBuffer);
+ std::copy(srcMemory, srcMemory + info.srcSize, stagingBuffer);
- mTextureUploadTotalCPUMemoryUsed += info.srcSize;
+ mTextureUploadTotalCPUMemoryUsed += info.srcSize;
+ }
// store staging buffer
source.memorySource.memory = stagingBuffer;
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
mSetForGLRecycling = false;
// if different buffer spec, we need new buffer
- if(!(createInfo.size == mCreateInfo.size
- && createInfo.allocationCallbacks == mCreateInfo.allocationCallbacks
- && createInfo.propertiesFlags == mCreateInfo.propertiesFlags
- && createInfo.usage == mCreateInfo.usage
- && createInfo.nextExtension == mCreateInfo.nextExtension ))
+ if(!(createInfo.size == mCreateInfo.size &&
+ createInfo.allocationCallbacks == mCreateInfo.allocationCallbacks &&
+ createInfo.propertiesFlags == mCreateInfo.propertiesFlags &&
+ createInfo.usage == mCreateInfo.usage &&
+ createInfo.nextExtension == mCreateInfo.nextExtension))
{
return false;
}
else
{
mBufferPtr = malloc(mCreateInfo.size);
+ if(DALI_UNLIKELY(mBufferPtr == nullptr))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", mCreateInfo.size);
+ }
}
}
}
else
{
- auto retval = malloc(size);
- mMappedPointer = retval;
+ auto retval = malloc(size);
+ mMappedPointer = retval;
+ if(DALI_UNLIKELY(mMappedPointer == nullptr))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", size);
+ }
mIsAllocatedLocally = true;
}
}
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
mNumSamples++;
mAccumulated += mCurrentFrameCount;
- mAccumulatedSquare += (mCurrentFrameCount * mCurrentFrameCount);
+ mAccumulatedSquare += (static_cast<uint64_t>(mCurrentFrameCount) * static_cast<uint64_t>(mCurrentFrameCount));
mCurrentFrameCount = 0;
}
const char* Sampler::GetDescription() const
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
if(DALI_LIKELY(!fseek(fp, 0, SEEK_SET)))
{
- globalMap = reinterpret_cast<GifByteType*>(malloc(sizeof(GifByteType) * length));
- length = fread(globalMap, sizeof(GifByteType), length, fp);
+ globalMap = reinterpret_cast<GifByteType*>(malloc(sizeof(GifByteType) * static_cast<unsigned long long>(length)));
+ if(DALI_UNLIKELY(globalMap == nullptr))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %llu\n", sizeof(GifByteType) * static_cast<unsigned long long>(length));
+ return false;
+ }
+ length = fread(globalMap, sizeof(GifByteType), length, fp);
}
else
{
if(DALI_LIKELY(!fseek(fp, 0, SEEK_SET)))
{
globalMap = reinterpret_cast<GifByteType*>(malloc(sizeof(GifByteType) * blobSize));
- length = fread(globalMap, sizeof(GifByteType), blobSize, fp);
- succeeded = true;
+ if(DALI_UNLIKELY(globalMap == nullptr))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", sizeof(GifByteType) * blobSize);
+ }
+ else
+ {
+ length = fread(globalMap, sizeof(GifByteType), blobSize, fp);
+ succeeded = true;
+ }
}
else
{
pixelsOut = static_cast<uint8_t*>(malloc(widthOut * heightOut * pixelSize));
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
pixelsOut = static_cast<uint8_t*>(malloc(widthIn * heightIn * pixelSize));
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthIn, heightIn, pixelSize);
// Return if the memory allocations fails.
return false;
}
pixelsOut = static_cast<uint8_t*>(malloc(widthOut * heightOut * pixelSize));
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
if(nullptr == pixelsOut)
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
widthOut = 0u;
heightOut = 0u;
auto planeSize = tjPlaneSizeYUV(i, scaledPostXformWidth, 0, scaledPostXformHeight, chrominanceSubsampling);
uint8_t* buffer = static_cast<uint8_t*>(malloc(planeSize));
- if(!buffer)
+ if(DALI_UNLIKELY(!buffer))
{
DALI_LOG_ERROR("Buffer allocation is failed [%d]\n", planeSize);
pixelBuffers.clear();
uint8_t* cmykBuffer = static_cast<uint8_t*>(malloc(sizeof(uint8_t) * scaledPostXformWidth * scaledPostXformHeight * cmykBytesPerPixel));
+ if(DALI_UNLIKELY(!cmykBuffer))
+ {
+ DALI_LOG_ERROR("cmykBuffer allocation is failed [%zu]\n", sizeof(uint8_t) * scaledPostXformWidth * scaledPostXformHeight * cmykBytesPerPixel);
+ return false;
+ }
+
decodeResult = tjDecompress2(jpeg.get(), jpegBufferPtr, jpegBufferSize, reinterpret_cast<uint8_t*>(cmykBuffer), scaledPreXformWidth, 0, scaledPreXformHeight, pixelLibJpegType, flags);
if(DALI_UNLIKELY(decodeResult == -1 && IsJpegDecodingFailed()))
{
// Internal jpeg downscaling is the same as our BOX_X sampling modes so only
// apply it if the application requested one of those:
// (use a switch case here so this code will fail to compile if other modes are added)
- bool downscale = true;
+ bool useTurboJpegScaleFactor = true;
switch(samplingMode)
{
case SamplingMode::BOX:
case SamplingMode::BOX_THEN_LINEAR:
case SamplingMode::DONT_CARE:
{
- downscale = true;
+ useTurboJpegScaleFactor = true;
break;
}
case SamplingMode::NO_FILTER:
case SamplingMode::NEAREST:
case SamplingMode::LINEAR:
{
- downscale = false;
+ useTurboJpegScaleFactor = false;
break;
}
}
- int scaleFactorIndex(0);
- if(downscale)
+ int scaleFactorIndex(-1);
+ int fittedScaledWidth(postXformImageWidth);
+ int fittedScaledHeight(postXformImageHeight);
+ if(useTurboJpegScaleFactor)
{
// Find nearest supported scaling factor (factors are in sequential order, getting smaller)
- for(int i = 1; i < numFactors; ++i)
+ for(int i = 0; i < numFactors; ++i)
{
- bool widthLessRequired = TJSCALED(postXformImageWidth, factors[i]) < requiredWidth;
- bool heightLessRequired = TJSCALED(postXformImageHeight, factors[i]) < requiredHeight;
+ int scaledWidth = TJSCALED(postXformImageWidth, factors[i]);
+ int scaledHeight = TJSCALED(postXformImageHeight, factors[i]);
+ bool widthLessRequired = scaledWidth < requiredWidth;
+ bool heightLessRequired = scaledHeight < requiredHeight;
// If either scaled dimension is smaller than the desired one, we were done at the last iteration
if((fittingMode == FittingMode::SCALE_TO_FILL) && (widthLessRequired || heightLessRequired))
{
break;
}
// This factor stays is within our fitting mode constraint so remember it:
- scaleFactorIndex = i;
+ scaleFactorIndex = i;
+ fittedScaledWidth = scaledWidth;
+ fittedScaledHeight = scaledHeight;
}
}
+ const int maxTextureSize = static_cast<int>(Dali::GetMaxTextureSize());
+
// Regardless of requested size, downscale to avoid exceeding the maximum texture size:
- for(int i = scaleFactorIndex; i < numFactors; ++i)
+ if(fittedScaledWidth >= maxTextureSize ||
+ fittedScaledHeight >= maxTextureSize)
{
- // Continue downscaling to below maximum texture size (if possible)
- scaleFactorIndex = i;
-
- if(TJSCALED(postXformImageWidth, (factors[i])) < static_cast<int>(Dali::GetMaxTextureSize()) &&
- TJSCALED(postXformImageHeight, (factors[i])) < static_cast<int>(Dali::GetMaxTextureSize()))
+ for(int i = scaleFactorIndex + 1; i < numFactors; ++i)
{
- // Current scale-factor downscales to below maximum texture size
- break;
+ // Continue downscaling to below maximum texture size (if possible)
+ scaleFactorIndex = i;
+ fittedScaledWidth = TJSCALED(postXformImageWidth, factors[i]);
+ fittedScaledHeight = TJSCALED(postXformImageHeight, factors[i]);
+
+ if(fittedScaledWidth < maxTextureSize &&
+ fittedScaledHeight < maxTextureSize)
+ {
+ // Current scale-factor downscales to below maximum texture size
+ break;
+ }
}
}
// We have finally chosen the scale-factor, return width/height values
- if(scaleFactorIndex > 0)
+ if(scaleFactorIndex >= 0 && scaleFactorIndex < numFactors)
{
preXformImageWidth = TJSCALED(preXformImageWidth, (factors[scaleFactorIndex]));
preXformImageHeight = TJSCALED(preXformImageHeight, (factors[scaleFactorIndex]));
- postXformImageWidth = TJSCALED(postXformImageWidth, (factors[scaleFactorIndex]));
- postXformImageHeight = TJSCALED(postXformImageHeight, (factors[scaleFactorIndex]));
+ postXformImageWidth = fittedScaledWidth;
+ postXformImageHeight = fittedScaledHeight;
}
}
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
rows = reinterpret_cast<png_bytep*>(malloc(sizeof(png_bytep) * height));
if(DALI_UNLIKELY(!rows))
{
- DALI_LOG_ERROR("malloc is failed\n");
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", sizeof(png_bytep) * height);
return false;
}
if(bufferSize > 0)
{
buffer = static_cast<uint8_t*>(malloc(bufferSize));
+ if(DALI_UNLIKELY(!buffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", bufferSize);
+ }
#if defined(DEBUG_ENABLED)
gPixelBufferAllocationTotal += bufferSize;
#endif
if(mBufferSize > 0)
{
destBuffer = static_cast<uint8_t*>(malloc(mBufferSize));
+ if(DALI_UNLIKELY(!destBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", mBufferSize);
+ return Dali::PixelData();
+ }
memcpy(destBuffer, mBuffer, mBufferSize);
}
ReleaseBuffer();
mBuffer = reinterpret_cast<unsigned char*>(malloc(size));
mBufferSize = size;
+ if(DALI_UNLIKELY(!mBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", mBufferSize);
+ }
#if defined(DEBUG_ENABLED)
gPixelBufferAllocationTotal += size;
#endif
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
if(DALI_LIKELY(!fseek(fp, 0, SEEK_SET)))
{
- mBuffer = reinterpret_cast<WebPByteType*>(malloc(sizeof(WebPByteType) * mBufferSize));
+ mBuffer = reinterpret_cast<WebPByteType*>(malloc(sizeof(WebPByteType) * mBufferSize));
+ if(DALI_UNLIKELY(!mBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", sizeof(WebPByteType) * mBufferSize);
+ return false;
+ }
mBufferSize = fread(mBuffer, sizeof(WebPByteType), mBufferSize, fp);
return true;
}
if(desiredSize.GetWidth() > 0 && desiredSize.GetHeight() > 0)
{
- const int desiredWidth = desiredSize.GetWidth();
+ const int desiredWidth = desiredSize.GetWidth();
const int desiredHeight = desiredSize.GetHeight();
WebPDecoderConfig config;
}
// Apply config for scaling
- config.options.use_scaling = 1;
- config.options.scaled_width = desiredWidth;
+ config.options.use_scaling = 1;
+ config.options.scaled_width = desiredWidth;
config.options.scaled_height = desiredHeight;
if(channelNumber == 4)
if(frameBuffer != nullptr)
{
- Pixel::Format pixelFormat = (channelNumber == 4) ? Pixel::RGBA8888 : Pixel::RGB888;
- int32_t bufferSize = desiredWidth * desiredHeight * Dali::Pixel::GetBytesPerPixel(pixelFormat);
- pixelBuffer = Dali::Devel::PixelBuffer::New(desiredWidth, desiredHeight, pixelFormat);
+ Pixel::Format pixelFormat = (channelNumber == 4) ? Pixel::RGBA8888 : Pixel::RGB888;
+ int32_t bufferSize = desiredWidth * desiredHeight * Dali::Pixel::GetBytesPerPixel(pixelFormat);
+ pixelBuffer = Dali::Devel::PixelBuffer::New(desiredWidth, desiredHeight, pixelFormat);
memcpy(pixelBuffer.GetBuffer(), frameBuffer, bufferSize);
}
{
Pixel::Format pixelFormat = (channelNumber == 4) ? Pixel::RGBA8888 : Pixel::RGB888;
int32_t bufferSize = width * height * Dali::Pixel::GetBytesPerPixel(pixelFormat);
- Internal::Adaptor::PixelBufferPtr internal =
- Internal::Adaptor::PixelBuffer::New(frameBuffer, bufferSize, width, height, width, pixelFormat);
- pixelBuffer = Devel::PixelBuffer(internal.Get());
+ Internal::Adaptor::PixelBufferPtr internal = Internal::Adaptor::PixelBuffer::New(frameBuffer, bufferSize, width, height, width, pixelFormat);
+ pixelBuffer = Devel::PixelBuffer(internal.Get());
}
}
}
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return false;
}
- int bytesWritten = 0;
+ unsigned int bytesWritten = 0;
// write isn't guaranteed to write the entire buffer in one go
- while(bytesWritten != static_cast<int>(bufferSizeInBytes))
+ while(bytesWritten != bufferSizeInBytes)
{
+ if(bufferSizeInBytes < bytesWritten)
+ {
+ DALI_LOG_ERROR("Socket writer error! required size : %u byte, real written : %u byte \n", bufferSizeInBytes, bytesWritten);
+ return false;
+ }
+
const char* byteBuffer = static_cast<const char*>(buffer);
byteBuffer += bytesWritten;
for(auto& iterator : mapIter->second)
{
DALI_ASSERT_DEBUG((*iterator) == task);
- if((*iterator)->GetPriorityType() == AsyncTask::PriorityType::HIGH)
+ if((*iterator)->GetPriorityType() == AsyncTask::PriorityType::HIGH && mWaitingHighProirityTaskCounts > 0u)
{
// Decrease the number of waiting tasks for high priority.
--mWaitingHighProirityTaskCounts;
}
}
- if(priorityType == AsyncTask::PriorityType::HIGH)
+ if(priorityType == AsyncTask::PriorityType::HIGH && mWaitingHighProirityTaskCounts > 0u)
{
// Decrease the number of waiting tasks for high priority.
--mWaitingHighProirityTaskCounts;
BidirectionalInfo* bidirectionalInfo = new BidirectionalInfo();
bidirectionalInfo->characterTypes = reinterpret_cast<FriBidiCharType*>(malloc(numberOfCharacters * sizeof(FriBidiCharType)));
- if(!bidirectionalInfo->characterTypes)
+ if(DALI_UNLIKELY(!bidirectionalInfo->characterTypes))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", numberOfCharacters * sizeof(FriBidiCharType));
delete bidirectionalInfo;
return 0;
}
bidirectionalInfo->embeddedLevels = reinterpret_cast<FriBidiLevel*>(malloc(numberOfCharacters * sizeof(FriBidiLevel)));
- if(!bidirectionalInfo->embeddedLevels)
+ if(DALI_UNLIKELY(!bidirectionalInfo->embeddedLevels))
{
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", numberOfCharacters * sizeof(FriBidiLevel));
free(bidirectionalInfo->characterTypes);
delete bidirectionalInfo;
return 0;
bidirectionalInfo->bracketTypes = reinterpret_cast<FriBidiBracketType*>(malloc(numberOfCharacters * sizeof(FriBidiBracketType)));
if(!bidirectionalInfo->bracketTypes)
{
- free(bidirectionalInfo->bracketTypes);
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", numberOfCharacters * sizeof(FriBidiBracketType));
+ free(bidirectionalInfo->embeddedLevels);
+ free(bidirectionalInfo->characterTypes);
delete bidirectionalInfo;
return 0;
}
// Retrieve the embedding levels.
if(fribidi_get_par_embedding_levels_ex(bidirectionalInfo->characterTypes, bidirectionalInfo->bracketTypes, numberOfCharacters, &bidirectionalInfo->paragraphDirection, bidirectionalInfo->embeddedLevels) == 0)
{
- free(bidirectionalInfo->characterTypes);
free(bidirectionalInfo->bracketTypes);
+ free(bidirectionalInfo->embeddedLevels);
+ free(bidirectionalInfo->characterTypes);
delete bidirectionalInfo;
return 0;
}
// Copy embedded levels as fribidi_reorder_line() may change them.
const size_t embeddedLevelsSize = static_cast<std::size_t>(numberOfCharacters) * sizeof(FriBidiLevel);
FriBidiLevel* embeddedLevels = reinterpret_cast<FriBidiLevel*>(malloc(embeddedLevelsSize));
- if(embeddedLevels)
+ if(DALI_LIKELY(embeddedLevels))
{
memcpy(embeddedLevels, bidirectionalInfo->embeddedLevels + firstCharacterIndex, embeddedLevelsSize);
// Free resources.
free(embeddedLevels);
}
+ else
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", embeddedLevelsSize);
+ }
}
bool GetMirroredText(Character* text,
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
const int rgbaCase,
const double glyphX,
const double glyphY,
- const int strideWidth,
+ const unsigned int strideWidth,
const Vector4& color,
const bool doBlendWithTextColor)
{
// This function provides a stride value that will respect all alignment requirements of the
// accelerated image-rendering code within cairo.
- const int stride = cairo_format_stride_for_width(cairoFormat,
+ const int stride = cairo_format_stride_for_width(cairoFormat,
static_cast<int>(parameters.width));
- const int strideWidth = stride / bpp;
+ const unsigned int strideWidth = static_cast<unsigned int>(std::abs(stride)) / bpp;
// Convert from DALi glyphs to Cairo glyphs.
std::vector<cairo_glyph_t> cairoGlyphs;
Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(strideWidth, parameters.height, pixelFormat);
unsigned char* buffer = pixelBuffer.GetBuffer();
- const unsigned int bufferSize = stride * parameters.height;
+ const unsigned int bufferSize = static_cast<unsigned int>(std::abs(stride)) * parameters.height;
memset(buffer, 0, bufferSize);
std::unique_ptr<cairo_surface_t, void (*)(cairo_surface_t*)> surfacePtr(cairo_image_surface_create_for_data(buffer,
data.buffer = newBuffer;
data.compressionType = TextAbstraction::GlyphBufferData::CompressionType::NO_COMPRESSION;
}
+ else
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", widthOut, heightOut, pixelSize);
+ }
}
Dali::Internal::Platform::RotateByShear(data.buffer,
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
hyphens = (char*)malloc(wordLength + 5);
- if(hyphens)
+ if(DALI_LIKELY(hyphens))
{
hnj_hyphen_hyphenate2(dict, (char*)(word), wordLength, hyphens, NULL, &rep, &pos, &cut);
free(hyphens);
}
+ else
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", wordLength + 5);
+ }
#endif
return hyphensList;
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/text/text-abstraction/plugin/font-client-utils.h>
+#include <dali/integration-api/debug.h>
+
namespace Dali::TextAbstraction::Internal
{
void EmbeddedItem::GetGlyphMetrics(GlyphInfo& glyph)
// Creates the output buffer
const uint32_t bufferSize = data.width * data.height * 4u;
data.buffer = (uint8_t*)malloc(bufferSize); // @note The caller is responsible for deallocating the bitmap data using free.
-
- memset(data.buffer, 0u, bufferSize);
+ if(DALI_UNLIKELY(!data.buffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", bufferSize);
+ }
+ else
+ {
+ memset(data.buffer, 0u, bufferSize);
+ }
// Just creates a void buffer. Doesn't matter what pixel format is set as is the application code the responsible of filling it.
}
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// Check if exists a pair 'fontDescriptionId, requestedPointSize' in the cache.
if(!mCacheHandler->FindFont(fontDescriptionId, requestedPointSize, fontCacheIndex))
{
- // Retrieve the font file name path.
- const FontDescription& description = *(mCacheHandler->mFontDescriptionCache.begin() + fontDescriptionId - 1u);
+ if(fontDescriptionId > 0u && fontDescriptionId <= mCacheHandler->mCharacterSetCache.Count())
+ {
+ // Retrieve the font file name path.
+ const FontDescription& description = *(mCacheHandler->mFontDescriptionCache.begin() + fontDescriptionId - 1u);
- // Retrieve the font id. Do not cache the description as it has been already cached.
- // Note : CacheFontPath() API call ValidateFont() + setup CharacterSet + cache the font description.
- // So set cacheDescription=false, that we don't call CacheFontPath().
- fontId = GetFontIdByPath(description.path, requestedPointSize, faceIndex, false);
+ // Retrieve the font id. Do not cache the description as it has been already cached.
+ // Note : CacheFontPath() API call ValidateFont() + setup CharacterSet + cache the font description.
+ // So set cacheDescription=false, that we don't call CacheFontPath().
+ fontId = GetFontIdByPath(description.path, requestedPointSize, faceIndex, false);
- if((fontId > 0u) && (fontId - 1u < mCacheHandler->mFontIdCache.size()))
- {
- fontCacheIndex = mCacheHandler->mFontIdCache[fontId - 1u].index;
- mCacheHandler->mFontFaceCache[fontCacheIndex].mCharacterSet = FcCharSetCopy(mCacheHandler->mCharacterSetCache[fontDescriptionId - 1u]);
+ if((fontId > 0u) && (fontId - 1u < mCacheHandler->mFontIdCache.size()))
+ {
+ fontCacheIndex = mCacheHandler->mFontIdCache[fontId - 1u].index;
+ mCacheHandler->mFontFaceCache[fontCacheIndex].mCharacterSet = FcCharSetCopy(mCacheHandler->mCharacterSetCache[fontDescriptionId - 1u]);
- // Cache the pair 'fontDescriptionId, requestedPointSize' to improve the following queries.
- mCacheHandler->CacheFontDescriptionSize(fontDescriptionId, requestedPointSize, fontCacheIndex);
+ // Cache the pair 'fontDescriptionId, requestedPointSize' to improve the following queries.
+ mCacheHandler->CacheFontDescriptionSize(fontDescriptionId, requestedPointSize, fontCacheIndex);
+ }
}
}
else
if(!data.isBufferOwned || data.compressionType != TextAbstraction::GlyphBufferData::CompressionType::NO_COMPRESSION)
{
uint8_t* newBuffer = (uint8_t*)malloc(data.width * data.height * Pixel::GetBytesPerPixel(data.format));
+ if(DALI_UNLIKELY(!newBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x %u\n", data.width, data.height, Pixel::GetBytesPerPixel(data.format));
+ return Dali::PixelData();
+ }
+
TextAbstraction::GlyphBufferData::Decompress(data, newBuffer);
if(data.isBufferOwned)
{
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
data.isBufferOwned = true;
data.buffer = (uint8_t*)malloc(bufferSize); // @note The caller is responsible for deallocating the bitmap data using free.
+
+ if(DALI_UNLIKELY(!data.buffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u\n", bufferSize);
+ return;
+ }
Dali::Internal::Platform::LanczosSample(srcBuffer,
inputDimensions,
srcWidth,
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
glyphData.mIsBitmap = true;
glyphData.mBitmap->buffer = (uint8_t*)malloc(bufferSize * sizeof(uint8_t)); // @note The caller is responsible for deallocating the bitmap data using free.
- memcpy(glyphData.mBitmap->buffer, freeTypeFace->glyph->bitmap.buffer, bufferSize);
+ if(DALI_UNLIKELY(!glyphData.mBitmap->buffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %zu\n", bufferSize * sizeof(uint8_t));
+ delete glyphData.mBitmap;
+ glyphData.mIsBitmap = false;
+ glyphData.mBitmap = nullptr;
+ error = static_cast<FT_Error>(-1);
+ }
+ else
+ {
+ memcpy(glyphData.mBitmap->buffer, freeTypeFace->glyph->bitmap.buffer, bufferSize);
+ }
}
else
{
if(glyphData.mBitmap->pitch == static_cast<int>(glyphData.mBitmap->width))
{
desiredBuffer = (uint8_t*)malloc(desiredWidth * desiredHeight * sizeof(uint8_t)); // @note The caller is responsible for deallocating the bitmap data using free.
- // Resize bitmap here.
- Dali::Internal::Platform::LanczosSample1BPP(glyphData.mBitmap->buffer,
- inputDimensions,
- glyphData.mBitmap->width,
- desiredBuffer,
- desiredDimensions);
+
+ if(DALI_UNLIKELY(!desiredBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x 1\n", desiredWidth, desiredHeight);
+ }
+ else
+ {
+ // Resize bitmap here.
+ Dali::Internal::Platform::LanczosSample1BPP(glyphData.mBitmap->buffer,
+ inputDimensions,
+ glyphData.mBitmap->width,
+ desiredBuffer,
+ desiredDimensions);
+ }
}
break;
}
if(glyphData.mBitmap->pitch == static_cast<int>(glyphData.mBitmap->width << 2u))
{
desiredBuffer = (uint8_t*)malloc((desiredWidth * desiredHeight * sizeof(uint8_t)) << 2u); // @note The caller is responsible for deallocating the bitmap data using free.
- // Resize bitmap here.
- Dali::Internal::Platform::LanczosSample4BPP(glyphData.mBitmap->buffer,
- inputDimensions,
- glyphData.mBitmap->width,
- desiredBuffer,
- desiredDimensions);
+
+ if(DALI_UNLIKELY(!desiredBuffer))
+ {
+ DALI_LOG_ERROR("malloc is failed. request malloc size : %u x %u x 4\n", desiredWidth, desiredHeight);
+ }
+ else
+ {
+ // Resize bitmap here.
+ Dali::Internal::Platform::LanczosSample4BPP(glyphData.mBitmap->buffer,
+ inputDimensions,
+ glyphData.mBitmap->width,
+ desiredBuffer,
+ desiredDimensions);
+ }
}
break;
}
{
const unsigned int ADAPTOR_MAJOR_VERSION = 2;
const unsigned int ADAPTOR_MINOR_VERSION = 3;
-const unsigned int ADAPTOR_MICRO_VERSION = 12;
+const unsigned int ADAPTOR_MICRO_VERSION = 14;
const char* const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-adaptor
Summary: The DALi Tizen Adaptor
-Version: 2.3.12
+Version: 2.3.14
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-adaptor.git / commitdiff