@scrypted/libav 1.0.179 → 1.0.181

package/openh264/codec/common/generate_version.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+git rev-list HEAD | sort > config.git-hash
+SRC_PATH=$1
+LOCALVER=`wc -l config.git-hash | awk '{print $1}'`
+if [ $LOCALVER \> 1 ] ; then
+    VER="$(git rev-list HEAD -n 1 | cut -c 1-7)"
+    if git status | grep -q "modified:" ; then
+        VER="${VER}+M"
+    fi
+    GIT_VERSION=$VER
+else
+    GIT_VERSION=
+    VER="x"
+fi
+GIT_VERSION='"'$GIT_VERSION'"'
+rm -f config.git-hash
+
+mkdir -p codec/common/inc
+cat $SRC_PATH/codec/common/inc/version_gen.h.template | sed "s/\$FULL_VERSION/$GIT_VERSION/g" > codec/common/inc/version_gen.h.new
+if cmp codec/common/inc/version_gen.h.new codec/common/inc/version_gen.h > /dev/null 2>&1; then
+    # Identical to old version, don't touch it (to avoid unnecessary rebuilds)
+    rm codec/common/inc/version_gen.h.new
+    echo "Keeping existing codec/common/inc/version_gen.h"
+    exit 0
+fi
+mv codec/common/inc/version_gen.h.new codec/common/inc/version_gen.h
+
+echo "Generated codec/common/inc/version_gen.h"

package/openh264/codec/common/inc/WelsList.h

