From 03de6950767b690e500ce5ada8004a5ed2393a21 Mon Sep 17 00:00:00 2001 From: zhaona45 Date: Fri, 12 Sep 2025 16:21:37 +0800 Subject: [PATCH] Add the eac3 decoder Issue: https://gitee.com/openharmony/multimedia_av_codec/issues/ICXKPB Signed-off-by: zhaona45 --- bundle.json | 1 + config.gni | 4 + .../native/avcodeclist/avcodeclist_impl.cpp | 1 + .../capi/avcodec/native_avcodec_base.cpp | 3 + .../inner_api/native/avcodec_codec_name.h | 4 + interfaces/inner_api/native/avcodec_info.h | 1 + .../inner_api/native/avcodec_mime_type.h | 4 + interfaces/kits/c/native_avcodec_base.h | 10 + .../engine/codeclist/audio_codeclist_info.cpp | 26 + .../engine/codeclist/audio_codeclist_info.h | 3 + services/media_engine/plugins/BUILD.gn | 4 + .../audio_decoder/eac3/BUILD.gn | 80 ++ .../eac3/ffmpeg_eac3_decoder_plugin.cpp | 214 +++++ .../eac3/ffmpeg_eac3_decoder_plugin.h | 83 ++ .../demuxer/ffmpeg_format_helper.cpp | 3 + test/BUILD.gn | 4 + test/unittest/audio_test/BUILD.gn | 111 +++ .../audio_eac3_decoder_capi_unit_test.cpp | 844 ++++++++++++++++++ .../audio_eac3_decoder_unit_test.cpp | 357 ++++++++ .../resources/audio_res/eac3_test.eac3 | Bin 0 -> 120372 bytes 20 files changed, 1757 insertions(+) create mode 100644 services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/BUILD.gn create mode 100644 services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.cpp create mode 100644 services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.h create mode 100644 test/unittest/audio_test/audio_eac3_decoder_capi_unit_test.cpp create mode 100644 test/unittest/audio_test/audio_eac3_decoder_unit_test.cpp create mode 100755 test/unittest/resources/audio_res/eac3_test.eac3 diff --git a/bundle.json b/bundle.json index b88693d7a..ba6847785 100644 --- a/bundle.json +++ b/bundle.json @@ -42,6 +42,7 @@ "av_codec_enable_codec_rm", "av_codec_enable_codec_rv", "av_codec_enable_codec_cook", + "av_codec_enable_codec_eac3", "av_codec_enable_demuxer_lrc", "av_codec_enable_demuxer_sami", "av_codec_enable_demuxer_ass" diff --git a/config.gni b/config.gni index 75c3f26f4..eaa922152 100644 --- a/config.gni +++ b/config.gni @@ -41,6 +41,7 @@ declare_args() { av_codec_enable_codec_rm = false av_codec_enable_codec_rv = false av_codec_enable_codec_cook = false + av_codec_enable_codec_eac3 = false av_codec_enable_demuxer_lrc = false av_codec_enable_demuxer_sami = false av_codec_enable_demuxer_ass = false @@ -158,6 +159,9 @@ if (av_codec_enable_codec_rv) { if (av_codec_enable_codec_cook) { av_codec_defines += [ "SUPPORT_CODEC_COOK" ] } +if (av_codec_enable_codec_eac3) { + av_codec_defines += [ "SUPPORT_CODEC_EAC3" ] +} if (av_codec_enable_demuxer_lrc) { av_codec_defines += [ "SUPPORT_DEMUXER_LRC" ] diff --git a/frameworks/native/avcodeclist/avcodeclist_impl.cpp b/frameworks/native/avcodeclist/avcodeclist_impl.cpp index dd13461b7..de04787c9 100644 --- a/frameworks/native/avcodeclist/avcodeclist_impl.cpp +++ b/frameworks/native/avcodeclist/avcodeclist_impl.cpp @@ -44,6 +44,7 @@ const std::vector AUDIO_MIME_VEC = { std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_G711A), std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_COOK), std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_AC3), + std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_EAC3), std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_AVS3DA), std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_LBVC), std::string(OHOS::MediaAVCodec::CodecMimeType::AUDIO_APE), diff --git a/frameworks/native/capi/avcodec/native_avcodec_base.cpp b/frameworks/native/capi/avcodec/native_avcodec_base.cpp index c23095dff..20f60e9d5 100644 --- a/frameworks/native/capi/avcodec/native_avcodec_base.cpp +++ b/frameworks/native/capi/avcodec/native_avcodec_base.cpp @@ -44,6 +44,9 @@ const char *OH_AVCODEC_MIMETYPE_AUDIO_LBVC = "audio/lbvc"; const char *OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT = "text/vtt"; const char *OH_AVCODEC_MIMETYPE_AUDIO_RAW = "audio/raw"; const char *OH_AVCODEC_MIMETYPE_AUDIO_G711A = "audio/g711a"; +#ifdef SUPPORT_CODEC_EAC3 +const char *OH_AVCODEC_MIMETYPE_AUDIO_EAC3 = "audio/eac3"; +#endif const char *OH_ED_KEY_TIME_STAMP = "timeStamp"; const char *OH_ED_KEY_EOS = "endOfStream"; diff --git a/interfaces/inner_api/native/avcodec_codec_name.h b/interfaces/inner_api/native/avcodec_codec_name.h index 0ec9033ca..ea2c0a97c 100644 --- a/interfaces/inner_api/native/avcodec_codec_name.h +++ b/interfaces/inner_api/native/avcodec_codec_name.h @@ -39,6 +39,7 @@ public: static constexpr std::string_view AUDIO_DECODER_LBVC_NAME = "OH.Media.Codec.Decoder.Audio.LBVC"; static constexpr std::string_view AUDIO_DECODER_COOK_NAME = "OH.Media.Codec.Decoder.Audio.COOK"; static constexpr std::string_view AUDIO_DECODER_AC3_NAME = "OH.Media.Codec.Decoder.Audio.AC3"; + static constexpr std::string_view AUDIO_DECODER_EAC3_NAME = "OH.Media.Codec.Decoder.Audio.EAC3"; static constexpr std::string_view AUDIO_DECODER_RAW_NAME = "OH.Media.Codec.Decoder.Audio.Raw"; static constexpr std::string_view AUDIO_ENCODER_FLAC_NAME = "OH.Media.Codec.Encoder.Audio.Flac"; @@ -80,6 +81,9 @@ public: AUDIO_DECODER_G711A_NAME, AUDIO_DECODER_APE_NAME, AUDIO_DECODER_RAW_NAME, +#ifdef SUPPORT_CODEC_EAC3 + AUDIO_DECODER_EAC3_NAME, +#endif #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY AUDIO_ENCODER_VENDOR_AAC_NAME, AUDIO_DECODER_OPUS_NAME, diff --git a/interfaces/inner_api/native/avcodec_info.h b/interfaces/inner_api/native/avcodec_info.h index 174fed775..d7869722c 100644 --- a/interfaces/inner_api/native/avcodec_info.h +++ b/interfaces/inner_api/native/avcodec_info.h @@ -632,6 +632,7 @@ public: static constexpr std::string_view AUDIO_G711A = "audio/g711a"; static constexpr std::string_view AUDIO_COOK = "audio/cook"; static constexpr std::string_view AUDIO_AC3 = "audio/ac3"; + static constexpr std::string_view AUDIO_EAC3 = "audio/eac3"; static constexpr std::string_view AUDIO_VIVID = "audio/av3a"; static constexpr std::string_view AUDIO_AVS3DA = "audio/av3a"; static constexpr std::string_view AUDIO_APE = "audio/x-ape"; diff --git a/interfaces/inner_api/native/avcodec_mime_type.h b/interfaces/inner_api/native/avcodec_mime_type.h index b61860ce9..3e665a75a 100644 --- a/interfaces/inner_api/native/avcodec_mime_type.h +++ b/interfaces/inner_api/native/avcodec_mime_type.h @@ -43,6 +43,7 @@ public: static constexpr std::string_view MEDIA_MIMETYPE_AUDIO_LBVC = "audio/lbvc"; static constexpr std::string_view MEDIA_MIMETYPE_AUDIO_COOK = "audio/cook"; static constexpr std::string_view MEDIA_MIMETYPE_AUDIO_AC3 = "audio/ac3"; + static constexpr std::string_view MEDIA_MIMETYPE_AUDIO_EAC3 = "audio/eac3"; static constexpr std::string_view MEDIA_MIMETYPE_AUDIO_RAW = "audio/raw"; static constexpr std::string_view MEDIA_MIMETYPE_VIDEO_AVC = "video/avc"; @@ -81,6 +82,9 @@ public: MEDIA_MIMETYPE_AUDIO_AMRNB, MEDIA_MIMETYPE_AUDIO_AMRWB, MEDIA_MIMETYPE_AUDIO_APE, +#ifdef SUPPORT_CODEC_EAC3 + MEDIA_MIMETYPE_AUDIO_EAC3, +#endif #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY MEDIA_MIMETYPE_AUDIO_OPUS, MEDIA_MIMETYPE_AUDIO_VIVID diff --git a/interfaces/kits/c/native_avcodec_base.h b/interfaces/kits/c/native_avcodec_base.h index 5bddb81df..fbcd67cae 100644 --- a/interfaces/kits/c/native_avcodec_base.h +++ b/interfaces/kits/c/native_avcodec_base.h @@ -369,6 +369,16 @@ extern const char *OH_AVCODEC_MIMETYPE_AUDIO_RAW; */ extern const char *OH_AVCODEC_MIMETYPE_AUDIO_G711A; +/** + * @brief Enumerates the mime types of audio EAC3 codec. + * + * @syscap SystemCapability.Multimedia.Media.CodecBase + * @since 20 + */ +#ifdef SUPPORT_CODEC_EAC3 +extern const char *OH_AVCODEC_MIMETYPE_AUDIO_EAC3; +#endif + /** * @brief Key for timeStamp in surfacebuffer, value type is int64_t. * @syscap SystemCapability.Multimedia.Media.CodecBase diff --git a/services/engine/codeclist/audio_codeclist_info.cpp b/services/engine/codeclist/audio_codeclist_info.cpp index e5ea4f1ae..72c5d8dc9 100644 --- a/services/engine/codeclist/audio_codeclist_info.cpp +++ b/services/engine/codeclist/audio_codeclist_info.cpp @@ -105,6 +105,12 @@ const std::vector AUDIO_OPUS_SAMPLE_RATE = {8000, 12000, 16000, 24000, constexpr int MAX_BIT_RATE_COOK = 510000; const std::vector AUDIO_COOK_SAMPLE_RATE = {8000, 11025, 22050, 44100}; #endif +#ifdef SUPPORT_CODEC_EAC3 +constexpr int MIN_BIT_RATE_EAC3 = 32000; +constexpr int MAX_BIT_RATE_EAC3 = 640000; +constexpr int EAC3_MAX_AUDIO_CHANNEL_COUNT = 16; +const std::vector AUDIO_EAC3_SAMPLE_RATE = {16000, 22050, 24000, 32000, 44100, 48000}; +#endif constexpr int MIN_BIT_RATE_AC3 = 32000; constexpr int MAX_BIT_RATE_AC3 = 640000; const std::vector AUDIO_AC3_SAMPLE_RATE = {32000, 44100, 48000}; @@ -557,6 +563,23 @@ CapabilityData AudioCodeclistInfo::GetAc3DecoderCapability() return audioAc3Capability; } +#ifdef SUPPORT_CODEC_EAC3 +CapabilityData AudioCodeclistInfo::GetEac3DecoderCapability() +{ + CapabilityData audioEac3Capability; + audioEac3Capability.codecName = AVCodecCodecName::AUDIO_DECODER_EAC3_NAME; + audioEac3Capability.codecType = AVCODEC_TYPE_AUDIO_DECODER; + audioEac3Capability.mimeType = AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_EAC3; + audioEac3Capability.isVendor = false; + audioEac3Capability.bitrate = Range(MIN_BIT_RATE_EAC3, MAX_BIT_RATE_EAC3); + audioEac3Capability.channels = Range(1, EAC3_MAX_AUDIO_CHANNEL_COUNT); + audioEac3Capability.sampleRate = AUDIO_EAC3_SAMPLE_RATE; + audioEac3Capability.sampleRateRanges = convertVectorToRange(AUDIO_EAC3_SAMPLE_RATE); + audioEac3Capability.maxInstance = MAX_SUPPORT_AUDIO_INSTANCE; + return audioEac3Capability; +} +#endif + AudioCodeclistInfo::AudioCodeclistInfo() { audioCapabilities_ = { @@ -568,6 +591,9 @@ AudioCodeclistInfo::AudioCodeclistInfo() GetG711muDecoderCapability(), GetRawDecoderCapability(), GetAacEncoderCapability(), GetFlacEncoderCapability(), GetG711muEncoderCapability(), GetAPEDecoderCapability(), GetMP3EncoderCapability(), GetG711aDecoderCapability(), +#ifdef SUPPORT_CODEC_EAC3 + GetEac3DecoderCapability(), +#endif #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY GetVividDecoderCapability(), GetAmrnbEncoderCapability(), GetAmrwbEncoderCapability(), GetLbvcDecoderCapability(), GetLbvcEncoderCapability(), GetL2hcEncoderCapability(), diff --git a/services/engine/codeclist/audio_codeclist_info.h b/services/engine/codeclist/audio_codeclist_info.h index 7867e27c4..3ef625536 100644 --- a/services/engine/codeclist/audio_codeclist_info.h +++ b/services/engine/codeclist/audio_codeclist_info.h @@ -42,6 +42,9 @@ public: CapabilityData GetLbvcEncoderCapability(); CapabilityData GetVendorAacEncoderCapability(); CapabilityData GetAc3DecoderCapability(); +#ifdef SUPPORT_CODEC_EAC3 + CapabilityData GetEac3DecoderCapability(); +#endif #ifdef AV_CODEC_AUDIO_VIVID_CAPACITY CapabilityData GetVividDecoderCapability(); CapabilityData GetAmrnbEncoderCapability(); diff --git a/services/media_engine/plugins/BUILD.gn b/services/media_engine/plugins/BUILD.gn index 4f4dd7008..56b46093e 100644 --- a/services/media_engine/plugins/BUILD.gn +++ b/services/media_engine/plugins/BUILD.gn @@ -40,4 +40,8 @@ group("av_codec_media_engine_plugins") { deps += [ "ffmpeg_adapter/audio_decoder/cook:media_plugin_CookAudioDecoder" ] } + if (av_codec_enable_codec_eac3) { + deps += + [ "ffmpeg_adapter/audio_decoder/eac3:media_plugin_Eac3AudioDecoder" ] + } } diff --git a/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/BUILD.gn b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/BUILD.gn new file mode 100644 index 000000000..d8002df27 --- /dev/null +++ b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/BUILD.gn @@ -0,0 +1,80 @@ +# Copyright (C) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//foundation/multimedia/av_codec/config.gni") + +config("ffmpeg_adapter_config") { + defines = [ + "HST_ANY_WITH_NO_RTTI", + "MEDIA_OHOS", + ] + + cflags = [ + "-fno-exceptions", + "-Wall", + "-fno-common", + "-fstack-protector-all", + "-Wshadow", + "-FPIC", + "-FS", + "-O2", + "-D_FORTIFY_SOURCE=2", + "-Wformat=2", + "-Wdate-time", + ] + + cflags_cc = [ + "-std=c++17", + "-fno-rtti", + ] + + include_dirs = [ + "$av_codec_root_dir/interfaces", + "$av_codec_root_dir/interfaces/inner_api/native", + "$av_codec_root_dir/services/dfx/include", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/audio_decoder", + ] +} + +ohos_shared_library("media_plugin_Eac3AudioDecoder") { + stack_protector_ret = true + sanitize = av_codec_sanitize + install_enable = true + configs = [ + ":ffmpeg_adapter_config", + "$av_codec_root_dir/services/dfx:av_codec_service_log_dfx_public_config", + ] + + sources = [ + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/ffmpeg_base_decoder.cpp", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common/ffmpeg_convert.cpp", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common/ffmpeg_converter.cpp", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common/ffmpeg_utils.cpp", + "ffmpeg_eac3_decoder_plugin.cpp", + ] + + public_external_deps = [ "ffmpeg:libohosffmpeg" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "media_foundation:media_foundation", + ] + + relative_install_dir = "media/media_plugins" + subsystem_name = "multimedia" + part_name = "av_codec" +} diff --git a/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.cpp b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.cpp new file mode 100644 index 000000000..86793c831 --- /dev/null +++ b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.cpp @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ffmpeg_eac3_decoder_plugin.h" +#include +#include "avcodec_codec_name.h" +#include "avcodec_log.h" +#include "plugin/codec_plugin.h" +#include "plugin/plugin_definition.h" +#include "avcodec_mime_type.h" +#include "avcodec_audio_common.h" +namespace { +using namespace OHOS::Media; +using namespace OHOS::Media::Plugins; +using namespace Ffmpeg; + +constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AvCodec-FFmpegEAC3DecoderPlugin"}; +constexpr int32_t MIN_CHANNELS = 1; +constexpr int32_t MAX_CHANNELS = 16; +constexpr int32_t MAX_BYTES_PER_SAMPLE = 4; +constexpr int32_t SAMPLES = 1536; + +static const int32_t EAC3_DECODER_SAMPLE_RATE_TABLE[] = {16000, 22050, 24000, 32000, 44100, 48000}; + +Status RegisterAudioDecoderPlugins(const std::shared_ptr ®) +{ + CodecPluginDef definition; + definition.name = std::string(OHOS::MediaAVCodec::AVCodecCodecName::AUDIO_DECODER_EAC3_NAME); + definition.pluginType = PluginType::AUDIO_DECODER; + definition.rank = 100; + definition.SetCreator([](const std::string &name) -> std::shared_ptr { + return std::make_shared(name); + }); + Capability cap; + cap.SetMime(MimeType::AUDIO_EAC3); + cap.AppendFixedKey(Tag::MEDIA_CODEC_MODE, CodecMode::SOFTWARE); + definition.AddInCaps(cap); + if (reg->AddPlugin(definition) != Status::OK) { + AVCODEC_LOGE("AudioEAC3DecoderPlugin Register Failure"); + return Status::ERROR_UNKNOWN; + } + return Status::OK; +} + +void UnRegisterAudioDecoderPlugin(){} + +PLUGIN_DEFINITION(Eac3AudioDecoder, LicenseType::LGPL, RegisterAudioDecoderPlugins, UnRegisterAudioDecoderPlugin); +} // namespace + +namespace OHOS { +namespace Media { +namespace Plugins { +namespace Ffmpeg { +FFmpegEAC3DecoderPlugin::FFmpegEAC3DecoderPlugin(const std::string &name) + : CodecPlugin(name), channels(0), basePlugin(std::make_unique()) {} + +FFmpegEAC3DecoderPlugin::~FFmpegEAC3DecoderPlugin() +{ + basePlugin->Release(); + basePlugin.reset(); + basePlugin = nullptr; +} + +Status FFmpegEAC3DecoderPlugin::Init() +{ + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::Prepare() +{ + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::Reset() +{ + return basePlugin->Reset(); +} + +Status FFmpegEAC3DecoderPlugin::Start() +{ + AVCODEC_LOGW("EAC3pLug::Start"); + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::Stop() +{ + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::SetParameter(const std::shared_ptr ¶meter) +{ + Status ret = basePlugin->AllocateContext("eac3"); + Status checkresult = CheckFormat(parameter); + if (checkresult != Status::OK) { + return checkresult; + } + if (ret != Status::OK) { + AVCODEC_LOGE("AllocateContext failed, ret=%{public}d", ret); + return ret; + } + ret = basePlugin->InitContext(parameter); + if (ret != Status::OK) { + AVCODEC_LOGE("InitContext failed, ret=%{public}d", ret); + return ret; + } + ret = basePlugin->OpenContext(); + if (ret != Status::OK) { + AVCODEC_LOGE("OpenContext failed. ret=%{public}d", ret); + return ret; + } + auto format = basePlugin->GetFormat(); + format->SetData(Tag::AUDIO_MAX_INPUT_SIZE, GetInputBufferSize()); + format->SetData(Tag::AUDIO_MAX_OUTPUT_SIZE, GetOutputBufferSize()); + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::GetParameter(std::shared_ptr ¶meter) +{ + parameter = basePlugin->GetFormat(); + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::QueueInputBuffer(const std::shared_ptr &inputBuffer) +{ + return basePlugin->ProcessSendData(inputBuffer); +} + +Status FFmpegEAC3DecoderPlugin::QueueOutputBuffer(std::shared_ptr &outputBuffer) +{ + return basePlugin->ProcessReceiveData(outputBuffer); +} + +Status FFmpegEAC3DecoderPlugin::GetInputBuffers(std::vector> &inputBuffers) +{ + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::GetOutputBuffers(std::vector> &outputBuffers) +{ + return Status::OK; +} + +Status FFmpegEAC3DecoderPlugin::Flush() +{ + return basePlugin->Flush(); +} + +Status FFmpegEAC3DecoderPlugin::Release() +{ + return basePlugin->Release(); +} + +bool FFmpegEAC3DecoderPlugin::CheckSampleRate(int32_t sampleRate) const noexcept +{ + bool isExist = std::any_of(std::begin(EAC3_DECODER_SAMPLE_RATE_TABLE), std::end(EAC3_DECODER_SAMPLE_RATE_TABLE), + [sampleRate](int32_t value) { return value == sampleRate; }); + return isExist; +} + +Status FFmpegEAC3DecoderPlugin::CheckFormat(const std::shared_ptr &format) +{ + int32_t channelCount; + int32_t sampleRate; + format->GetData(Tag::AUDIO_CHANNEL_COUNT, channelCount); + format->GetData(Tag::AUDIO_SAMPLE_RATE, sampleRate); + if (!CheckSampleRate(sampleRate)) { + AVCODEC_LOGE("SampleRate=%{public}d not support.", sampleRate); + return Status::ERROR_INVALID_PARAMETER; + } else if (channelCount < MIN_CHANNELS){ + AVCODEC_LOGE("ChannelCount=%{public}d invalid, less than 0.", channelCount); + return Status::ERROR_INVALID_PARAMETER; + } else if (channelCount > MAX_CHANNELS){ + AVCODEC_LOGE("ChannelCount=%{public}d invalid, %{public}d at most.", channelCount, MAX_CHANNELS); + return Status::ERROR_INVALID_PARAMETER; + } + if (!basePlugin->CheckSampleFormat(format, channelCount)) { + AVCODEC_LOGE("CheckSampleFormat failed."); + return Status::ERROR_INVALID_PARAMETER; + } + channels = channelCount; + return Status::OK; +} + +int32_t FFmpegEAC3DecoderPlugin::GetInputBufferSize() +{ + int32_t inputBufferSize = SAMPLES * channels * MAX_BYTES_PER_SAMPLE; + int32_t maxSize = basePlugin->GetMaxInputSize(); + if (maxSize < 0 || maxSize > inputBufferSize) { + maxSize = inputBufferSize; + } + return maxSize; +} + +int32_t FFmpegEAC3DecoderPlugin::GetOutputBufferSize() +{ + int32_t outputBufferSize = SAMPLES * channels * MAX_BYTES_PER_SAMPLE; + return outputBufferSize; +} +} // namespace Ffmpeg +} // namespace Plugins +} // namespace Media +} // namespace OHOS diff --git a/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.h b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.h new file mode 100644 index 000000000..8ec42bf79 --- /dev/null +++ b/services/media_engine/plugins/ffmpeg_adapter/audio_decoder/eac3/ffmpeg_eac3_decoder_plugin.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FFMPEG_EAC3_DECODER_PLUGIN_H +#define FFMPEG_EAC3_DECODER_PLUGIN_H + +#include "ffmpeg_base_decoder.h" +#include "plugin/codec_plugin.h" +#include "plugin/plugin_definition.h" + +namespace OHOS { +namespace Media { +namespace Plugins { +namespace Ffmpeg { +class FFmpegEAC3DecoderPlugin : public CodecPlugin +{ +public: + explicit FFmpegEAC3DecoderPlugin(const std::string &name); + + ~FFmpegEAC3DecoderPlugin(); + + Status Init() override; + + Status Prepare() override; + + Status Reset() override; + + Status Start() override; + + Status Stop() override; + + Status SetParameter(const std::shared_ptr ¶meter) override; + + Status GetParameter(std::shared_ptr ¶meter) override; + + Status QueueInputBuffer(const std::shared_ptr &inputBuffer) override; + + Status QueueOutputBuffer(std::shared_ptr &outputBuffer) override; + + Status GetInputBuffers(std::vector> &inputBuffers) override; + + Status GetOutputBuffers(std::vector> &outputBuffers) override; + + Status Flush() override; + + Status Release() override; + + Status SetDataCallback(DataCallback *dataCallback) override + { + dataCallback_ = dataCallback; + basePlugin->SetCallback(dataCallback_); + return Status::OK; + } + +private: + bool CheckSampleRate(int32_t sampleRate) const noexcept; + Status CheckFormat(const std::shared_ptr &format); + int32_t GetInputBufferSize(); + int32_t GetOutputBufferSize(); + +private: + int32_t channels; + DataCallback *dataCallback_ {nullptr}; + std::unique_ptr basePlugin; +}; + +} // namespace Ffmpeg +} // namespace Plugins +} // namespace Media +} // namespace OHOS +#endif diff --git a/services/media_engine/plugins/ffmpeg_adapter/demuxer/ffmpeg_format_helper.cpp b/services/media_engine/plugins/ffmpeg_adapter/demuxer/ffmpeg_format_helper.cpp index bf9c52f09..a13eb2291 100644 --- a/services/media_engine/plugins/ffmpeg_adapter/demuxer/ffmpeg_format_helper.cpp +++ b/services/media_engine/plugins/ffmpeg_adapter/demuxer/ffmpeg_format_helper.cpp @@ -115,6 +115,9 @@ static std::map g_codecIdToMime = { {AV_CODEC_ID_COOK, MimeType::AUDIO_COOK}, #endif {AV_CODEC_ID_AC3, MimeType::AUDIO_AC3}, +#ifdef SUPPORT_CODEC_EAC3 + {AV_CODEC_ID_EAC3, MimeType::AUDIO_EAC3}, +#endif {AV_CODEC_ID_SUBRIP, MimeType::TEXT_SUBRIP}, {AV_CODEC_ID_WEBVTT, MimeType::TEXT_WEBVTT}, #ifdef SUPPORT_DEMUXER_LRC diff --git a/test/BUILD.gn b/test/BUILD.gn index 64c61969d..ee4f0d780 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -143,6 +143,10 @@ group("av_codec_unit_test") { if (av_codec_support_hcodec) { deps += [ "unittest/hcodec_test:hcodec_unit_test" ] } + if(av_codec_enable_codec_eac3) { + deps += [ "unittest/audio_test:audio_eac3_decoder_unit_test" ] + deps += [ "unittest/audio_test:audio_eac3_decoder_capi_unit_test" ] + } if (av_codec_enable_special_codec) { deps += [ "unittest/audio_vivid_test:audio_vivid_ability_unit_test", diff --git a/test/unittest/audio_test/BUILD.gn b/test/unittest/audio_test/BUILD.gn index a7ae4eaaf..8638d575e 100644 --- a/test/unittest/audio_test/BUILD.gn +++ b/test/unittest/audio_test/BUILD.gn @@ -985,6 +985,117 @@ ohos_unittest("audio_g711a_decoder_unit_test") { ] } +################################################################################################################## +ohos_unittest("audio_eac3_decoder_unit_test") { + sanitize = av_codec_test_sanitize + module_out_path = module_output_path + include_dirs = av_codec_unittest_include_dirs + include_dirs += [ + "./", + "$av_codec_root_dir/interfaces/kits/c", + "$av_codec_root_dir/services/engine/common/include", + "$av_codec_root_dir/services/engine/base/include", + "$av_codec_root_dir/services/engine/codec/include/audio/decoder", + "$av_codec_root_dir/services/utils/include", + "$av_codec_root_dir/services/engine/codec/include/audio", + ] + + cflags = [ + "-fno-exceptions", + "-Wall", + "-fno-common", + "-fstack-protector-strong", + "-Wshadow", + "-FPIC", + "-FS", + "-O2", + "-D_FORTIFY_SOURCE=2", + "-Wformat=2", + "-Wdate-time", +] + + cflags_cc = cflags + + public_configs = [] + + if (av_codec_support_test) { + sources = [ "./audio_eac3_decoder_unit_test.cpp" ] + } + + deps = [ + "$av_codec_root_dir/interfaces/inner_api/native:av_codec_client", + "$av_codec_root_dir/interfaces/kits/c:capi_packages", + "$av_codec_root_dir/services/services:av_codec_service", + "$av_codec_root_dir/services/utils:av_codec_service_utils", + ] + + external_deps = [ + "c_utils:utils", + "media_foundation:media_foundation", + ] +} + +################################################################################################################## +ohos_unittest("audio_eac3_decoder_capi_unit_test") { + sanitize = av_codec_test_sanitize + module_out_path = module_output_path + include_dirs = av_codec_unittest_include_dirs + include_dirs += [ + "./", + "$av_codec_root_dir/interfaces/kits/c", + "$av_codec_root_dir/services/engine/common/include", + "$av_codec_root_dir/services/engine/base/include", + "$av_codec_root_dir/services/utils/include", + "$av_codec_root_dir/services/engine/codec/include/audio", + "$av_codec_root_dir/services/engine/factory", + "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter", + "$av_codec_root_dir/services/engine/codec/include/audio/decoder", + "$av_codec_root_dir/test/unittest/common/common_mock/", + "$av_codec_root_dir/test/unittest/common/common_mock/drm_mock/capi/", + ] + + cflags = av_codec_unittest_cflags + + cflags_cc = cflags + + public_configs = [] + + if (av_codec_support_test) { + sources = [ "./audio_eac3_decoder_capi_unit_test.cpp" ] + } + + deps = [ + "$av_codec_root_dir/interfaces/inner_api/native:av_codec_client", + "$av_codec_root_dir/interfaces/kits/c:capi_packages", + "$av_codec_root_dir/services/engine/codec/audio:av_codec_audio_ffmpeg_codec", + "$av_codec_root_dir/services/services:av_codec_service", + "$av_codec_root_dir/services/utils:av_codec_service_utils", + ] + + external_deps = [ + "ffmpeg:libohosffmpeg", + "graphic_surface:surface", + "media_foundation:native_media_core", + "media_foundation:media_foundation", + ] + + if (target_cpu == "arm64") { + av_codec_path = "\"/system/lib64\"" + } else { + av_codec_path = "\"/system/lib\"" + } + defines = [ "AV_CODEC_PATH=${av_codec_path}" ] + defines += av_codec_defines + if (av_codec_support_drm) { + external_deps += [ + "drm_framework:drm_framework", + "drm_framework:native_drm", + ] + } + resource_config_file = + "$av_codec_root_dir/test/unittest/resources/ohos_test.xml" +} + ################################################################################################################## ohos_unittest("audio_sync_codec_adapter_unit_test") { sanitize = av_codec_test_sanitize diff --git a/test/unittest/audio_test/audio_eac3_decoder_capi_unit_test.cpp b/test/unittest/audio_test/audio_eac3_decoder_capi_unit_test.cpp new file mode 100644 index 000000000..dc0c7d13a --- /dev/null +++ b/test/unittest/audio_test/audio_eac3_decoder_capi_unit_test.cpp @@ -0,0 +1,844 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "avcodec_codec_name.h" +#include "avcodec_common.h" +#include "avcodec_errors.h" +#include "avcodec_mime_type.h" +#include "media_description.h" +#include "native_avcodec_base.h" +#include "securec.h" +#include "avcodec_audio_common.h" +#include "native_avbuffer.h" +#include "common/native_mfmagic.h" +#include "native_avcodec_audiocodec.h" +#include "native_audio_channel_layout.h" +#include "media_key_system_mock.h" +#include "native_avcapability.h" +#include "common/status.h" +#include "native_avcodec_audiodecoder.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS::Media; +using namespace OHOS::MediaAVCodec; + +namespace { +const string CODEC_EAC3_NAME = std::string(std::string(AVCodecCodecName::AUDIO_DECODER_EAC3_NAME)); +constexpr int32_t MAX_CHANNELS = 16; +constexpr uint32_t DEFAULT_SAMPLE_RATE = 48000; +constexpr string_view INPUT_EAC3_FILE_PATH = "/data/test/media/test_eac3.ec3"; +constexpr string_view OUTPUT_EAC3_PCM_FILE_PATH = "/data/test/media/test_decoder_eac3.pcm"; +const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so"; +} // namespace + +namespace OHOS { +namespace MediaAVCodec { +class AudioCodecBufferSignal { +public: + std::mutex inMutex_; + std::mutex outMutex_; + std::mutex startMutex_; + std::condition_variable inCond_; + std::condition_variable outCond_; + std::condition_variable startCond_; + std::queue inQueue_; + std::queue outQueue_; + std::queue inBufferQueue_; + std::queue outBufferQueue_; +}; + +static uint32_t g_outputFormatChangedTimes = 0; +static int32_t g_outputSampleRate = 0; +static int32_t g_outputChannels = 0; + +static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData) +{ + (void)codec; + (void)errorCode; + (void)userData; + cout << "Error received, errorCode:" << errorCode << endl; +} + +static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData) +{ + (void)codec; + (void)userData; + g_outputFormatChangedTimes++; + OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, &g_outputChannels); + OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, &g_outputSampleRate); + cout << "OnOutputFormatChanged received, rate:" << g_outputSampleRate << ",channel:" << g_outputChannels << endl; +} + +static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData) +{ + (void)codec; + AudioCodecBufferSignal *signal = static_cast(userData); + unique_lock lock(signal->inMutex_); + signal->inQueue_.push(index); + signal->inBufferQueue_.push(data); + signal->inCond_.notify_all(); +} + +static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData) +{ + (void)codec; + AudioCodecBufferSignal *signal = static_cast(userData); + unique_lock lock(signal->outMutex_); + signal->outQueue_.push(index); + signal->outBufferQueue_.push(data); + signal->outCond_.notify_all(); +} + +class AudioCodeEac3DecoderUnitTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + int32_t InitFile(); + void InputFunc(); + void OutputFunc(); + bool ReadBuffer(OH_AVBuffer *buffer, uint32_t index); + int32_t CreateCodecFunc(); + void HandleInputEOS(const uint32_t index); + int32_t Configure(); + int32_t Start(); + int32_t Stop(); + void Release(); + int32_t CheckSoFunc(); + +protected: + bool isTestingFormat_ = false; + std::atomic isRunning_ = false; + std::unique_ptr inputLoop_; + std::unique_ptr outputLoop_; + struct OH_AVCodecCallback cb_; + AudioCodecBufferSignal *signal_ = nullptr; + OH_AVCodec *audioDec_ = nullptr; + OH_AVFormat *format_ = nullptr; + bool isFirstFrame_ = true; + uint32_t frameCount_ = 0; + std::ifstream inputFile_; + std::unique_ptr soFile_; + std::ofstream pcmOutputFile_; +}; + +void AudioCodeEac3DecoderUnitTest::SetUpTestCase(void) +{ + cout << "[SetUpTestCase]: " << endl; +} + +void AudioCodeEac3DecoderUnitTest::TearDownTestCase(void) +{ + cout << "[TearDownTestCase]: " << endl; +} + +void AudioCodeEac3DecoderUnitTest::SetUp(void) +{ + g_outputFormatChangedTimes = 0; + g_outputSampleRate = 0; + g_outputChannels = 0; + cout << "[SetUp]: SetUp!!!" << endl; +} + +void AudioCodeEac3DecoderUnitTest::TearDown(void) +{ + if (isTestingFormat_) { + EXPECT_EQ(g_outputFormatChangedTimes, 1); + } else { + EXPECT_EQ(g_outputFormatChangedTimes, 0); + } + cout << "[TearDown]: over!!!" << endl; + + if (signal_) { + delete signal_; + signal_ = nullptr; + } + if (inputFile_.is_open()) { + inputFile_.close(); + } + if (pcmOutputFile_.is_open()) { + pcmOutputFile_.close(); + } + + if (format_ != nullptr) { + OH_AVFormat_Destroy(format_); + format_ = nullptr; + } +} + +void AudioCodeEac3DecoderUnitTest::Release() +{ + Stop(); + OH_AudioCodec_Destroy(audioDec_); +} + +void AudioCodeEac3DecoderUnitTest::HandleInputEOS(const uint32_t index) +{ + std::cout << "end buffer\n"; + OH_AudioCodec_PushInputBuffer(audioDec_, index); +} + + +bool AudioCodeEac3DecoderUnitTest::ReadBuffer(OH_AVBuffer *buffer, uint32_t index) +{ + constexpr int BITRATE = 96000; + constexpr int SAMPLERATE = 48000; + constexpr int SAMPLES_PER_FRAME = 1536; + + size_t frameSize = (BITRATE * SAMPLES_PER_FRAME) / (SAMPLERATE * 8); + + inputFile_.read(reinterpret_cast(OH_AVBuffer_GetAddr(buffer)), frameSize); + std::streamsize bytesRead = inputFile_.gcount(); + + if (bytesRead != static_cast(frameSize)) { + cout << "EOF reached" << endl; + buffer->buffer_->memory_->SetSize(1); + buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS; + HandleInputEOS(index); + return false; + } + + buffer->buffer_->memory_->SetSize(frameSize); + buffer->buffer_->pts_ = frameCount_ * SAMPLES_PER_FRAME * 1000000LL / SAMPLERATE; + buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE; + + return true; +} + + +void AudioCodeEac3DecoderUnitTest::InputFunc() +{ + while (isRunning_.load()) { + unique_lock lock(signal_->inMutex_); + signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); }); + + if (!isRunning_.load()) { + break; + } + + uint32_t index = signal_->inQueue_.front(); + auto buffer = signal_->inBufferQueue_.front(); + if (buffer == nullptr) { + cout << "Fatal: GetInputBuffer fail" << endl; + break; + } + if (ReadBuffer(buffer, index) == false) { + break; + } + + int32_t ret; + if (isFirstFrame_) { + buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA; + ret = OH_AudioCodec_PushInputBuffer(audioDec_, index); + isFirstFrame_ = false; + } else { + buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE; + ret = OH_AudioCodec_PushInputBuffer(audioDec_, index); + } + signal_->inQueue_.pop(); + signal_->inBufferQueue_.pop(); + frameCount_++; + if (ret != AVCS_ERR_OK) { + cout << "Fatal error, exit" << endl; + break; + } + } + cout << "stop, exit" << endl; + inputFile_.close(); +} + +void AudioCodeEac3DecoderUnitTest::OutputFunc() +{ + if (!pcmOutputFile_.is_open()) { + std::cout << "open " << OUTPUT_EAC3_PCM_FILE_PATH << " failed!" << std::endl; + } + while (isRunning_.load()) { + unique_lock lock(signal_->outMutex_); + signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); }); + + if (!isRunning_.load()) { + cout << "wait to stop, exit" << endl; + break; + } + + uint32_t index = signal_->outQueue_.front(); + OH_AVBuffer *data = signal_->outBufferQueue_.front(); + + if (data == nullptr) { + cout << "OutputFunc OH_AVBuffer is nullptr" << endl; + continue; + } + pcmOutputFile_.write(reinterpret_cast(OH_AVBuffer_GetAddr(data)), data->buffer_->memory_->GetSize()); + + if (data != nullptr && + (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || data->buffer_->memory_->GetSize() == 0)) { + cout << "decode eos" << endl; + isRunning_.store(false); + signal_->startCond_.notify_all(); + } + signal_->outBufferQueue_.pop(); + signal_->outQueue_.pop(); + if (OH_AudioCodec_FreeOutputBuffer(audioDec_, index) != AV_ERR_OK) { + cout << "Fatal: FreeOutputData fail" << endl; + break; + } + + if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) { + cout << "decode eos" << endl; + isRunning_.store(false); + signal_->startCond_.notify_all(); + } + } + cout << "stop, exit" << endl; + pcmOutputFile_.close(); +} + +int32_t AudioCodeEac3DecoderUnitTest::Start() +{ + isRunning_.store(true); + inputLoop_ = make_unique(&AudioCodeEac3DecoderUnitTest::InputFunc, this); + if (inputLoop_ == nullptr) { + cout << "Fatal: No memory" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + + outputLoop_ = make_unique(&AudioCodeEac3DecoderUnitTest::OutputFunc, this); + if (outputLoop_ == nullptr) { + cout << "Fatal: No memory" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + return OH_AudioCodec_Start(audioDec_); +} + +int32_t AudioCodeEac3DecoderUnitTest::Stop() +{ + isRunning_.store(false); + if (inputLoop_ != nullptr && inputLoop_->joinable()) { + { + unique_lock lock(signal_->inMutex_); + signal_->inCond_.notify_all(); + } + inputLoop_->join(); + inputLoop_ = nullptr; + while (!signal_->inQueue_.empty()) { + signal_->inQueue_.pop(); + } + while (!signal_->inBufferQueue_.empty()) { + signal_->inBufferQueue_.pop(); + } + } + + if (outputLoop_ != nullptr && outputLoop_->joinable()) { + { + unique_lock lock(signal_->outMutex_); + signal_->outCond_.notify_all(); + } + outputLoop_->join(); + outputLoop_ = nullptr; + while (!signal_->outQueue_.empty()) { + signal_->outQueue_.pop(); + } + while (!signal_->outBufferQueue_.empty()) { + signal_->outBufferQueue_.pop(); + } + } + std::cout << "start stop!\n"; + return OH_AudioCodec_Stop(audioDec_); +} + +int32_t AudioCodeEac3DecoderUnitTest::InitFile() +{ + inputFile_.open(INPUT_EAC3_FILE_PATH.data(), std::ios::binary); + pcmOutputFile_.open(OUTPUT_EAC3_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary); + + if (!inputFile_.is_open()) { + cout << "Fatal: open input file failed" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + if (!pcmOutputFile_.is_open()) { + cout << "Fatal: open output file failed" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + return OH_AVErrCode::AV_ERR_OK; +} + +int32_t AudioCodeEac3DecoderUnitTest::CreateCodecFunc() +{ + audioDec_ = OH_AudioCodec_CreateByName((std::string(AVCodecCodecName::AUDIO_DECODER_EAC3_NAME)).data()); + if (audioDec_ == nullptr) { + cout << "Fatal: CreateByName fail" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + + signal_ = new AudioCodecBufferSignal(); + if (signal_ == nullptr) { + cout << "Fatal: create signal fail" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable}; + int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_); + if (ret != OH_AVErrCode::AV_ERR_OK) { + cout << "Fatal: SetCallback fail" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + + return OH_AVErrCode::AV_ERR_OK; +} + +int32_t AudioCodeEac3DecoderUnitTest::Configure() +{ + format_ = OH_AVFormat_Create(); + if (format_ == nullptr) { + cout << "Fatal: create format failed" << endl; + return OH_AVErrCode::AV_ERR_UNKNOWN; + } + uint32_t bitRate = 384000; + OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNELS); + OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE); + OH_AVFormat_SetLongValue(format_, MediaDescriptionKey::MD_KEY_BITRATE.data(), bitRate); + return OH_AudioCodec_Configure(audioDec_, format_); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, Setdecoder_Eac3_001, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 1); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_MONO); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 48000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_002, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 2); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_STEREO); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 48000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_003, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 3); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_3POINT0); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 48000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_004, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 4); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_QUAD); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 44100); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_005, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 4); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_QUAD_SIDE); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 44100); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_006, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 4); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_4POINT0); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 44100); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_007, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 5); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_5POINT0); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 44100); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_008, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 2); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_MONO | CH_SET_LOW_FREQUENCY); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 48000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), AVSampleFormat::AV_SAMPLE_FMT_FLTP); + + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_009, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 4); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_QUAD | CH_SET_LOW_FREQUENCY | CH_SET_BACK_CENTER); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 44100); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), AVSampleFormat::AV_SAMPLE_FMT_FLTP); + + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_010, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 3); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_2POINT1); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 32000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, CheckSampleFormat_Eac3_011, TestSize.Level1) +{ + ASSERT_EQ(AV_ERR_OK, CreateCodecFunc()); + OH_AVFormat *fmt = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), 4); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_3POINT1); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), 32000); + OH_AVFormat_SetIntValue(fmt, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), + AVSampleFormat::AV_SAMPLE_FMT_FLTP); + EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, fmt)); + OH_AVFormat_Destroy(fmt); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_CreateByName_01, TestSize.Level1) +{ + audioDec_ = OH_AudioCodec_CreateByName((std::string(AVCodecCodecName::AUDIO_DECODER_EAC3_NAME)).data()); + EXPECT_NE(nullptr, audioDec_); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_CreateByName_02, TestSize.Level1) +{ + audioDec_ = OH_AudioCodec_CreateByName(nullptr); + EXPECT_EQ(nullptr, audioDec_); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_CreateByName_03, TestSize.Level1) +{ + audioDec_ = OH_AudioCodec_CreateByName("audio_decoder.eac3"); + EXPECT_EQ(nullptr, audioDec_); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_CreateByMime_01, TestSize.Level1) +{ + audioDec_ = OH_AudioCodec_CreateByMime(std::string(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_EAC3).data(), false); + EXPECT_NE(nullptr, audioDec_); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_CreateByMime_02, TestSize.Level1) +{ + audioDec_ = OH_AudioCodec_CreateByMime(nullptr, false); + EXPECT_EQ(nullptr, audioDec_); + Release(); +} + + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_PushInputData_InvalidIndex_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + + const uint32_t index = 1024; // 非法 index + EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_ReleaseOutputBuffer_InvalidIndex_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + + const uint32_t index = 1024; + EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Configure_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_SetParameter_01, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_)); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_SetParameter_02, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Start_01, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Start_02, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_)); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Stop_01, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + sleep(1); + + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop()); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Flush_01, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Reset_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Reset_02, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Reset_03, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Destroy_01, TestSize.Level1) +{ + isTestingFormat_ = true; + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + { + unique_lock lock(signal_->startMutex_); + signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); }); + } + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_)); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Destroy_02, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_)); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_GetOutputFormat_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + + EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_IsValid_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + bool isValid = false; + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioDec_, &isValid)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_Prepare_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_PushInputData_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + + // case0 传参异常 + uint32_t index = 0; + EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index)); + Release(); +} + +HWTEST_F(AudioCodeEac3DecoderUnitTest, audioDecoder_Eac3_ReleaseOutputBuffer_01, TestSize.Level1) +{ + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile()); + ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure()); + EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start()); + + // case0 传参异常 + uint32_t index = 1024; + EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index)); + Release(); +} +} // namespace MediaAVCodec +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/audio_test/audio_eac3_decoder_unit_test.cpp b/test/unittest/audio_test/audio_eac3_decoder_unit_test.cpp new file mode 100644 index 000000000..8cde29abd --- /dev/null +++ b/test/unittest/audio_test/audio_eac3_decoder_unit_test.cpp @@ -0,0 +1,357 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "plugin/plugin_manager_v2.h" +#include "plugin/codec_plugin.h" +#include "avcodec_codec_name.h" +#include "avcodec_common.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS::Media; +using namespace OHOS::Media::Plugins; + +namespace OHOS { +namespace Media { +namespace Plugins { +namespace { +const string CODEC_EAC3_DEC_NAME = std::string(MediaAVCodec::AVCodecCodecName::AUDIO_DECODER_EAC3_NAME); +constexpr int32_t EAC3_SAMPLE_RATE = 44100; +constexpr int32_t EAC3_CHANNEL_COUNT = 2; +constexpr int64_t EAC3_BIT_RATE = 192000; +constexpr int32_t EAC3_MAX_INPUT_SIZE = 8192; +} // namespace + +class EAC3UnitTest : public testing::Test, public DataCallback +{ +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp() override; + void TearDown() override; + + void OnInputBufferDone(const shared_ptr &inputBuffer) override + { + (void)inputBuffer; + } + void OnOutputBufferDone(const shared_ptr &outputBuffer) override + { + (void)outputBuffer; + } + void OnEvent(const shared_ptr event) override + { + (void)event; + } + +protected: + shared_ptr CreatePlugin(); + void DestroyPlugin(); + shared_ptr CreateMeta(); + shared_ptr CreateAVBuffer(size_t capacity, size_t size); + bool ReadOneFrame(ifstream &file, shared_ptr &buffer); + + shared_ptr plugin_ = nullptr; + shared_ptr meta_ = nullptr; +}; + +void EAC3UnitTest::SetUpTestCase(void) +{ +} + +void EAC3UnitTest::TearDownTestCase(void) +{ +} + +void EAC3UnitTest::SetUp(void) +{ + plugin_ = CreatePlugin(); + ASSERT_NE(plugin_, nullptr); + meta_ = CreateMeta(); + ASSERT_NE(meta_, nullptr); +} + +void EAC3UnitTest::TearDown(void) +{ + if (plugin_) { + plugin_->Release(); + } +} + +shared_ptr EAC3UnitTest::CreatePlugin() +{ + auto plugin = PluginManagerV2::Instance().CreatePluginByName(CODEC_EAC3_DEC_NAME); + if (!plugin) { + return nullptr; + } + return reinterpret_pointer_cast(plugin); +} + +shared_ptr EAC3UnitTest::CreateMeta() +{ + auto meta = make_shared(); + meta->Set(EAC3_CHANNEL_COUNT); + meta->Set(EAC3_SAMPLE_RATE); + meta->Set(AudioChannelLayout::STEREO); + meta->Set(EAC3_BIT_RATE); + meta->Set(AudioSampleFormat::SAMPLE_S16LE); + return meta; +} + +shared_ptr EAC3UnitTest::CreateAVBuffer(size_t capacity, size_t size) +{ + auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE); + auto avBuffer = AVBuffer::CreateAVBuffer(avAllocator, capacity); + avBuffer->memory_->SetSize(size); + return avBuffer; +} + +bool EAC3UnitTest::ReadOneFrame(ifstream &file, shared_ptr &buffer) +{ + // syncword(0x0B77) + 16bit(strmtyp(2)+substreamid(3)+frmsiz(11)) + const size_t MAX_FRAME_SIZE = 4096; + int c = 0; + int prev = -1; + streampos frameStartPos; + while (file.good()) { + c = file.get(); + if (c == EOF) { + return false; + } + if (prev == 0x0B && c == 0x77) { + frameStartPos = file.tellg(); + file.seekg(-2, ios::cur); + break; + } + prev = c; + } + if (!file.good()) { + return false; + } + unsigned char header[4]; + file.read(reinterpret_cast(header), 4); + if (file.gcount() != 4) { + return false; + } + if (!(header[0] == 0x0B && header[1] == 0x77)) { + return false; + } + uint16_t word = (static_cast(header[2]) << 8) | header[3]; + uint16_t frmsiz = word & 0x07FF; // lower 11 bits + size_t frameSizeBytes = static_cast(frmsiz + 1) * 2; + if (frameSizeBytes < 4 || frameSizeBytes > MAX_FRAME_SIZE) { + return false; + } + size_t remaining = frameSizeBytes - 4; + vector frameBuf(frameSizeBytes); + frameBuf[0] = header[0]; + frameBuf[1] = header[1]; + frameBuf[2] = header[2]; + frameBuf[3] = header[3]; + file.read(reinterpret_cast(frameBuf.data() + 4), remaining); + if (static_cast(file.gcount()) != remaining) { + return false; + } + buffer = CreateAVBuffer(frameSizeBytes, frameSizeBytes); + memcpy_s(buffer->memory_->GetAddr(), buffer->memory_->GetCapacity(), frameBuf.data(), frameSizeBytes); + return true; +} + +HWTEST_F(EAC3UnitTest, SetParameter_001, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); +} + +HWTEST_F(EAC3UnitTest, SetParameter_002, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + meta_->Set(0); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(-1); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(EAC3_CHANNEL_COUNT); + meta_->Set(0); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(-1); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(EAC3_SAMPLE_RATE); +} + +HWTEST_F(EAC3UnitTest, SetParameter_003, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + meta_->Remove(Tag::AUDIO_CHANNEL_COUNT); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(EAC3_CHANNEL_COUNT); + meta_->Remove(Tag::AUDIO_SAMPLE_RATE); + ASSERT_NE(plugin_->SetParameter(meta_), Status::OK); + meta_->Set(EAC3_SAMPLE_RATE); +} + +HWTEST_F(EAC3UnitTest, Lifecycle_001, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->Start(), Status::OK); + ASSERT_EQ(plugin_->Flush(), Status::OK); + ASSERT_EQ(plugin_->Stop(), Status::OK); + ASSERT_EQ(plugin_->Reset(), Status::OK); + ASSERT_EQ(plugin_->Release(), Status::OK); +} + +HWTEST_F(EAC3UnitTest, Eos_001, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetDataCallback(this), Status::OK); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->Start(), Status::OK); + auto inputBuffer = CreateAVBuffer(1024, 0); + inputBuffer->flag_ = MediaAVCodec::AVCODEC_BUFFER_FLAG_EOS; + ASSERT_EQ(plugin_->QueueInputBuffer(inputBuffer), Status::OK); + auto outputBuffer = CreateAVBuffer(EAC3_MAX_INPUT_SIZE * 4, 0); + ASSERT_EQ(plugin_->QueueOutputBuffer(outputBuffer), Status::END_OF_STREAM); + ASSERT_EQ(plugin_->Stop(), Status::OK); +} + +HWTEST_F(EAC3UnitTest, GetParameter_001, TestSize.Level1) +{ + meta_->Set(EAC3_MAX_INPUT_SIZE); + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + shared_ptr outMeta = make_shared(); + ASSERT_EQ(plugin_->GetParameter(outMeta), Status::OK); + int32_t channelCount = 0; + int32_t sampleRate = 0; + int32_t maxInputSize = 0; + ASSERT_TRUE(outMeta->Get(channelCount)); + ASSERT_EQ(channelCount, EAC3_CHANNEL_COUNT); + ASSERT_TRUE(outMeta->Get(sampleRate)); + ASSERT_EQ(sampleRate, EAC3_SAMPLE_RATE); + ASSERT_TRUE(outMeta->Get(maxInputSize)); + ASSERT_GT(maxInputSize, 0); +} + +HWTEST_F(EAC3UnitTest, GetParameter_002, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetDataCallback(this), Status::OK); + // 1536 * 2 * 4 = 12288 + int32_t defaultInputSize = 1536 * EAC3_CHANNEL_COUNT * 4; + shared_ptr outMeta = make_shared(); + int32_t maxInputSize = 0; + int32_t smallInputSize = 4096; + meta_->Set(smallInputSize); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->GetParameter(outMeta), Status::OK); + ASSERT_TRUE(outMeta->Get(maxInputSize)); + ASSERT_EQ(maxInputSize, smallInputSize); + int32_t largeInputSize = 20000; + meta_->Set(largeInputSize); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->GetParameter(outMeta), Status::OK); + ASSERT_TRUE(outMeta->Get(maxInputSize)); + ASSERT_EQ(maxInputSize, defaultInputSize); + meta_->Set(-1); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->GetParameter(outMeta), Status::OK); + ASSERT_TRUE(outMeta->Get(maxInputSize)); + ASSERT_EQ(maxInputSize, defaultInputSize); +} + +HWTEST_F(EAC3UnitTest, Decode_With_Invalid_File_001, TestSize.Level1) +{ + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetDataCallback(this), Status::OK); + meta_->Set(EAC3_MAX_INPUT_SIZE); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->Start(), Status::OK); + auto inputBuffer = CreateAVBuffer(EAC3_MAX_INPUT_SIZE, 1024); + auto outputBuffer = CreateAVBuffer(EAC3_MAX_INPUT_SIZE * 4, 0); + // No valid data, so it errors + ASSERT_EQ(plugin_->QueueInputBuffer(inputBuffer), Status::ERROR_INVALID_DATA); + Status status = plugin_->QueueOutputBuffer(outputBuffer); + ASSERT_TRUE(status == Status::OK || status == Status::ERROR_NOT_ENOUGH_DATA || status == Status::ERROR_UNKNOWN); + ASSERT_EQ(plugin_->Stop(), Status::OK); +} + +HWTEST_F(EAC3UnitTest, Decode_With_Valid_File_001, TestSize.Level1) +{ + const char *filePath = "/data/test/media/eac3_test.eac3"; + ifstream file(filePath, ios::binary); + ASSERT_EQ(file.is_open(), true); + ASSERT_EQ(plugin_->Init(), Status::OK); + ASSERT_EQ(plugin_->SetDataCallback(this), Status::OK); + meta_->Set(EAC3_MAX_INPUT_SIZE); + ASSERT_EQ(plugin_->SetParameter(meta_), Status::OK); + ASSERT_EQ(plugin_->Start(), Status::OK); + bool sentEos = false; + int inputFrameCount = 0; + int outputFrameCount = 0; + while (!sentEos) { + shared_ptr inBuf; + if (ReadOneFrame(file, inBuf)) { + ASSERT_EQ(plugin_->QueueInputBuffer(inBuf), Status::OK); + inputFrameCount++; + } else { + auto eos = CreateAVBuffer(0, 0); + ASSERT_NE(eos, nullptr); + eos->flag_ = MediaAVCodec::AVCODEC_BUFFER_FLAG_EOS; + ASSERT_EQ(plugin_->QueueInputBuffer(eos), Status::OK); + sentEos = true; + } + for (int i = 0; i < 8; i++) { + auto outBuf = CreateAVBuffer(EAC3_MAX_INPUT_SIZE * 8, 0); + ASSERT_NE(outBuf, nullptr); + Status s = plugin_->QueueOutputBuffer(outBuf); + if (s == Status::OK || s == Status::ERROR_AGAIN) { + if (outBuf->memory_->GetSize() > 0) { + outputFrameCount++; + } + } else if (s == Status::ERROR_NOT_ENOUGH_DATA || s == Status::END_OF_STREAM) { + break; + } else { + ASSERT_TRUE(false) << "Unexpected status=" << static_cast(s); + } + } + } + for (int tries = 0; tries < 64; ++tries) { + auto outBuf = CreateAVBuffer(EAC3_MAX_INPUT_SIZE * 8, 0); + ASSERT_NE(outBuf, nullptr); + Status s = plugin_->QueueOutputBuffer(outBuf); + if (s == Status::OK || s == Status::ERROR_AGAIN) { + if (outBuf->memory_->GetSize() > 0) { + outputFrameCount++; + } + } else if (s == Status::END_OF_STREAM) { + break; + } else if (s == Status::ERROR_NOT_ENOUGH_DATA) { + continue; + } else { + ASSERT_TRUE(false) << "Unexpected status(post-EOS)=" << static_cast(s); + } + } + if (outputFrameCount == 0) { + GTEST_LOG_(WARNING) << "No decoded frames produced. inputFrameCount=" << inputFrameCount; + } + ASSERT_GT(inputFrameCount, 0); + ASSERT_GT(outputFrameCount, 0); + ASSERT_EQ(plugin_->Stop(), Status::OK); +} + +} // namespace Plugins +} // namespace Media +} // namespace OHOS diff --git a/test/unittest/resources/audio_res/eac3_test.eac3 b/test/unittest/resources/audio_res/eac3_test.eac3 new file mode 100755 index 0000000000000000000000000000000000000000..a231cf953d30b9afc57769dd68487f62ba13cee3 GIT binary patch literal 120372 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

