Backup:ffmpeg open audio file failed.

external/ffmpeg/CMakeLists.txt

@@ -5,7 +5,7 @@ if(${TARGET_PLATFORM} MATCHES ${DEFINE_LINUX})
     --cxx=${CMAKE_CXX_COMPILER} \
     --prefix=${EXTERNAL_LIBS_OUTPUT_PATH}/ffmpeg \
     --enable-parsers --enable-decoder=h264 \
-    --enable-ffmpeg --enable-shared --enable-static \
+    --enable-ffmpeg --enable-static \
     --enable-gpl --enable-nonfree --enable-version3 --enable-small \
     --enable-muxer=mov --enable-muxer=mp4 \
     --enable-decoder=aac \

external/ffmpeg/README.md

@@ -1,8 +1,22 @@
 # 1. ffmpeg开发文档
 
-## 1.1. 问题记录
+## 1.1. ffplay命令使用
 
-### 1.1.1. avformat_open_input执行失败
+* 播放G711a音频文件
+
+```code
+$ ffplay -i audio.g711a -f alaw -ac 1 -ar 8000
+```
+
+* 播放h264视频文件
+
+```code
+$ ffplay video.h264
+```
+
+## 1.2. 问题记录
+
+### 1.2.1. avformat_open_input执行失败
 
 &emsp;&emsp;在执行avformat_open_input时，返回-1094995529<0，错误
 

external/goahead-5.2.0/CMakeLists.txt