@@ -0,0 +1,287 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2015, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    WelsList
+ *
+ * \brief   for the list function needed in ThreadPool
+ *
+ * \date    9/27/2015 Created
+ *
+ *************************************************************************************
+ */
+
+
+#ifndef _WELS_LIST_H_
+#define _WELS_LIST_H_
+
+#include "typedefs.h"
+#include <stdlib.h>
+
+namespace WelsCommon {
+
+template<typename TNodeType>
+struct SNode {
+  TNodeType* pPointer;
+  SNode* pPrevNode;
+  SNode* pNextNode;
+};
+
+template<typename TNodeType>
+class CWelsList {
+ public:
+  CWelsList() {
+    m_iCurrentNodeCount = 0;
+    m_iMaxNodeCount = 50;
+
+    m_pCurrentList = NULL;
+    m_pFirst = NULL;
+    m_pCurrent = NULL;
+    m_pLast = NULL;
+  };
+  ~CWelsList() {
+    if (m_pCurrentList) {
+      free (m_pCurrentList);
+      m_pCurrentList = NULL;
+    }
+
+    m_pCurrentList = NULL;
+    m_pFirst = NULL;
+    m_pCurrent = NULL;
+    m_pLast = NULL;
+  };
+
+  int32_t size() {
+    return m_iCurrentNodeCount;
+  }
+
+  bool push_back (TNodeType* pNode) {
+    if (!pNode) {
+      return false;
+    }
+
+    if (NULL == m_pCurrentList) {
+      m_pCurrentList = static_cast<SNode<TNodeType>*> (malloc (m_iMaxNodeCount * sizeof (SNode<TNodeType>)));
+      if (NULL == m_pCurrentList) {
+        return false;
+      } else {
+        ResetStorage();
+      }
+    }
+
+    if (NULL == m_pCurrent) {
+      if (!ExpandList()) {
+        return false;
+      }
+    }
+
+    m_pCurrent->pPointer = pNode;
+    m_pCurrent = m_pCurrent->pNextNode;
+    m_iCurrentNodeCount++;
+
+    return true;
+  }
+
+  TNodeType* begin() {
+    if (m_pFirst) {
+      return m_pFirst->pPointer;
+    }
+    return NULL;
+  }
+
+  void pop_front() {
+    if (m_iCurrentNodeCount == 0) {
+      return;
+    }
+
+    SNode<TNodeType>* pTemp = m_pFirst;
+
+    m_pFirst = m_pFirst->pNextNode;
+    m_pFirst->pPrevNode = NULL;
+
+    CleanOneNode (pTemp);
+
+    m_pLast->pNextNode = pTemp;
+    pTemp->pPrevNode = m_pLast;
+    m_pLast = pTemp;
+
+    if (NULL == m_pCurrent)
+      m_pCurrent = m_pLast;
+
+    m_iCurrentNodeCount --;
+  }
+
+  bool erase (TNodeType* pNode) {
+    if (0 == m_iCurrentNodeCount) {
+      return false;
+    }
+
+    SNode<TNodeType>* pTemp = m_pFirst;
+    do {
+      if (pNode == pTemp->pPointer) {
+        if (pTemp->pPrevNode) {
+          pTemp->pPrevNode->pNextNode = pTemp->pNextNode;
+        } else {
+          m_pFirst = pTemp->pNextNode;
+        }
+
+        if (pTemp->pNextNode) {
+          pTemp->pNextNode->pPrevNode = pTemp->pPrevNode;
+        }
+
+        CleanOneNode (pTemp);
+        m_iCurrentNodeCount --;
+
+        m_pLast->pNextNode = pTemp;
+        pTemp->pPrevNode = m_pLast;
+        m_pLast = pTemp;
+
+        return true;
+      }
+
+      pTemp = pTemp->pNextNode;
+
+    } while (pTemp && pTemp->pPointer);
+    return false;
+  }
+
+  bool findNode (TNodeType* pNodeTarget) {
+    if ((m_iCurrentNodeCount > 0) && pNodeTarget) {
+      SNode<TNodeType>* pNode = m_pFirst;
+      while (pNode) {
+        if (pNode->pPointer == pNodeTarget) {
+          return true;
+        }
+        pNode = pNode->pNextNode;
+      }
+    }
+    return false;
+  }
+
+  TNodeType* getNode (int iNodeIdx) {
+    if ((iNodeIdx > m_iCurrentNodeCount - 1) || (0 == m_iCurrentNodeCount)) {
+      return NULL;
+    }
+    SNode<TNodeType>* pNode = m_pFirst;
+    for (int i = 0; i < iNodeIdx; i++) {
+      if (pNode->pNextNode) {
+        pNode = pNode->pNextNode;
+      } else {
+        return NULL;
+      }
+    }
+    return pNode->pPointer;
+  }
+
+ private:
+  bool ExpandList() {
+    SNode<TNodeType>* tmpCurrentList = static_cast<SNode<TNodeType>*> (malloc (m_iMaxNodeCount * 2 * sizeof (
+                                         SNode<TNodeType>)));
+    if (tmpCurrentList == NULL) {
+      return false;
+    }
+    InitStorage (tmpCurrentList, (m_iMaxNodeCount * 2) - 1);
+
+    SNode<TNodeType>* pTemp = m_pFirst;
+    for (int i = 0; ((i < m_iMaxNodeCount) && pTemp); i++) {
+      tmpCurrentList[i].pPointer = pTemp->pPointer;
+      pTemp = pTemp->pNextNode;
+    }
+
+    free (m_pCurrentList);
+    m_pCurrentList = tmpCurrentList;
+    m_iCurrentNodeCount = m_iMaxNodeCount;
+    m_iMaxNodeCount = m_iMaxNodeCount * 2;
+    m_pFirst = & (m_pCurrentList[0]);
+    m_pLast = & (m_pCurrentList[m_iMaxNodeCount - 1]);
+    m_pCurrent = & (m_pCurrentList[m_iCurrentNodeCount]);
+    return true;
+  }
+
+  void InitStorage (SNode<TNodeType>* pList, const int32_t iMaxIndex) {
+    pList[0].pPrevNode = NULL;
+    pList[0].pPointer = NULL;
+    pList[0].pNextNode = & (pList[1]);
+    for (int i = 1; i < iMaxIndex; i++) {
+      pList[i].pPrevNode = & (pList[i - 1]);
+      pList[i].pPointer = NULL;
+      pList[i].pNextNode = & (pList[i + 1]);
+    }
+    pList[iMaxIndex].pPrevNode = & (pList[iMaxIndex - 1]);
+    pList[iMaxIndex].pPointer = NULL;
+    pList[iMaxIndex].pNextNode = NULL;
+  }
+
+
+  void CleanOneNode (SNode<TNodeType>* pSNode) {
+    pSNode->pPointer = NULL;
+    pSNode->pPrevNode = NULL;
+    pSNode->pNextNode = NULL;
+  }
+
+  void ResetStorage() {
+    InitStorage (m_pCurrentList, m_iMaxNodeCount - 1);
+    m_pCurrent = m_pCurrentList;
+    m_pFirst = & (m_pCurrentList[0]);
+    m_pLast = & (m_pCurrentList[m_iMaxNodeCount - 1]);
+  }
+
+ private:
+  int32_t m_iCurrentNodeCount;
+  int32_t m_iMaxNodeCount;
+  SNode<TNodeType>* m_pCurrentList;
+  SNode<TNodeType>* m_pFirst;
+  SNode<TNodeType>* m_pLast;
+  SNode<TNodeType>* m_pCurrent;
+};
+
+template<typename TNodeType>
+class CWelsNonDuplicatedList : public CWelsList<TNodeType> {
+ public:
+  bool push_back (TNodeType* pNode) {
+    if (0 != this->size()) {
+      if ((NULL != pNode) && (this->findNode (pNode))) {      //not checking NULL for easier testing
+        return false;
+      }
+    }
+
+    return CWelsList<TNodeType>::push_back (pNode);
+  }
+
+};
+
+
+}
+
+
+#endif
+
+
+

