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 bf9c52f098a380f48122081f36a3db436e6cd686..36466203e62772efb9c76287a21cadd4c475926d 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,7 @@ static std::map<AVCodecID, std::string_view> g_codecIdToMime = {
     {AV_CODEC_ID_COOK, MimeType::AUDIO_COOK},
 #endif
     {AV_CODEC_ID_AC3, MimeType::AUDIO_AC3},
+    {AV_CODEC_ID_EAC3, MimeType::AUDIO_EAC3},
     {AV_CODEC_ID_SUBRIP, MimeType::TEXT_SUBRIP},
     {AV_CODEC_ID_WEBVTT, MimeType::TEXT_WEBVTT},
 #ifdef SUPPORT_DEMUXER_LRC
@@ -145,6 +146,7 @@ static std::map<std::string, FileType> g_convertFfmpegFileType = {
     {"mpeg", FileType::MPEGPS},
     {"rm", FileType::RM},
     {"ac3", FileType::AC3},
+    {"eac3", FileType::EAC3},
     {"ape", FileType::APE},
     {"srt", FileType::SRT},
     {"webvtt", FileType::VTT},
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 64c61969dfe4e1a07fb6a441896cd6e33bc8106f..1e0f4a80f2342a48416f5b01ec8acd149b9eba9a 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -249,6 +249,8 @@ group("av_codec_fuzz_test") {
       "fuzztest/demuxerapi11_fuzzer:DemuxerAPI11FuzzTest",
       "fuzztest/demuxeravi_fuzzer:DemuxerAviFuzzTest",
       "fuzztest/demuxeraviapi11_fuzzer:DemuxerAviAPI11FuzzTest",
+      "fuzztest/demuxereac3_fuzzer:DemuxerEac3FuzzTest",
+      "fuzztest/demuxereac3api11_fuzzer:DemuxerEac3API11FuzzTest",
       "fuzztest/demuxerflac_fuzzer:DemuxerFlacFuzzTest",
       "fuzztest/demuxerflacapi11_fuzzer:DemuxerFlacAPI11FuzzTest",
       "fuzztest/demuxerflv_fuzzer:DemuxerFlvFuzzTest",
@@ -275,6 +277,7 @@ group("av_codec_fuzz_test") {
       "fuzztest/demuxerpluginamr_fuzzer:DemuxerPluginAmrFuzzTest",
       "fuzztest/demuxerpluginape_fuzzer:DemuxerPluginApeFuzzTest",
       "fuzztest/demuxerpluginavi_fuzzer:DemuxerPluginAviFuzzTest",
+      "fuzztest/demuxerplugineac3_fuzzer:DemuxerPluginEac3FuzzTest",
       "fuzztest/demuxerpluginflac_fuzzer:DemuxerPluginFlacFuzzTest",
       "fuzztest/demuxerpluginflvtest_fuzzer:DemuxerPluginFlvtestFuzzTest",
       "fuzztest/demuxerpluginfmp4_fuzzer:DemuxerPluginFmp4FuzzTest",
diff --git a/test/fuzztest/demuxereac3_fuzzer/BUILD.gn b/test/fuzztest/demuxereac3_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..874589297163875016a9c992e9bfa507ef2765f3
--- /dev/null
+++ b/test/fuzztest/demuxereac3_fuzzer/BUILD.gn
@@ -0,0 +1,64 @@
+# 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.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+module_output_path = "av_codec/av_codec"
+MEDIA_ROOT_DIR = "//foundation/multimedia/av_codec/"
+
+##############################fuzztest##########################################
+ohos_fuzztest("DemuxerEac3FuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "$MEDIA_ROOT_DIR/test/fuzztest/demuxereac3_fuzzer"
+  include_dirs = [
+    "$MEDIA_ROOT_DIR/interfaces/kits/c",
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxer_fuzzer",
+  ]
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxer_fuzzer/demuxer_sample.cpp",
+    "demuxereac3_fuzzer.cpp",
+  ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_single",
+    "media_foundation:native_media_core",
+    "window_manager:libwm",
+  ]
+  deps = [
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native:av_codec_client",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_avdemuxer",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_avsource",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_codecbase",
+  ]
+  resource_config_file =
+      "$MEDIA_ROOT_DIR/test/moduletest/resources/ohos_test.xml"
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":DemuxerEac3FuzzTest",
+  ]
+}
+###############################################################################
diff --git a/test/fuzztest/demuxereac3_fuzzer/corpus/eac3_test.eac3 b/test/fuzztest/demuxereac3_fuzzer/corpus/eac3_test.eac3
new file mode 100644
index 0000000000000000000000000000000000000000..e32336af547a7bbfd658caf458207fccba353c0a
Binary files /dev/null and b/test/fuzztest/demuxereac3_fuzzer/corpus/eac3_test.eac3 differ
diff --git a/test/fuzztest/demuxereac3_fuzzer/demuxereac3_fuzzer.cpp b/test/fuzztest/demuxereac3_fuzzer/demuxereac3_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..976a996e3762351bdc44a02951f8a5c922d4e006
--- /dev/null
+++ b/test/fuzztest/demuxereac3_fuzzer/demuxereac3_fuzzer.cpp
@@ -0,0 +1,117 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "securec.h"
+#include <fuzzer/FuzzedDataProvider.h>
+#include <iostream>
+#include "demuxer_sample.h"
+
+#define FUZZ_PROJECT_NAME "demuxer_fuzzer"
+using namespace std;
+using namespace OHOS::Media;
+namespace OHOS {
+const char *EAC3_PATH = "/data/test/fuzz_create.eac3";
+const int64_t EXPECT_SIZE = 36;
+const size_t URI_BUFFER_SIZE = 21;
+const int64_t URI_COUNT = 20;
+const char FLAG = '\0';
+const size_t LANGUAGE_BUFFER_SIZE = 3;
+const size_t LANGUAGE_COUNT = 2;
+bool CheckDataValidity(FuzzedDataProvider *fdp, size_t size)
+{
+    if (size <= EXPECT_SIZE) {
+        return false;
+    }
+    int32_t fd = open(EAC3_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+    if (fd < 0) {
+        return false;
+    }
+    uint8_t *pstream = nullptr;
+    uint16_t framesize = fdp->ConsumeIntegralInRange<uint16_t>(0, 0xfff);
+    pstream = (uint8_t *)malloc(framesize * sizeof(uint8_t));
+    if (!pstream) {
+        std::cerr << "Memory alloction failed" << std::endl;
+        return false;
+    }
+    fdp->ConsumeData(pstream, framesize);
+    int len = write(fd, pstream, framesize);
+    if (len <= 0) {
+        close(fd);
+        free(pstream);
+        pstream = nullptr;
+        return false;
+    }
+    close(fd);
+    free(pstream);
+    pstream = nullptr;
+    return true;
+}
+bool DemuxerFuzzTest(const uint8_t *data, size_t size)
+{
+    FuzzedDataProvider fdp(data, size);
+    if (!CheckDataValidity(&fdp, size)) {
+        return false;
+    }
+    struct Params params;
+    params.time = fdp.ConsumeIntegral<int64_t>();
+    char *uri = new char[URI_BUFFER_SIZE];
+    if (strncpy_s(uri, URI_BUFFER_SIZE, fdp.ConsumeBytesAsString(URI_COUNT).c_str(), URI_COUNT) != 0) {
+        delete[] uri;
+        return false;
+    }
+    uri[URI_COUNT] = FLAG;
+    params.setTrackType = fdp.ConsumeIntegral<int64_t>();
+    params.setDuration = fdp.ConsumeIntegral<int64_t>();
+    params.setHeight = fdp.ConsumeIntegral<int64_t>();
+    params.setFrameRate = fdp.ConsumeIntegral<int64_t>();
+    char *setLanguage = new char[LANGUAGE_BUFFER_SIZE];
+    if (strncpy_s(setLanguage, LANGUAGE_BUFFER_SIZE, fdp.ConsumeBytesAsString(LANGUAGE_COUNT).c_str(),
+        LANGUAGE_COUNT) != 0) {
+        delete[] uri;
+        delete[] setLanguage;
+        return false;
+    }
+    setLanguage[LANGUAGE_COUNT] = FLAG;
+    params.setCodecConfigSize = fdp.ConsumeIntegral<uint8_t>();
+    params.sampleRate = fdp.ConsumeIntegral<int32_t>();
+    params.channelCount = fdp.ConsumeIntegral<int32_t>();
+    params.setVideoHeight = fdp.ConsumeIntegral<int32_t>();
+    params.setVideoWidth = fdp.ConsumeIntegral<int32_t>();
+    uint32_t createSize = fdp.ConsumeIntegral<uint32_t>();
+    shared_ptr<DemuxerSample> demuxerSample = make_shared<DemuxerSample>();
+    demuxerSample->filePath = EAC3_PATH;
+    demuxerSample->RunNormalDemuxer(createSize, uri, setLanguage, params);
+    delete[] uri;
+    delete[] setLanguage;
+    int ret = remove(EAC3_PATH);
+    if (ret != 0) {
+        return false;
+    }
+    return true;
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::DemuxerFuzzTest(data, size);
+    return 0;
+}
diff --git a/test/fuzztest/demuxereac3_fuzzer/project.xml b/test/fuzztest/demuxereac3_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..56add82b410638f779e206084098030cccdf7aa3
--- /dev/null
+++ b/test/fuzztest/demuxereac3_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>10240000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/test/fuzztest/demuxereac3api11_fuzzer/BUILD.gn b/test/fuzztest/demuxereac3api11_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..b039c6dbe64f601ad3580afc3a2e4a052b38cea6
--- /dev/null
+++ b/test/fuzztest/demuxereac3api11_fuzzer/BUILD.gn
@@ -0,0 +1,64 @@
+# 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.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+module_output_path = "av_codec/av_codec"
+MEDIA_ROOT_DIR = "//foundation/multimedia/av_codec/"
+
+##############################fuzztest##########################################
+ohos_fuzztest("DemuxerEac3API11FuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "$MEDIA_ROOT_DIR/test/fuzztest/demuxereac3api11_fuzzer"
+  include_dirs = [
+    "$MEDIA_ROOT_DIR/interfaces/kits/c",
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxer_fuzzer",
+  ]
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxer_fuzzer/demuxer_sample.cpp",
+    "demuxereac3_fuzzer.cpp",
+  ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_single",
+    "media_foundation:native_media_core",
+    "window_manager:libwm",
+  ]
+  deps = [
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native:av_codec_client",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_avdemuxer",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_avsource",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_codecbase",
+  ]
+  resource_config_file =
+      "$MEDIA_ROOT_DIR/test/moduletest/resources/ohos_test.xml"
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":DemuxerEac3API11FuzzTest",
+  ]
+}
+###############################################################################
diff --git a/test/fuzztest/demuxereac3api11_fuzzer/corpus/eac3_test.eac3 b/test/fuzztest/demuxereac3api11_fuzzer/corpus/eac3_test.eac3
new file mode 100644
index 0000000000000000000000000000000000000000..e32336af547a7bbfd658caf458207fccba353c0a
Binary files /dev/null and b/test/fuzztest/demuxereac3api11_fuzzer/corpus/eac3_test.eac3 differ
diff --git a/test/fuzztest/demuxereac3api11_fuzzer/demuxereac3_fuzzer.cpp b/test/fuzztest/demuxereac3api11_fuzzer/demuxereac3_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9fad45bf0929f7638f3835fb4b436de5c14419a2
--- /dev/null
+++ b/test/fuzztest/demuxereac3api11_fuzzer/demuxereac3_fuzzer.cpp
@@ -0,0 +1,117 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "securec.h"
+#include <fuzzer/FuzzedDataProvider.h>
+#include <iostream>
+#include "demuxer_sample.h"
+
+#define FUZZ_PROJECT_NAME "demuxer_fuzzer"
+using namespace std;
+using namespace OHOS::Media;
+namespace OHOS {
+const char *EAC3_PATH = "/data/test/fuzz_create.eac3";
+const int64_t EXPECT_SIZE = 36;
+const size_t URI_BUFFER_SIZE = 21;
+const int64_t URI_COUNT = 20;
+const char FLAG = '\0';
+const size_t LANGUAGE_BUFFER_SIZE = 3;
+const size_t LANGUAGE_COUNT = 2;
+bool CheckDataValidity(FuzzedDataProvider *fdp, size_t size)
+{
+    if (size <= EXPECT_SIZE) {
+        return false;
+    }
+    int32_t fd = open(EAC3_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+    if (fd < 0) {
+        return false;
+    }
+    uint8_t *pstream = nullptr;
+    uint16_t framesize = fdp->ConsumeIntegralInRange<uint16_t>(0, 0xfff);
+    pstream = (uint8_t *)malloc(framesize * sizeof(uint8_t));
+    if (!pstream) {
+        std::cerr << "Memory alloction failed" << std::endl;
+        return false;
+    }
+    fdp->ConsumeData(pstream, framesize);
+    int len = write(fd, pstream, framesize);
+    if (len <= 0) {
+        close(fd);
+        free(pstream);
+        pstream = nullptr;
+        return false;
+    }
+    close(fd);
+    free(pstream);
+    pstream = nullptr;
+    return true;
+}
+bool DemuxerFuzzTest(const uint8_t *data, size_t size)
+{
+    FuzzedDataProvider fdp(data, size);
+    if (!CheckDataValidity(&fdp, size)) {
+        return false;
+    }
+    struct Params params;
+    params.time = fdp.ConsumeIntegral<int64_t>();
+    char *uri = new char[URI_BUFFER_SIZE];
+    if (strncpy_s(uri, URI_BUFFER_SIZE, fdp.ConsumeBytesAsString(URI_COUNT).c_str(), URI_COUNT) != 0) {
+        delete[] uri;
+        return false;
+    }
+    uri[URI_COUNT] = FLAG;
+    params.setTrackType = fdp.ConsumeIntegral<int64_t>();
+    params.setDuration = fdp.ConsumeIntegral<int64_t>();
+    params.setHeight = fdp.ConsumeIntegral<int64_t>();
+    params.setFrameRate = fdp.ConsumeIntegral<int64_t>();
+    char *setLanguage = new char[LANGUAGE_BUFFER_SIZE];
+    if (strncpy_s(setLanguage, LANGUAGE_BUFFER_SIZE, fdp.ConsumeBytesAsString(LANGUAGE_COUNT).c_str(),
+        LANGUAGE_COUNT) != 0) {
+        delete[] uri;
+        delete[] setLanguage;
+        return false;
+    }
+    setLanguage[LANGUAGE_COUNT] = FLAG;
+    params.setCodecConfigSize = fdp.ConsumeIntegral<uint8_t>();
+    params.sampleRate = fdp.ConsumeIntegral<int32_t>();
+    params.channelCount = fdp.ConsumeIntegral<int32_t>();
+    params.setVideoHeight = fdp.ConsumeIntegral<int32_t>();
+    params.setVideoWidth = fdp.ConsumeIntegral<int32_t>();
+    uint32_t createSize = fdp.ConsumeIntegral<uint32_t>();
+    shared_ptr<DemuxerSample> demuxerSample = make_shared<DemuxerSample>();
+    demuxerSample->filePath = EAC3_PATH;
+    demuxerSample->RunNormalDemuxerApi11(createSize, uri, setLanguage, params);
+    delete[] uri;
+    delete[] setLanguage;
+    int ret = remove(EAC3_PATH);
+    if (ret != 0) {
+        return false;
+    }
+    return true;
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::DemuxerFuzzTest(data, size);
+    return 0;
+}
diff --git a/test/fuzztest/demuxereac3api11_fuzzer/project.xml b/test/fuzztest/demuxereac3api11_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..56add82b410638f779e206084098030cccdf7aa3
--- /dev/null
+++ b/test/fuzztest/demuxereac3api11_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>10240000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/test/fuzztest/demuxerplugineac3_fuzzer/BUILD.gn b/test/fuzztest/demuxerplugineac3_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..8a6546fe167f15ca66b68c62a112c2123d49cffc
--- /dev/null
+++ b/test/fuzztest/demuxerplugineac3_fuzzer/BUILD.gn
@@ -0,0 +1,63 @@
+# 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.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+module_output_path = "av_codec/av_codec"
+MEDIA_ROOT_DIR = "//foundation/multimedia/av_codec/"
+
+##############################fuzztest##########################################
+ohos_fuzztest("DemuxerPluginEac3FuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "$MEDIA_ROOT_DIR/test/fuzztest/demuxerplugineac3_fuzzer"
+  include_dirs = [
+    "$MEDIA_ROOT_DIR/interfaces/kits/c",
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxerpluginmp4_fuzzer",
+    "$MEDIA_ROOT_DIR/services/media_engine/plugins/ffmpeg_adapter/demuxer",
+  ]
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [
+    "demuxerplugineac3_fuzzer.cpp",
+    "$MEDIA_ROOT_DIR/test/fuzztest/demuxerpluginmp4_fuzzer/demuxerplugintype_sample.cpp",
+  ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+    "media_foundation:native_media_core",
+    "window_manager:libwm",
+  ]
+  deps = [
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native:av_codec_client",
+    "$MEDIA_ROOT_DIR/services/media_engine/modules:av_codec_media_engine_modules",
+  ]
+  resource_config_file =
+      "$MEDIA_ROOT_DIR/test/moduletest/resources/ohos_test.xml"
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    ":DemuxerPluginEac3FuzzTest",
+  ]
+}
+###############################################################################
\ No newline at end of file
diff --git a/test/fuzztest/demuxerplugineac3_fuzzer/corpus/eac3_test.eac3 b/test/fuzztest/demuxerplugineac3_fuzzer/corpus/eac3_test.eac3
new file mode 100644
index 0000000000000000000000000000000000000000..e32336af547a7bbfd658caf458207fccba353c0a
Binary files /dev/null and b/test/fuzztest/demuxerplugineac3_fuzzer/corpus/eac3_test.eac3 differ
diff --git a/test/fuzztest/demuxerplugineac3_fuzzer/demuxerplugineac3_fuzzer.cpp b/test/fuzztest/demuxerplugineac3_fuzzer/demuxerplugineac3_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..478d40da9ca148491b63caaaa5d9c29541cb82b4
--- /dev/null
+++ b/test/fuzztest/demuxerplugineac3_fuzzer/demuxerplugineac3_fuzzer.cpp
@@ -0,0 +1,56 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <memory>
+#include <fuzzer/FuzzedDataProvider.h>
+#include "demuxerplugintype_sample.h"
+
+#define FUZZ_PROJECT_NAME "demuxerplugineac3_fuzzer"
+using namespace std;
+using namespace OHOS::Media;
+
+namespace OHOS {
+void DemuxerPluginFuzzWithFunc(const uint8_t *data, size_t size)
+{
+    std::shared_ptr<DemuxerPluginTypeTest> demuxerTest = std::make_shared<DemuxerPluginTypeTest>();
+    demuxerTest->testFilePath_ = "/data/test/demuxerplugineac3.eac3";
+    demuxerTest->demuxerPluginName_ = "avdemux_eac3";
+    FuzzedDataProvider fdp(data, size);
+    uint8_t *pstream = nullptr;
+    uint16_t framesize = fdp.ConsumeIntegralInRange<uint16_t>(0, 0xfff);
+    pstream = (uint8_t *)malloc(framesize * sizeof(uint8_t));
+    if (!pstream) {
+        std::cerr << "Memory alloction failed" << std::endl;
+        return;
+    }
+    fdp.ConsumeData(pstream, framesize);
+    bool ret = demuxerTest->InitWithData(pstream, framesize);
+    free(pstream);
+    pstream = nullptr;
+    if (ret) {
+        demuxerTest->RunDemuxerInterfaceFuzz();
+    }
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::DemuxerPluginFuzzWithFunc(data, size);
+    return 0;
+}
\ No newline at end of file
diff --git a/test/fuzztest/demuxerplugineac3_fuzzer/project.xml b/test/fuzztest/demuxerplugineac3_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..67fc9c58258ba6eee265b34a9c609df6448e95cf
--- /dev/null
+++ b/test/fuzztest/demuxerplugineac3_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>10240000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>5120</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/test/moduletest/resources/ohos_test.xml b/test/moduletest/resources/ohos_test.xml
index e7e7275c81bb7575dc92a339145f79cb5c4c8ba9..0ca93254b727663510c8218db0731ab317c84cad 100644
--- a/test/moduletest/resources/ohos_test.xml
+++ b/test/moduletest/resources/ohos_test.xml
@@ -168,6 +168,18 @@
             <option name="shell" value="restorecon /data/test/"/>
         </preparer>
 	</target>
+    <target name="DemuxerEac3FuzzTest">
+        <preparer>
+            <option name="shell" value="mkdir -p /data/test/"/>
+            <option name="shell" value="restorecon /data/test/"/>
+        </preparer>
+	</target>
+    <target name="DemuxerEac3API11FuzzTest">
+        <preparer>
+            <option name="shell" value="mkdir -p /data/test/"/>
+            <option name="shell" value="restorecon /data/test/"/>
+        </preparer>
+	</target>
 	<target name="DemuxerFlacFuzzTest">
         <preparer>
             <option name="shell" value="mkdir -p /data/test/"/>
diff --git a/test/unittest/avsource_test/avsource_unit_test.cpp b/test/unittest/avsource_test/avsource_unit_test.cpp
index eea04c3096da4708fe02d87403ea9ed74b41c6d6..b8044d729d9b1c2a5f714140ffcf919b57650738 100644
--- a/test/unittest/avsource_test/avsource_unit_test.cpp
+++ b/test/unittest/avsource_test/avsource_unit_test.cpp
@@ -96,6 +96,9 @@ string g_samiPath = TEST_FILE_PATH + string("sami_test.smi");
 string g_assPath = TEST_FILE_PATH + string("ass_test.ssa");
 string g_mp4AuxlPath = TEST_FILE_PATH + string("muxer_auxl_265_264_aac.mp4");
 string g_mp4AuxlUri = TEST_URI_PATH + string("muxer_auxl_265_264_aac.mp4");
+string g_eac3Path = TEST_FILE_PATH + string("audio/eac3_test.eac3");
+string g_eac3Uri = TEST_URI_PATH + string("audio/eac3_test.eac3");
+string g_eac3ErrorPath = TEST_FILE_PATH + string("audio/test_error.eac3");
 
 } // namespace
 
@@ -466,6 +469,52 @@ void AVSourceUnitTest::CheckAuxlAac()
     checkPass_ = true;
 }
 
+void AVSourceUnitTest::CheckEac3MediaInfo()
+{
+    checkPass_ = false;
+    format_ = source_->GetSourceFormat();
+    ASSERT_NE(format_, nullptr);
+    printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
+    ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
+    ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
+    ASSERT_EQ(formatVal_.duration, 11066500);
+    ASSERT_EQ(formatVal_.trackCount, 1);
+#ifdef AVSOURCE_INNER_UNIT_TEST
+    ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
+    ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
+    ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
+    ASSERT_EQ(formatVal_.hasVideo, 0);
+    ASSERT_EQ(formatVal_.hasAudio, 1);
+    ASSERT_EQ(formatVal_.fileType, 110);
+#endif
+    ASSERT_EQ(source_->Destroy(), AV_ERR_OK);
+    checkPass_ = true;
+}
+
+void AVSourceUnitTest::CheckEac3StreamInfo()
+{
+    checkPass_ = false;
+    trackIndex_ = 0;
+    format_ = source_->GetTrackFormat(trackIndex_);
+    ASSERT_NE(format_, nullptr);
+    printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
+    ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
+    ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
+    ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
+    ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
+    ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
+    ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
+    ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
+    ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
+    ASSERT_EQ(formatVal_.sampleRate, 44100);
+    ASSERT_EQ(formatVal_.channelCount, 2);
+    ASSERT_EQ(formatVal_.bitRate, 191559);
+    ASSERT_EQ(formatVal_.codecMime, "audio/eac3");
+    ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
+    ASSERT_EQ(formatVal_.channelLayout, 3);
+    checkPass_ = true;
+}
+
 /**********************************source FD**************************************/
 namespace {
 /**
@@ -651,6 +700,20 @@ HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithFD_1090, TestSize.Level1)
     close(fd2);
 }
 
+/**
+ * @tc.name: AVSource_CreateSourceWithFD_1100
+ * @tc.desc: create source with fd, but file is error
+ * @tc.type: FUNC
+ */
+HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithFD_1100, TestSize.Level1)
+{
+    printf("---- %s ----\n", g_eac3ErrorPath.c_str());
+    fd_ = OpenFile(g_eac3ErrorPath);
+    size_ = GetFileSize(g_eac3ErrorPath);
+    source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
+    ASSERT_EQ(source_, nullptr);
+}
+
 /**
  * @tc.name: AVSource_CreateSourceWithDataSource_Compare_Fd_1000
  * @tc.desc: destroy source
@@ -3064,4 +3127,64 @@ HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithDataSourceExt_1000, TestSize
     delete infile1;
     delete infile2;
 }
+
+/**
+ * @tc.name: AVSource_GetFormat_1809
+ * @tc.desc: get source format(eac3)
+ * @tc.type: FUNC
+ */
+HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1809, TestSize.Level1)
+{
+    ASSERT_EQ(access(g_eac3Path.c_str(), F_OK), 0);
+    fd_ = OpenFile(g_eac3Path);
+    size_ = GetFileSize(g_eac3Path);
+    printf("---- %s ----\n", g_eac3Path.c_str());
+    source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
+    ASSERT_NE(source_, nullptr);
+    CheckEac3MediaInfo();
+    ASSERT_TRUE(checkPass_);
+}
+
+/**
+ * @tc.name: AVSource_GetFormat_1810
+ * @tc.desc: get format when the file is eac3
+ * @tc.type: FUNC
+ */
+HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1810, TestSize.Level1)
+{
+    ASSERT_EQ(access(g_eac3Path.c_str(), F_OK), 0);
+    fd_ = OpenFile(g_eac3Path);
+    size_ = GetFileSize(g_eac3Path);
+    printf("---- %s ------\n", g_eac3Path.c_str());
+    source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
+    ASSERT_NE(source_, nullptr);
+    CheckEac3StreamInfo();
+    ASSERT_TRUE(checkPass_);
+}
+
+/**
+ * @tc.name: AVSource_GetFormat_1811
+ * @tc.desc: get source format(eac3 url)
+ * @tc.type: FUNC
+ */
+HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1811, TestSize.Level1)
+{
+    InitResource(g_eac3Uri, URI);
+    ASSERT_TRUE(initStatus_);
+    CheckEac3MediaInfo();
+    ASSERT_TRUE(checkPass_);
+}
+
+/**
+ * @tc.name: AVSource_GetFormat_1812
+ * @tc.desc: get format when the file is eac3(url)
+ * @tc.type: FUNC
+ */
+HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1812, TestSize.Level1)
+{
+    InitResource(g_eac3Uri, URI);
+    ASSERT_TRUE(initStatus_);
+    CheckEac3StreamInfo();
+    ASSERT_TRUE(checkPass_);
+}
 } // namespace