@@ -1,4 +1,30 @@
 include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
 include(${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/goahead.cmake)
-set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+include(${UTILS_SOURCE_PATH}/WebServer/build/webserver.cmake)
-set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+add_custom_target(
+    goahead-5.2.0
+    COMMAND test -f ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/Makefile || tar zxvf goahead-5.2.0.tar.gz
+    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/modify/http.c ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/src
+    COMMAND chmod 777 -R GoAhead
+    COMMAND cd GoAhead && make CC=${CMAKE_C_COMPILER} ARCH=${SET_ARCH} PROFILE=${LIB_TYPE} ME_GOAHEAD_UPLOAD_DIR=\"${GOAHEAD_UPLOAD_TMP_PATH}\" 
+    ME_GOAHEAD_SSL_KEY=\"${GOAHEAD_CONFIG_FILE_PATH}/self.key\" ME_GOAHEAD_SSL_CERTIFICATE=\"${GOAHEAD_CONFIG_FILE_PATH}/self.crt\"
+    ${ME_GOAHEAD_LIMIT_POST} -f ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/modify/goahead-linux-static-fancy.mk
+    COMMAND echo "Copy goahead lib to output path."
+    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgo.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
+    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libmbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libmbedtls.a
+    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgoahead-mbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgoahead-mbedtls.a
+    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.crt ${PLATFORM_PATH}/cmake-shell/
+    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.key ${PLATFORM_PATH}/cmake-shell/
+    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/route.txt ${PLATFORM_PATH}/cmake-shell/
+    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/auth.txt ${PLATFORM_PATH}/cmake-shell/
+    WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/
+)
+
+add_custom_target(
+  remove_goahead_source_files
+  COMMAND rm -rf GoAhead
+  WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/
+)
+ 
+# 将clean目标依赖于我们自定义的clean_script目标
+add_dependencies(sdk_clean remove_goahead_source_files)

test/application/HuntingCamera/CMakeLists.txt

@@ -1,6 +1,8 @@
 # include(${CMAKE_SOURCE_DIR}/build/independent_source.cmake)
 include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
 include(${APPLICATION_SOURCE_PATH}/HuntingCamera/build/hunting_camera.cmake)
+include(${UTILS_SOURCE_PATH}/WebServer/build/webserver.cmake)
+include(${UTILS_SOURCE_PATH}/MediaBase/build/mediabase.cmake)
 set(EXECUTABLE_OUTPUT_PATH ${TEST_OUTPUT_PATH}/bin)
 
 include_directories(
@@ -43,8 +45,11 @@ endif()
 
 set(TARGET_NAME HuntingCameraTest)
 add_executable(${TARGET_NAME} ${SRC_FILES_MAIN} ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} HuntingMainLib MissionManagerTestTool McuManagerTestTool McuAskBaseTestTool
+target_link_libraries(${TARGET_NAME} -Wl,--start-group HuntingMainLib MissionManagerTestTool McuManagerTestTool McuAskBaseTestTool
-                                     AppManagerTestTool HalTestTool DeviceManagerTestTool TestManager gtest gmock pthread)
+                                     AppManagerTestTool HalTestTool DeviceManagerTestTool TestManager
+                                     MediaBase avformat avcodec avutil swresample avdevice avfilter swscale postproc z
+                                     -Wl,--end-group
+                                     gtest gmock pthread)
 if(${TEST_COVERAGE} MATCHES "true")
     target_link_libraries(${TARGET_NAME} gcov)
 endif()

test/hal/tool/src/CameraHalMock.cpp

@@ -19,19 +19,25 @@
 #include "StatusCode.h"
 #include <memory>
 CameraHalTest::CameraHalTest(const CameraType &cameraType)
-    : mCameraType(cameraType), mReadH264File(nullptr), mTaskRuning(false)
+    : mCameraType(cameraType), mReadH264File(nullptr), mReadG711File(nullptr), mTaskRuning(false)
 {
 }
 void CameraHalTest::Init(void)
 {
     CameraHal::Init();
     if (nullptr == mReadH264File) {
-        ReadVideoFileCallback callback = [](const void *stream, const unsigned int length, void *context) -> void {
+        ReadVideoFileCallback videCallback = [](const void *stream, const unsigned int length, void *context) -> void {
-            // LogInfo("CameraHalTest::ReadVideoFileCallback.\n");
             ((CameraHalTest *)context)->ReadDataFromH264File(stream, length);
         };
         mReadH264File = ICreateMediaBase(MEDIA_HANDLE_TYPE_READ_H264);
-        ISetReadVideoCallback(mReadH264File, callback, this);
+        ISetReadVideoCallback(mReadH264File, videCallback, this);
+    }
+    if (nullptr == mReadG711File) {
+        ReadAudioFileCallback audioCallback = [](const void *stream, const unsigned int length, void *context) -> void {
+            ((CameraHalTest *)context)->ReadDataFromH264File(stream, length);
+        };
+        mReadG711File = ICreateMediaBase(MEDIA_HANDLE_TYPE_READ_H264);
+        ISetReadVideoCallback(mReadG711File, audioCallback, this);
     }
 }
 void CameraHalTest::UnInit(void)
@@ -48,6 +54,12 @@ void CameraHalTest::UnInit(void)
         IMediaBaseFree(mReadH264File);
         mReadH264File = nullptr;
     }
+    if (mReadG711File) {
+        ISetReadAudioCallback(mReadG711File, nullptr, nullptr);
+        IStopReadFile(mReadG711File);
+        IMediaBaseFree(mReadG711File);
+        mReadG711File = nullptr;
+    }
 }
 void CameraHalTest::SetCameraMonitor(std::shared_ptr<VCameraHalMonitor> &monitor)
 {
@@ -83,6 +95,9 @@ StatusCode CameraHalTest::StopTask(void)
     if (nullptr != mReadH264File) {
         IStopReadFile(mReadH264File);
     }
+    if (nullptr != mReadG711File) {
+        IStopReadFile(mReadG711File);
+    }
     mCv.notify_one();
     return CameraHal::StopTask();
 }
@@ -97,6 +112,9 @@ void CameraHalTest::MockReportMediaStream(void)
     if (nullptr != mReadH264File) {
         IStartReadFile(mReadH264File, TEST_SOURCE_PATH "/support_test/video.h264");
     }