3HdK`_@g%uoSKIX!_GmHHc? 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�TaSU;)lB z%MH0*#d5hD;|*~AJlsS@aB1|iFt**d zQ>8ME`-PDkL2a&8=AFMte-Pi}CK)U0jbh9g1mir`z@;Zqu6Txx^BENqUtu|?bfZ=u z@TYDWi5up%XfT5QgOT+pl%fBdF89wIvW{>1>h-$K$(xUMRtF6 z@S-9&NNrDJU-*+wY!6Rc<|mG6=kkbU>$jD~*K*p{?|e=KFm@@KiZyMeQsPyi=%Tes zd2(FnYH;uiF(jcaNPl(i)&-D8ZB$F1 z>FA=1e1QLf_-I6c^F=#w*R~gyoTM1IURDjbh^vQgNtjM2F~~d8jQD}xXx?WWkz9L2 zO}0<>tjtdAjLjMB{X%8L{^Or-Bi&GF`AxT#@UtG6$UDah&eT+Ofg3enqrQ@ji4fxb zhKp}wX0SM-YtrSw^)e=!of$bVYvMiNUnbrYe`FN7&(qVYbvfh+;> z7zMe_PJaymwU_yX5URPrL*;Q=oz~-B%iWF!>p;#npkjyiWoncFRW$?qSs8 za#3$R_}(KEG? z+^fuzs#S}4LW-vjuaNFfaG=G)*dgT%Na5cu?2B_-zk@ZO-s1^ZW6G^1C@W8>D!Hy- zwO$nO*afJy7+}SY*=#Mc@Jf%Ue-;>sjNk+lx^CI4>9R!|)EmA$mVI$m_1SPe^uWB?DQTC%<#9Dy$YkyM93Dy(i+GxTv zxsCiRF{dA5pkzo8N998NRCBlVj?pzw`}Nh~_%;hBW>%mJw~MP12CBGO)L*Mu7c*oc zk{KS2)o0>oUHw2VIhVZ7qCnxOLb7dM#WiM!a$A5nAAJpz#1>4bb1*SyqYU<>QZY*Y zKMVyT{AUXNbLnFhNyS{8!mul<)g3?f>|L@{pXGw({@PlgT1+YUTH{T z*IDqDu>bw-G4yKNy#@}k?wrXt<>ja!;Zh09hW;5^h?cavJ6PJVV;pCrkv}oM5w@TP z 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⋘niv?u?HjLXl%UV$!=xG3)N&S4-I)X&L&!BJL{RNrDW@rE^U2 zg=BAMk-n-rxUM6S!qwvsVcxKcPM)@BhZeGmU1T~&{uAw2sINAXukhqFOR~V(n3n<* z66ViGRjh-Yqhi3vkGY%LlMU0V>BhZV5mbaq$TPs>7QI0mps47GHvsdxi2$DQ5r9Wf z-aEtzYi7M2c%kf6{{qo!-M@R1UdB-sGvi~{i9m*$o|E>aEJ6Tdbr-4%;S;MwyMgAP zEO|a(XM)W_T)pT{6%sr5(_TTJ(p}w2w*mVAOnH*0vcN4&Ltir%C2#IrI#CE?;4!== zNHa7V%l-4H6l0wxlmfoSQ-*fXsjk)R)>LuK0hY4s8 zYm$(Xzc}KM%F;!ETNd2P7k-C2FlAHWnU^imEc;c9ke)^EmqFD*ShL_h^4#)p+Hx(< z&U@BuBhqzuJWt%}0cKW16;{=D_@D5ZAKbI?y?))>ZtJ3tIMJQT&&kQ+TLrj&_f7y| zMG)nG*Vw59TN1s9%!0_gfk<-!#~h`zyxC_qyEegjzibqkAlx8aMEw0M`DC)Me7r`0 zRQbTRT4u`>4*mDz@beCo#Jbdl?e?P=({7+#x%3N~b6KM`U2K=mTfIK9Z<+FyI7_|T zWi}?JxzG0=(Wi_0p`nkd^h5EBA!uAhexd{swt$*xk%KIMSk>ras>|ChdRoFIqWpl< z$w()aq|Fflc~uwe@w9wdhcWp#@6KiA22{^&vQ)+C1>-v#hy!KN45@0k45lncgGE-$ z5v$-u{X`FtXvjxKOtOjJa0R}F_We2;=BlV}z`9&T3&a}|!FRCGl4g=TIZ;Ee2PiFU zF~3mG`KRfI`^k&2`%LR01z|cUf^rReotD^6bM}`a))z;1%f%hy2%p)o_8idBkt}bCs%P@_`L5rEh+RY{;4Y*Iul_1NcY}IV-2bVckQR$6_I(>w{S3f^)FO!Ou>!vVZ=? zLq#EaY0A0nAv$VHu^f5+Xkrx$6cxU^rdL6?V1;}4Ja|eku!YaIB58U~nS5{s9XIU@ zod_qMw`@LLgK=8&;I5tcuPgzZ7g3$)d> zxHkQcEBm%(!oO(?Rt!qL3r8Cy>YSfkCaO(i=-&EHc~F@P-v!=#n~{SfGaN{Ta>_$w zTY671LUBSc@ytHm-*bLqL+K%X=3`p>`;b7@0by^Eq&1?cZMW#OeW>3(LNuW`-r)Q+ zOkviu8DWQ-rY>`sZ19~@@j09I@ykA;?wJR+NItiP`p7&vDF?xqhoQnE7pS3Wh`wkC z*QiU}n-(axc@sWm_A&m~ja6xv2;j*R3a|?wQ$4X5-^xTbC^YD$i&)OTbu7Fg zrjhq+a?tWN)!apI`ypaYVD28=hH5Wb<L1Za*18)9>yM-74%GhTd;deYk z`gr5T^T#dC%NBj$PO_6~ohS}*P_zINI-F3G__Y+R$SHZg*hmiCfU4!O$bBI8T9J4F%PYminxXth za3dSs56r6#>|S)}6GF|1u}wItO>yR3ndpMRa$3w9u6B)bvMjD(2H%Rzg?R?7^@UT zOko6iXXr!1)uhk@u&>qu_N9|sI%r>Me}YBsy&%ZBRp6WMHy4Ocjp2)8biv-H^(ArR zcrr5h_y%jza=rzx5z+I;wW7i&L7LR6RL^7Pg|AtR8~$wYo<#I|mr2N*gNV_G8Av6_ zs$fmg>FclQKS{8Az;rnn54G}?eOY_XC`!t&fN2W=O|Bb07igAh8Ef`%mn! zN5F1+m*j5p2ipqb$uu7QjSnh&FTkft%QO#}w`~mUg{rbeneRW$5wT2Ep6f8MUeAwn zS7;!Ij1z=`*%1}`Y)1;~&=>}WL=U7MMJ7~IzRFO0{D|UuG3BdqyK}eMjSy+l2^Yh2 zx60`l3pE8_>xi#%h+X2H&){q!0SSX$!1RY6XL&_tDMKIuZ9-gz8KlAkQ4_e?S;u)| zWUjK1uQb$51Y5%Qem|ikEo6&gG9g+yrVTY@$=)M{3q_twyl|TKbES&8L}=SzO!dMq zwpcd9=<$Pv@RwrSm;AHKnKQ`7^GrlP%YLRQLoqV* z|8pcWZ{Fzg$@a{*zd^M#9g0*C-iX^&`;M7n~>zp?W3B)s3;C%I)6etj8Q0c>0z2giia zBy({TSnd)t5UP5#MHQfV>jbH52o%{7p~=9d_M3CwMAS#cZFS$9mjck~t$aOJq43oL zOrxtt4y6!)Jk;#&Ls0=H+u!K>&A_@Zy5*ol2Rv_i!v08&*HRBK24umNj+KxqVj|Eo$TMX zFw&MVMC=2)^FIQD5AnXi+hZ8Xq6gQ;4b~Y<*=X}SM!u=<=;@GwP71t%V;XoTYy82m z>@-bubMUTH$j7kL%8r~;jx>R=Q8o^|*(uoqHlEC^T%{1zv z{yg}IAQ+iE9y-HbzzE-*bFAegH%o9yO&*FGg9D~mLJ)uxfV54a8|p8r8t}(G_Q&{8 zdV})dXtb6P-d53(jw)?`B85yrJk4a49Fx0p{r%!l&2Fkl#zQCPe?Up-ipq~1bs#|%Tnyw+q13$$zX!76j0IA z)TC+gKvnebROszmC#X<Mc7`DNxr@~rJ+kwro7C|bpef3Pcb z2;&=ZJMzCUU3c#;4mAh_Vb%ZSoY3I5DIt~?01Mz#o4@EvFeD)FWR7!~@VLVd(Hy)D zL=S_xBGJ2@!C)qiz`XpV;5MotDp4Z&CjO}wJLV!hsPIT{{1|1w@0yw75zF`QdRS(~ znLwBFRQg~u|84mKT8sJ5J2lERB=~VST_iNM6{}?w%vi_90Y$4=*9~%?WBeM=lwO)M zzYi|W5=?iFh>0>tmuZxn$`ak zK>)yOd}(>1sFunlWR@WK2bX3m$Y7oWYP{7Pa&2dlAi;euli z*vUh;pR!On2F!7aFfP?X&0zg-6G(+{-v*C*cn?h>+zu{vHDctvd&=nX`Kjlx|Dy3Q zpq4OKUtU*85Q09;YwI8H=7(tCrlf>^5Zh zY}TRFY`H<2TQ!S`(%sj7+q?NIc2YAo_^GB@Id^TM$Mad5fsAd*^0EcD7$Am?ZKpM_ z@x0t9>)Rd!l|MksfO+UN%HbxRJI1M^GDz_@jEng)4_ASIFhC>H-){$V)md$qgv`;% zO9QnQuuaEBMwK{x=M;E4FJ`8^m42}%sn+Yrjt0ju1V3Sx#BYk5^N=O|inZf@hehg)175-cCbVC!HvoyYf1tOnPFwNVbWj=X$NrD> z(20PusuFegq>Qf-0;-qI^NMTT-hkW#u0ii2=M^=jchU>^6T@Uw88k0bw|E-7v}BD< z?olfJG&-jBd<<4_MXgS^-!9_YCgHC$d4Rf{)k5^xLD1{Sh33*$NlCy3rl=Iyzx{GK zdp{0S_f)kyXXjJv z4T;M0%gF#5P>5|At7{=_pMcg{xM?=_LyJxF4z5GF7l+blR3dqcPNawB)H-DbB_mGe zgSvs^H-o`>fYA`dSxxv1PPqf0q$<*rS)*fV`|CRRfMVv|tDY5)vN=_#g&Cf)1GG=0 zbl}%gRGwp2&;a;0V{nq*ai?lJDJkj?7otGcd}yjPBBd`mRfan>bOOUcG15lc^FAj& zLSDoZuD1hU8c(F@Qjs^-M?`Q+B3Yqm#TfekBM1PXPx}W$e>bQ6)qz(4yJF?tRMnJ_ z=dU|e3qIrt#>*9~dhS>MTv`^GoIyr+MoD1P0^Dn*&R%K zfxCQw--{aX2EZ>P0x@vZ0Px*}^pf5o0B*~GiO#ND(+`2mmD}hN4FgFg>CDQ7T#|5k z1)u>0g!aAfHN>eQL5q>`wv*#V`?i;n+hhIlD<>e2{1A?d5EC3u^9&-Yv_NoWZJUTS zcE%ex!19obO?!#K6`RIVWye_IDfs;!0!+}b10U?1b6n9yhL7pjz`Lw7F<2#_uD#`_ zWj-@eE9Q^)iCmy{Y0jY0!Ymr-;!G$4g+DP~c zV_GMqBZjsp~sixV<= z-&)=~*Avn$Ef{z(f=*0~fvAru;y`WphjfAEw2KDKMWQe5$mmNynn^%|dm^~RChaH4 z-s$li6!k}C!LK~}>=5;;4w3N}C)B>}g{I4ngP5^nDS)UiLora0J#JxGg+Y+i;DZv6 z9rFyg3}9~I8Gv>HPhvlEopYOsoJQ+a;Wpn%bhNh~!kBxKPXB0^*siXI1nbRh(XXrB zOak)e-0r0FlfCX6PR~cSLmbi)Wy!ML;2yl3c&@XMN0s!_}l_2^SKg7o}kTXog16~PC1=rD{aBp*qZFliQbb7h( zzZHKa`rI=xW>ym3FOSQSR8c9KMg!z#{{xmI{#j5?cphgVPN&!c+JF#NPnypLLFmnfC3t=Cbx%E(`o3NV&cK_Pe8iEOi=!Z>E4vLCt0Sj~%c zQp$3Cr%_RX>;~zQC^K~|0aUb_ybm?38s0-zm8}Y!VZmi zs(<)stoXk%^j9KDQL1TD^Q=m(#4mo>(5CNQDt#GX^w}xgOf&dfw|@M!@g&%R1@AKjWi+57VgtM=jZi+#na^H z^!>c;>&0xPFPi2M6Y+5rS(#`o(XKc%3CcQ|pS~S8ugWY<#b2-vpZ`jC{UjKLX@{V0 z)h$2aDCQTrHUoGXWyZql+mVYjAvd!K{JChmCh#p`ryVP~gamd9_G~K3kl|l`j=hHD z%sN0y?XbpC(0;xXruX^(M}y2w|P{-kR#cw&aAOK=mvu)$K#X zG08Zs^9Vu1Tb{dgs0omdd)ROJ5g9vA^Iv9SUa3nZ2<|? zbi|%qD$)w`V^rZj`T8zk#}=0ORT$YyNK6{FvPh?dhRfWzu%#Q@#dT-6{#(+xW^f!+a$^ z?F#iDW23EkLa*VZtA&0BXrqh3kdboOPL&%WqK(FZq@GyJ~w3RWd6eeOjG{t652lQbRM;pMPvfqffNoeQ_Yk?0+D z@2iz9aF`8+_@sC6tnn)2Cua17N>v3l&Kt2{%ZeSBsg_O-yhVfwK59w*$o_pzPjk3S zeBc5G6b#rwOp#3fhH=7M63`Z5Ci@|i%nAj$Nk>$^oPjpRy|O-JAyNoad#4>Nj7fsK z`hHy@HmS|5XSc2-UtFP!tYSj^6vaGN>g&YMSMJWF2-nK5s3B75SGc|xeMzXud-b9Z#r#7d~q(GUE3R+Nfwm`ni!!)hA|b`;=BCSRx%U zi@JkEeqigxN!n6qx6e0d)>xq8Lkb%+x^W+#c~9Me4s$s(uPg9hNb)-U2Sb1Ba@G-) zoU*BY=FRKv>JRMvvgK+;`{yGtT`u^UY>_j!$CJ;&f_DeKD53Mj7IyidGjARCBkxo3 zdDz%od(jEZr+{^gMQ3w(mot*faXToKkKOvhCF{JI8vfJwgU+*CjPI)aDP#f;<<(c& zkT1lCMy6EV8?s+8Td@rURfR36OBCb1G=k#1(du@0q%jNe0RCx(F$1FjWKWM2z;y_a!XRq-sdY1k!dcXh*rP# zrjgS=(zzw&8qQaWM^Lx1{CT|db}_+_`E`RW18MeIocdn3{q_<*Qd^w&5u1c)p99C{MuIPU zr#dAnL(zc15Lc@(8FtjtA&b)HmF%BeZEc0p;A}n}p+2S?&cC!makxN*(2xU_QeD;U$j9G-E zCk3nGfugP@mxd^G+&EXP_Y>^|P2OF_z3mCH=qo7+&eR;y1&{LM5yk#{OLe1m<2(+#~v74A?q>08jWCcrI1eY2pDS1I_}2$gjh> z0eZYAEb{BfTVbY$zMdn1xCt*@ux?D5V@^eAC_~ zJC>5vBAVeDeR*O31TXUp<(D)C)*#5>q)l4!kzjHe8nq+!e>zzd%@BU*#M@>!-nv{q zDxKsEiiso(lqu9lUJHi-64 zf0|#m_@=SqG9Q5@5`P%Z2u}kLb^0!;PS+&V=d|7@3-HFy6VnV%ae<#e5&d9GMxE^+ zPjlA$VW_|9m*P!GnT5(3Pbt3!T)N{ZV=k{IBDWNUEGg45KD2W;S;5kId3j8#o$B1{Vj2!hEF7wEc)cA{3f@ookzcqXMRZd| zr3;&H3LLpN_-Ne5^tGwCX&7ka&ecvB>jp<3LDI8fjsxz|wTf6bOOyZ3UCNydcdUApQ8_UMGZ^g3e`o z0oTV*_=)2gW87AaM7@)E%!1S;n7e-3;fz0>3P^RTsuMIKhnIYoN4wKsHt==EBs0Lvef@unE3lHP`oTnW{2Q^57xeT8&`jKiYOXN=+tm@87vXa$KY>i-E zpLwfu))_yP#5*q4=%U+!t33GUED&ZM0NS4R*&;9T(@|?%QF>mNR7a%I;j4#Eo!&Vf zzZK<%8G%iIQhnXWB7wPIvLiJY7~>^1VYC+2kA1Sn?dJK8v9Rh}f$N^e#c;dMl zZKWIcp-Z|qYhu_nK+A`iwn#eX4I;IOR5c#1g{-%pH!1uDhQD92gpqvax3$7%0%nHFT3k~Hi~Q6j1`k4N$Md2v(l&t%0O8O0og-c_p>kD zVzNS8JUNFy0aHNj6f^|uryX!Y68l4k?D=Cwm_Jpo779TZ2h4?fg#A-$FP&X%A?m%@GezhT~H)p07R1F|_ zxHFtX-BEmz4L0W3q*mv~hlASOBwd%VN0Ct@S zg7de7^Z4dg{ZfR1k=1!q%k;ejBe!eZF;i6wD}t!OBu6~E(S=;2HcnFVk$H;5x_LZr zzR|rLv1oyRwW)P~6Nsxte9mP~E?%caW6oMBFapQY+P2Mx z?^`qM=Yb%0enH58w&>_DOh|kqv70S!OL`UWEzj@B7oT0{f3*^E(kE87+emD_;>^#n zc@5g(*RJheZg*%LQWP>-5t<82Y>Q!TQ+fRl(!xA@BP8&<7X~ zU29bxRFCkM3x3MJhE)=MA;$PiQz-FGAZNKSrSsF7XoX#|`WY05)l;H>klp=7dxSF& z>)-(bd4ZPYjH1ShY}6L>g}qI8l!ydXa8Wm|+j=y2lT`C-REa~y z50^*|oY*P&l^bkDRDGZ=f*>%?O`{&Re`5TDd|Ly# zJ?~;SbyDMSBi)K5{b2naDB%_e0YNDT)13E_I!sJ{MLqxFmj6tnwz+|DOV1GE`2Jnw z&crIS7a~SRlmNKGGmvC^?u8m{QcuBMcYTbzw)tg-dMZGNxosten-*M2LMrYOes8AH zy0&Rp?U$Nf0fGPkm|b}?Zo`CW%#h(;le*K2c9YrVIDjx7DC6N}q-&eU5H1oC?QEN~ zU)VVV`<$LzCV*rwS))8Z&^*>kx)XCk1@-+VlC`A--@B8miGE#-Sg8};7ZNTI6tNnr z1oTN!K^gY+JH|^{!;Eo{Flg2hwZ55AbN&#W$!vW)z*;SE{5FI*nx(Jpl(#F5wcLFa zL{1Zo0e+s{h7wo1Qk(RcvEv7^0K9eR5*s8%;4hmnaS|qHui9WHzqS&QmFB0L)wYk@S%wR3O4E zq5x;G9hyRoez0T_!MvG7x4;dkdk5%^_3uSQb`9pr#c`JpbAL06*{(K)o_+t~*Ze*v zdbPE|j&IPF@sS?R)di;4FAO6a6$tu`G9Hja?*WzH5cIiO`w;p79`_j9d%S`Dsz!KVZZl>y2G=qZD-qUpEN3*PXrsep!4U_O} z`ua(uOk#)mqU0*ao4kxhTRk=2f*1WE;}N)S!1j&dRA_;$PyP{sz}|T|pU&W3W?Yuc z`clj!nyYI{lJ#^-0&=>mh>1t|H%BhlN-?}owT^%~v;cs$zcF0AeIzL+n1gxIk$>B+ zMQ(p0=(q5vCPSNP1_A8?-^4gkQnpkjG6{RaMTK`+OVY6OX(}sxYAGLQw6>EEjTx>r zqG2gquD@NjX3a!$gH*M}zlc=5-qZ}R5yy0gC?a~-luvbECUIe+EGO#*}?PX%#EZLGa>f(E44Kt&=txOs1&U4u6=HR)^x znKOGvk`)RoCh`0e<#Z2tP@7GiNPq#?d-KoBF4+xt^_0?j2XmQWLh^0w zmkawfa5O0hc_cHwS^-dabKZqGnoI%7L845qeOX7Te{S#o=Aj*g|Hcq(misE3(#6QR zsnUwf#$S6{QL+;=B3RDwsrsjRQe}5Zg~MMrc0ZWA@MSk${ zA0FDf7Xh$yFNl&W414(yb=@<;@`+(DD6II10=ffMM;F?50xdWWk`^-`q~RKK;%TnD z=9d(}D|3E$Yu`;;xas}gbk3dh@_gn*)P>X_Qj119EB$n+)wp>J;ZA&A#DH|3#--Lh zjTQbf4QmCi&pU9XKem6&MUpIm7l3p8o5616j$)N8rPW|X;%BjbKJ$Q~+^E5ojL2`d z&po>X%K?1LL$SP!I?Nba!JESzkNO{de|XoWD#YD8nvYZoGKd2rdt$PXtA%UZdXuvH zGNq(~$dcP@P#g}+&$-Xa^24woG(yID-Wxk1Zy`@gfm>x6qSOeBP?Y;|9AN2F?w^!w zfKVJ{%jCApzs*ParGGK^;qK|(f_`2&i$~fwh5AC?VwzG6#wcu5vZ&@!1&It)Egbu@ z57eXY0@VyBjGa*(N{5y7m5juw!USx!R@0+oLSHY=N6`U;xp-*d>Q+f#%hpHO%~9FK zjg}>>&dK==+#qiM_^W)6B^x#T+Y?qy_IsifG{bN$?`y@*KZ!rHa4H9*YAV{3Q<_KD z?VHhAGxauYHGC!~wD>Rt2WF$RX|e~d?!>zi(CM(dk;QYGzo`-mrnM7dq>J|cf@Fen z5`ND{V(&U~-Y>dBw@^62%%ZU;Ma2n%vV{X@#N-ocx)kN`nzwP|os2s|w3F)xN?suKqZQE>e!KxP@%hEH=l5|A*j^n|4PHDd z^-%lrGiG@!dM`2sKQ%0P#hZ^-2A~$MvYO}>13PU*WZluN-pCVzvc#C=k8r<$BKI!6 z@VVw;m!voongT{)OGAlfcY`A|kQNkiW}#E(U0x?4afQ{9meB$)b&S=hxel1&TZmzf zZMG>2oTa0tG&!jE)X2>jA>FO8x|X$`%wj3;Yi1a_34DZ3y$}p)AZxeJFF@+&8#zvC4{U{SBXgeP@XMgQ5TRoCd)XNz$JdIgj7hJh1U{p7s>;{y>7wa(>v? zi?xMXfBCjwZ43KxlQTKNYKQiD>0#P7jE4lL@rtW%2lje#F2Mx0Qg;;J$^R_etmR)l zZ@`bedw#JVzB4VnKSaix_=ak~>{?L3X_{(i+vPaZ^huNtZWF67rWK5n%er!*JaU)p zBxgx$)M+b!0eGkB1Ya5qXt4Y}9jP-j0IqL@gP*IKlWtvuFs`Uu{7^Pm=8zS?fL=^qmozejrLioiDVhLV5ho*#R6lo2 z4>b_BMwt!?_WfkE%P)CF-1!dg@G~{@oRqcI@90x0sW(u%wm6;|GB6woD~ep{ea=qKRY3})yjE%S@C8$!M~`F$?Fj;HlNrp7nRJB` zrhQp663do>%4-6|X?Od*ZGi~z3<;+krol7ESmJm%@Z4w1g#r#Eb8N4hsCu!0Q)u5} z;*&q9|3=HND@QcrUgdv>#Za%@LURyvCP6?l@{NX>!~v&J|1L70oQ7LSyv)7Uu1N%? z#?D&+_4K@RD3XpiSzI)%nJ;dH&6B51a<Aypa)0eu3m&`a>NXbQiskuvZ+c4NCq`bCGx%ZZCD&H=$YD6pE5a79lBB1|)Kj%G zJoM*(1(P6zwNN5|y#3?ei~e(v%qQ#*Wga2ukIChp-cLd@)7#Ym(MTOmvs+ruj+yis z8{JyR%u+Fbn}+c%4mU>4y+Z~zszi(~S)*rzhD+pG9F;L-jovmH0!{w6Pa+Du9)?Z$ zVE+0f6`$YpHsr+ZpfIKfsjtA>>;fJLa!e+ha_KkO{i;QkJOF(0J#H^N;DN+*#A~4* zHEt!8Fsl2lK;IF?=~JOjw3iB^fy6S#p1j~lnjU(Zzy|lp?0Ib7n|BHCxGA(wBP(3S zi5r9rTDARBH6=yh5EC6jhydWTpzAo+`?@u40H5B}b(ZfLmN>QNn;0rFAXr35U~IMK z8*_ig?h!6<2b&552o4cKs%Dz_wrjybs3e+`7L$^*hg7)o?qn9C*oI-dE<^Z;-5|Sl zCDzA%>XgOCdhS@y8h}DM6UK>EkZx0B-P6*eT8^;ZvYy%-cS_EE@Tq&w(k{PYhcWv=piNs@O)O*^l+0aH^SSjLo5hZ^|vg6}*MsviSBZheS^$MLuhWflF1 zm=c%Z<+DqSYA|`U%(2E0oT0*gJ8wB3nnqj<`0Vc5v<8nRBaz2f@KJu)813O514DyvhCnQ>V5v7VnaX&p1Z zQV`H_EGe_Scr^uVaG>xG$-cMUwr6eS?Q@6Ld@6xkNoD6+T|C^XbD~!t+8pds2p*pZe{My z#)-^7)gW(Fo)ayJ`Y91w$sMJE^=4_D%rvsG=aE>Pkbi?I^}|0r^f!jAk6A0LV66|F zm9S(iHh$UaFRnK~ka%F4LPclz_sSmme|b)YefQN)E=*vz;I9vm&S(4_iln%XsjL2+ zdqLpA)tA^vkI?0Gb;*!lv$n(!_G#H&Rm+vTN|;ZL236}Mv@|3!9<7YN8w=u62WENi zO&YSJlZ$rj8u(Q=U8vtHqAcOHO`wm@l=p@MAc+tOsgGN7>y_CC;>h?7{d$<#zE)yF zfS8JfhzpHzrr2>wm&J9Rrr|v+$ko|g<(x)N}gyr6m+u3SuQ zScC96o^N$Zk@-wi!xNn;LxanmWWr|*SuU#Q`^LXpkw=4A zknlCdz;SkOITjekv9A zlW5^!uBV0=?=Nh7%y!J6={wF}o{_6@`u@rjI$2)})V~yV!^w3tzGa+x8>Nvpi>E() z(Px?GCMC8cG8nE-wKfWE<( zOZ;6lX!Wp_0h$+P*xP|nJFRc~hr;}Jzx4`!=21&H9~GZzk^Wlr9253kTf?nJkJ9J% z)QM4E=O~L(G>t7|-foZ#(YVTvi+nwvbh`^k$|<0^Mkru-zQk29Y4wvxo zU1}svEjn$>U}&ah{t1gGTCw35&>T5|L?c{gY8;%^zTcJj7#QfS$1@59R)`2tfmLWC ziIcIx3&XFM1~6NAi#YO5)`S4Y@({?Ve>nK-M{dz8N;0b$pT;JIZqhIGJ-7b8O)m~P zR&N;CVpEpC{>XP&>a;b_(*x9~7X4^vk+(lga@Z{*_BQyjmPYzgLvOz$7zN^!?jERn zH2k1t$eB@A$X{3tP1PtO+2AWoCAR9&{V=f{6 zF>T{XVYKr5F?a_iaanf>X|}yltLVER_`ohI!pT@U5us&W{_wr9;9ZdMzTS*;H8w^? z9vXWXV_g~q03bH}Zw%ScR7?8+Rnwa*XAEJwoYF_tYR&4AIv5XCUnlcAvX@jBF^=U{ z`0kJ%U6@S3FhqZ3RP0xcAUJiQUjhI z)vPzS-S&$h3cono)(kc=$FV5B&Q9DVhi!|J@L;dGYY6z)0fK?Tn;5+`5r%JZRE`NT z1GKUTa%qB4&6(A&7}@~6*53H;+%;bu8@!!jo#2^t8$D{yU(s1^*>qCJj-KCase(d? z34UonV^wicT-)44upmpbZGrrHzSQ8vCeswiQ>{ykubq8a4mZP;H#jXAV zuldo9B0uzF4Qp%+Ntkhww+rQrZWOK7GF`L_sgA@6zv?8(+i?`!Fpq`|k|>&JJ~W1i zah*)5Y%m{+y)j;%DwURjB&{aOLTTT~8XHVVhu{OQv8@nSvc)5F;`!U&gPR_7<%9u* zZE5lP?i0`zH;-cLk8Y)zEbx`9dL*W@pnbu!d`6Bz zZKF4xG&Fs{q1gVYHEd((@@NZra4YfinlUXY!ox8Lx#0ZDaM?Rv`&=v)C8*f)2)La+hAEk3@Bn6MAMpHru zUJlN}cQDXZ9WglhK=%2Zuh?3W`>=>TgQMB9mg#^-ullNso)g!DoOXT-V{kb5yEHS1 zwSj-XPm+7iIOv%EFph+~Tb56`Iz_W6DjNhVp0ZvL%7_(c;_)${I?nFfuh&ZaL1Uw1 z!3+ij?4Q4mqCu*}_$rE#K#75RBFNGHgE0JeSic{Yln(?Dg56JqW#D|HXdG!ng>>JA zgQBzt&}H`!-Pqa^w?D6YH^|rBEm%j%zd3#)(CQ_WHbn5 zO5dXEJ>^-8z{CdmRw?>^C8mi!5kV|t*U`0ZW9W0b|87qRU=1;t_>?=)R7qVF9=-*P z;yi_=)WEfnAU>O;rz#B1q6q8-P|*(zKhR3$`StsZEVQ)l=ImdfRzl4mvPf}wvKbl_ zi{|@g2YAM%eG5#Lhlil-0yGJ-mz1VnEs*UM{+SOVEW$$Im2 zD{%#-*u+1Hf6*qsS`LbjJ~l&rD?haYQ><6P&8AQ-3cm)llkm2al#3V68T z-Nw1YqjswNL$OS@_DdnBQ45;49lJ&Gy2|^?Q5Hrp`!7uX#^JPkjpGpF_%R#0wanGm zh;3K=mY`~<^R%eazI`@fg+g^eaKJ`$1L!s<<-sq*De;Q?`%b7-r(Jm1rJZo8Oq7WL z_Yo~{63q=o+FyRi(PTs`V{f4upkD!ig2nG&x?2%mc0-?ECR;ZF^lRY&>TU_jM*QhA zoaxcj$+Yf|?J5zMo&@E}RE=_-^DG;mOH%DJ>8DLD3&O3D5i-5bR`FAE^A34R9#T=v zii2Oh6}uN7J{M#_P}9Z^u*vT?V@f2ZP+&%#%Ao;WHm5jBY8gBau?9va0gDvnd2!e% zs`kuA`RQWyvv2qEl0SsltWx9Xg@^MLvFF6zqRRv`b7=M2B^Ez|!lG&lDsLULLLiW5M5J1a?g)K#zpiFAJoFi)c zK0$E!UGx++%@~mcIWP~?U3orBG(`hbnmccl-#c1NOaa%wAc=ri8jVhy(t)pX#Ac_)kfPM1FO1O6&i;-GNc z$0}qWVr02EDQY+F^4hEm&FD;PNO&BR8luL;6&?+l7BW0RB5i=tI9)CTDIf!fkLUM$ z`x(fjr&!F`%?nK=J!O)&W1vX&i_lo{L>dxjjy3B?PE8Gr3PT*aY4Fjcl_d97PTfX! zDE(uQ)iTB-NHH%DVfZA{j)$oYYol;@$)QPJDZ3igia$mqZ4GRiF}BIrGz?_STmdyJ zTX#qs+zjq28UBNv|9Wf2{X2#Jo7q0IWQl+=+hpXOdg)XDVYbmX=hCX_b**sIIbaA< zXW1Vw6pz>?{o7|8e1u`^Xf73es~WJ3Q=@g<>fMidF$)fozbKp{`1Bk*>nYmZwklbf zYi{}40PJ=`?^Ea8;;U40JfXP3&B=M&6B870Q7P^7JAitf)^VWUR$T6on|DYa<((-N zi@v?&EZK^_>4qybjwzTT#6jd8W44#W{Pc2ORb&v7N7lT z7OE7o4L)j@3vG`w7~AZybzxbb4x=Ak>-*?@hb0%0iGAXR69SqRzx%qQ@cnK!eUgZ; zCN?+IXgh0?mc6c8qmLfXPoHpMUBYX?M&IVJ=){Wu{t2j%;nn@pms(U9h&u~#9Flue zB?U;}k#dG?c*WhfkhEAIVgt9pP&nvML=MF3W4q&FdWsGzX(B_(oSsKq{pti$W!;P~ zsWz=h2pqadWIy6!v2+g8;Sd%|ySz<#m`SU#CvRvzwBHmYyh|4C%RxtDm|qXtZr}%b zvyTyD5P#@qj%Y?`aBl=6>kb+w2Ep?9ydZM5C~>tYmnn8GoJ>bDXp%N8lcT|DM+mvks$N^n1$W^!w0k zqh7L-Igb9J7%Xh(?+uB(tnKSidh>0)>UZ$q$H!l&hvhNGuLY}e5wi4Jt`0sC1x}S+ z1%JJ996k=r%-xig8~Q%zpFca1)rxwYK+N{}n0NJOLR#Vi*EiN(GDrT)CztNy5(+`C zuozkhs;gq6gy@hiEq$9YZ383!wyn65Nfy{K`*1iBC%r1%>im40KB3h6(kb1F)*R7@2ST~ z6_stg-hUI9lo>xskp150BNE<qAiiXw{&YHa;+=y2#43fIk> zeiX{VSmvOobMwI6ShPWT_*CF^B{U6BK?$F8@RHc(cdm2klJc-z+o?%7mY{Si*}mQ; zf@ulj417w{CkoMJR!I{63C8!YUUV+;IDyROhHO6(`L|fJohWJyq>(u#`B%YE9(er{ z?YxJ3D?YPNNtR2lfcGHDgSe3FQ!p-_3p(W}nJ-RDg#n6pVv-g!RNaG4z8-P<6)ttQ zT9H|j?Q6m?A>rG3>hz%~xv}V@uBO%yql6^FYk6c9_eFr!3YaO+wpu*(j|9QV2AQw@O`$Vk)u#!~d!e_Pz57G! zUnB61FJGP5nQFr)^QL(@?aG@v$gWm-cEU5c+ID_r|3sT5eDHE^6oJ}@l4N~KP)|L| z%*gp5ivd~iBAGDw!ruFqVh_KUwL1MI0uSvxrfM!m0KMpog%YEpbcSLRHgmNc0ATX1 zm?WeMLo=nw)?R@%?UtG{L7`zG4Vb|cVwBBpIfkHmXW5&U$W z*;uO=1hS#yI1-Oaq=~yL?$lLfD~~x{3cgiQYQw2emJjkCIs*f@U><-_GPq8M5ION_ zCb)V6OR5dR0Wjt;Qto$mg~+#$JN|N~-ahnw%?%j0qj6A4e)-hggoOr0GQ+zL-mKeH z78&FXod_*EHaBX|WS*i=ZG*4+dy3J;gPA12aHVzjH3Dc^j+>Zh&hV@if*?x?_>{!f zcjI@>SW_aus;>c%kP$lnph~grKv&wAu)LJkFo|NQ1|w&Wo-@0OLHQTs1gY!5`{8H1 zM9Q9h@)WQOsoL*GBa1~#5$;9q^nJ7zsd}_@9#l!&3HFrU=wgdARz$)$2`{azSG!pt z?o^3a2q%nhiv*=+P)q9gLxlw~DCbR`xB($NK>DhXqf;<5f=7v*J{19ujv0~-z6Z3dK$D@WcXg&=&oMI}dh z8l9sjaV^E0{k-oAQH=A$@X!*N=Y9rHaIfMqhU!wVE#&?{e_ipjHIf(1PL>_>gZY!9 z868ZHP};1@H~VVohd$~T0Tv{}pIZ2=lPJiVpsZrHnqdPz({qr-iTi!zy+D6EvIuyZ z;L{lw0t8aVvlNGcVGRL2w}3D#fPl&@;Yc3Odq#|V-2k#~%B~x;Ov#5K^AXdDbh?dd zFLb-%F1u3I8jrbWCd}6;5h`Q@4)jtMd~!Usd}`a$6LQ8Y#j|HbjCqYb6uT4@PG^jO zGI5Y#RI}i2Xk-b0gdr6axkE}QF%%DK0ad|?x`jt&GsGGeSdK9SaKbO3$kOa$Rkz2- z^6T5eSDW%O3Xfr`R}e@2(av=AKvo?%2^wO36*Gpt;4CVEr4uTRRaX|BmZZ@6s#?f> zW{7!dzbmIpjQsSrq9`N_=o(WwLeB)9FZgOBGEjmYg+*Iw^16uo`fVMED+(GVWs?T` z!OMWbs&MFE4E^JLa5#oJ@L<)&eBU%cDVATtN1u~Q-RvWtYzG1+KN$3TRw#J;HN`D*e zQB-S@vp0_og9T?mbZP!AN2H!JSGvTFDHkh2F76+^RWn>7?b*nNWV}KKIuWE{I4ZX$ zLH4A}#}-J20zfOwfNoYXC>#I)VO&IVMuC)vuWdvt421V7E?la@!c3r8hfuNwtY4yQ zNRJ$1362$*qx&hp;GU8ssXd*M4=IUrOcXO}*=sxm^(S3I=~drQj{Er*`Z}2oC)7A< z-3H(?iS|Wy;h@EEuU74hx~xrVeo#w~&q68V<^-rq)6z^NZbu*{Du7N93Zd=g&2z$!NYgsP-Z7QaV~ZL z+)&xV-?3YN71C?;-kOK&jZRbS$~i_~(Ae)R<*dZ4RVl{bEIL)Z%i8z_qfQwTWRe}i z-0}F9Z^camXzPZPwEK%MEPDm1Hia!X5d}$A9kc`^!(t}SSsxIub3I%Q&lmBz*w8M8 z|3JkxPR%UM0D`!Jn24!Wgx&il7=H}GNVx9zqE1CZVv6)!`O-SBU&nQu{HHKnBK%#l zx6V^JLbj9x>>Axs$Q0;8>{BD`5A<0VFb8DSWo5 zdLoyocMc5Qwuv+*7g7M`%iRtFN9?hn(8?Y_7El5eoBC04{7}Oafl|7zE?K%G?ci22 zC`NJ4Ni{1xN{FEWN5o@t}vNFZDl$Lkya56--ln&z_G}QB%6jgDfeZ#vs zF{Xc_Uu*cPR>b?l-5JCZ&nsoi-?_x>=duVT}IIPjdBu}GlzltFNXeM z6deAZhcc~U7=o#`VK=OGbm9Gv$?svzb^|U)+K2OXAOOYw*x-=SBvszZywhg@q_{KGY)lMK-YOJ#t(wAFF!qXjW( zhNhilMg3}%M#S#bcN)i)0%^+m@b>TSHWoS>S3KoCr24YS%xf#@t{MHb?8sC>Ii2azozR~oBurQGv!UPr{T;HedlBq4}`kaJ_7qx&j~5Fy_`U=Saa3R6U@ zXV0!-%06d}IF-xHGiw%k*h=rFYLjw&j;Xb9W>OT{BA$2YX!7Y$F#E76uu7Ato;pL# zU-q53E1OC^X9+98ke=E6jY?s)HRJA47UE|&EmtH#5a2Ykqt zfIfZ;G?^8XHUJ-*eN-&_SFeHOrW&z+d+-Aw~shNB0)`hOu>sLbay0Gi0T=Nfej7Q zgB$1e5@=i_OEJ+AJ;?b#=u5pQI`;W@t?ZK#8zn0s53vixr^&v$5y?J0@&O4Ea;=`l zsLI`r7KA@srs_Pwj22-I$ytDm+i%W;M4??fZC@~pN)l*}(a8@HVdd44G5IvLu0EeX zjD`ML-d8nor(^I(TaZOeF!uFr-psF{u9>)w!GYA6bMs}V3q>_~((fJ)5ugdo(-u4a zd`xvOQJBJse_b;ldzlftOhDYnQ6TnZj!QPdlRiHUavMhMQ!YoJEFTG38m|>Hb#K+A zJW>D#;{bA@fFEN6xoYY-O+8iv=>tcC(^RE$XJTQ5h_Rf^3cl<9V;L(l*HodWj4{J| zw8A;@)zxVUL@1(HrM;J8v!|ZV<`|>pdV9%%980Ht{0-N!ov!SL7&Eu<9>JeWO)Vul zZI_IQH5xfA{bYt~Cee-JwP^)4{x1)a6866s`ezQkcC}=I?Q-_88`j1Yd_Sey-g={m zXqbytum0~YR}JekhOu&8!HJ}YH!zu;UN=3`=~tESQ=-dw6<$jC-u*b25L)LS*AyqD z-G04UOSrE{$76MSwxVB7vw42MhPeLH@Q5Sllp9xHwAy2^Ox(gjhjeE&QmHYnt*4^o z%Gs1a;|-C!Yopu}t86LRuYMR1ZpkirloA_&gnQy#l!KBpiY5*csI!xHAT7-zu%=F2 zM2}zVnBvk#bK4+_tk8b{X9;+%B`}>CIzVV`_3PrN*V5|~kH34L4f(+}>968_*~lC@ zEEtJS4d*(R*MFFal-b4Si4U`f51WMY^O5b_EuT2Owf`Z`t{l?2^ue1by`&};M z{W;w@-&h-cR;^LgB|P#`;lg!8h9}W)!AZ3wJgADgdE14z<_;<;C?-C)6};Y8LG|Yi zN~`H~7|0Q(`jvm*0mazXGO@5jNo1tzCq*YlhlmH>1Id2Uj9igX4g1>nm<9D~58Z;^+*N8X?j5snOa9)>#wIO8IAFri{ovkgM`M^SqbHcsb*J7=uH&Ha zElIWcCjl12VqaC+kNxLC`LDQ z!g4g%G?eV^4A*glmot`zhM2z%faAJ98X16cBj{^h4jzT`686EdJAB1$!1RIvi5Ljw z)4yC35;;y@3a2U{c5pZ=q!e{gUKC9=V!|R=x(t+E(Lp@sO1T;_X(>yXiwC&5FZTS{ zT{K0>mNVjREz@<3L?_>ly;ds71Hl${ z9tzy0Hh|5cAiX@gBet)~hEs|&3l++G-I7Ikm$P^vq~C>C1o_{(k|f2G?z)RKjWq$X z`dJuva3X_SEuU+6<4{%1V&3>v{%#I>jp!A)ia%ANU6we6Tw=Ymw9zpF#t8QH6YxbF+MspkQv8p0SI2MO@5{^g z>jLoL{XKb0LLBz_3_NWOfo~|cGKX`K?p(?z-KBVE*L*Su_6F0K2xqIW$SD)eF0V?~ zT~VZgm0qEFiQM8ko#K+d0(4%I#2TJSt)T-NSxG!(26$NK^nCjrNKUXyMUF9XJ zZv)+T^NO#YjXl{_w-R0-d$Cc=Emv4#X4Izsa3Mo}A?Y49hus7ekf!|>8}67}o)T67 zTCzu=B16mA<|K)v=+Y!>8pubpkR$eo;juLBBF1fN8UkSM?w8OR0672{y*`L3w@d0- zAajglDSd=kj9<0J6o!QYT_OF*dem`P7NQL&+xUCD1Bi>N#@J!w(zag8aPY<2dYPr^ zygAwb1;jWS8j`yEz;4}-nhE~dsGc6=-y{udXa>3{udOe0bl_$?z-bTwLj~1AXi=@e zM3@B$ig7|j?HGMWF-sBSyWSI?yh0HhXJ{@}we?V~`}{W9%_iyeu+@^PzQ?g#ovB+# zbK}Rd=3c6)oTsuWi*tgczB|h&aroHiu@u8cDlATxcZ3%7TTHv0ORPIZ5+;mIazuo! z#fkv^j1g1IQecE`;}{J!6?&>6wekE>B*1tEpm|L>8~kj{_J(4Rz(?OWHG1+iJ*wVf z2Wds6%_Nd8;~>wF(XWakx#y2cz83ez?gzS)k^R;N+5HDdBnhw4i0??2*lwCR0>Vzi zEZX$jo^>mcPLfYoYgpbBGUyd6+~rEmo?i{HmkMS(Kj&})enQ$%Kj0nH;2gxdJ07+6|?_i05~yRSB90i6%tAR4Ep$ozYX7VFOpe_ z2RR?>@CVbWo`bD#64=NDIx+jCsy7TOLRC!2x$tJ%{KUc^@Aw-r{q$qA&L49qIdiL4g=400~?-;h(&>RpNCJ z!g}*ww1<5Yd%u2Ft5VOnBb-zj-P)cswVA~D4j$}iil*hxFh**OANc(m3*3lEU+G5o z4Jc_y(vq;d&|Stde!Neh|G5=(FE_f9L+p07hwqx^%{vJ2*zX1kp?7nB6lvNR$@{ik zE!8UyEi;#Q1$aCpC5TQtom@6u#JdXN$U!-;EHOi6BdX6iN;)iaJ#6dghx5T|M{#Z5 z-o64w!LDX)d-Y&G=J_r9vT$h&8coj`x(S}uvv?UVcJ+&!vwM(9Ow~^d)BoX_f z2#8JxxD@)_tAH^KmU;8w)4!(`Nd)&+86hY1MZO8?MfC&HGb=1L@v5Nj#Z&CtV;w+f zSpSof6;3^IvI317os!|4QN!%i{=3OF>>Dv>rm^3rkdF%rJm=*3p4?w2x7G4b zpUX7dP)10B7K@1SrHA@wLNTkY_XE#ef0p0Yk=k({&jjM;{D2I>0XXAK&piM_aE%{H z-N6OT;4zu z8j1kJmaB=rS|*|SE8)0G6Lno}eg?M@*co#9x3!$1F5;Gyn4q6fMfe!4{DK(PZ)BsX z$vlItd_CI5OQJWS#9{7{UE8hX+GJX~SOcswf7yipdcbf0#n3-<=(Vdk2W$?d^Vjyk zQck^FPw2g5VXEy~*c`%O_)x3=pS11jioB~&KT#-Q&Ig{uurr|`7rKBsytaVjwt>zU$R&fb^tw4 z%esaR_@cT|^2RC?U60t(7#JCc@ZM>dzloO-6l*l9I&xor5BD|^frR)Osl~#?rwy7L z=mRy5%V=bm64*)91r)+>F409z#dfSS56Hj?_gF2`c*!y!K?#!tceFyckz(RPcHzFW zSVSu02DI!Me5Fz(4@I;$Y-5rE!S{rOI;Gs5Foz}5)u1Z43GX)LYQYnP+99z{#!-QF z=UzeCE;~5Su=d3!IHCopXiYsu&wEfYe~pY4bYiQY_-Y=-5HCX9Nm?o6vt1{?|4HBo zLxs~21ft=rVOQVxFRu5$swO2zegEMz&sW>YYAl!eXgP*nGm%VbKBl$qSoLG+iEID> z9uNVP;x(45of0bMzLyr)9r&RN4FF*Mp)5uXaX@c+|ISKZ+8_%*8JP5Sbf>77)Z<$& z-xoPWL%6RA>AY$anmE(5twk?glQq9@ckU}JZHnCUTi238R^+ueYq~p18A#TjGL##o zNoB1<@VX6WUqPx-YaVfDn_@i%*-6imzGuj003?{cqcCkcvMO%C&ppJtpQBvB0p1UM zT2SLY_N^*zSEkzDVp)(6w*XCFi?MN_pD8A)jyco55>TMeiX)7TG?C}W#m6Qoe*a5F z`wbD&{GNbujgXieQ4c0U;g##+==LqPWl#Hsj|`Q3bcvGJL_EU}bi6Sw;R0nfIeY)37*`qxp$ zvsN9ib_ipCsB3_={Qi`TMi0uD2wM3ZZMqbTj6hU_NY%hKhsjK=*~3!L3hYG=SJip> zy5??T_x&U%O4-2ZQk<9V0XsQ?v0u&OB1_rJ!LZyeCYl6$SMtR7$=H?9-Qd-`PHb*n zr)aS&H1%R%GXSFs5II?5XddCmxri5X&-X zP|1ckwJYRsSox-JpihGK9ydF3mFyCv^-VA1Zyi*`v|n9Y$O?aAwS+*r2*Yl0>sHT3 za;{H@JXw`1NFw`P2i@_P$!GZvx|mE@+}DIl_iL%=vy*En=q16#CLh;L zh}hWG5QEYiuFD>GsPvaTR;flJoAXO*1wq z3`i@xnwBS)bTSbuDnG5gAr!^aZmVd7mE({iZmR;%oWq^zY=`RV8m|oggQC^W{|AQ7 zEXI}cy)xTi?L)Ft0p@C!ETqXx6|*L$Z`l@*ZwYn?nrM(u%!!Bv!>MglY@(Sf3#p2}lu|JeVib()Hf!Ma6p*Idn;_FCK~(%{Mgh%Lb!GM-ueowg0D9`6H_cV`Ht}{~4sw&lP8zWI+P4#K!h|u>ROEl7+QHetV zep#r~kvTiXx<23A(gKBcp?F~UT7=gUd>ckvaMP%)9Q)$Bh*e_SB?SOIfChql5(VSR zm58`nV&q(h0`7{H>u*5sa59sJ%#BomtBpiN!~RY=2`E)QBAWWvqhi`6jc47d)UAV+ z2J)UqpRew_rdnSWcU+2{tjsnUyvPv%9pQq52t^5FfCOP%VF&dcR7N6eu%(ggtAUAU zJWV$ei8&bVnFNKO=4B>KswYouI1iQMs*P8Cz#Og&Z6zL#8wD;=3IRJKV`BTcWw?wv zNAxr&s?d1#B4upfVTv-{!%1Q|g69i;R$zH!dA%_$?C1Tng1jVz7F!dbjI_^zF%*fy z3b>v}jEp9#Q8Con?^4NiTHlyYF8Rz3cto82a1#0Bd7i<^s<}Jxs$A>-B>p zN8mqfh{M!!m3YN^Zl9|N`xrp)YX4Ah zN78(6{ENh!C19AbLewbQ@ra51w{f2Lyteu$4ppmA@0et!m?!R?9O4=b)=q@(SYs_A zUZ}&ewUk5!FZRgc21OQ*Is4iD4PwzuB!CqG8&zuD_@PO@g`R}Ej5u+x1icbmL}elR zz8+k>L@zA;+7%hTmm3~L{33z#y~`o}gwx;$+aQ)c=H`qWzrgX+{X!kR&aIC!4|00A zZ?P8z*PJGn{ky#cH-WZ&9osiHS1Ce+M?+ug0;5E$dBLTu5L1PA|4g|&1#O=wAWBk8 zlTMnk)j1-X?oZC`TD%gb1fUJ;d_o&`@(DF|Wsx`+dx51Dz#muhN+q@Zhp)L*O)97TSTY|<`oI1rpUJpo&Y`#A&$5Z>m2wur$|hv?{ab)KDB%|fdkVJ@Jx^LU7m+i`oDDkHkDZ9q%NMNJ2wiyd5=9bIK4rv>{wbP7>OKpPAV3w5y;-7}UHYOB1%cLV<-NVg7r3%eE1jh@F zAI18Cw?3&(*T0J+f`mo@n4tpj^+<2uzBlD!fmel=#&4{CfmpOZL8sUkMfK5Cs!sQwO68Qic~KDZ$!nn9HL zh;r6RP$@T5Y6G&6$@@rcs_EdF5dJPif*+lxp856*XqUZBB8t3-#Y~XHdW@zDMN zZkgi$ta1N&b?5(Y4E=3mE&2WFE~!Sa0hWx#h0o%hQa{{U^%aJp<-d2V%6#QYg%xGH zul_plVCSJ9XKeF6rsV-n^RP69KQ|EEUmd7$47X4Mg1Y|0B&}k5f|2KkPkQ2%`h7dU zu4M}bFDQSr`7-+k5{YPyR^8NdAoo`9ikGEm;}cLNFgsC=)0!TQY*uA2r0}({H67{b ze@TV}&AhLs`drEdULUVw!=R#xCXWj6&5Z!1BfL$~C zE|i{JB(-PV9WNXIaoA*A30QvS$dNX!l$&PBP%3+a{beG%S;*jD%je!qc z_0lLQZ%PRg6o*_DKsx~bsI!5IT5WS6D0jeZiGmo%hi0N1K({R3JhRXbCl{5r@g;qm z1uX(0vddva;nMv5ciB@}u}|W*vl#kVh55N(9O!d1a+ZI9@z{_FIq6X(e^_*&E*Ki(0|5y`FzZ!ES6Ej$)Sao4CCf2RG40v_Z&{Gd_7JBH$&;1RvH ze}tL-jr7U>#CwWwTB2eE*Hz_vCo4a`PKz{T{?x9RxXQJFGMmlPWu5}#+W#hQz(TP%Cx4Wu*CR4ypt0u z`-@Sdxmy5AU8nnUm=3mx3qYk>{Y`(qAxd1(%DU?RzYI^k;eTW3wUg8Ee;jz5ny_T7 z|D?+ueIMm3{_A30{!siMCpauVIN*+)`S@?j>6c%yT`tJ94Az{25^xM_!Mlg=yu#~8 z3?<7`J`5+Go@N&@S~3l06zFxQ`23XX*m%o!zBB!$YTY4=Ph?5PRmH@hby5ZO@hz-M zZa}(rZ1{emC6DGk=rc`iX|jR<$cuYG70QY;sOt4)^1af85lO>7f#|0}V$QwnC}f1H z3z2x#?_VVjM!wXkh)V*=iw*((7>6!(Hdh@1c^b}<30?f(3W!%PEplNyc*VRa*}EMr zW~*}6vRVcdJq?b5W~uP@s*@UH%sP!PsSn^3%vWyqO?XoZ31;^GN?+RiDR!s68^4wN zxqi@Z!J2cMZW2yJBle&~jqbpV4gXWcQpFZFFr4=8;cTD1wn3DBF*?Qru0UdUWKo$Z z8D<-@GC%<;Z;m9R4={&)w_IC7o`-}=>hzn**LxY>_tGs<*^XkuDJKK-?G9nQXDAw< zoORy`Bah52nS34}Ruo;5{`8?aT}DTmF8>utzY$ykN#olIhM9lrUG{>e7x+Ne2n)TU*Zcj;&W3(af zM2wgis__6UKG=ZkYOL!1;mc~WHHWA9LsqtL~s-KVphTwHzcD9`9&iFAhO9k zTxeez?fsOOxCu;P2ly zA^BOP{)r@b?@L04=DPN(Z?Zc5WKKS9WxY-d`v$ik2hd4I2kL5p8YB&>$IVUB8 zA?W{{L4Q9R3jc2m!8iq0r5s#Xx?HC&3ak~pR!8X$mW)-<7hI6Q@S(JlN_E<1@^AYP zP0nm-Pmo+bJ>m&0<@7|pi5z_jw#$WIs+guA{Z zH!c<3YIheU&T}M7v@yb)#*mbaa9i1APFT&(cMaov-RL2-ZloUiRDB2tDLsa_wE&)B3|n#=@X(hJvFDz? z`8sMhWjb#_T*0>l>-L(P%q;a%vdBO5xVoJ;MB;7FaEjwi7ep-e@OHJc6}E0LK+@jv(}-rDLkHtnpqPVEETdshaY3i06IMDyWvA_;~o18ot(G*{tET@>nD!ZNSj zFyw6;R^$V$ur$mG4w!`Q2Q6=@T7C%*3V=ibEa(}c{UhtOM1;uL7&$yzj1@Rx011{t zDp(;oW@x^RTd|Q`-DE*fXw#REsUv!BFI~N_Wp&qi&{w>gS~QC*IcZPLeQVV7X_KCk zwRSS94u~%IDDT55#Qpt<%ueGvvoi0}+#BV9#j0qQ*17^Eg~w}DH}fnmp>4NT7;UnC?~-xR%{gaH_CYY;{N2G|;&HPl`xb=Iik$@>4;`#4 zRi~9VE~)cvRzlPmMkNxcmdv^+Ao_x)O!Bp)_uT^g?ru)i{{T{K>%SQKC!rB`9^!zd z`Yg156K%M?@l&s@RXRw3?Q(rVW`pvL)itm*1^d<$jKDBbSW+--ms_-jB{T+?UmqWT zL;ss{T6ztDiI}%hC|6>opP_E?Js*zfEF1TWfL@h{f~a`n+_9EBN)z#Ju1|?LuU{QY ziX84%z-)9QnqQpwtzG{pWTJal$Fxu>M%pOfr7#Xzp0a;b^XGn@pl-!#EcV4ei=?x- zhT1|+j>~6onI}gCaW>= zi^XTdf#!bdurKKn;`Z+6k_o9L?`U~76%4>>Tu_5)k7x)mf+p_F5SId=+zkj_EgTMt zGS4|xRLru*`u2j)a6XqpioP^qIiHx4vBewSH(fVa`|hr?_;q|WqEuUGSKFyy z0^*D;go#&wc73@4GP#1wL*;ow#gTPW^FHvoEy#;85t0vaRO{?X*2)| zz8db1Taxz{VFM^&Yy$$sI}nLROgX{}^%dWbQcei%iOu~)df=GOIlXoiArXLQRHFk3 z583eL($m~Ec5i4$wc3Fr;?uH915G5Q@YZ2$mo{x`C}&cHm7N zk#n0%1(|T4Ok~6fP%U7T7ixi{#5HeYa2H`Cc3F^bsR84}EO<=fQS~a8ow$El#So9b z0dKvA^_I!mVdiwDb@1k*e3S~ub$eCzE93xZ%jCPOH_pS}+e_P==FKy3QieF&hz<9K zHZxH$^+nxIQg3z=a`39jFF`qh-Do;!{TGMGicI|lpk2mM0?h)IK#}*PSrI-MTG2hT z4JduNWcl{2dyn*#%=ivCmVOUR#{vK)(+6f3eQ69a(`r9(Kj2~!Wzl&UAM-D<)?$p+ zPUOt`}S?KB8BS**$g7M?D%zMlRc(MyQ5cKY6XZ#-kf_?09{1-$2eLn=_6#njVtw*9!-)~_U>I(dRI{e{pVm;}8 z8Z2!a);`p@R}%05OA3bVa*AKts2YTVA6Sl$x5~?o@rNPk_nZ`tqmKn^aFm&{2vRtK z(uCDJl1U1F386CZ-Z;{T)O*Gz^vPvWk!qP{q2HxEh$`98dgQn|TciC2J4^P15TD<~ z;VDKZ6V7*4DPX9bzY|lM>ALqSBi)24)HrIY_~yLg8;*V%>G&mTL^T2hBS<6g9;-gt z!5x=@OvT_64PJN-cnJMuoZhT$Mw9q2n8#nVp%ajXAlu9;DZb63adV@Q6fF&G_Z0m$ zQ&Ns?(|{B;q&W3NhVfpS2KAn>?$Zf2!Z-@8d{%^~6sJ9uK+e6RV|B*$n>|HRCVW@X z#?3&)4hT9b(}{x)#YJ=2O-r}ucXNsb2>byc3l=_te9ebbamO$7eYas37j7pm@jjyR zKQKHys6WZXAvCpY?lM`E`KrW$R0_457<8FmxnzCu2$je(<2K&;m^-a|1dvCsguHDK zeD3{r?6;4dv}pXu5H93_Ho%-YRddmd$OKj3UbQ+#Mspt~3Ue^VVM}lY-o^gDM4d$d zWcMEozoUw@M=si5TkrRp%#!{AD=+(1OD+^^HEvyMly}yauOByIEw0`)mRh~blh&a< zx3t%njG`V-#N``9(2ct$T&`X z0x~SVV9t^?tDD_-vNLbx>M0Z^7o$NFLip!S}nL1z5)z~fF` znBWxlAQ1hFp?~ypj__105gD5>?}M0LtBL^UH|dD)u=b&9;dyCI} z%BNp^#V`z=-66qRA8xhU+aML5$KAXT{KG>Ew;z{<1lhx@gp1*es)h@r^CCNTAHNd= z?~PMZ=`v`Q6-iRV?wW#E{E(EL>IOcT(MIjmSFhW}TDi6`6+MN6#*#8`Y2n^AcYzg{ zG5E}o^%Jk0xV6p3_Q-#i33GdP7u%80&FUP)8erHqpiNrPu`OvUR07DKydH6}&H?M} z`6DO0BT8)zU+!7j)jE}0&f(76>SHTPNRx?8Mkzwyf;YS`HFQq$6pI6H6Ap znfYl1u~5ax6eJ83MaAI=EHve6yg};Jn$sL~PyFG5k(VP+*Ejko0OdJ}G}%V#vkF=A zDj!8s8eFEqXw=W{Gpup|On2E76r%8)63QaS_wH-}8PJVTC%}(*wJ_@6{qM-fj96Hly(Pj4ShIsl|=rydHTj%`O-B%c{9t~ zni7{ynD}vNT-&`-s`>QX33q~*Qur4t?q!;>+iE3W98=X{G`|2+WuDS+ff zmGSF1{%kJA10&{02wR#baU3?lPI6Zdb!V~Fc};NMC8@l(f?r*SR@db>Cf1%zH&ITs zqGzLaaDf3g$6SAi-+bxa^Uk4Ne}u`<9~e3~uDg98?!R63mh0aCkv z_qMoz1DopEb=ql_x|L;ej@m~!6cMG1A*|=6tjy~VkQo{qw zFU}+Bh}~`h-l~Ow=Rx@|94nH4TkvWt0>gTkonX9NHiknqOs;S{h15n-UiR?khXf|D zjs!9K4^%2+tpxj`Vo!kJp1k6%>(k>(Ve79w`A+nvsElzGn#k7xsV=vIaWDBs?C=31 zi8&#I3l-G5y?qDAJ~N}?MdWxCq$^@Km9+usv{e^@yvxE>nZ11lZw3^}Z1wmIXWQM)}><1vnS9nC$xVEh>* z6GLKC%OtoWZMygSNptM^6xEWz5k&f_EIRN8vhJ5;!#0mWy!TTgnf|m;c902Ga8g!> zPIfC5jSC-m;QTPDCyPTP$Q5xsY9Uo*R8vW~H(uG8GsVGu95YHoTe55rtN|dt@pNT0`&55ELVY6ip^%L@lc0q~TeM=mxqA?&4T=t*p#e>0t@D(5F10N&LoHI{omwRvJ(yqXZ!37he!Rv z?W^d_;|rsB9Ald0Q)D=YYp~qpbgGX%2s!5D*%Pj8bVXD{_I-=M$%U5w^kewwE}`8i zORs1^&BZiEQb!6B{%qpEULDP=w@=GNm-`CRWeI%)u)a}mdO>_ zEI%Al=3*UHewE%MJ-$q#g}fBean$b$fAFpNp8v+^*4(7sF)%L~hi6ch0qMb#4IXN?jPI z##X;$grLPa5_S2US*qdDCqQcC`EAlSUJa zGCL6uGQAO)DV7d=xc+gJN{4f67nmU(Us0wC-@kVQ>FYauko)7PBpO_Up1-8IkS{Ap z;Ew&IXO>o?tvy`m)Bz%$peP5v zui>Qp(m6&sA8$E^`>M*U#XWY#2X=AR+L`)CVq5}tL4_7{ql=U-Z!5+p`d?Jrnva}dAC*bv`p+jJ)Il%Vv2O2)RoVZ z?`&q|H;FLYykpgm!eGs{8&h&NEvi5F