openharmony/multimedia_video_processing_engine
1
0
Fork 0
mirror of https://github.com/openharmony/multimedia_video_processing_engine.git synced 2026-07-19 19:13:31 -04:00
Code Issues Packages Projects Releases Wiki Activity

!7 fix ut and update algorithm video

Browse Source 
Merge pull request !7 from 刘尚/master
This commit is contained in:
openharmony_ci
2025-03-06 01:51:24 +00:00
committed by Gitee
parent 6174657251 ec4156e0df
commit 6558e59baa
15 changed files with 370 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files
framework/BUILD.gn
+5 -12
View File
@@ -29,6 +29,8 @@ config("export_config") {
"$COLORSPACE_CONVERTER_DISPLAY_DIR/include",
"$VIDEO_REFRESHRATE_PREDICTION_DIR/include",
"$ALGORITHM_DIR/common/include",
"$METADATA_GENERATOR_VIDEO_DIR/include",
"$ALGORITHM_EXTENSION_MANAGER_DIR/include",
]
}
config("video_process_config") {
@@ -93,8 +95,6 @@ config("video_process_config") {
"$SKIA_DIR/third_party/externals/angle2/src/common",
"$SKIA_DIR/third_party/externals/angle2/src/",
"$SKIA_DIR/third_party/externals/angle2/src/common/third_party/base/",
"//foundation/graphic/graphic_2d/utils/color_manager/export",
"//base/startup/init/interfaces/innerkits/include/syspara/",
]
}
@@ -192,13 +192,13 @@ ohos_shared_library("videoprocessingengine") {
"$ALGORITHM_COMMON_DIR/image_openclsetup.cpp"
]
deps = [ "//third_party/skia:skia_ohos",
deps = [
"$VIDEO_PROCESSING_ENGINE_ROOT_DIR/services:videoprocessingservice_interface",
":aihdr_engine",
":ai_super_resolution",
":extream_vision_engine",
"//third_party/opencl-headers:libcl",
"//third_party/bounds_checking_function:libsec_static"]
]
external_deps = [
"c_utils:utils",
@@ -347,9 +347,6 @@ ohos_shared_library("video_processing_capi_impl") {
"$CAPI_VIDEO_DIR/aihdr_enhancer/include/",
"$CAPI_VIDEO_DETAIL_ENHANCER_DIR/include/",
"$CAPI_VIDEO_COLORSPACE_CONVERTER_DIR/include/",
"//foundation/graphic/graphic_surface/interfaces/inner_api/surface/",
"//foundation/graphic/graphic_surface/surface/include/",
"//foundation/graphic/graphic_2d/interfaces/inner_api",
"$CAPI_VIDEO_METADATA_GENERATOR_DIR/include/",
"$VIDEO_PROCESSING_ENGINE_ROOT_DIR/services/include",
"${target_gen_dir}/../services/",
@@ -411,17 +408,12 @@ ohos_shared_library("detailEnhancer") {
include_dirs = [
"$DFX_DIR/include",
"//foundation/multimedia/media_foundation/interface/kits/c",
"//foundation/multimedia/image_framework/interfaces/kits/native/include/image",
"//foundation/multimedia/image_framework/frameworks/kits/js/common/ndk/include",
"//foundation/multimedia/video_processing_engine/interfaces/kits/js",
"//foundation/multimedia/media_foundation/video_processing_engine/interface/kits/c",
"//foundation/multimedia/video_processing_engine/interfaces/inner_api",
"//foundation/multimedia/video_processing_engine/framework/capi/image_processing/include/",
]
sources = [
"//foundation/multimedia/video_processing_engine/framework/capi/image_processing/detail_enhance_napi.cpp",
"//foundation/multimedia/image_framework/frameworks/innerkitsimpl/common/src/memory_manager.cpp",
]
deps = [
@@ -436,6 +428,7 @@ ohos_shared_library("detailEnhancer") {
"hitrace:hitrace_meter",
"ipc:ipc_napi",
"media_foundation:native_media_core",
"media_foundation:media_foundation",
"napi:ace_napi",
"image_framework:image_utils",
"image_framework:image_native",
framework/algorithm/aihdr_enhancer_video/aihdr_enhancer_video_impl.cpp
+2
View File
@@ -249,6 +249,8 @@ int32_t AihdrEnhancerVideoImpl::Prepare()
void AihdrEnhancerVideoImpl::InitBuffers()
{
std::lock_guard<std::mutex> lock(mutex_);
CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr");
flushCfg_.damage.x = 0;
flushCfg_.damage.y = 0;
flushCfg_.damage.w = requestCfg_.width;
framework/algorithm/colorspace_converter_video/colorspace_converter_video_impl.cpp
+2
View File
@@ -414,6 +414,8 @@ void GetFormatFromSurfaceBuffer(Format &outputFormat, sptr<SurfaceBuffer> &buffe
void ColorSpaceConverterVideoImpl::InitBuffers()
{
std::lock_guard<std::mutex> lock(mutex_);
CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr");
flushCfg_.damage.x = 0;
flushCfg_.damage.y = 0;
flushCfg_.damage.w = requestCfg_.width;
framework/algorithm/common/algorithm_video_impl.cpp
+232 -130
View File
@@ -74,34 +74,72 @@ VPEAlgoErrCode VpeVideoImpl::SetOutputSurface(const sptr<Surface>& surface)
"Invalid input: surface is invalid!");
std::lock_guard<std::mutex> lock(lock_);
if (producer_ == surface) {
VPE_LOGD("Oops! The same surface!");
return VPE_ALGO_ERR_OK;
}
std::lock_guard<std::mutex> producerLock(producerLock_);
if (producer_ != nullptr) {
if (producer_->GetUniqueId() == surface->GetUniqueId()) {
VPE_LOGD("Oops! The same surface!");
return VPE_ALGO_ERR_OK;
}
producer_->UnRegisterReleaseListener();
producer_->CleanCache(true);
}
surface->UnRegisterReleaseListener();
surface->CleanCache(true);
GSError err = surface->RegisterReleaseListener([this](sptr<SurfaceBuffer>&) { return OnProducerBufferReleased(); });
CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, VPE_ALGO_ERR_UNKNOWN, "RegisterReleaseListener failed!");
VPE_LOGI("Set output buffer queue size to %{public}u", BUFFER_QUEUE_SIZE);
surface->SetQueueSize(BUFFER_QUEUE_SIZE);
surface->Connect();
AttachBuffers(surface);
surface->CleanCache();
AttachAndRefreshProducerBuffers(surface);
if (state_.load() != VPEState::IDLE) {
cvTrigger_.notify_one();
}
producer_ = surface;
VPEAlgoErrCode ret = VPE_ALGO_ERR_OK;
if (isEnable_.load()) {
ret = UpdateRequestCfg(surface, requestCfg_);
}
VPE_LOGD("requestCfg_({ %{public}s })", ToString(requestCfg_).c_str());
VPE_LOGD("requestCfg_({ %{public}s }) ret:%{public}d", ToString(requestCfg_).c_str(), ret);
isForceUpdateProducer_ = true;
if (ret == VPE_ALGO_ERR_OK) {
if (consumer_ != nullptr) {
return UpdateProducerLocked();
}
}
return ret;
}
VPEAlgoErrCode VpeVideoImpl::UpdateProducerLocked()
{
auto transform = consumer_->GetTransform();
GSError err;
if (isForceUpdateProducer_ || lastTransform_ != transform) {
err = producer_->SetTransform(transform);
CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, VPE_ALGO_ERR_UNKNOWN,
"Failed to SetTransform(%{public}d), ret:%{public}d!", transform, err);
lastTransform_ = transform;
VPE_LOGD("producer_->SetTransform(%{public}d) success.", transform);
}
if (lastConsumerBufferId_ == 0) {
return VPE_ALGO_ERR_OK;
}
ScalingMode scaleMode;
err = consumer_->GetScalingMode(lastConsumerBufferId_, scaleMode);
CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, VPE_ALGO_ERR_UNKNOWN,
"Failed to GetScalingMode(%{public}u), ret:%{public}d!", lastConsumerBufferId_, err);
if (isForceUpdateProducer_ || lastScalingMode_ != scaleMode) {
err = producer_->SetScalingMode(scaleMode);
CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, VPE_ALGO_ERR_UNKNOWN,
"Failed to SetScalingMode(%{public}d), ret:%{public}d!", scaleMode, err);
lastScalingMode_ = scaleMode;
VPE_LOGD("producer_->SetScalingMode(%{public}d) success.", scaleMode);
}
isForceUpdateProducer_ = false;
return VPE_ALGO_ERR_OK;
}
sptr<Surface> VpeVideoImpl::GetInputSurface()
{
sptr<Surface> producerSurface;
@@ -118,10 +156,9 @@ VPEAlgoErrCode VpeVideoImpl::Start()
{
return ExecuteWhenIdle(
[this]() {
if (consumer_ == nullptr || producer_ == nullptr || cb_ == nullptr) {
VPE_LOGE("The input surface, output surface or callback is NOT ready!");
return VPE_ALGO_ERR_INVALID_OPERATION;
}
CHECK_AND_RETURN_RET_LOG(isInitialized_.load(), VPE_ALGO_ERR_INVALID_OPERATION, "NOT initialized!");
CHECK_AND_RETURN_RET_LOG(consumer_ != nullptr && producer_ != nullptr && cb_ != nullptr,
VPE_ALGO_ERR_INVALID_OPERATION, "The input surface, output surface or callback is NOT ready!");
state_ = VPEState::RUNNING;
OnStateLocked(VPEAlgoState::RUNNING);
return VPE_ALGO_ERR_OK;
@@ -145,22 +182,34 @@ VPEAlgoErrCode VpeVideoImpl::Release()
VPEAlgoErrCode VpeVideoImpl::Flush()
{
std::unique_lock<std::mutex> lock(lock_);
cvDone_.wait(lock, [this]() { return !isProcessing_.load(); });
std::queue<SurfaceBufferInfo> tempQueue1;
std::queue<SurfaceBufferInfo> tempQueue2;
VPE_LOGD("step in");
std::lock_guard<std::mutex> lock(lock_);
{
std::lock_guard<std::mutex> bufferLock(bufferLock_);
consumerBufferQueue_.swap(tempQueue1);
while (!renderBufferQueue_.empty()) {
producerBufferQueue_.push(renderBufferQueue_.front());
renderBufferQueue_.pop();
}
attachBufferQueue_.swap(tempQueue2);
attachBufferIDs_.clear();
std::unique_lock<std::mutex> lockTask(taskLock_);
cvDone_.wait(lockTask, [this]() { return !isProcessing_.load(); });
}
ClearConsumerLocked(tempQueue1);
ClearConsumerLocked(tempQueue2);
if (isEnable_.load()) {
std::queue<SurfaceBufferInfo> tempQueue1;
std::queue<SurfaceBufferInfo> tempQueue2;
{
std::lock_guard<std::mutex> bufferLock(bufferLock_);
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
consumerBufferQueue_.swap(tempQueue1);
for (auto& [index, bufferInfo] : renderBufferQueue_) {
producerBufferQueue_.push(bufferInfo);
}
renderBufferQueue_.clear();
attachBufferQueue_.swap(tempQueue2);
attachBufferIDs_.clear();
}
ClearConsumerLocked(tempQueue1);
ClearConsumerLocked(tempQueue2);
} else {
producer_->CleanCache(false);
ClearBufferQueues();
}
VPE_LOGD("step out");
return VPE_ALGO_ERR_OK;
}
@@ -203,7 +252,7 @@ VPEAlgoErrCode VpeVideoImpl::NotifyEos()
return ExecuteWhenNotIdle(
[this]() {
{
std::lock_guard<std::mutex> buffferlock(bufferLock_);
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
SurfaceBufferInfo bufferInfo{};
bufferInfo.bufferFlag = VPE_BUFFER_FLAG_EOS;
consumerBufferQueue_.push(bufferInfo);
@@ -215,16 +264,16 @@ VPEAlgoErrCode VpeVideoImpl::NotifyEos()
VPEAlgoErrCode VpeVideoImpl::ReleaseOutputBuffer(uint32_t index, bool render)
{
return ExecuteWhenNotIdle(
[this, index, render]() { return RenderOutputBufferLocked(index, -1, render); },
CHECK_AND_RETURN_RET_LOG(state_.load() != VPEState::IDLE, VPE_ALGO_ERR_INVALID_OPERATION,
"Release output buffer must be called during running!");
return RenderOutputBuffer(index, -1, render);
}
VPEAlgoErrCode VpeVideoImpl::RenderOutputBufferAtTime(uint32_t index, int64_t renderTimestamp)
{
return ExecuteWhenNotIdle(
[this, index, renderTimestamp]() { return RenderOutputBufferLocked(index, renderTimestamp, true); },
CHECK_AND_RETURN_RET_LOG(state_.load() != VPEState::IDLE, VPE_ALGO_ERR_INVALID_OPERATION,
"Render output buffer must be called during running!");
return RenderOutputBuffer(index, renderTimestamp, true);
}
bool VpeVideoImpl::IsInitialized() const
@@ -234,40 +283,17 @@ bool VpeVideoImpl::IsInitialized() const
VPEAlgoErrCode VpeVideoImpl::Initialize()
{
VPE_LOGD("Start to initializing... this:%{public}p", this);
std::lock_guard<std::mutex> lock(lock_);
if (isInitialized_.load()) {
VPE_LOGD("Already initialize!");
return VPE_ALGO_ERR_OK;
}
VPE_LOGD("Start to initializing...");
isRunning_ = true;
worker_ = std::thread([this]() {
while (isRunning_.load()) {
{
std::unique_lock<std::mutex> bufferLock(bufferLock_);
if (!cvTrigger_.wait_for(bufferLock, 200s, [this] {
VPE_LOGD("run:%d stopping:%d consumerBQ:%{public}zu producerBQ:%{public}zu "
"renderBQ:%{public}zu flushBQ:%{public}zu attachBQ:%{public}zu",
isRunning_.load(), state_.load() == VPEState::STOPPING,
consumerBufferQueue_.size(), producerBufferQueue_.size(),
renderBufferQueue_.size(), flushBufferQueue_.size(), attachBufferQueue_.size());
return !isRunning_.load() || state_.load() == VPEState::STOPPING ||
(!producerBufferQueue_.empty() && !consumerBufferQueue_.empty());
})) {
VPE_LOGI("Video processing timeout.");
continue;
}
if (!isRunning_.load()) {
VPE_LOGI("Video processing clear.");
break;
}
if (producerBufferQueue_.empty() || consumerBufferQueue_.empty()) {
CheckSpuriousWakeup();
VPE_LOGD("Empty! consumerBQ:%{public}zu producerBQ:%{public}zu", consumerBufferQueue_.size(),
producerBufferQueue_.size());
continue;
}
if (!WaitTrigger()) {
continue;
}
VPE_LOGD("ProcessBuffers");
ProcessBuffers();
@@ -282,13 +308,16 @@ VPEAlgoErrCode VpeVideoImpl::Initialize()
VPEAlgoErrCode VpeVideoImpl::Deinitialize()
{
std::unique_lock<std::mutex> lock(lock_);
VPE_LOGD("Start to deinitializing... this:%{public}p", this);
cvDone_.wait(lock, [this]() { return !isProcessing_.load(); });
std::lock_guard<std::mutex> lock(lock_);
if (!isInitialized_.load()) {
VPE_LOGD("Already deinitialize!");
return VPE_ALGO_ERR_OK;
}
{
std::unique_lock<std::mutex> taskLock(taskLock_);
cvDone_.wait(taskLock, [this]() { return !isProcessing_.load(); });
}
isInitialized_ = false;
VPEAlgoErrCode errorCode = OnDeinitialize();
if (state_.load() == VPEState::RUNNING) {
@@ -301,6 +330,7 @@ VPEAlgoErrCode VpeVideoImpl::Deinitialize()
}
CheckStoppingLocked();
cb_ = nullptr;
std::lock_guard<std::mutex> producerLock(producerLock_);
ClearBufferQueues();
if (consumer_ != nullptr) {
consumer_->UnregisterConsumerListener();
@@ -327,7 +357,7 @@ void VpeVideoImpl::RefreshBuffers()
return;
}
if (!isBufferQueueReady_) {
if (!isBufferQueueReady_.load()) {
VPE_LOGD("Skip refreshing when buffer queue is not ready.");
return;
}
@@ -377,7 +407,7 @@ void VpeVideoImpl::UpdateRequestCfg([[maybe_unused]] const sptr<SurfaceBuffer>&
{
}
void VpeVideoImpl::OnErrorLocked(VPEAlgoErrCode errorCode)
void VpeVideoImpl::OnError(VPEAlgoErrCode errorCode)
{
if (cb_ != nullptr) {
VPE_LOGD("OnError(%{public}d)", errorCode);
@@ -404,6 +434,7 @@ void VpeVideoImpl::OnEffectChange(uint32_t type)
void VpeVideoImpl::OnOutputBufferAvailable(uint32_t index, const VpeBufferInfo& info)
{
if (cb_ != nullptr) {
VPE_LOGD("OnOutputBufferAvailable(%{public}u, flag:%{public}d)", index, info.flag);
cb_->OnOutputBufferAvailable(index, info);
}
}
@@ -411,9 +442,10 @@ void VpeVideoImpl::OnOutputBufferAvailable(uint32_t index, const VpeBufferInfo&
GSError VpeVideoImpl::OnConsumerBufferAvailable()
{
std::lock_guard<std::mutex> lock(lock_);
CHECK_AND_RETURN_RET_LOG(consumer_ != nullptr, GSERROR_OK, "Input surface is null!");
if (state_.load() != VPEState::RUNNING) {
VPE_LOGD("NOT running now!");
return GSERROR_INVALID_OPERATING;
return GSERROR_OK;
}
SurfaceBufferInfo bufferInfo{};
@@ -425,18 +457,18 @@ GSError VpeVideoImpl::OnConsumerBufferAvailable()
return err;
}
VPE_LOGD("consumer_->AcquireBuffer({ %{public}s })", ToString(bufferInfo.buffer).c_str());
lastConsumerBufferId_ = bufferInfo.buffer->GetSeqNum();
{
std::lock_guard<std::mutex> buffferlock(bufferLock_);
if (!isBufferQueueReady_) {
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
if (!isBufferQueueReady_.load()) {
isBufferQueueReady_ = true;
requestCfg_.usage = bufferInfo.buffer->GetUsage();
requestCfg_.timeout = 0;
requestCfg_.strideAlignment = 32; // 32 bits align
UpdateRequestCfg(bufferInfo.buffer, requestCfg_);
VPE_LOGD("Use requestCfg_({ %{public}s }) to prepare buffers.", ToString(requestCfg_).c_str());
PrepareBuffers();
needPrepareBuffers_ = true;
}
consumerBufferQueue_.push(bufferInfo);
}
@@ -447,22 +479,16 @@ GSError VpeVideoImpl::OnConsumerBufferAvailable()
GSError VpeVideoImpl::OnProducerBufferReleased()
{
VPE_LOGD("step in");
std::lock_guard<std::mutex> lock(lock_);
CHECK_AND_RETURN_RET_LOG(consumer_ != nullptr || producer_ != nullptr, GSERROR_OK,
"Input or output surface is null!");
std::lock_guard<std::mutex> producerLock(producerLock_);
CHECK_AND_RETURN_RET_LOG(producer_ != nullptr, GSERROR_OK, "Output surface is null!");
{
std::lock_guard<std::mutex> bufferLock(bufferLock_);
if (flushBufferQueue_.empty()) {
VPE_LOGD("NO flush buffer!");
return GSERROR_OK;
}
GSError err = GSERROR_OK;
SurfaceBufferInfo bufferInfo{};
CHECK_AND_RETURN_RET_LOG(RequestBuffer(bufferInfo, err), err, "Failed to request buffer!");
PopBuffer(flushBufferQueue_, bufferInfo.buffer->GetSeqNum(), bufferInfo,
[this](sptr<SurfaceBuffer>& buffer) {
CHECK_AND_RETURN_LOG(buffer != nullptr, "OnProducerBufferReleased: Flush buffer is null!");
VPE_LOGD("OnProducerBufferReleased: Pop flush buffer { %{public}s } flushBQ=%{public}zu",
ToString(buffer).c_str(), flushBufferQueue_.size());
});
@@ -474,22 +500,31 @@ GSError VpeVideoImpl::OnProducerBufferReleased()
return GSERROR_OK;
}
VPEAlgoErrCode VpeVideoImpl::RenderOutputBufferLocked(uint32_t index, int64_t renderTimestamp, bool render)
VPEAlgoErrCode VpeVideoImpl::RenderOutputBuffer(uint32_t index, int64_t renderTimestamp, bool render)
{
std::unique_lock<std::mutex> bufferLock(bufferLock_);
SurfaceBufferInfo bufferInfo{};
bool isFound = PopBuffer(renderBufferQueue_, index, bufferInfo, [](sptr<SurfaceBuffer>&) {});
auto it = renderBufferQueue_.find(index);
CHECK_AND_RETURN_RET_LOG(it != renderBufferQueue_.end(), VPE_ALGO_ERR_INVALID_PARAM,
"Invalid input: index=%{public}u!", index);
SurfaceBufferInfo bufferInfo = it->second;
renderBufferQueue_.erase(it);
bufferLock.unlock();
CHECK_AND_RETURN_RET_LOG(isFound, VPE_ALGO_ERR_INVALID_PARAM, "Invalid input: index=%{public}u!", index);
if (render) {
BufferFlushConfig flushcfg{};
flushcfg.damage.w = bufferInfo.buffer->GetWidth();
flushcfg.damage.h = bufferInfo.buffer->GetHeight();
flushcfg.timestamp = (renderTimestamp == -1) ? bufferInfo.timestamp : renderTimestamp;
auto ret = producer_->FlushBuffer(bufferInfo.buffer, -1, flushcfg);
VPE_LOGD("producer_->FlushBuffer({ %{public}s })=%{public}d flushBQ=%{public}zu",
ToString(bufferInfo.buffer).c_str(), ret, flushBufferQueue_.size() + 1);
{
std::lock_guard<std::mutex> producerLock(producerLock_);
CHECK_AND_RETURN_RET_LOG(producer_ != nullptr, VPE_ALGO_ERR_INVALID_OPERATION, "Output surface is null!");
auto ret = producer_->FlushBuffer(bufferInfo.buffer, -1, flushcfg);
VPE_LOGD("producer_->FlushBuffer({ %{public}s })=%{public}d flushBQ=%{public}zu",
ToString(bufferInfo.buffer).c_str(), ret, flushBufferQueue_.size() + 1);
if (ret != GSERROR_OK) {
return VPE_ALGO_ERR_UNKNOWN;
}
}
bufferLock.lock();
flushBufferQueue_.push(bufferInfo);
} else {
@@ -520,15 +555,17 @@ sptr<Surface> VpeVideoImpl::CreateConsumerSurfaceLocked()
sptr<Surface> producerSurface = Surface::CreateSurfaceAsProducer(producer);
CHECK_AND_RETURN_RET_LOG(producerSurface != nullptr, nullptr, "Failed to create producer surface!");
producerSurface->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE |
BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_MEM_MMZ_CACHE | BUFFER_USAGE_HW_COMPOSER);
BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_MEM_MMZ_CACHE | BUFFER_USAGE_HW_COMPOSER); // [TEST]
consumer_->SetQueueSize(BUFFER_QUEUE_SIZE);
VPE_LOGI("Set input buffer queue size to %{public}u", BUFFER_QUEUE_SIZE);
hasConsumer_ = true;
return producerSurface;
}
bool VpeVideoImpl::RequestBuffer(SurfaceBufferInfo& bufferInfo, GSError& errorCode)
{
CHECK_AND_RETURN_RET_LOG(hasConsumer_.load(), false, "Input surface is null!");
int releaseFence = -1;
errorCode = producer_->RequestBuffer(bufferInfo.buffer, releaseFence, requestCfg_);
if (errorCode != GSERROR_OK || bufferInfo.buffer == nullptr) {
@@ -568,6 +605,8 @@ bool VpeVideoImpl::RequestBuffer(SurfaceBufferInfo& bufferInfo, GSError& errorCo
void VpeVideoImpl::PrepareBuffers()
{
std::lock_guard<std::mutex> lock(lock_);
CHECK_AND_RETURN_LOG(producer_ != nullptr, "producer is null!");
for (uint32_t i = 0; i < producer_->GetQueueSize(); i++) {
GSError errorCode;
SurfaceBufferInfo bufferInfo{};
@@ -576,16 +615,31 @@ void VpeVideoImpl::PrepareBuffers()
}
}
void VpeVideoImpl::AttachBuffers(const sptr<Surface>& producer)
void VpeVideoImpl::AttachAndRefreshProducerBuffers(const sptr<Surface>& producer)
{
std::lock_guard<std::mutex> bufferLock(bufferLock_);
std::queue<SurfaceBufferInfo> tempQueue;
producerBufferQueue_.swap(tempQueue);
AttachBuffers(producer, tempQueue);
AttachBuffers(producer, flushBufferQueue_);
RefreshProducerBuffers(flushBufferQueue_, [](SurfaceBufferInfo&) { return true; });
}
void VpeVideoImpl::AttachBuffers(const sptr<Surface>& producer, std::queue<SurfaceBufferInfo>& bufferQueue)
{
RefreshProducerBuffers(bufferQueue,
[&producer](SurfaceBufferInfo& bufferInfo) {
auto errorCode = producer->AttachBufferToQueue(bufferInfo.buffer);
if (errorCode != GSERROR_OK) {
VPE_LOGW("AttachBuffers: Failed to producer->AttachBufferToQueue({ %{public}s })=%{public}d",
ToString(bufferInfo.buffer).c_str(), errorCode);
return false;
}
return true;
});
}
void VpeVideoImpl::RefreshProducerBuffers(std::queue<SurfaceBufferInfo>& bufferQueue,
std::function<bool(SurfaceBufferInfo&)>&& refresher)
{
for (; !bufferQueue.empty(); bufferQueue.pop()) {
auto bufferInfo = bufferQueue.front();
@@ -593,10 +647,7 @@ void VpeVideoImpl::AttachBuffers(const sptr<Surface>& producer, std::queue<Surfa
VPE_LOGW("buffer is null!");
continue;
}
auto errorCode = producer->AttachBufferToQueue(bufferInfo.buffer);
if (errorCode != GSERROR_OK) {
VPE_LOGW("Failed to producer->AttachBufferToQueue({ %{public}s })=%{public}d",
ToString(bufferInfo.buffer).c_str(), errorCode);
if (!refresher(bufferInfo)) {
continue;
}
producerBufferQueue_.push(bufferInfo);
@@ -605,29 +656,29 @@ void VpeVideoImpl::AttachBuffers(const sptr<Surface>& producer, std::queue<Surfa
void VpeVideoImpl::ProcessBuffers()
{
sptr<Surface> consumer;
{
std::lock_guard<std::mutex> lock(lock_);
if (consumer_ == nullptr) {
return;
}
consumer = consumer_;
isProcessing_ = true;
CHECK_AND_RETURN_LOG(consumer_ != nullptr && producer_ != nullptr, "consumer or producer is null!");
UpdateProducerLocked();
}
while (isRunning_.load()) {
std::lock_guard<std::mutex> taskLock(taskLock_);
isProcessing_ = true;
SurfaceBufferInfo srcBufferInfo;
SurfaceBufferInfo dstBufferInfo;
{
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
std::lock_guard<std::mutex> bufferLock(bufferLock_);
if (producerBufferQueue_.empty() || consumerBufferQueue_.empty()) {
break;
}
srcBufferInfo = consumerBufferQueue_.front();
dstBufferInfo = producerBufferQueue_.front();
if (srcBufferInfo.buffer == nullptr) {
consumerBufferQueue_.pop();
continue;
}
dstBufferInfo = producerBufferQueue_.front();
if (dstBufferInfo.buffer == nullptr) {
producerBufferQueue_.pop();
continue;
@@ -635,43 +686,41 @@ void VpeVideoImpl::ProcessBuffers()
consumerBufferQueue_.pop();
producerBufferQueue_.pop();
}
if (srcBufferInfo.bufferFlag == VPE_BUFFER_FLAG_EOS) {
VPE_LOGD("EOS frame.");
OutputBuffer(srcBufferInfo, dstBufferInfo, [] {});
break;
}
if (isEnable_.load()) {
if (!ProcessBuffer(consumer, srcBufferInfo, dstBufferInfo)) {
if (!ProcessBuffer(srcBufferInfo, dstBufferInfo)) {
continue;
}
} else {
BypassBuffer(srcBufferInfo, dstBufferInfo);
}
}
VPE_LOGD("consumerBQ:%{public}zu producerBQ:%{public}zu renderBQ:%{public}zu flushBQ:%{public}zu "
"attachBQ:%{public}zu", consumerBufferQueue_.size(), producerBufferQueue_.size(), renderBufferQueue_.size(),
flushBufferQueue_.size(), attachBufferQueue_.size());
{
std::lock_guard<std::mutex> lock(lock_);
isProcessing_ = false;
}
PrintBufferSize();
isProcessing_ = false;
cvDone_.notify_all();
}
bool VpeVideoImpl::ProcessBuffer(sptr<Surface>& consumer, SurfaceBufferInfo& srcBufferInfo,
SurfaceBufferInfo& dstBufferInfo)
bool VpeVideoImpl::ProcessBuffer(SurfaceBufferInfo& srcBufferInfo, SurfaceBufferInfo& dstBufferInfo)
{
if (srcBufferInfo.bufferFlag != VPE_BUFFER_FLAG_EOS) {
dstBufferInfo.timestamp = srcBufferInfo.timestamp;
auto errorCode = Process(srcBufferInfo.buffer, dstBufferInfo.buffer);
auto ret = consumer->ReleaseBuffer(srcBufferInfo.buffer, -1);
VPE_LOGD("consumer_->ReleaseBuffer({ %{public}s })=%{public}d",
ToString(srcBufferInfo.buffer).c_str(), ret);
if (errorCode != VPE_ALGO_ERR_OK) {
OnErrorLocked(errorCode);
std::lock_guard<std::mutex> bufferLock(bufferLock_);
producerBufferQueue_.push(dstBufferInfo);
VPE_LOGW("Failed to process({ %{public}s },{ %{public}s })=%{public}d",
ToString(srcBufferInfo.buffer).c_str(), ToString(dstBufferInfo.buffer).c_str(), errorCode);
return false;
}
dstBufferInfo.timestamp = srcBufferInfo.timestamp;
auto errorCode = Process(srcBufferInfo.buffer, dstBufferInfo.buffer);
auto ret = consumer_->ReleaseBuffer(srcBufferInfo.buffer, -1);
VPE_LOGD("consumer_->ReleaseBuffer({ %{public}s })=%{public}d", ToString(srcBufferInfo.buffer).c_str(), ret);
if (errorCode != VPE_ALGO_ERR_OK) {
OnError(errorCode);
std::lock_guard<std::mutex> bufferLock(bufferLock_);
producerBufferQueue_.push(dstBufferInfo);
VPE_LOGW("Failed to process({ %{public}s },{ %{public}s })=%{public}d",
ToString(srcBufferInfo.buffer).c_str(), ToString(dstBufferInfo.buffer).c_str(), errorCode);
return false;
}
OutputBuffer(srcBufferInfo, dstBufferInfo, true, [] {});
OutputBuffer(srcBufferInfo, dstBufferInfo, [] {});
NotifyEnableStatus(type_, "enable");
return true;
}
@@ -687,20 +736,22 @@ void VpeVideoImpl::BypassBuffer(SurfaceBufferInfo& srcBufferInfo, SurfaceBufferI
ToString(dstBufferInfo.buffer).c_str(), ret1,
ToString(srcBufferInfo.buffer).c_str(), ret2, ToString(requestCfg_).c_str());
}
OutputBuffer(srcBufferInfo, srcBufferInfo, false, [this, &srcBufferInfo] {
OutputBuffer(srcBufferInfo, srcBufferInfo, [this, &srcBufferInfo] {
attachBufferIDs_.insert(srcBufferInfo.buffer->GetSeqNum());
attachBufferQueue_.push(srcBufferInfo);
});
VPE_LOGD("cache(%{public}s)->%{public}zu/%{public}zu", ToString(srcBufferInfo.buffer).c_str(),
attachBufferIDs_.size(), attachBufferIDs_.size());
NotifyEnableStatus(0, "disable");
}
void VpeVideoImpl::OutputBuffer(const SurfaceBufferInfo& bufferInfo, const SurfaceBufferInfo& bufferImage,
bool isProcessed, std::function<void(void)>&& getReadyToRender)
std::function<void(void)>&& getReadyToRender)
{
{
std::lock_guard<std::mutex> bufferLock(bufferLock_);
renderBufferQueue_.push(bufferImage);
renderBufferQueue_[bufferImage.buffer->GetSeqNum()] = bufferImage;
VPE_LOGD("renderBufferQueue_.push({ %{public}s })", ToString(bufferImage.buffer).c_str());
getReadyToRender();
}
VpeBufferInfo info {
@@ -708,16 +759,16 @@ void VpeVideoImpl::OutputBuffer(const SurfaceBufferInfo& bufferInfo, const Surfa
.presentationTimestamp = bufferInfo.timestamp,
};
OnOutputBufferAvailable(bufferImage.buffer->GetSeqNum(), info);
}
void VpeVideoImpl::NotifyEnableStatus(uint32_t type, const std::string& status)
{
if (!isEnableChange_.load()) {
VPE_LOGD("no enable change");
VPE_LOGD("Keep %{public}s.", status.c_str());
return;
}
OnEffectChange(type);
std::lock_guard<std::mutex> lock(lock_);
if (isEnable_.load() && !isProcessed) {
VPE_LOGD("No frame is processed after enabling.");
return;
}
OnEffectChange(isEnable_.load() ? type_ : 0);
isEnableChange_ = false;
}
@@ -729,6 +780,7 @@ bool VpeVideoImpl::PopBuffer(std::queue<SurfaceBufferInfo>& bufferQueue, uint32_
bufferInfo = bufferQueue.front();
bufferQueue.pop();
func(bufferInfo.buffer);
VPE_LOGD("index:%{public}u buffer:{ %{public}s }", index, ToString(bufferInfo.buffer).c_str());
if (bufferInfo.buffer != nullptr && bufferInfo.buffer->GetSeqNum() == index) {
isFound = true;
break;
@@ -737,6 +789,15 @@ bool VpeVideoImpl::PopBuffer(std::queue<SurfaceBufferInfo>& bufferQueue, uint32_
return isFound;
}
void VpeVideoImpl::PrintBufferSize() const
{
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
std::lock_guard<std::mutex> bufferLock(bufferLock_);
VPE_LOGD("consumerBQ:%{public}zu producerBQ:%{public}zu renderBQ:%{public}zu flushBQ:%{public}zu "
"attachBQ:%{public}zu", consumerBufferQueue_.size(), producerBufferQueue_.size(), renderBufferQueue_.size(),
flushBufferQueue_.size(), attachBufferQueue_.size());
}
void VpeVideoImpl::SetRequestCfgLocked(const sptr<SurfaceBuffer>& buffer)
{
requestCfg_.usage = buffer->GetUsage();
@@ -746,6 +807,42 @@ void VpeVideoImpl::SetRequestCfgLocked(const sptr<SurfaceBuffer>& buffer)
orgRequestCfg_ = requestCfg_;
}
bool VpeVideoImpl::WaitTrigger()
{
uint32_t consumerSize = 0;
uint32_t producerSize = 0;
std::unique_lock<std::mutex> bufferLock(bufferLock_);
if (!cvTrigger_.wait_for(bufferLock, 200s, [this, &consumerSize, &producerSize] {
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
if (needPrepareBuffers_.load()) {
PrepareBuffers();
needPrepareBuffers_ = false;
}
consumerSize = consumerBufferQueue_.size();
producerSize = producerBufferQueue_.size();
VPE_LOGD("run:%d stopping:%d consumerBQ:%{public}u producerBQ:%{public}u "
"renderBQ:%{public}zu flushBQ:%{public}zu attachBQ:%{public}zu",
isRunning_.load(), state_.load() == VPEState::STOPPING, consumerSize, producerSize,
renderBufferQueue_.size(), flushBufferQueue_.size(), attachBufferQueue_.size());
return !isRunning_.load() || state_.load() == VPEState::STOPPING ||
(consumerSize > 0 && producerSize > 0);
})) {
VPE_LOGI("Video processing timeout.");
return false;
}
if (!isRunning_.load()) {
VPE_LOGI("Video processing clear.");
return false;
}
if (consumerSize == 0 || producerSize == 0) {
CheckSpuriousWakeup();
VPE_LOGD("Empty! consumerBQ:%{public}u producerBQ:%{public}u", consumerSize, producerSize);
return false;
}
return true;
}
void VpeVideoImpl::CheckSpuriousWakeup()
{
if (!CheckStopping()) {
@@ -781,7 +878,10 @@ void VpeVideoImpl::ClearConsumerLocked(std::queue<SurfaceBufferInfo>& bufferQueu
{
while (!bufferQueue.empty()) {
auto bufferInfo = bufferQueue.front();
consumer_->ReleaseBuffer(bufferInfo.buffer, -1);
auto err = consumer_->ReleaseBuffer(bufferInfo.buffer, -1);
if (err != GSERROR_OK) {
VPE_LOGW("Failed to ReleaseBuffer({ %{public}s }):%{public}d", ToString(bufferInfo.buffer).c_str(), err);
}
bufferQueue.pop();
}
}
@@ -791,11 +891,13 @@ void VpeVideoImpl::ClearBufferQueues()
std::queue<SurfaceBufferInfo> tempQueue1;
std::queue<SurfaceBufferInfo> tempQueue2;
{
std::lock_guard<std::mutex> consumerBufferLock(consumerBufferLock_);
std::lock_guard<std::mutex> bufferLock(bufferLock_);
isBufferQueueReady_ = false;
consumerBufferQueue_.swap(tempQueue1);
ClearQueue(producerBufferQueue_);
ClearQueue(renderBufferQueue_);
renderBufferQueue_.clear();
ClearQueue(flushBufferQueue_);
attachBufferQueue_.swap(tempQueue2);
attachBufferIDs_.clear();
}
framework/algorithm/common/include/algorithm_video_impl.h
+32 -10
View File
@@ -26,6 +26,7 @@
#include <set>
#include <string>
#include <thread>
#include <unordered_map>
#include "refbase.h"
#include "surface.h"
@@ -100,7 +101,7 @@ private:
std::weak_ptr<VpeVideoImpl> owner_;
};
void OnErrorLocked(VPEAlgoErrCode errorCode);
void OnError(VPEAlgoErrCode errorCode);
void OnStateLocked(VPEAlgoState state);
void OnEffectChange(uint32_t type);
void OnOutputBufferAvailable(uint32_t index, const VpeBufferInfo& info);
@@ -108,20 +109,26 @@ private:
GSError OnConsumerBufferAvailable();
GSError OnProducerBufferReleased();
VPEAlgoErrCode RenderOutputBufferLocked(uint32_t index, int64_t renderTimestamp, bool render);
VPEAlgoErrCode UpdateProducerLocked();
VPEAlgoErrCode RenderOutputBuffer(uint32_t index, int64_t renderTimestamp, bool render);
sptr<Surface> CreateConsumerSurfaceLocked();
bool RequestBuffer(SurfaceBufferInfo& bufferInfo, GSError& errorCode);
void PrepareBuffers();
void AttachBuffers(const sptr<Surface>& producer);
void AttachAndRefreshProducerBuffers(const sptr<Surface>& producer);
void AttachBuffers(const sptr<Surface>& producer, std::queue<SurfaceBufferInfo>& bufferQueue);
void RefreshProducerBuffers(std::queue<SurfaceBufferInfo>& bufferQueue,
std::function<bool(SurfaceBufferInfo&)>&& refresher);
void ProcessBuffers();
bool ProcessBuffer(sptr<Surface>& consumer, SurfaceBufferInfo& srcBufferInfo, SurfaceBufferInfo& dstBufferInfo);
bool ProcessBuffer(SurfaceBufferInfo& srcBufferInfo, SurfaceBufferInfo& dstBufferInfo);
void BypassBuffer(SurfaceBufferInfo& srcBufferInfo, SurfaceBufferInfo& dstBufferInfo);
void OutputBuffer(const SurfaceBufferInfo& bufferInfo, const SurfaceBufferInfo& bufferImage, bool isProcessed,
void OutputBuffer(const SurfaceBufferInfo& bufferInfo, const SurfaceBufferInfo& bufferImage,
std::function<void(void)>&& getReadyToRender);
void NotifyEnableStatus(uint32_t type, const std::string& status);
bool PopBuffer(std::queue<SurfaceBufferInfo>& bufferQueue, uint32_t index, SurfaceBufferInfo& bufferInfo,
std::function<void(sptr<SurfaceBuffer>&)>&& func);
void PrintBufferSize() const;
void SetRequestCfgLocked(const sptr<SurfaceBuffer>& buffer);
bool WaitTrigger();
void CheckSpuriousWakeup();
bool CheckStopping();
bool CheckStoppingLocked();
@@ -146,24 +153,39 @@ private:
// Guarded by lock_ begin
std::atomic<bool> isInitialized_{false};
std::atomic<bool> isRunning_{false};
std::atomic<bool> isProcessing_{false};
std::atomic<bool> isEnable_{true};
std::atomic<bool> isEnableChange_{true};
std::atomic<bool> hasConsumer_{false};
std::atomic<VPEState> state_{VPEState::IDLE};
uint32_t lastConsumerBufferId_{};
GraphicTransformType lastTransform_{};
ScalingMode lastScalingMode_{};
bool isForceUpdateProducer_{true};
std::thread worker_{};
std::shared_ptr<VpeVideoCallback> cb_{};
sptr<Surface> consumer_{};
sptr<Surface> producer_{};
sptr<Surface> producer_{}; // Also guarded by producerLock_
BufferRequestConfig requestCfg_{};
BufferRequestConfig orgRequestCfg_{};
// Guarded by lock_ end
mutable std::mutex producerLock_{};
mutable std::mutex taskLock_{};
// Guarded by taskLock_ begin
std::atomic<bool> isProcessing_{false};
// Guarded by taskLock_ end
mutable std::mutex consumerBufferLock_{};
// Guarded by consumerBufferLock_ begin
std::atomic<bool> isBufferQueueReady_{false};
std::atomic<bool> needPrepareBuffers_{false};
std::queue<SurfaceBufferInfo> consumerBufferQueue_{};
// Guarded by consumerBufferLock_ end
mutable std::mutex bufferLock_{};
// Guarded by bufferLock_ begin
bool isBufferQueueReady_{};
std::queue<SurfaceBufferInfo> consumerBufferQueue_{};
std::queue<SurfaceBufferInfo> producerBufferQueue_{};
std::queue<SurfaceBufferInfo> renderBufferQueue_{};
std::unordered_map<uint32_t, SurfaceBufferInfo> renderBufferQueue_{};
std::queue<SurfaceBufferInfo> flushBufferQueue_{};
std::queue<SurfaceBufferInfo> attachBufferQueue_{};
std::set<uint32_t> attachBufferIDs_{};
framework/algorithm/detail_enhancer_video/detail_enhancer_video_impl.cpp
+5
View File
@@ -76,6 +76,11 @@ VPEAlgoErrCode DetailEnhancerVideoImpl::Stop()
return detailEnhancerVideo_->Stop();
}
VPEAlgoErrCode DetailEnhancerVideoImpl::Release()
{
return detailEnhancerVideo_->Release();
}
VPEAlgoErrCode DetailEnhancerVideoImpl::RenderOutputBuffer([[maybe_unused]] uint32_t index)
{
return VPE_ALGO_ERR_OK;
framework/algorithm/detail_enhancer_video/include/detail_enhancer_video_impl.h
+1
View File
@@ -40,6 +40,7 @@ public:
VPEAlgoErrCode SetParameter(const DetailEnhancerParameters& parameter, SourceType type) override;
VPEAlgoErrCode Start() override;
VPEAlgoErrCode Stop() override;
VPEAlgoErrCode Release() override;
VPEAlgoErrCode RenderOutputBuffer(uint32_t index) override;
VPEAlgoErrCode ReleaseOutputBuffer(uint32_t index, bool render) override;
framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp
+2
View File
@@ -259,6 +259,8 @@ int32_t MetadataGeneratorVideoImpl::Prepare()
void MetadataGeneratorVideoImpl::InitBuffers()
{
std::lock_guard<std::mutex> lock(mutex_);
CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr");
flushCfg_.damage.x = 0;
flushCfg_.damage.y = 0;
flushCfg_.damage.w = requestCfg_.width;
test/moduletest/colorspace_converter_video/BUILD.gn
-1
View File
@@ -22,7 +22,6 @@ ohos_moduletest("colorspace_converter_video_module_test") {
".",
"$INTERFACES_INNER_API_DIR",
"$DFX_DIR/include",
"//foundation/graphic/graphic_2d/interfaces/inner_api",
"$COLORSPACE_CONVERTER_VIDEO_DIR/include",
]
test/moduletest/metadata_generator_video/BUILD.gn
+1 -2
View File
@@ -22,7 +22,6 @@ ohos_moduletest("metadata_generator_video_module_test") {
".",
"$INTERFACES_INNER_API_DIR",
"$DFX_DIR/include",
"//foundation/graphic/graphic_2d/interfaces/inner_api",
"$METADATA_GENERATOR_VIDEO_DIR/include",
]
@@ -53,7 +52,7 @@ ohos_moduletest("metadata_generator_video_module_test") {
"hitrace:hitrace_meter",
"drivers_interface_display:display_commontype_idl_headers",
]
subsystem_name = "multimedia"
part_name = "video_processing_engine"
}
test/nativedemo/vpe_demo/BUILD.gn
+1 -1
View File
@@ -63,7 +63,6 @@ ohos_executable("detailEnh_demo") {
"$INTERFACES_INNER_API_DIR",
"$TEST_UTILS_PATH/DetailEnhancer/sample",
"$TEST_UTILS_PATH/DetailEnhancer/sample",
"//foundation/multimedia/media_foundation/interface/inner_api/meta"
]
defines = []
@@ -85,6 +84,7 @@ ohos_executable("detailEnh_demo") {
external_deps = [
"c_utils:utils",
"graphic_surface:surface",
"media_foundation:media_foundation",
"drivers_interface_display:display_commontype_idl_headers",
]
test/unittest/colorSpace_converter_video_ndk/BUILD.gn
+4 -10
View File
@@ -38,16 +38,9 @@ ohos_unittest("colorSpace_converter_video_ndk_unit_test") {
"$ALGORITHM_DIR/colorspace_converter_video/include",
"$VIDEO_PROCESSING_ENGINE_ROOT_DIR/services/include",
"$TEST_UTILS_PATH/ColorSpaceConverter/sample/video",
"//foundation/multimedia/media_foundation/interface/kits/c/",
"//foundation/multimedia/media_foundation/video_processing_engine/interface/kits/c/",
"//foundation/multimedia/media_foundation/video_processing_engine/",
"//foundation/multimedia/media_foundation/video_processing_engine/framework/dfx/include/",
"//foundation/multimedia/media_foundation/video_processing_engine/framework/capi/video_processing/include/",
"//foundation/multimedia/media_foundation/video_processing_engine/interface/inner_api/",
"//foundation/multimedia/video_processing_engine/interfaces/inner_api/",
"//foundation/multimedia/video_processing_engine/framework/algorithm/colorspace_converter_video/include/",
"//foundation/graphic/graphic_2d/interfaces/inner_api/",
"//foundation/graphic/graphic_2d_ext/ohcore/graphic_compat_layer/include/utils/",
"$FRAMEWORK_DIR/dfx/include/",
"$FRAMEWORK_DIR/capi/video_processing/include/",
"$COLORSPACE_CONVERTER_VIDEO_DIR/include/",
]
sources = [ "colorSpace_converter_video_ndk_unit_test.cpp" ]
@@ -66,6 +59,7 @@ ohos_unittest("colorSpace_converter_video_ndk_unit_test") {
"graphic_2d:librender_service_client",
"hilog:libhilog",
"hitrace:hitrace_meter",
"media_foundation:media_foundation",
"media_foundation:native_media_core",
"media_foundation:video_processing",
"ipc:ipc_core",
test/unittest/detail_enhancer_video/detail_enhancer_video_unit_test.cpp
+82 -59
View File
@@ -143,6 +143,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_init_01, TestSize.Level1)
{
auto detailEnhVideo = DetailEnhancerVideo::Create();
EXPECT_NE(detailEnhVideo, nullptr);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_02, TestSize.Level1)
@@ -151,6 +152,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_02, TestSize.Level1)
std::shared_ptr<DetailEnhancerVideoCallback> cb = nullptr;
auto ret = detailEnhVideo->RegisterCallback(cb);
EXPECT_NE(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_03, TestSize.Level1)
@@ -162,6 +164,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_03, TestSize.Level1)
};
auto ret = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_04, TestSize.Level1)
@@ -173,6 +176,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_04, TestSize.Level1)
};
auto ret = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_05, TestSize.Level1)
@@ -184,6 +188,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_05, TestSize.Level1)
};
auto ret = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_06, TestSize.Level1)
@@ -191,6 +196,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_06, TestSize.Level1)
auto detailEnhVideo = DetailEnhancerVideo::Create();
auto ret = detailEnhVideo->GetInputSurface();
EXPECT_NE(ret, nullptr);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_07, TestSize.Level1)
@@ -199,6 +205,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_07, TestSize.Level1)
auto ret = detailEnhVideo->GetInputSurface();
ret = detailEnhVideo->GetInputSurface();
EXPECT_EQ(ret, nullptr);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_08, TestSize.Level1)
@@ -207,6 +214,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_08, TestSize.Level1)
sptr<Surface> surface = nullptr;
auto ret = detailEnhVideo->SetOutputSurface(surface);
EXPECT_NE(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_09, TestSize.Level1)
@@ -215,161 +223,173 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_09, TestSize.Level1)
auto ret = detailEnhVideo->RenderOutputBuffer(0);
EXPECT_EQ(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_10, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto ret = detailEnh->NotifyEos();
auto detailEnhVideo = DetailEnhancerVideo::Create();
auto ret = detailEnhVideo->NotifyEos();
EXPECT_NE(ret, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
// set parameter to midium
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_11, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_MEDIUM,
};
auto res = detailEnh->SetParameter(param, VIDEO);
auto res = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
// set parameter to low
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_12, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_LOW,
};
auto res = detailEnh->SetParameter(param, VIDEO);
auto res = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
// set parameter to none
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_13, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_NONE,
};
auto res = detailEnh->SetParameter(param, VIDEO);
auto res = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_14, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
auto res = detailEnh->SetParameter(param, VIDEO);
res = detailEnh->SetParameter(param, VIDEO);
auto res = detailEnhVideo->SetParameter(param, VIDEO);
res = detailEnhVideo->SetParameter(param, VIDEO);
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_15, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_16, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto ret = detailEnh->GetInputSurface();
res = detailEnh->Start();
res = detailEnhVideo->SetParameter(param, VIDEO);
auto ret = detailEnhVideo->GetInputSurface();
res = detailEnhVideo->Start();
EXPECT_NE(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_17, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto res = detailEnh->Stop();
auto detailEnhVideo = DetailEnhancerVideo::Create();
auto res = detailEnhVideo->Stop();
EXPECT_NE(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_18, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface1 = detailEnh->GetInputSurface();
res = detailEnh->SetOutputSurface(surface1);
res = detailEnh->Start();
res = detailEnh->NotifyEos();
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface1 = detailEnhVideo->GetInputSurface();
res = detailEnhVideo->SetOutputSurface(surface1);
res = detailEnhVideo->Start();
res = detailEnhVideo->NotifyEos();
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_19, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface1 = detailEnh->GetInputSurface();
res = detailEnh->SetOutputSurface(surface1);
res = detailEnh->Start();
res = detailEnh->ReleaseOutputBuffer(100, true); // 100 index
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface1 = detailEnhVideo->GetInputSurface();
res = detailEnhVideo->SetOutputSurface(surface1);
res = detailEnhVideo->Start();
res = detailEnhVideo->ReleaseOutputBuffer(100, true); // 100 index
EXPECT_NE(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_20, TestSize.Level1)
{
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface1 = detailEnh->GetInputSurface();
res = detailEnh->SetOutputSurface(surface1);
res = detailEnh->Start();
res = detailEnh->ReleaseOutputBuffer(100, false); // 100 index
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface1 = detailEnhVideo->GetInputSurface();
res = detailEnhVideo->SetOutputSurface(surface1);
res = detailEnhVideo->Start();
res = detailEnhVideo->ReleaseOutputBuffer(100, false); // 100 index
EXPECT_NE(res, VPE_ALGO_ERR_OK);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_21, TestSize.Level1)
{
OHNativeWindowBuffer *ohNativeWindowBuffer;
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface = detailEnh->GetInputSurface();
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface = detailEnhVideo->GetInputSurface();
auto detailEnh2 = DetailEnhancerVideo::Create();
auto surface2 = detailEnh2->GetInputSurface();
res = detailEnh->SetOutputSurface(surface2);
res = detailEnh->Start();
res = detailEnhVideo->SetOutputSurface(surface2);
res = detailEnhVideo->Start();
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
int fenceFd = -1;
@@ -383,25 +403,26 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_21, TestSize.Level1)
ret = FlushSurf(ohNativeWindowBuffer);
ASSERT_EQ(ret, VPE_ALGO_ERR_OK);
OH_NativeWindow_DestroyNativeWindow(nativeWindow);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_22, TestSize.Level1)
{
OHNativeWindowBuffer *ohNativeWindowBuffer;
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface = detailEnh->GetInputSurface();
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface = detailEnhVideo->GetInputSurface();
auto detailEnh2 = DetailEnhancerVideo::Create();
auto surface2 = detailEnh2->GetInputSurface();
surface2->SetRequestWidthAndHeight(10, 10);
res = detailEnh->SetOutputSurface(surface2);
res = detailEnh->Start();
res = detailEnhVideo->SetOutputSurface(surface2);
res = detailEnhVideo->Start();
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
int fenceFd = -1;
@@ -415,25 +436,26 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_22, TestSize.Level1)
ret = FlushSurf(ohNativeWindowBuffer);
ASSERT_EQ(ret, VPE_ALGO_ERR_OK);
OH_NativeWindow_DestroyNativeWindow(nativeWindow);
detailEnhVideo->Release();
}
HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_23, TestSize.Level1)
{
OHNativeWindowBuffer *ohNativeWindowBuffer;
auto detailEnh = DetailEnhancerVideo::Create();
auto detailEnhVideo = DetailEnhancerVideo::Create();
std::shared_ptr<DetailEnhancerVideoCallback> cb = std::make_shared<DetailEnhancerVideoCallbackImpl>();
auto res = detailEnh->RegisterCallback(cb);
auto res = detailEnhVideo->RegisterCallback(cb);
DetailEnhancerParameters param {
.uri = "",
.level = DETAIL_ENH_LEVEL_HIGH,
};
res = detailEnh->SetParameter(param, VIDEO);
auto surface = detailEnh->GetInputSurface();
res = detailEnhVideo->SetParameter(param, VIDEO);
auto surface = detailEnhVideo->GetInputSurface();
auto detailEnh2 = DetailEnhancerVideo::Create();
auto surface2 = detailEnh2->GetInputSurface();
surface2->SetRequestWidthAndHeight(10, 0);
res = detailEnh->SetOutputSurface(surface2);
res = detailEnh->Start();
res = detailEnhVideo->SetOutputSurface(surface2);
res = detailEnhVideo->Start();
EXPECT_EQ(res, VPE_ALGO_ERR_OK);
int fenceFd = -1;
@@ -447,6 +469,7 @@ HWTEST_F(DetailEnhancerVideoUnitTest, detailenhancer_23, TestSize.Level1)
ret = FlushSurf(ohNativeWindowBuffer);
ASSERT_EQ(ret, VPE_ALGO_ERR_OK);
OH_NativeWindow_DestroyNativeWindow(nativeWindow);
detailEnhVideo->Release();
}
} // namespace VideoProcessingEngine
test/unittest/metadata_gen_video_ndk/BUILD.gn
+1 -10
View File
@@ -38,16 +38,6 @@ ohos_unittest("metadata_gen_video_ndk_unit_test") {
"$ALGORITHM_DIR/colorspace_converter_video/include",
"$VIDEO_PROCESSING_ENGINE_ROOT_DIR/services/include",
"$TEST_UTILS_PATH/ColorSpaceConverter/sample/video",
"//foundation/multimedia/media_foundation/interface/kits/c/",
"//foundation/multimedia/media_foundation/video_processing_engine/interface/kits/c/",
"//foundation/multimedia/media_foundation/video_processing_engine/",
"//foundation/multimedia/media_foundation/video_processing_engine/framework/dfx/include/",
"//foundation/multimedia/media_foundation/video_processing_engine/framework/capi/video_processing/include/",
"//foundation/multimedia/media_foundation/video_processing_engine/interface/inner_api/",
"//foundation/multimedia/video_processing_engine/interfaces/inner_api/",
"//foundation/multimedia/video_processing_engine/framework/algorithm/colorspace_converter_video/include/",
"//foundation/graphic/graphic_2d/interfaces/inner_api/",
"//foundation/graphic/graphic_2d_ext/ohcore/graphic_compat_layer/include/utils/",
]
sources = [ "metadata_gen_video_ndk_unit_test.cpp" ]
@@ -66,6 +56,7 @@ ohos_unittest("metadata_gen_video_ndk_unit_test") {
"graphic_2d:librender_service_client",
"hilog:libhilog",
"hitrace:hitrace_meter",
"media_foundation:media_foundation",
"media_foundation:native_media_core",
"media_foundation:video_processing",
"ipc:ipc_core",
test/unittest/vpe_framework/BUILD.gn
-1
View File
@@ -36,7 +36,6 @@ ohos_unittest("vpe_framework_unit_test") {
"$METADATA_GENERATOR_DIR/include",
"$PLUGIN_DIR/include",
"$INTERFACES_INNER_API_DIR",
"$SKIA_DIR",
]
sources = [