diff --git a/test/unittest/avsource_test/avsource_unit_test.h b/test/unittest/avsource_test/avsource_unit_test.h
index 679006a409226a2aff9d3842041e67d926470539..86a5223c74670bc6bfed9ba2cd3a8bfcba731506 100644
--- a/test/unittest/avsource_test/avsource_unit_test.h
+++ b/test/unittest/avsource_test/avsource_unit_test.h
@@ -118,6 +118,8 @@ protected:
     void CheckAuxlHevc();
     void CheckAuxlAvc();
     void CheckAuxlAac();
+    void CheckEac3MediaInfo();
+    void CheckEac3StreamInfo();
 };
 } // namespace MediaAVCodec
 } // namespace OHOS
diff --git a/test/unittest/demuxer_test/demuxer_unit_test.cpp b/test/unittest/demuxer_test/demuxer_unit_test.cpp
index 908aab8449c38ec98a50b90969bc3722206d3fd3..86be1919b43ba4eea823e4a40591dc969e6b4cf5 100644
--- a/test/unittest/demuxer_test/demuxer_unit_test.cpp
+++ b/test/unittest/demuxer_test/demuxer_unit_test.cpp
@@ -105,6 +105,7 @@ string g_aigcStrMovPath = TEST_FILE_PATH + string("aigc_str.mov");
 string g_aigcStrFlvPath = TEST_FILE_PATH + string("aigc_str.flv");
 string g_aigcStrMkvPath = TEST_FILE_PATH + string("aigc_str.mkv");
 string g_aigcStrAviPath = TEST_FILE_PATH + string("aigc_str.avi");