package/openh264/codec/common/inc/WelsLock.h

@@ -0,0 +1,97 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2015, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    WelsLock.h
+ *
+ * \brief   class wrapping for locks
+ *
+ * \date    5/09/2012 Created
+ *
+ *************************************************************************************
+ */
+
+#ifndef _WELS_LOCK_H_
+#define _WELS_LOCK_H_
+
+#include "macros.h"
+#include "typedefs.h"
+#include "WelsThreadLib.h"
+
+namespace WelsCommon {
+
+class CWelsLock {
+  DISALLOW_COPY_AND_ASSIGN (CWelsLock);
+ public:
+  CWelsLock() {
+    WelsMutexInit (&m_cMutex);
+  }
+
+  virtual ~CWelsLock() {
+    WelsMutexDestroy (&m_cMutex);
+  }
+
+  WELS_THREAD_ERROR_CODE  Lock() {
+    return WelsMutexLock (&m_cMutex);
+  }
+
+  WELS_THREAD_ERROR_CODE Unlock() {
+    return WelsMutexUnlock (&m_cMutex);
+  }
+
+ private:
+  WELS_MUTEX   m_cMutex;
+};
+
+class CWelsAutoLock {
+  DISALLOW_COPY_AND_ASSIGN (CWelsAutoLock);
+ public:
+  CWelsAutoLock (CWelsLock& cLock) : m_cLock (cLock) {
+    m_cLock.Lock();
+  }
+
+  virtual ~CWelsAutoLock() {
+    m_cLock.Unlock();
+  }
+
+ private:
+  CWelsLock&    m_cLock;
+};
+
+}
+
+#endif
+
+
+
+
+
+
+

package/openh264/codec/common/inc/WelsTask.h

@@ -0,0 +1,75 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2015, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    WelsTask.h
+ *
+ * \brief   Interfaces introduced in thread pool
+ *
+ * \date    5/09/2012 Created
+ *
+ *************************************************************************************
+ */
+
+#ifndef _WELS_TASK_H_
+#define _WELS_TASK_H_
+
+#include "codec_def.h"
+
+namespace WelsCommon {
+
+class IWelsTaskSink {
+ public:
+  virtual int OnTaskExecuted() = 0;
+  virtual int OnTaskCancelled() = 0;
+};
+
+class IWelsTask {
+ public:
+  IWelsTask (IWelsTaskSink* pSink) {
+    m_pSink = pSink;
+  };
+  virtual ~IWelsTask() { }
+
+  virtual int Execute() = 0;
+
+  IWelsTaskSink* GetSink() {
+    return m_pSink;
+  };
+
+ protected:
+  IWelsTaskSink*   m_pSink;
+};
+
+}
+
+#endif
+
+

