Backup:ffmpeg test.

hal/src/HalMakePtr.cpp

@@ -89,10 +89,11 @@ StatusCode HalMakePtr::CreateWifiHal(std::shared_ptr<VWifiHal> &impl)
     impl = std::make_shared<WifiHal>();
     return CreateStatusCode(STATUS_CODE_OK);
 }
-StatusCode HalMakePtr::CreateCameraHal(std::shared_ptr<VCameraHal> &impl)
+std::shared_ptr<VCameraHal> HalMakePtr::CreateCameraHal(const CameraType &type)
 {
-    LogWarning("CreateCameraHal.\n");
+    LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
-    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+    auto camera = std::make_shared<VCameraHal>();
+    return camera;
 }
 StatusCode HalMakePtr::CreateSdCardHal(std::shared_ptr<VSdCardHal> &impl)
 {

hal/src/HalMakePtr.h

@@ -26,18 +26,10 @@ public:
     HalMakePtr() = default;
     virtual ~HalMakePtr() = default;
     static std::shared_ptr<HalMakePtr> &GetInstance(std::shared_ptr<HalMakePtr> *impl = nullptr);
-    virtual StatusCode Init()
-    {
-        return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
-    }
-    virtual StatusCode UnInit()
-    {
-        return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
-    }
     virtual StatusCode CreateHalPtr(IHal **hal);
     virtual StatusCode CreateHalSharePtr(std::shared_ptr<IHalCpp> &impl);
     virtual StatusCode CreateWifiHal(std::shared_ptr<VWifiHal> &impl);
-    virtual StatusCode CreateCameraHal(std::shared_ptr<VCameraHal> &impl);
+    virtual std::shared_ptr<VCameraHal> CreateCameraHal(const CameraType &type);
     virtual StatusCode CreateSdCardHal(std::shared_ptr<VSdCardHal> &impl);
     virtual StatusCode CreateAllKeysHal(std::vector<std::shared_ptr<VKeyControl>> &keys);
     virtual StatusCode CreateAllLedsHal(std::vector<std::shared_ptr<VLedControl>> &leds);

middleware/MediaManager/CMakeLists.txt

@@ -40,12 +40,6 @@ add_custom_target(
     -p ${PLATFORM_PATH}/cmake-shell
     WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/MediaManager
 )
-add_custom_command(
-    TARGET ${TARGET_NAME}
-    PRE_BUILD
-    COMMAND make MediaManager_code_check
-    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
-)
 file(GLOB_RECURSE HEADER_FILES *.h)
 add_custom_target(
     MediaManager_code_format

middleware/MediaManager/src/SaveStream.cpp

@@ -22,8 +22,8 @@ SaveStream::SaveStream() : mFileAudio(nullptr), mFileVideo(nullptr)
 }
 void SaveStream::Init(void)
 {
-    mFileAudio = fopen("/tmp/audio.g711", "a+"); // TODO:
+    mFileAudio = fopen("./audio.g711", "a+"); // TODO:
-    mFileVideo = fopen("/tmp/video.h264", "a+"); // TODO:
+    mFileVideo = fopen("./video.h264", "a+"); // TODO:
 }
 void SaveStream::UnInit(void)
 {
@@ -39,6 +39,7 @@ void SaveStream::UnInit(void)
 void SaveStream::GetVideoStream(const void *stream, const unsigned int &length, const unsigned long long &timeStamp)
 {
     if (mFileVideo) {
+        LogInfo("ddddddddddddddddddddddddddddddddddddddGet video stream, length: %d\n", length);
         size_t writeLength = fwrite(stream, 1, length, mFileVideo);
         if (writeLength != length) {
             LogError("Write video stream failed.\n");

test/application/HuntingCamera/CMakeLists.txt

@@ -32,6 +32,7 @@ link_directories(
     ${LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}/libconfig/lib
+    ${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg/lib
 )
 
 aux_source_directory(. SRC_FILES_MAIN)

test/application/HuntingCamera/src_mock/HuntingCameraTest.cpp

@@ -40,10 +40,10 @@ void HuntingCameraTest::TearDownTestCase()
 }
 void HuntingCameraTest::SetUp()
 {
-    CreateAllCamerasMcok();
     std::shared_ptr<MainThread> mainThread = std::make_shared<MainThreadTest>();
     MainThread::GetInstance(&mainThread);
     HalTestTool::Init();
+    CreateAllCamerasMcok();
     CreateAllKeysMcok();
     CreateAllLedsMcok();
     AppManagerTestTool::Init();
@@ -68,13 +68,13 @@ void HuntingCameraTest::TearDown()
     std::shared_ptr<LinuxApiMock> test = std::make_shared<LinuxApiMock>();
     LinuxApiMock::GetInstance(&test);
     McuManagerTestTool::UnInit();
-    MainThread::GetInstance()->UnInit();
-    std::shared_ptr<MainThread> mainThread = std::make_shared<MainThread>();
-    MainThread::GetInstance(&mainThread);
     DeviceManagerTestTool::UnInit();
     DestroyAllCamerasMock();
     DestroyAllKeysMock();
     DestroyAllLedsMock();
+    MainThread::GetInstance()->UnInit();
+    std::shared_ptr<MainThread> mainThread = std::make_shared<MainThread>();
+    MainThread::GetInstance(&mainThread);
 }
 void HuntingCameraTest::CreateAllCamerasMcok(void)
 {
@@ -83,6 +83,7 @@ void HuntingCameraTest::CreateAllCamerasMcok(void)
 }
 void HuntingCameraTest::DestroyAllCamerasMock(void)
 {
+    HalTestTool::DestroyCameraHalTest(mAllCamerasMock);
     mAllCamerasMock.clear();
 }
 void HuntingCameraTest::CreateAllKeysMcok(void)

test/hal/CMakeLists.txt

@@ -12,6 +12,7 @@ include_directories(
 link_directories(
     ${LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}
+    ${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg/lib
 )
 
 aux_source_directory(. SRC_FILES)

test/hal/tool/CMakeLists.txt

@@ -10,6 +10,7 @@ include_directories(
     ${UTILS_SOURCE_PATH}/Log/include
     ${UTILS_SOURCE_PATH}/KeyControl/include
     ${UTILS_SOURCE_PATH}/LedControl/include
+    ${UTILS_SOURCE_PATH}/MediaBase/include
     ${HAL_SOURCE_PATH}/src
     ${TEST_SOURCE_PATH}
     ${TEST_SOURCE_PATH}/utils/LinuxApiMock/include
@@ -21,7 +22,7 @@ include_directories(
 aux_source_directory(./src TEST_TOOL_SRC_FILES)
 set(TEST_TOOL_TARGET HalTestTool)
 add_library(${TEST_TOOL_TARGET} STATIC ${TEST_TOOL_SRC_FILES})
-target_link_libraries(${TEST_TOOL_TARGET} Hal KeyControl LedControl LinuxApiMock Log)
+target_link_libraries(${TEST_TOOL_TARGET} MediaBase Hal KeyControl LedControl LinuxApiMock Log)
 
 add_custom_target(
     HalTestTool_code_check

test/hal/tool/include/HalTestTool.h

@@ -76,6 +76,7 @@ public:
     static std::shared_ptr<VKeyHal> MakeKeyHalTest(const std::string &keyName);
     static std::shared_ptr<VLedHal> MakeLedHalTest(const std::string &ledName);
     static std::shared_ptr<VCameraHal> MakeCameraHalTest(const CameraType &type);
+    static void DestroyCameraHalTest(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCamerasMock);
 
 private:
     std::shared_ptr<IHalCpp> mHalMock;

test/hal/tool/src/CameraHalMock.cpp

@@ -15,11 +15,42 @@
 #include "CameraHalMock.h"
 #include "IHalCpp.h"
 #include "ILog.h"
+#include "MediaBase.h"
 #include "StatusCode.h"
 #include <memory>
-CameraHalTest::CameraHalTest(const CameraType &cameraType) : mCameraType(cameraType)
+CameraHalTest::CameraHalTest(const CameraType &cameraType)
+    : mCameraType(cameraType), mReadH264File(nullptr), mTaskRuning(false)
 {
 }
+void CameraHalTest::Init(void)
+{
+    CameraHal::Init();
+    if (nullptr == mReadH264File) {
+        ReadVideoFileCallback callback = [](const void *stream, const unsigned int length, void *context) -> void {
+            ((CameraHalTest *)context)->ReadDataFromH264File(stream, length);
+        };
+        mReadH264File = ICreateMediaBase(MEDIA_HANDLE_TYPE_READ_H264);
+        ISetReadVideoCallback(mReadH264File, callback, this);
+    }
+}
+void CameraHalTest::UnInit(void)
+{
+    CameraHal::UnInit();
+    mTaskRuning = false;
+    mCv.notify_one();
+    if (mTaskTimerThread.joinable()) {
+        mTaskTimerThread.join();
+    }
+    LogInfo(
+        "====================================================================9999999999999999999999 000000000000000\n");
+    if (mReadH264File) {
+        ISetReadVideoCallback(mReadH264File, nullptr, nullptr);
+        IStopReadFile(mReadH264File);
+        IMediaBaseFree(mReadH264File);
+        LogInfo("====================================================================9999999999999999999999\n");
+        mReadH264File = nullptr;
+    }
+}
 void CameraHalTest::SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor)
 {
     LogInfo("CameraHalTest::SetCameraMonitor.\n");
@@ -36,17 +67,53 @@ void CameraHalTest::SetCameraMonitorTrace(std::shared_ptr<VCameraHalMonitor> &mo
 StatusCode CameraHalTest::StartSingleTask(const CameraTaskParam &param)
 {
     LogInfo("CameraHalTest::StartSingleTask\n");
+    auto taskTimerThread = [=](std::shared_ptr<CameraHalTest> cameraHal) {
+        LogInfo("MockReportMediaStream start.\n");
+        cameraHal->MockReportMediaStream();
+    };
+    std::shared_ptr<CameraHalTest> cameraHal = std::dynamic_pointer_cast<CameraHalTest>(CameraHal::shared_from_this());
+    mTaskTimerThread = std::thread(taskTimerThread, cameraHal);
     StatusCode code = StartSingleTaskTrace(param);
-    // if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
-    //     return HalCpp::GetAllKeys(allKeys);
+        return CameraHal::StartSingleTask(param);
-    // }
+    }
     return code;
 }
+StatusCode CameraHalTest::StopTask(void)
+{
+    mTaskRuning = false;
+    if (nullptr != mReadH264File) {
+        IStopReadFile(mReadH264File);
+    }
+    mCv.notify_one();
+    return CameraHal::StopTask();
+}
 StatusCode CameraHalTest::StartSingleTaskTrace(const CameraTaskParam &param)
 {
     LogInfo("CameraHalTest::StartSingleTaskTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+void CameraHalTest::MockReportMediaStream(void)
+{
+    mTaskRuning = true;
+    if (nullptr != mReadH264File) {
+        IStartReadFile(mReadH264File, TEST_SOURCE_PATH "/support_test/video.h264");
+    }
+    while (mTaskRuning) {
+        std::unique_lock<std::mutex> lock(mMutex);
+        mCv.wait(lock, [&] {
+            return !mTaskRuning;
+        });
+        /**
+         * @brief If the recording time is over, you need to stop the recording timer here.
+         */
+        mTaskRuning = false;
+    }
+}
+void CameraHalTest::ReadDataFromH264File(const void *stream, const unsigned int length)
+{
+    GetVideoStream(stream, length, 0);
+}
 CameraHalMock::CameraHalMock(const CameraType &cameraType) : CameraHalTest(cameraType)
 {
 }

test/hal/tool/src/CameraHalMock.h

@@ -14,24 +14,40 @@
  */
 #ifndef CAMERA_HAL_MOCK_H
 #define CAMERA_HAL_MOCK_H
+#include "CameraHal.h"
 #include "HalCpp.h"
 #include "HalTestTool.h"
-class CameraHalTest : public VCameraHal
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+class CameraHalTest : public CameraHal
 {
 public:
     CameraHalTest(const CameraType &cameraType);
     virtual ~CameraHalTest() = default;
+    void Init(void) override;
+    void UnInit(void) override;
+
+protected:
     void SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor) override;
     StatusCode StartSingleTask(const CameraTaskParam &param) override;
-
+    StatusCode StopTask(void) override;
-private:
     virtual void SetCameraMonitorTrace(std::shared_ptr<VCameraHalMonitor> &monitor);
     virtual StatusCode StartSingleTaskTrace(const CameraTaskParam &param);
 
+private:
+    void MockReportMediaStream(void);
+    void ReadDataFromH264File(const void *stream, const unsigned int length);
+
 protected:
     const CameraType mCameraType;
     std::weak_ptr<VCameraHalMonitor> mMonitor;
     std::shared_ptr<CameraReportEvent> mFastBootEvent;
+    void *mReadH264File;
+    std::mutex mMutex;
+    std::condition_variable mCv;
+    bool mTaskRuning;
+    std::thread mTaskTimerThread;
 };
 class CameraHalMock : public CameraHalTest
 {

test/hal/tool/src/HalMakePtrTest.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include "HalMakePtrTest.h"
+#include "CameraHalMock.h"
 #include "HalCppMock.h"
 #include "HalMakePtr.h"
 #include "IHalCpp.h"
@@ -77,4 +78,10 @@ StatusCode HalMakePtrTest::CreateAllKeysHal(std::vector<std::shared_ptr<VKeyCont
         HalMakePtr::CreateAllKeysHal(keys);
     }
     return CreateStatusCode(STATUS_CODE_OK);
+}
+std::shared_ptr<VCameraHal> HalMakePtrTest::CreateCameraHal(const CameraType &type)
+{
+    auto camera = std::make_shared<CameraHalMock>(type);
+    camera->Init();
+    return camera;
 }

test/hal/tool/src/HalMakePtrTest.h

@@ -29,6 +29,7 @@ public:
     StatusCode CreateHalSharePtr(std::shared_ptr<IHalCpp> &impl) override;
     StatusCode CreateSdCardHal(std::shared_ptr<VSdCardHal> &impl) override;
     StatusCode CreateAllKeysHal(std::vector<std::shared_ptr<VKeyControl>> &keys) override;
+    std::shared_ptr<VCameraHal> CreateCameraHal(const CameraType &type) override;
 
 public:
     std::shared_ptr<HalCppMock> mHalCppMock;

test/hal/tool/src/HalTestTool.cpp

@@ -378,6 +378,18 @@ std::shared_ptr<VLedHal> HalTestTool::MakeLedHalTest(const std::string &ledName)
 }
 std::shared_ptr<VCameraHal> HalTestTool::MakeCameraHalTest(const CameraType &type)
 {
-    std::shared_ptr<VCameraHal> camera = std::make_shared<CameraHalMock>(type);
+    std::shared_ptr<VCameraHal> camera = HalMakePtrTest::GetInstance()->CreateCameraHal(type);
     return camera;
+}
+void HalTestTool::DestroyCameraHalTest(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCamerasMock)
+{
+    for (const auto &camera : allCamerasMock) {
+        std::shared_ptr<CameraHalMock> impl = std::dynamic_pointer_cast<CameraHalMock>(camera.second);
+        if (impl) {
+            impl->UnInit();
+        }
+        else {
+            LogError("impl is null.\n");
+        }
+    }
 }

test/middleware/AppManager/CMakeLists.txt

@@ -25,6 +25,7 @@ include_directories(
 link_directories(
     ${LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}
+    ${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg/lib
 )
 
 aux_source_directory(. SRC_FILES_MAIN)

test/middleware/DeviceManager/CMakeLists.txt

@@ -23,6 +23,7 @@ include_directories(
 link_directories(
     ${LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}
+    ${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg/lib
 )
 
 aux_source_directory(. SRC_FILES_MAIN)
@@ -51,12 +52,6 @@ add_custom_target(
     -p ${PLATFORM_PATH}/cmake-shell
     WORKING_DIRECTORY ${TEST_SOURCE_PATH}/middleware/DeviceManager
 )
-add_custom_command(
-    TARGET ${TARGET_NAME}
-    PRE_BUILD
-    COMMAND make DeviceManagerTest_code_check
-    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
-)
 
 file(GLOB_RECURSE HEADER_FILES *.h)
 add_custom_target(

test/middleware/MediaManager/CMakeLists.txt

@@ -24,6 +24,7 @@ include_directories(
 link_directories(
     ${LIBS_OUTPUT_PATH}
     ${EXTERNAL_LIBS_OUTPUT_PATH}
+    ${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg/lib
 )
 
 aux_source_directory(. SRC_FILES_MAIN)

utils/MediaBase/include/MediaBase.h

@@ -24,10 +24,13 @@ enum MediaHandleType
     MEDIA_HANDLE_TYPE_READ_G711,
     MEDIA_HANDLE_TYPE_END
 };
+typedef void (*ReadVideoFileCallback)(const void *, const unsigned int, void *);
 void *ICreateMediaBase(const MediaHandleType type);
 // StatusCode Init(void *object);
 // StatusCode UnInit(void *object);
+StatusCode ISetReadVideoCallback(void *object, ReadVideoFileCallback callback, void *context);
 StatusCode IStartReadFile(void *object, const char *path);
+StatusCode IStopReadFile(void *object);
 void IMediaBaseFree(void *object);
 #ifdef __cplusplus
 }

utils/MediaBase/src/IMediaBase.cpp

@@ -26,6 +26,16 @@ StatusCode IMediaBase::StartReadFile(const std::string &path)
     LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode IMediaBase::StopReadFile(void)
+{
+    LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode IMediaBase::SetReadVideoCallback(ReadVideoFileCallback callback, void *context)
+{
+    LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
 static const char *MEDIA_BASE_NAME = "media_adapter";
 const char *GetMediaBaseModuleName(void)
 {

utils/MediaBase/src/IMediaBase.h

@@ -22,6 +22,8 @@ public:
     IMediaBase() = default;
     virtual ~IMediaBase() = default;
     virtual StatusCode StartReadFile(const std::string &path);
+    virtual StatusCode StopReadFile(void);
+    virtual StatusCode SetReadVideoCallback(ReadVideoFileCallback callback, void *context);
 };
 typedef struct media_base_header
 {

utils/MediaBase/src/MediaBase.cpp

@@ -35,6 +35,13 @@ static bool ObjectCheck(void *object)
     }
     return true;
 }
+StatusCode ISetReadVideoCallback(void *object, ReadVideoFileCallback callback, void *context)
+{
+    if (ObjectCheck(object) == true) {
+        return (*(std::shared_ptr<IMediaBase> *)object)->SetReadVideoCallback(callback, context);
+    }
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 StatusCode IStartReadFile(void *object, const char *path)
 {
     if (ObjectCheck(object) == true) {
@@ -42,6 +49,13 @@ StatusCode IStartReadFile(void *object, const char *path)
     }
     return CreateStatusCode(STATUS_CODE_OK);
 }
+StatusCode IStopReadFile(void *object)
+{
+    if (ObjectCheck(object) == true) {
+        return (*(std::shared_ptr<IMediaBase> *)object)->StopReadFile();
+    }
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 void IMediaBaseFree(void *object)
 {
     if (ObjectCheck(object) == true) {

utils/MediaBase/src/MediaBaseImpl.cpp

@@ -28,6 +28,9 @@ extern "C" {
 #ifdef __cplusplus
 }
 #endif
+MediaBaseImpl::MediaBaseImpl() : mReadVideoCallback(nullptr), mReadVideoCallbackContext(nullptr), mTaskRuning(false)
+{
+}
 StatusCode MediaBaseImpl::StartReadFile(const std::string &path)
 {
     InitFfmpeg();
@@ -58,18 +61,26 @@ StatusCode MediaBaseImpl::StartReadFile(const std::string &path)
         LogError("Didn't find a video stream.\n");
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
-    AVPacket packet;
+    auto taskTimerThread = [=](std::shared_ptr<MediaBaseImpl> media) {
-    // av_new_packet(&packet, AV_INPUT_BUFFER_MIN_SIZE);
+        LogInfo("ReadFileThread start.\n");
-    while (av_read_frame(pFormatCtx, &packet) >= 0) {
+        media->ReadFileThread(pFormatCtx, video_stream_index);
-        // 检查数据包是否属于视频流
+    };
-        if (packet.stream_index == video_stream_index) {
+    std::shared_ptr<MediaBaseImpl> media = shared_from_this();
-            LogInfo("Frame data address: %p, length: %zu\n", packet.data, packet.size);
+    mTaskTimerThread = std::thread(taskTimerThread, media);
-        }
+    return CreateStatusCode(STATUS_CODE_OK);
-        // 释放数据包
+}
-        av_packet_unref(&packet);
+StatusCode MediaBaseImpl::StopReadFile(void)
+{
+    mTaskRuning = false;
+    if (mTaskTimerThread.joinable()) {
+        mTaskTimerThread.join();
     }
-
+    return CreateStatusCode(STATUS_CODE_OK);
-    avformat_close_input(&pFormatCtx);
+}
+StatusCode MediaBaseImpl::SetReadVideoCallback(ReadVideoFileCallback callback, void *context)
+{
+    mReadVideoCallback = callback;
+    mReadVideoCallbackContext = context;
     return CreateStatusCode(STATUS_CODE_OK);
 }
 void MediaBaseImpl::InitFfmpeg(void)
@@ -77,4 +88,28 @@ void MediaBaseImpl::InitFfmpeg(void)
 }
 void MediaBaseImpl::UnInitFfmpeg(void)
 {
+}
+void MediaBaseImpl::ReadFileThread(AVFormatContext *pFormatCtx, int video_stream_index)
+{
+    mTaskRuning = true;
+    AVPacket packet;
+    // av_new_packet(&packet, AV_INPUT_BUFFER_MIN_SIZE);
+    while (av_read_frame(pFormatCtx, &packet) >= 0) {
+        if (nullptr == mReadVideoCallback) {
+            continue;
+        }
+        if (false == mTaskRuning) {
+            break;
+        }
+        // 检查数据包是否属于视频流
+        if (packet.stream_index == video_stream_index) {
+            // LogInfo("Frame data address: %p, length: %zu\n", packet.data, packet.size);
+            mReadVideoCallback(packet.data, packet.size, mReadVideoCallbackContext);
+        }
+        // 释放数据包
+        av_packet_unref(&packet);
+    }
+
+    avformat_close_input(&pFormatCtx);
+    LogInfo("==============================================================================\n");
 }

utils/MediaBase/src/MediaBaseImpl.h

@@ -15,15 +15,36 @@
 #ifndef MEDIA_BASE_IMPL_H
 #define MEDIA_BASE_IMPL_H
 #include "IMediaBase.h"
-class MediaBaseImpl : public IMediaBase
+#ifdef __cplusplus
+extern "C" {
+#endif
+// #include <libavcodec/avcodec.h>
+#include <libavcodec/packet.h>
+#include <libavformat/avformat.h>
+#include <libavutil/avutil.h>
+// #include <libswscale/swscale.h>
+#ifdef __cplusplus
+}
+#endif
+#include <thread>
+class MediaBaseImpl : public IMediaBase, public std::enable_shared_from_this<MediaBaseImpl>
 {
 public:
-    MediaBaseImpl() = default;
+    MediaBaseImpl();
     virtual ~MediaBaseImpl() = default;
     StatusCode StartReadFile(const std::string &path) override;
+    StatusCode StopReadFile(void) override;
+    StatusCode SetReadVideoCallback(ReadVideoFileCallback callback, void *context) override;
 
 private:
     void InitFfmpeg(void);
     void UnInitFfmpeg(void);
+    void ReadFileThread(AVFormatContext *pFormatCtx, int video_stream_index);
+
+private:
+    ReadVideoFileCallback mReadVideoCallback;
+    void *mReadVideoCallbackContext;
+    bool mTaskRuning;
+    std::thread mTaskTimerThread;
 };
 #endif

utils/TcpModule/src/TcpServerImpl.cpp

@@ -117,6 +117,8 @@ void TcpServerImpl::Init(void)
     hio_t *listenio = hloop_create_tcp_server(mLoop, mParam.mIp, mParam.mPort, on_accept);
     if (nullptr == listenio) {
         LogError("hloop_create_tcp_server failed\n");
+        hloop_free(&mLoop);
+        mLoop = nullptr;
         return;
     }
     LogInfo("listenfd=%d\n", hio_fd(listenio));