From 5a08cceee50ff8ced24269f1f3decff5d86d156c Mon Sep 17 00:00:00 2001 From: liushang Date: Wed, 5 Mar 2025 09:20:18 +0800 Subject: [PATCH] fix ut and update algorithm video Signed-off-by: liushang --- framework/BUILD.gn | 17 +- .../aihdr_enhancer_video_impl.cpp | 2 + .../colorspace_converter_video_impl.cpp | 2 + .../algorithm/common/algorithm_video_impl.cpp | 360 +++++++++++------- .../common/include/algorithm_video_impl.h | 42 +- .../detail_enhancer_video_impl.cpp | 5 + .../include/detail_enhancer_video_impl.h | 1 + .../metadata_generator_video_impl.cpp | 2 + .../colorspace_converter_video/BUILD.gn | 1 - .../metadata_generator_video/BUILD.gn | 3 +- test/nativedemo/vpe_demo/BUILD.gn | 2 +- .../colorSpace_converter_video_ndk/BUILD.gn | 14 +- .../detail_enhancer_video_unit_test.cpp | 141 ++++--- test/unittest/metadata_gen_video_ndk/BUILD.gn | 11 +- test/unittest/vpe_framework/BUILD.gn | 1 - 15 files changed, 369 insertions(+), 235 deletions(-) diff --git a/framework/BUILD.gn b/framework/BUILD.gn index 4641a9b..5b6b5b7 100644 --- a/framework/BUILD.gn +++ b/framework/BUILD.gn @@ -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", diff --git a/framework/algorithm/aihdr_enhancer_video/aihdr_enhancer_video_impl.cpp b/framework/algorithm/aihdr_enhancer_video/aihdr_enhancer_video_impl.cpp index 1f8c895..1c7cbd2 100644 --- a/framework/algorithm/aihdr_enhancer_video/aihdr_enhancer_video_impl.cpp +++ b/framework/algorithm/aihdr_enhancer_video/aihdr_enhancer_video_impl.cpp @@ -249,6 +249,8 @@ int32_t AihdrEnhancerVideoImpl::Prepare() void AihdrEnhancerVideoImpl::InitBuffers() { + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr"); flushCfg_.damage.x = 0; flushCfg_.damage.y = 0; flushCfg_.damage.w = requestCfg_.width; diff --git a/framework/algorithm/colorspace_converter_video/colorspace_converter_video_impl.cpp b/framework/algorithm/colorspace_converter_video/colorspace_converter_video_impl.cpp index c0066ef..9bf3555 100644 --- a/framework/algorithm/colorspace_converter_video/colorspace_converter_video_impl.cpp +++ b/framework/algorithm/colorspace_converter_video/colorspace_converter_video_impl.cpp @@ -414,6 +414,8 @@ void GetFormatFromSurfaceBuffer(Format &outputFormat, sptr &buffe void ColorSpaceConverterVideoImpl::InitBuffers() { + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr"); flushCfg_.damage.x = 0; flushCfg_.damage.y = 0; flushCfg_.damage.w = requestCfg_.width; diff --git a/framework/algorithm/common/algorithm_video_impl.cpp b/framework/algorithm/common/algorithm_video_impl.cpp index 86179de..af624af 100644 --- a/framework/algorithm/common/algorithm_video_impl.cpp +++ b/framework/algorithm/common/algorithm_video_impl.cpp @@ -74,34 +74,72 @@ VPEAlgoErrCode VpeVideoImpl::SetOutputSurface(const sptr& surface) "Invalid input: surface is invalid!"); std::lock_guard lock(lock_); - if (producer_ == surface) { - VPE_LOGD("Oops! The same surface!"); - return VPE_ALGO_ERR_OK; - } + std::lock_guard 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&) { 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 VpeVideoImpl::GetInputSurface() { sptr 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 lock(lock_); - cvDone_.wait(lock, [this]() { return !isProcessing_.load(); }); - std::queue tempQueue1; - std::queue tempQueue2; + VPE_LOGD("step in"); + std::lock_guard lock(lock_); { - std::lock_guard bufferLock(bufferLock_); - consumerBufferQueue_.swap(tempQueue1); - while (!renderBufferQueue_.empty()) { - producerBufferQueue_.push(renderBufferQueue_.front()); - renderBufferQueue_.pop(); + std::unique_lock lockTask(taskLock_); + cvDone_.wait(lockTask, [this]() { return !isProcessing_.load(); }); + } + + if (isEnable_.load()) { + std::queue tempQueue1; + std::queue tempQueue2; + { + std::lock_guard bufferLock(bufferLock_); + std::lock_guard consumerBufferLock(consumerBufferLock_); + consumerBufferQueue_.swap(tempQueue1); + for (auto& [index, bufferInfo] : renderBufferQueue_) { + producerBufferQueue_.push(bufferInfo); + } + renderBufferQueue_.clear(); + attachBufferQueue_.swap(tempQueue2); + attachBufferIDs_.clear(); } - attachBufferQueue_.swap(tempQueue2); - attachBufferIDs_.clear(); + ClearConsumerLocked(tempQueue1); + ClearConsumerLocked(tempQueue2); + } else { + producer_->CleanCache(false); + ClearBufferQueues(); } - ClearConsumerLocked(tempQueue1); - ClearConsumerLocked(tempQueue2); + VPE_LOGD("step out"); return VPE_ALGO_ERR_OK; } @@ -203,7 +252,7 @@ VPEAlgoErrCode VpeVideoImpl::NotifyEos() return ExecuteWhenNotIdle( [this]() { { - std::lock_guard buffferlock(bufferLock_); + std::lock_guard 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 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 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 lock(lock_); VPE_LOGD("Start to deinitializing... this:%{public}p", this); - cvDone_.wait(lock, [this]() { return !isProcessing_.load(); }); + std::lock_guard lock(lock_); if (!isInitialized_.load()) { VPE_LOGD("Already deinitialize!"); return VPE_ALGO_ERR_OK; } + { + std::unique_lock 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 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& { } -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 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 buffferlock(bufferLock_); - if (!isBufferQueueReady_) { + std::lock_guard 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 lock(lock_); - CHECK_AND_RETURN_RET_LOG(consumer_ != nullptr || producer_ != nullptr, GSERROR_OK, - "Input or output surface is null!"); + std::lock_guard producerLock(producerLock_); + CHECK_AND_RETURN_RET_LOG(producer_ != nullptr, GSERROR_OK, "Output surface is null!"); { std::lock_guard 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& 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 bufferLock(bufferLock_); - SurfaceBufferInfo bufferInfo{}; - bool isFound = PopBuffer(renderBufferQueue_, index, bufferInfo, [](sptr&) {}); + 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 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 VpeVideoImpl::CreateConsumerSurfaceLocked() sptr 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 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& producer) +void VpeVideoImpl::AttachAndRefreshProducerBuffers(const sptr& producer) { std::lock_guard bufferLock(bufferLock_); std::queue tempQueue; producerBufferQueue_.swap(tempQueue); AttachBuffers(producer, tempQueue); - AttachBuffers(producer, flushBufferQueue_); + RefreshProducerBuffers(flushBufferQueue_, [](SurfaceBufferInfo&) { return true; }); } void VpeVideoImpl::AttachBuffers(const sptr& producer, std::queue& 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& bufferQueue, + std::function&& refresher) { for (; !bufferQueue.empty(); bufferQueue.pop()) { auto bufferInfo = bufferQueue.front(); @@ -593,10 +647,7 @@ void VpeVideoImpl::AttachBuffers(const sptr& producer, std::queueAttachBufferToQueue(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& producer, std::queue consumer; { std::lock_guard 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 taskLock(taskLock_); + isProcessing_ = true; + SurfaceBufferInfo srcBufferInfo; SurfaceBufferInfo dstBufferInfo; { + std::lock_guard consumerBufferLock(consumerBufferLock_); std::lock_guard 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 lock(lock_); - isProcessing_ = false; - } + PrintBufferSize(); + + isProcessing_ = false; cvDone_.notify_all(); } -bool VpeVideoImpl::ProcessBuffer(sptr& 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 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 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&& getReadyToRender) + std::function&& getReadyToRender) { { std::lock_guard 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 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& 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& bufferQueue, uint32_ return isFound; } +void VpeVideoImpl::PrintBufferSize() const +{ + std::lock_guard consumerBufferLock(consumerBufferLock_); + std::lock_guard 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& buffer) { requestCfg_.usage = buffer->GetUsage(); @@ -746,6 +807,42 @@ void VpeVideoImpl::SetRequestCfgLocked(const sptr& buffer) orgRequestCfg_ = requestCfg_; } +bool VpeVideoImpl::WaitTrigger() +{ + uint32_t consumerSize = 0; + uint32_t producerSize = 0; + std::unique_lock bufferLock(bufferLock_); + if (!cvTrigger_.wait_for(bufferLock, 200s, [this, &consumerSize, &producerSize] { + std::lock_guard 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& 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 tempQueue1; std::queue tempQueue2; { + std::lock_guard consumerBufferLock(consumerBufferLock_); std::lock_guard bufferLock(bufferLock_); isBufferQueueReady_ = false; consumerBufferQueue_.swap(tempQueue1); ClearQueue(producerBufferQueue_); - ClearQueue(renderBufferQueue_); + renderBufferQueue_.clear(); + ClearQueue(flushBufferQueue_); attachBufferQueue_.swap(tempQueue2); attachBufferIDs_.clear(); } diff --git a/framework/algorithm/common/include/algorithm_video_impl.h b/framework/algorithm/common/include/algorithm_video_impl.h index fccfa1b..a5a8a8a 100644 --- a/framework/algorithm/common/include/algorithm_video_impl.h +++ b/framework/algorithm/common/include/algorithm_video_impl.h @@ -26,6 +26,7 @@ #include #include #include +#include #include "refbase.h" #include "surface.h" @@ -100,7 +101,7 @@ private: std::weak_ptr 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 CreateConsumerSurfaceLocked(); bool RequestBuffer(SurfaceBufferInfo& bufferInfo, GSError& errorCode); void PrepareBuffers(); - void AttachBuffers(const sptr& producer); + void AttachAndRefreshProducerBuffers(const sptr& producer); void AttachBuffers(const sptr& producer, std::queue& bufferQueue); + void RefreshProducerBuffers(std::queue& bufferQueue, + std::function&& refresher); void ProcessBuffers(); - bool ProcessBuffer(sptr& 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&& getReadyToRender); + void NotifyEnableStatus(uint32_t type, const std::string& status); bool PopBuffer(std::queue& bufferQueue, uint32_t index, SurfaceBufferInfo& bufferInfo, std::function&)>&& func); + void PrintBufferSize() const; void SetRequestCfgLocked(const sptr& buffer); + bool WaitTrigger(); void CheckSpuriousWakeup(); bool CheckStopping(); bool CheckStoppingLocked(); @@ -146,24 +153,39 @@ private: // Guarded by lock_ begin std::atomic isInitialized_{false}; std::atomic isRunning_{false}; - std::atomic isProcessing_{false}; std::atomic isEnable_{true}; std::atomic isEnableChange_{true}; + std::atomic hasConsumer_{false}; std::atomic state_{VPEState::IDLE}; + uint32_t lastConsumerBufferId_{}; + GraphicTransformType lastTransform_{}; + ScalingMode lastScalingMode_{}; + bool isForceUpdateProducer_{true}; std::thread worker_{}; std::shared_ptr cb_{}; sptr consumer_{}; - sptr producer_{}; + sptr 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 isProcessing_{false}; + // Guarded by taskLock_ end + + mutable std::mutex consumerBufferLock_{}; + // Guarded by consumerBufferLock_ begin + std::atomic isBufferQueueReady_{false}; + std::atomic needPrepareBuffers_{false}; + std::queue consumerBufferQueue_{}; + // Guarded by consumerBufferLock_ end mutable std::mutex bufferLock_{}; // Guarded by bufferLock_ begin - bool isBufferQueueReady_{}; - std::queue consumerBufferQueue_{}; std::queue producerBufferQueue_{}; - std::queue renderBufferQueue_{}; + std::unordered_map renderBufferQueue_{}; std::queue flushBufferQueue_{}; std::queue attachBufferQueue_{}; std::set attachBufferIDs_{}; diff --git a/framework/algorithm/detail_enhancer_video/detail_enhancer_video_impl.cpp b/framework/algorithm/detail_enhancer_video/detail_enhancer_video_impl.cpp index b6978b4..e183e46 100644 --- a/framework/algorithm/detail_enhancer_video/detail_enhancer_video_impl.cpp +++ b/framework/algorithm/detail_enhancer_video/detail_enhancer_video_impl.cpp @@ -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; diff --git a/framework/algorithm/detail_enhancer_video/include/detail_enhancer_video_impl.h b/framework/algorithm/detail_enhancer_video/include/detail_enhancer_video_impl.h index 56c549c..19ac60c 100644 --- a/framework/algorithm/detail_enhancer_video/include/detail_enhancer_video_impl.h +++ b/framework/algorithm/detail_enhancer_video/include/detail_enhancer_video_impl.h @@ -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; diff --git a/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp b/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp index 848072e..b9fe40b 100644 --- a/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp +++ b/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp @@ -259,6 +259,8 @@ int32_t MetadataGeneratorVideoImpl::Prepare() void MetadataGeneratorVideoImpl::InitBuffers() { + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(outputSurface_ != nullptr, "outputSurface_ is nullptr"); flushCfg_.damage.x = 0; flushCfg_.damage.y = 0; flushCfg_.damage.w = requestCfg_.width; diff --git a/test/moduletest/colorspace_converter_video/BUILD.gn b/test/moduletest/colorspace_converter_video/BUILD.gn index 2d8a2b1..3ad7289 100644 --- a/test/moduletest/colorspace_converter_video/BUILD.gn +++ b/test/moduletest/colorspace_converter_video/BUILD.gn @@ -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", ] diff --git a/test/moduletest/metadata_generator_video/BUILD.gn b/test/moduletest/metadata_generator_video/BUILD.gn index 1e0b7e3..49a220e 100644 --- a/test/moduletest/metadata_generator_video/BUILD.gn +++ b/test/moduletest/metadata_generator_video/BUILD.gn @@ -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" } \ No newline at end of file diff --git a/test/nativedemo/vpe_demo/BUILD.gn b/test/nativedemo/vpe_demo/BUILD.gn index 394d6db..bd9c222 100644 --- a/test/nativedemo/vpe_demo/BUILD.gn +++ b/test/nativedemo/vpe_demo/BUILD.gn @@ -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", ] diff --git a/test/unittest/colorSpace_converter_video_ndk/BUILD.gn b/test/unittest/colorSpace_converter_video_ndk/BUILD.gn index 142740b..36a20ad 100644 --- a/test/unittest/colorSpace_converter_video_ndk/BUILD.gn +++ b/test/unittest/colorSpace_converter_video_ndk/BUILD.gn @@ -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", diff --git a/test/unittest/detail_enhancer_video/detail_enhancer_video_unit_test.cpp b/test/unittest/detail_enhancer_video/detail_enhancer_video_unit_test.cpp index 7deb3a0..2c332f8 100644 --- a/test/unittest/detail_enhancer_video/detail_enhancer_video_unit_test.cpp +++ b/test/unittest/detail_enhancer_video/detail_enhancer_video_unit_test.cpp @@ -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 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 = 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 cb = std::make_shared(); - 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 diff --git a/test/unittest/metadata_gen_video_ndk/BUILD.gn b/test/unittest/metadata_gen_video_ndk/BUILD.gn index 17069ac..ff36419 100644 --- a/test/unittest/metadata_gen_video_ndk/BUILD.gn +++ b/test/unittest/metadata_gen_video_ndk/BUILD.gn @@ -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", diff --git a/test/unittest/vpe_framework/BUILD.gn b/test/unittest/vpe_framework/BUILD.gn index aa71a82..3136491 100644 --- a/test/unittest/vpe_framework/BUILD.gn +++ b/test/unittest/vpe_framework/BUILD.gn @@ -36,7 +36,6 @@ ohos_unittest("vpe_framework_unit_test") { "$METADATA_GENERATOR_DIR/include", "$PLUGIN_DIR/include", "$INTERFACES_INNER_API_DIR", - "$SKIA_DIR", ] sources = [ -- Gitee