package/openh264/codec/common/inc/WelsTaskThread.h

@@ -0,0 +1,83 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2015, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    WelsTaskThread.h
+ *
+ * \brief   connecting task and thread
+ *
+ * \date    5/09/2012 Created
+ *
+ *************************************************************************************
+ */
+
+
+#ifndef _WELS_TASK_THREAD_H_
+#define _WELS_TASK_THREAD_H_
+
+
+#include "WelsTask.h"
+#include "WelsThread.h"
+
+namespace WelsCommon {
+
+class CWelsTaskThread;
+
+class IWelsTaskThreadSink {
+ public:
+  virtual WELS_THREAD_ERROR_CODE OnTaskStart (CWelsTaskThread* pThread, IWelsTask* pTask) = 0;
+  virtual WELS_THREAD_ERROR_CODE OnTaskStop (CWelsTaskThread* pThread, IWelsTask* pTask) = 0;
+};
+
+class CWelsTaskThread : public CWelsThread {
+ public:
+  CWelsTaskThread (IWelsTaskThreadSink* pSink);
+  virtual ~CWelsTaskThread();
+
+  WELS_THREAD_ERROR_CODE  SetTask (IWelsTask* pTask);
+  virtual void ExecuteTask();
+
+  uintptr_t    GetID() const {
+    return m_uiID;
+  }
+
+ private:
+  CWelsLock   m_cLockTask;
+  IWelsTaskThreadSink*   m_pSink;
+  IWelsTask*    m_pTask;
+  uintptr_t    m_uiID;
+
+  DISALLOW_COPY_AND_ASSIGN (CWelsTaskThread);
+};
+
+}
+
+#endif
+

package/openh264/codec/common/inc/WelsThread.h

@@ -0,0 +1,106 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2015, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    WelsThread.h
+ *
+ * \brief   Interfaces introduced in threads
+ *
+ * \date    5/09/2012 Created
+ *
+ *************************************************************************************
+ */
+
+
+#ifndef _WELS_THREAD_H_
+#define _WELS_THREAD_H_
+
+
+#include "macros.h"
+#include "WelsLock.h"
+#include "WelsThreadLib.h"
+
+namespace WelsCommon {
+
+class CWelsThread {
+ public:
+  CWelsThread();
+  virtual ~CWelsThread();
+
+  virtual void Thread();
+  virtual void ExecuteTask() = 0;
+  virtual WELS_THREAD_ERROR_CODE Start();
+  virtual void Kill();
+  WELS_MUTEX          m_hMutex;
+ protected:
+  static WELS_THREAD_ROUTINE_TYPE  TheThread (void* pParam);
+
+  void SetRunning (bool bRunning) {
+    CWelsAutoLock  cLock (m_cLockStatus);
+
+    m_bRunning = bRunning;
+  }
+  void SetEndFlag (bool bEndFlag) {
+    CWelsAutoLock  cLock (m_cLockStatus);
+
+    m_bEndFlag = bEndFlag;
+  }
+
+  bool GetRunning() const {
+    return m_bRunning;
+  }
+
+  bool GetEndFlag() const {
+    return m_bEndFlag;
+  }
+
+  void SignalThread() {
+    WelsEventSignal (&m_hEvent, &m_hMutex, &m_iConVar);
+  }
+
+ private:
+  WELS_THREAD_HANDLE  m_hThread;
+  WELS_EVENT          m_hEvent;
+  CWelsLock           m_cLockStatus;
+  bool                m_bRunning;
+  bool                m_bEndFlag;
+  int                 m_iConVar;
+
+  DISALLOW_COPY_AND_ASSIGN (CWelsThread);
+};
+
+
+}
+
+
+
+#endif
+
+