+    if (nullptr != mReadG711File) {
+        IStartReadFile(mReadG711File, TEST_SOURCE_PATH "/support_test/audio.g711a");
+    }
     while (mTaskRuning) {
         std::unique_lock<std::mutex> lock(mMutex);
         mCv.wait(lock, [&] {

test/hal/tool/src/CameraHalMock.h

@@ -44,6 +44,7 @@ protected:
     std::weak_ptr<VCameraHalMonitor> mMonitor;
     std::shared_ptr<CameraReportEvent> mFastBootEvent;
     void *mReadH264File;
+    void *mReadG711File;
     std::mutex mMutex;
     std::condition_variable mCv;
     bool mTaskRuning;

utils/FxHttpServer/CMakeLists.txt

@@ -23,7 +23,7 @@ aux_source_directory(./src SRC_FILES)
 
 set(TARGET_NAME FxHttpServer)
 add_library(${TARGET_NAME} STATIC ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} StatusCode Log -Wl,--start-group httpsrv -Wl,--end-group)
+target_link_libraries(${TARGET_NAME} StatusCode Log httpsrv)
 
 add_custom_target(
     FxHttpServer_code_check

utils/MediaBase/CMakeLists.txt

@@ -19,7 +19,7 @@ aux_source_directory(./src SRC_FILES)
 
 set(TARGET_NAME MediaBase)
 add_library(${TARGET_NAME} STATIC ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} avformat avcodec avutil swresample StatusCode Log)
+target_link_libraries(${TARGET_NAME} StatusCode Log)
 
 add_custom_target(
     MediaBase_code_check

utils/MediaBase/build/mediabase.cmake

@@ -0,0 +1,2 @@
+
+set(FFMPEG_EXTERNAL_LIBS avformat avcodec avutil swresample avdevice avfilter swscale postproc z)

utils/MediaBase/include/MediaBase.h

@@ -25,10 +25,12 @@ enum MediaHandleType
     MEDIA_HANDLE_TYPE_END
 };
 typedef void (*ReadVideoFileCallback)(const void *, const unsigned int, void *);
+typedef void (*ReadAudioFileCallback)(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 ISetReadAudioCallback(void *object, ReadVideoFileCallback callback, void *context);
 StatusCode IStartReadFile(void *object, const char *path);
 StatusCode IStopReadFile(void *object);
 void IMediaBaseFree(void *object);

utils/MediaBase/src/IMediaBase.cpp

@@ -36,6 +36,11 @@ StatusCode IMediaBase::SetReadVideoCallback(ReadVideoFileCallback callback, void
     LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode IMediaBase::SetReadAudioCallback(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)
 {
@@ -48,6 +53,6 @@ std::shared_ptr<IMediaBase> *NewIMediaBase(const MediaHandleType &type)
     MeidaAdapter tmp;
     memcpy((void *)impl, (void *)&tmp, sizeof(MeidaAdapter));
     impl->mHeader.mCheckName = MEDIA_BASE_NAME;
-    impl->mIMediaBase = MediaBaseMakePtr::GetInstance()->CreateMediaBase();
+    impl->mIMediaBase = MediaBaseMakePtr::GetInstance()->CreateMediaBase(type);
     return (std::shared_ptr<IMediaBase> *)(((char *)impl) + sizeof(MediaBaseHeader));
 }

utils/MediaBase/src/IMediaBase.h

@@ -24,6 +24,7 @@ public:
     virtual StatusCode StartReadFile(const std::string &path);
     virtual StatusCode StopReadFile(void);
     virtual StatusCode SetReadVideoCallback(ReadVideoFileCallback callback, void *context);
+    virtual StatusCode SetReadAudioCallback(ReadVideoFileCallback callback, void *context);
 };
 typedef struct media_base_header
 {

utils/MediaBase/src/MediaBase.cpp

@@ -42,6 +42,13 @@ StatusCode ISetReadVideoCallback(void *object, ReadVideoFileCallback callback, v
     }
     return CreateStatusCode(STATUS_CODE_OK);
 }
+StatusCode ISetReadAudioCallback(void *object, ReadVideoFileCallback callback, void *context)
+{
+    if (ObjectCheck(object) == true) {
+        return (*(std::shared_ptr<IMediaBase> *)object)->SetReadAudioCallback(callback, context);
+    }
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 StatusCode IStartReadFile(void *object, const char *path)
 {
     if (ObjectCheck(object) == true) {

utils/MediaBase/src/MediaBaseImpl.cpp

@@ -14,6 +14,7 @@
  */
 #include "MediaBaseImpl.h"
 #include "ILog.h"
+#include "MediaBase.h"
 #include "StatusCode.h"
 #include <cstdlib>
 #include <string>
@@ -28,8 +29,10 @@ extern "C" {
 #ifdef __cplusplus
 }
 #endif
-MediaBaseImpl::MediaBaseImpl() : mReadVideoCallback(nullptr), mReadVideoCallbackContext(nullptr), mTaskRuning(false)
+MediaBaseImpl::MediaBaseImpl(const MediaHandleType &type)
+    : mType(type), mReadVideoCallback(nullptr), mReadVideoCallbackContext(nullptr), mTaskRuning(false)
 {
+    MediaTypeConvert();
 }
 StatusCode MediaBaseImpl::StartReadFile(const std::string &path)
 {
@@ -37,7 +40,10 @@ StatusCode MediaBaseImpl::StartReadFile(const std::string &path)
     int result = 0;
     AVFormatContext *pFormatCtx = nullptr;
     if ((result = avformat_open_input(&pFormatCtx, path.c_str(), nullptr, nullptr)) < 0) {
-        LogError("Couldn't open file: %s, result=%d\n", path.c_str(), result);
+        char error_str[AV_ERROR_MAX_STRING_SIZE];
+        av_make_error_string(error_str, AV_ERROR_MAX_STRING_SIZE, result);
+        LogError("Couldn't open file: %s, result=%s\n", path.c_str(), error_str);
+        // LogError("Couldn't open file: %s, result=%s\n", path.c_str(), av_err2str(result));
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
     // LogInfo("File: %s\n", pFormatCtx->filename);
@@ -50,20 +56,20 @@ StatusCode MediaBaseImpl::StartReadFile(const std::string &path)
         LogError("Couldn't find stream information.\n");
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
-    int video_stream_index = -1;
+    int mediaStreamIndex = -1;
     for (unsigned int i = 0; i < pFormatCtx->nb_streams; i++) {
-        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+        if (pFormatCtx->streams[i]->codecpar->codec_type == mFFmpegMediaType) {
-            video_stream_index = i;
+            mediaStreamIndex = i;
             break;
         }
     }
-    if (video_stream_index == -1) {
+    if (mediaStreamIndex == -1) {
-        LogError("Didn't find a video stream.\n");
+        LogError("Didn't find a stream.\n");
         return CreateStatusCode(STATUS_CODE_NOT_OK);
     }
     auto taskTimerThread = [=](std::shared_ptr<MediaBaseImpl> media) {
         LogInfo("ReadFileThread start.\n");
-        media->ReadFileThread(pFormatCtx, video_stream_index);
+        media->ReadFileThread(pFormatCtx, mediaStreamIndex);
     };
     std::shared_ptr<MediaBaseImpl> media = shared_from_this();
     mTaskTimerThread = std::thread(taskTimerThread, media);
@@ -83,16 +89,25 @@ StatusCode MediaBaseImpl::SetReadVideoCallback(ReadVideoFileCallback callback, v
     mReadVideoCallbackContext = context;
     return CreateStatusCode(STATUS_CODE_OK);
 }
+StatusCode MediaBaseImpl::SetReadAudioCallback(ReadVideoFileCallback callback, void *context)
+{
+    mReadAudioCallback = callback;
+    mReadAudioCallbackContext = context;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 void MediaBaseImpl::InitFfmpeg(void)
 {
 }
 void MediaBaseImpl::UnInitFfmpeg(void)
 {
 }
-void MediaBaseImpl::ReadFileThread(AVFormatContext *pFormatCtx, int video_stream_index)
+void MediaBaseImpl::ReadFileThread(AVFormatContext *pFormatCtx, int mediaStreamIndex)
 {
     mTaskRuning = true;
-    if (nullptr == mReadVideoCallback) {
+    if (AVMEDIA_TYPE_VIDEO == mFFmpegMediaType && nullptr == mReadVideoCallback) {
+        LogWarning("ReadVideoCallback is null.\n");
+    }
+    if (AVMEDIA_TYPE_AUDIO == mFFmpegMediaType && nullptr == mReadVideoCallback) {
         LogWarning("ReadVideoCallback is null.\n");
     }
     AVPacket packet;
@@ -108,12 +123,12 @@ void MediaBaseImpl::ReadFileThread(AVFormatContext *pFormatCtx, int video_stream
             break;
         }
         // Checks whether the packet belongs to a video stream.
-        if (packet.stream_index == video_stream_index) {
+        if (packet.stream_index == mediaStreamIndex) {
-            playTimeMs = (packet.duration * pFormatCtx->streams[video_stream_index]->time_base.num * 1000) /
+            playTimeMs = (packet.duration * pFormatCtx->streams[mediaStreamIndex]->time_base.num * 1000) /
-                         pFormatCtx->streams[video_stream_index]->time_base.den;
+                         pFormatCtx->streams[mediaStreamIndex]->time_base.den;
-            LogInfo("Play time ms:%d\n", playTimeMs);
             // LogInfo("Frame data address: %p, length: %zu\n", packet.data, packet.size);
-            mReadVideoCallback(packet.data, packet.size, mReadVideoCallbackContext);
+            // LogInfo("Play time ms:%d\n", playTimeMs);
+            ReadFrame(&packet);
             std::this_thread::sleep_for(std::chrono::milliseconds(playTimeMs));
         }
         // Release the data packet.
@@ -122,4 +137,27 @@ void MediaBaseImpl::ReadFileThread(AVFormatContext *pFormatCtx, int video_stream
     av_packet_unref(&packet);
 
     avformat_close_input(&pFormatCtx);
+}
+void inline MediaBaseImpl::ReadFrame(AVPacket *packet)
+{
+    if (AVMEDIA_TYPE_VIDEO == mFFmpegMediaType) {
+        mReadVideoCallback(packet->data, packet->size, mReadVideoCallbackContext);
+    }
+    else if (AVMEDIA_TYPE_AUDIO == mFFmpegMediaType) {
+        mReadVideoCallback(packet->data, packet->size, mReadVideoCallbackContext);
+    }
+}
+void MediaBaseImpl::MediaTypeConvert(void)
+{
+    switch (mType) {
+    case MediaHandleType::MEDIA_HANDLE_TYPE_READ_H264:
+        mFFmpegMediaType = AVMEDIA_TYPE_VIDEO;
+        break;
+    case MediaHandleType::MEDIA_HANDLE_TYPE_READ_G711:
+        mFFmpegMediaType = AVMEDIA_TYPE_AUDIO;
+        break;
+    default:
+        LogError("Unknown media type.\n");
+        break;
+    }
 }

utils/MediaBase/src/MediaBaseImpl.h

@@ -30,20 +30,27 @@ extern "C" {
 class MediaBaseImpl : public IMediaBase, public std::enable_shared_from_this<MediaBaseImpl>
 {
 public:
-    MediaBaseImpl();
+    MediaBaseImpl(const MediaHandleType &type);
     virtual ~MediaBaseImpl() = default;
     StatusCode StartReadFile(const std::string &path) override;
     StatusCode StopReadFile(void) override;
     StatusCode SetReadVideoCallback(ReadVideoFileCallback callback, void *context) override;
+    StatusCode SetReadAudioCallback(ReadVideoFileCallback callback, void *context) override;
 
 private:
     void InitFfmpeg(void);
     void UnInitFfmpeg(void);
     void ReadFileThread(AVFormatContext *pFormatCtx, int video_stream_index);
+    void ReadFrame(AVPacket *packet);
+    void MediaTypeConvert(void);
 
 private:
+    const MediaHandleType &mType;
+    enum AVMediaType mFFmpegMediaType;
     ReadVideoFileCallback mReadVideoCallback;
     void *mReadVideoCallbackContext;
+    ReadVideoFileCallback mReadAudioCallback;
+    void *mReadAudioCallbackContext;
     bool mTaskRuning;
     std::thread mTaskTimerThread;
 };

utils/MediaBase/src/MediaBaseMakePtr.cpp

@@ -31,9 +31,9 @@ std::shared_ptr<MediaBaseMakePtr> &MediaBaseMakePtr::GetInstance(std::shared_ptr
     }
     return instance;
 }
-std::shared_ptr<IMediaBase> MediaBaseMakePtr::CreateMediaBase(void)
+std::shared_ptr<IMediaBase> MediaBaseMakePtr::CreateMediaBase(const MediaHandleType &type)
 {
     LogInfo("MediaBaseMakePtr::CreateMediaBase.\n");
-    auto tmp = std::make_shared<MediaBaseImpl>();
+    auto tmp = std::make_shared<MediaBaseImpl>(type);
     return tmp;
 }

utils/MediaBase/src/MediaBaseMakePtr.h

@@ -23,6 +23,6 @@ public:
     MediaBaseMakePtr() = default;
     virtual ~MediaBaseMakePtr() = default;
     static std::shared_ptr<MediaBaseMakePtr> &GetInstance(std::shared_ptr<MediaBaseMakePtr> *impl = nullptr);
-    virtual std::shared_ptr<IMediaBase> CreateMediaBase(void);
+    virtual std::shared_ptr<IMediaBase> CreateMediaBase(const MediaHandleType &type);
 };
 #endif

utils/WebServer/CMakeLists.txt

@@ -40,7 +40,7 @@ aux_source_directory(./src SRC_FILES)
 
 set(TARGET_NAME WebServer)
 add_library(${TARGET_NAME} STATIC ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} StatusCode Log -Wl,--start-group libgo.a libmbedtls.a libgoahead-mbedtls.a -Wl,--end-group)
+target_link_libraries(${TARGET_NAME} libgo.a libmbedtls.a libgoahead-mbedtls.a libgo.a StatusCode Log)
 
 add_custom_target(
     WebServer_code_check
@@ -72,56 +72,17 @@ add_custom_command(
 endif()
 
 # build goahead before make libgo.a
-add_custom_command(
-    OUTPUT ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/Makefile
-    COMMAND echo "tar zxvf goahead-5.2.0.tar.gz"
-    COMMAND tar zxvf goahead-5.2.0.tar.gz
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/modify/http.c ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/src
-    WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/
-)
 add_custom_command(
     OUTPUT ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
-    DEPENDS ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/Makefile
+    COMMAND echo "Did not found goahead libs in output_files, now compile goahead."
-    COMMAND make CC=${CMAKE_C_COMPILER} ARCH=${SET_ARCH} PROFILE=${LIB_TYPE} ME_GOAHEAD_UPLOAD_DIR=\"${GOAHEAD_UPLOAD_TMP_PATH}\" 
+    COMMAND make goahead-5.2.0
-    ME_GOAHEAD_SSL_KEY=\"${GOAHEAD_CONFIG_FILE_PATH}/self.key\" ME_GOAHEAD_SSL_CERTIFICATE=\"${GOAHEAD_CONFIG_FILE_PATH}/self.crt\"
-    ${ME_GOAHEAD_LIMIT_POST} -f ../modify/goahead-linux-static-fancy.mk
-    # COMMAND make CC=${CMAKE_C_COMPILER} ARCH=${SET_ARCH} PROFILE=${LIB_TYPE} -f ../modify/goahead-linux-static-fancy.mk // TODO:
-    COMMAND echo "Copy goahead lib to output path."
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgo.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libmbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libmbedtls.a
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgoahead-mbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgoahead-mbedtls.a
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.crt ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.key ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/route.txt ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/auth.txt ${PLATFORM_PATH}/cmake-shell/
-    WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead
-)
-add_custom_target(
-    libgo.a
-    DEPENDS ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
-    # COMMAND mkdir ${GOAHEAD_UPLOAD_TMP_PATH}
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/modify/http.c ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/src
-    COMMAND touch ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/src/http.c
     WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
 )
 add_custom_target(
-    goahead_compile
+    compile_goahead
-    COMMAND test ! -f ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a || rm ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
+    DEPENDS ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
-    COMMAND test ! -f ${EXTERNAL_LIBS_OUTPUT_PATH}/libmbedtls.a || rm ${EXTERNAL_LIBS_OUTPUT_PATH}/libmbedtls.a
-    COMMAND test ! -f ${EXTERNAL_LIBS_OUTPUT_PATH}/libgoahead-mbedtls.a || rm ${EXTERNAL_LIBS_OUTPUT_PATH}/libgoahead-mbedtls.a
-    COMMAND make CC=${CMAKE_C_COMPILER} ARCH=${SET_ARCH} PROFILE=${LIB_TYPE} ME_GOAHEAD_UPLOAD_DIR=\"${GOAHEAD_UPLOAD_TMP_PATH}\" 
-    ME_GOAHEAD_SSL_KEY=\"${GOAHEAD_CONFIG_FILE_PATH}/self.key\" ME_GOAHEAD_SSL_CERTIFICATE=\"${GOAHEAD_CONFIG_FILE_PATH}/self.crt\"
-    ${ME_GOAHEAD_LIMIT_POST} -f ../modify/goahead-linux-static-fancy.mk
-    COMMAND echo "Copy goahead lib to output path."
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgo.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgo.a
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libmbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libmbedtls.a
-    COMMAND mv ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/libgoahead-mbedtls.a ${EXTERNAL_LIBS_OUTPUT_PATH}/libgoahead-mbedtls.a
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.crt ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/build/${GOAHEAD_INCLUDE_PATH}/bin/self.key ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/route.txt ${PLATFORM_PATH}/cmake-shell/
-    COMMAND cp ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead/test/auth.txt ${PLATFORM_PATH}/cmake-shell/
-    WORKING_DIRECTORY ${EXTERNAL_SOURCE_PATH}/goahead-5.2.0/GoAhead
 )
+add_dependencies(${TARGET_NAME} compile_goahead)
 
 define_file_name(${TARGET_NAME})
 

utils/WebServer/build/webserver.cmake

@@ -8,4 +8,6 @@ if (NOT DEFINED GOAHEAD_CONFIG_FILE_PATH)
 else()
     add_definitions(-DGOAHEAD_CONFIG_FILE_PATH=\"${GOAHEAD_CONFIG_FILE_PATH}\") # 代码中使用该宏定义下的配置文件
 endif()
-add_definitions(-DGOAHEAD_DOCUMENTS_PATH=\"${GOAHEAD_DOCUMENTS_PATH}\")
+add_definitions(-DGOAHEAD_DOCUMENTS_PATH=\"${GOAHEAD_DOCUMENTS_PATH}\")
+
+set(GOAHEAD_EXTERNAL_LIBS go mbedtls goahead-mbedtls)