+string g_eac3Path = TEST_FILE_PATH + string("audio/eac3_test.eac3");
 } // namespace
 
 void DemuxerUnitTest::SetUpTestCase(void)
@@ -580,6 +581,25 @@ HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1090, TestSize.Level1)
     ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
 }
 
+/**
+ * @tc.name: Demuxer_UnselectTrackByID_1110
+ * @tc.desc: select and remove track by ID
+ * @tc.type: FUNC
+ */
+HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1110, TestSize.Level1)
+{
+    InitResource(g_eac3Path, LOCAL);
+    ASSERT_TRUE(initStatus_);
+    ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
+    ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
+    ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
+    ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
+    ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
+    ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
+    ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
+    ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
+}
+
 /**
  * @tc.name: Demuxer_UnselectTrackByID_1100
  * @tc.desc: select and remove track by ID
@@ -3485,6 +3505,69 @@ HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1807, TestSize.Level1)
     ASSERT_TRUE(seekTestFlag_);
 }
 
+/**
+ * @tc.name: Demuxer_ReadSample_1807
+ * @tc.desc: copy current sample to buffer(eac3)
+ * @tc.type: FUNC
+ */
+HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1807, TestSize.Level1)
+{
+    InitResource(g_eac3Path, LOCAL);
+    ASSERT_NE(source_, nullptr);
+    ASSERT_NE(format_, nullptr);
+    ASSERT_NE(demuxer_, nullptr);
+    ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
+    sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
+    ASSERT_NE(sharedMem_, nullptr);
+    ASSERT_TRUE(SetInitValue());
+    while (!isEOS(eosFlag_)) {
+        for (auto idx : selectedTrackIds_) {
+            ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
+            CountFrames(idx);
+        }
+    }
+    printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
+    ASSERT_EQ(frames_[0], 317);
+    ASSERT_EQ(keyFrames_[0], 317);
+    RemoveValue();
+    ASSERT_EQ(demuxer_->Destroy(), AV_ERR_OK);
+}
+
+/**
+ * @tc.name: Demuxer_SeekToTime_1808
+ * @tc.desc: seek to the specified time(eac3)
+ * @tc.type: FUNC
+ */
+HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1808, TestSize.Level1)
+{
+    InitResource(g_eac3Path, LOCAL);
+    ASSERT_TRUE(SetInitValue());
+    for (auto idx : selectedTrackIds_) {
+        ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
+    }
+    list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000, 8000}; // ms
+    vector<int32_t> audioVals = {317, 317, 317, 187, 188, 188, 115, 116, 116, 259, 260, 260, 29, 30, 30, 87, 88, 88};
+    sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
+    ASSERT_NE(sharedMem_, nullptr);
+    for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
+        for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
+            ret_ = demuxer_->SeekToTime(*toPts, *mode);
+            if (ret_ != AV_ERR_OK) {
+                printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
+                continue;
+            }
+            ReadData();
+            printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
+            ASSERT_EQ(frames_[0], audioVals[numbers_]);
+            numbers_ += 1;
+            RemoveValue();
+            selectedTrackIds_.clear();
+        }
+    }
+    ASSERT_NE(demuxer_->SeekToTime(12000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
+    ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
+}
+
 /**
  * @tc.number    : Demuxer_GetReservedBuffer_1000
  * @tc.name      : demux MP4 muxed by avmuxer,check user reserved buffer
diff --git a/test/unittest/resources/demuxer_res/audio/eac3_test.eac3 b/test/unittest/resources/demuxer_res/audio/eac3_test.eac3
new file mode 100644
index 0000000000000000000000000000000000000000..e32336af547a7bbfd658caf458207fccba353c0a
Binary files /dev/null and b/test/unittest/resources/demuxer_res/audio/eac3_test.eac3 differ
diff --git a/test/unittest/resources/demuxer_res/audio/test_error.eac3 b/test/unittest/resources/demuxer_res/audio/test_error.eac3
new file mode 100644
index 0000000000000000000000000000000000000000..7bc769b32e9d99de36363a346ad444958edc66f6
Binary files /dev/null and b/test/unittest/resources/demuxer_res/audio/test_error.eac3 differ