shithub: openh264

Download patch

ref: f2bd22acd5713cdb92ec2db8851e0f97ad26cc1f
parent: 7b96c6756ec1c20805e8a17f7d754af15620ea5f
author: Martin Storsjö <[email protected]>
date: Sat Feb 8 18:28:42 EST 2014

Use char instead of str_t

--- a/codec/common/WelsThreadLib.cpp
+++ b/codec/common/WelsThreadLib.cpp
@@ -268,7 +268,7 @@
   return sem_destroy (event);	// match with sem_init
 }
 
-WELS_THREAD_ERROR_CODE    WelsEventOpen (WELS_EVENT** p_event, str_t* event_name) {
+WELS_THREAD_ERROR_CODE    WelsEventOpen (WELS_EVENT** p_event, char* event_name) {
   if (p_event == NULL || event_name == NULL)
     return WELS_THREAD_ERROR_GENERAL;
   *p_event = sem_open (event_name, O_CREAT, (S_IRUSR | S_IWUSR)/*0600*/, 0);
@@ -280,7 +280,7 @@
     return WELS_THREAD_ERROR_OK;
   }
 }
-WELS_THREAD_ERROR_CODE    WelsEventClose (WELS_EVENT* event, str_t* event_name) {
+WELS_THREAD_ERROR_CODE    WelsEventClose (WELS_EVENT* event, char* event_name) {
   WELS_THREAD_ERROR_CODE err = sem_close (event);	// match with sem_open
   if (event_name)
     sem_unlink (event_name);
--- a/codec/common/WelsThreadLib.h
+++ b/codec/common/WelsThreadLib.h
@@ -110,8 +110,8 @@
 WELS_THREAD_ERROR_CODE    WelsMutexDestroy (WELS_MUTEX* mutex);
 
 #ifdef __GNUC__
-WELS_THREAD_ERROR_CODE    WelsEventOpen (WELS_EVENT** p_event, str_t* event_name);
-WELS_THREAD_ERROR_CODE    WelsEventClose (WELS_EVENT* event, str_t* event_name);
+WELS_THREAD_ERROR_CODE    WelsEventOpen (WELS_EVENT** p_event, char* event_name);
+WELS_THREAD_ERROR_CODE    WelsEventClose (WELS_EVENT* event, char* event_name);
 #endif//__GNUC__
 WELS_THREAD_ERROR_CODE    WelsEventInit (WELS_EVENT* event);
 WELS_THREAD_ERROR_CODE    WelsEventDestroy (WELS_EVENT* event);
--- a/codec/common/cpu.cpp
+++ b/codec/common/cpu.cpp
@@ -92,8 +92,8 @@
     /* CMOV instruction checking */
     uiCPU |= WELS_CPU_CMOV;
   }
-  if ((!strcmp ((const str_t*)chVendorName, CPU_Vendor_INTEL)) ||
-      (!strcmp((const str_t*)chVendorName, CPU_Vendor_AMD)) ) {	// confirmed_safe_unsafe_usage
+  if ((!strcmp ((const char*)chVendorName, CPU_Vendor_INTEL)) ||
+      (!strcmp((const char*)chVendorName, CPU_Vendor_AMD)) ) {	// confirmed_safe_unsafe_usage
     if (uiFeatureD & 0x10000000) {
       /* Multi-Threading checking: contains of multiple logic processors */
       uiCPU |= WELS_CPU_HTT;
@@ -139,7 +139,7 @@
     } else {
       *pNumberOfLogicProcessors = 1;
     }
-    if( !strcmp((const str_t*)chVendorName, CPU_Vendor_INTEL) ){
+    if( !strcmp((const char*)chVendorName, CPU_Vendor_INTEL) ){
       if( uiMaxCpuidLevel >= 4 ){
         uiFeatureC = 0;
         WelsCPUId(0x4, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
@@ -152,7 +152,7 @@
 
   WelsCPUId (0x80000000, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
 
-  if ((!strcmp ((const str_t*)chVendorName, CPU_Vendor_AMD))
+  if ((!strcmp ((const char*)chVendorName, CPU_Vendor_AMD))
       && (uiFeatureA >= 0x80000001)) {	// confirmed_safe_unsafe_usage
     WelsCPUId (0x80000001, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
     if (uiFeatureD & 0x00400000) {
@@ -163,7 +163,7 @@
     }
   }
 
-  if (!strcmp ((const str_t*)chVendorName, CPU_Vendor_INTEL)) {	// confirmed_safe_unsafe_usage
+  if (!strcmp ((const char*)chVendorName, CPU_Vendor_INTEL)) {	// confirmed_safe_unsafe_usage
     int32_t  family, model;
 
     WelsCPUId (1, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
@@ -176,8 +176,8 @@
   }
 
   // get cache line size
-  if ((!strcmp ((const str_t*)chVendorName, CPU_Vendor_INTEL))
-      || ! (strcmp ((const str_t*)chVendorName, CPU_Vendor_CYRIX))) {	// confirmed_safe_unsafe_usage
+  if ((!strcmp ((const char*)chVendorName, CPU_Vendor_INTEL))
+      || ! (strcmp ((const char*)chVendorName, CPU_Vendor_CYRIX))) {	// confirmed_safe_unsafe_usage
     WelsCPUId (1, &uiFeatureA, &uiFeatureB, &uiFeatureC, &uiFeatureD);
 
     CacheLineSize = (uiFeatureB & 0xff00) >>
--- a/codec/common/crt_util_safe_x.cpp
+++ b/codec/common/crt_util_safe_x.cpp
@@ -61,7 +61,7 @@
 
 #if  defined(_MSC_VER) && (_MSC_VER>=1500)
 
-int32_t WelsSnprintf (str_t* pBuffer,  int32_t iSizeOfBuffer, const str_t* kpFormat, ...) {
+int32_t WelsSnprintf (char* pBuffer,  int32_t iSizeOfBuffer, const char* kpFormat, ...) {
   va_list  pArgPtr;
   int32_t  iRc;
 
@@ -74,17 +74,17 @@
   return iRc;
 }
 
-str_t* WelsStrncpy (str_t* pDest, int32_t iSizeInBytes, const str_t* kpSrc) {
+char* WelsStrncpy (char* pDest, int32_t iSizeInBytes, const char* kpSrc) {
   strncpy_s (pDest, iSizeInBytes, kpSrc, _TRUNCATE);
 
   return pDest;
 }
 
-int32_t WelsVsnprintf (str_t* pBuffer, int32_t iSizeOfBuffer, const str_t* kpFormat, va_list pArgPtr) {
+int32_t WelsVsnprintf (char* pBuffer, int32_t iSizeOfBuffer, const char* kpFormat, va_list pArgPtr) {
   return vsnprintf_s (pBuffer, iSizeOfBuffer, _TRUNCATE, kpFormat, pArgPtr);
 }
 
-WelsFileHandle* WelsFopen (const str_t* kpFilename,  const str_t* kpMode) {
+WelsFileHandle* WelsFopen (const char* kpFilename,  const char* kpMode) {
   WelsFileHandle* pFp = NULL;
   if (fopen_s (&pFp, kpFilename, kpMode) != 0) {
     return NULL;
@@ -101,7 +101,7 @@
   return _ftime_s (pTp);
 }
 
-int32_t WelsStrftime (str_t* pBuffer, int32_t iSize, const str_t* kpFormat, const SWelsTime* kpTp) {
+int32_t WelsStrftime (char* pBuffer, int32_t iSize, const char* kpFormat, const SWelsTime* kpTp) {
   struct tm   sTimeNow;
   int32_t iRc;
 
@@ -115,7 +115,7 @@
 
 #else
 
-int32_t WelsSnprintf (str_t* pBuffer,  int32_t iSizeOfBuffer, const str_t* kpFormat, ...) {
+int32_t WelsSnprintf (char* pBuffer,  int32_t iSizeOfBuffer, const char* kpFormat, ...) {
   va_list pArgPtr;
   int32_t iRc;
 
@@ -130,7 +130,7 @@
   return iRc;
 }
 
-str_t* WelsStrncpy (str_t* pDest, int32_t iSizeInBytes, const str_t* kpSrc) {
+char* WelsStrncpy (char* pDest, int32_t iSizeInBytes, const char* kpSrc) {
   strncpy (pDest, kpSrc, iSizeInBytes); //confirmed_safe_unsafe_usage
   pDest[iSizeInBytes - 1] = '\0';
 
@@ -137,7 +137,7 @@
   return pDest;
 }
 
-int32_t WelsVsnprintf (str_t* pBuffer, int32_t iSizeOfBuffer, const str_t* kpFormat, va_list pArgPtr) {
+int32_t WelsVsnprintf (char* pBuffer, int32_t iSizeOfBuffer, const char* kpFormat, va_list pArgPtr) {
   int32_t iRc = vsnprintf (pBuffer, iSizeOfBuffer, kpFormat, pArgPtr); //confirmed_safe_unsafe_usage
   if (iRc < 0)
     pBuffer[iSizeOfBuffer - 1] = '\0';
@@ -145,7 +145,7 @@
 }
 
 
-WelsFileHandle* WelsFopen (const str_t* kpFilename,  const str_t* kpMode) {
+WelsFileHandle* WelsFopen (const char* kpFilename,  const char* kpMode) {
   return fopen (kpFilename, kpMode);
 }
 
@@ -158,7 +158,7 @@
   return 0;
 }
 
-int32_t WelsStrftime (str_t* pBuffer, int32_t iSize, const str_t* kpFormat, const SWelsTime* kpTp) {
+int32_t WelsStrftime (char* pBuffer, int32_t iSize, const char* kpFormat, const SWelsTime* kpTp) {
   struct tm*   pTnow;
   int32_t iRc;
 
@@ -175,7 +175,7 @@
 
 #else  //GCC
 
-int32_t WelsSnprintf (str_t* pBuffer,  int32_t iSizeOfBuffer, const str_t* kpFormat, ...) {
+int32_t WelsSnprintf (char* pBuffer,  int32_t iSizeOfBuffer, const char* kpFormat, ...) {
   va_list pArgPtr;
   int32_t iRc;
 
@@ -188,17 +188,17 @@
   return iRc;
 }
 
-str_t* WelsStrncpy (str_t* pDest, int32_t iSizeInBytes, const str_t* kpSrc) {
+char* WelsStrncpy (char* pDest, int32_t iSizeInBytes, const char* kpSrc) {
   strncpy (pDest, kpSrc, iSizeInBytes); //confirmed_safe_unsafe_usage
   pDest[iSizeInBytes - 1] = '\0';
   return pDest;
 }
 
-int32_t WelsVsnprintf (str_t* pBuffer, int32_t iSizeOfBuffer, const str_t* kpFormat, va_list pArgPtr) {
+int32_t WelsVsnprintf (char* pBuffer, int32_t iSizeOfBuffer, const char* kpFormat, va_list pArgPtr) {
   return vsnprintf (pBuffer, iSizeOfBuffer, kpFormat, pArgPtr); //confirmed_safe_unsafe_usage
 }
 
-WelsFileHandle* WelsFopen (const str_t* kpFilename,  const str_t* kpMode) {
+WelsFileHandle* WelsFopen (const char* kpFilename,  const char* kpMode) {
   return fopen (kpFilename, kpMode);
 }
 
@@ -219,7 +219,7 @@
   return 0;
 }
 
-int32_t WelsStrftime (str_t* pBuffer, int32_t iSize, const str_t* kpFormat, const SWelsTime* kpTp) {
+int32_t WelsStrftime (char* pBuffer, int32_t iSize, const char* kpFormat, const SWelsTime* kpTp) {
   struct tm*   pTnow;
   int32_t iRc;
 
@@ -234,7 +234,7 @@
 #endif
 
 
-str_t* WelsStrcat (str_t* pDest, int32_t iSizeInBytes, const str_t* kpSrc) {
+char* WelsStrcat (char* pDest, int32_t iSizeInBytes, const char* kpSrc) {
     int32_t iCurLen = strlen(pDest);
     return WelsStrncpy(pDest + iCurLen, iSizeInBytes - iCurLen, kpSrc);
 }
--- a/codec/common/crt_util_safe_x.h
+++ b/codec/common/crt_util_safe_x.h
@@ -75,12 +75,12 @@
 typedef      struct timeb      SWelsTime;
 #endif
 
-int32_t   WelsSnprintf (str_t* buffer,  int32_t sizeOfBuffer,  const str_t* format, ...);
-str_t*   WelsStrncpy (str_t* dest, int32_t sizeInBytes, const str_t* src);
-str_t*   WelsStrcat (str_t* dest, int32_t sizeInBytes, const str_t* src);
-int32_t   WelsVsnprintf (str_t* buffer, int32_t sizeOfBuffer, const str_t* format, va_list argptr);
+int32_t   WelsSnprintf (char* buffer,  int32_t sizeOfBuffer,  const char* format, ...);
+char*   WelsStrncpy (char* dest, int32_t sizeInBytes, const char* src);
+char*   WelsStrcat (char* dest, int32_t sizeInBytes, const char* src);
+int32_t   WelsVsnprintf (char* buffer, int32_t sizeOfBuffer, const char* format, va_list argptr);
 
-WelsFileHandle*        WelsFopen (const str_t* filename,  const str_t* mode);
+WelsFileHandle*        WelsFopen (const char* filename,  const char* mode);
 int32_t                WelsFclose (WelsFileHandle*   fp);
 int32_t                WelsFread (void* buffer, int32_t size, int32_t count, WelsFileHandle* fp);
 int32_t                WelsFwrite (const void* buffer, int32_t size, int32_t count, WelsFileHandle* fp);
@@ -88,7 +88,7 @@
 int32_t                WelsFflush (WelsFileHandle* fp);
 
 int32_t                WelsGetTimeOfDay (SWelsTime* tp);
-int32_t                WelsStrftime (str_t* buffer, int32_t size, const str_t* format, const SWelsTime* tp);
+int32_t                WelsStrftime (char* buffer, int32_t size, const char* format, const SWelsTime* tp);
 uint16_t               WelsGetMillisecond (const SWelsTime* tp);
 
 
--- a/codec/common/logging.cpp
+++ b/codec/common/logging.cpp
@@ -41,7 +41,7 @@
   g_TraceLevel = level;
 }
 
-int32_t welsStderrLevelTrace (int32_t level, const str_t* format, va_list ap) {
+int32_t welsStderrLevelTrace (int32_t level, const char* format, va_list ap) {
   if (level < g_TraceLevel) {
     vfprintf (stderr, format, ap);
   }
--- a/codec/common/logging.h
+++ b/codec/common/logging.h
@@ -40,10 +40,10 @@
 
 
 // Internal details.
-int32_t welsStderrLevelTrace (int32_t level, const str_t* format, va_list ap);
+int32_t welsStderrLevelTrace (int32_t level, const char* format, va_list ap);
 
 template<int level> int32_t welsStderrTrace (
-  const str_t* format, ...) {
+  const char* format, ...) {
   va_list ap;
   va_start (ap, format);
   welsStderrLevelTrace (level, format, ap);
--- a/codec/common/typedefs.h
+++ b/codec/common/typedefs.h
@@ -60,8 +60,6 @@
 
 #endif // _MSC_VER defined
 
-// FIXME:     all string type should be declared explicit as char.
-typedef char      str_t;
 // The 'float' type is portable and usable without any need for any extra typedefs.
 
 #ifdef EPSN
--- a/codec/decoder/core/inc/mem_align.h
+++ b/codec/decoder/core/inc/mem_align.h
@@ -59,7 +59,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag);
+void* WelsMalloc (const uint32_t kuiSize, const char* kpTag);
 
 /*!
 *************************************************************************************
@@ -73,7 +73,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void WelsFree (void* pPtr, const str_t* kpTag);
+void WelsFree (void* pPtr, const char* kpTag);
 
 #define WELS_SAFE_FREE(pPtr, pTag)		if (pPtr) { WelsFree(pPtr, pTag); pPtr = NULL; }
 
--- a/codec/decoder/core/src/mem_align.cpp
+++ b/codec/decoder/core/src/mem_align.cpp
@@ -44,7 +44,7 @@
 #endif
 //
 
-void* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
+void* WelsMalloc (const uint32_t kuiSize, const char* kpTag) {
   const int32_t kiSizeVoidPtr	= sizeof (void**);
   const int32_t kiSizeInt		= sizeof (int32_t);
   const int32_t kiAlignBytes	= 15;
@@ -84,7 +84,7 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
-void WelsFree (void* pPtr, const str_t* kpTag) {
+void WelsFree (void* pPtr, const char* kpTag) {
   if (pPtr) {
 #ifdef MEMORY_CHECK
     if (NULL != pMemCheckFree && kpTag != NULL) {
--- a/codec/decoder/plus/inc/welsCodecTrace.h
+++ b/codec/decoder/plus/inc/welsCodecTrace.h
@@ -66,9 +66,9 @@
 virtual ~IWelsTrace() {};
 
 virtual int32_t  SetTraceLevel (int32_t iLevel) = 0;
-virtual int32_t  Trace (const int32_t kLevel, const str_t* kpFormat,  va_list pVl) = 0;
+virtual int32_t  Trace (const int32_t kLevel, const char* kpFormat,  va_list pVl) = 0;
 
-static void  WelsTrace (void* pObject, const int32_t kLevel, const str_t* kpFormat, va_list pVl) {
+static void  WelsTrace (void* pObject, const int32_t kLevel, const char* kpFormat, va_list pVl) {
   IWelsTrace*   pThis = (IWelsTrace*) (pObject);
 
   if (pThis) {
@@ -76,7 +76,7 @@
   }
 }
 
-static void WelsVTrace (void* pObject, const int32_t kLevel, const str_t* kpFormat, ...) {
+static void WelsVTrace (void* pObject, const int32_t kLevel, const char* kpFormat, ...) {
   IWelsTrace* pThis = (IWelsTrace*) (pObject);
 
   va_list  argptr;
@@ -96,9 +96,9 @@
 class CWelsTraceBase : public IWelsTrace {
  public:
 virtual int32_t  SetTraceLevel (int32_t iLevel);
-virtual int32_t  Trace (const int32_t kLevel, const str_t* kpFormat,  va_list pVl);
+virtual int32_t  Trace (const int32_t kLevel, const char* kpFormat,  va_list pVl);
 
-virtual int32_t  WriteString (int32_t iLevel, const str_t* pStr) = 0;
+virtual int32_t  WriteString (int32_t iLevel, const char* pStr) = 0;
  protected:
 CWelsTraceBase() {
   m_iLevel = WELS_LOG_DEFAULT;
@@ -110,11 +110,11 @@
 
 class CWelsTraceFile : public CWelsTraceBase {
  public:
-CWelsTraceFile (const str_t*   filename = (const str_t*)"wels_decoder_trace.txt");
+CWelsTraceFile (const char*   filename = (const char*)"wels_decoder_trace.txt");
 virtual ~CWelsTraceFile();
 
  public:
-virtual int32_t  WriteString (int32_t iLevel, const str_t* pStr);
+virtual int32_t  WriteString (int32_t iLevel, const char* pStr);
 
  private:
 WelsFileHandle* m_pTraceFile;
@@ -127,7 +127,7 @@
 virtual ~CWelsTraceWinDgb() {};
 
  public:
-virtual int32_t  WriteString (int32_t iLevel, const str_t* pStr);
+virtual int32_t  WriteString (int32_t iLevel, const char* pStr);
 };
 #endif
 
@@ -137,7 +137,7 @@
 virtual ~CWelsCodecTrace();
 
  public:
-virtual int32_t  WriteString (int32_t iLevel, const str_t* pStr);
+virtual int32_t  WriteString (int32_t iLevel, const char* pStr);
 
  protected:
 int32_t  LoadWelsTraceModule();
--- a/codec/decoder/plus/src/welsCodecTrace.cpp
+++ b/codec/decoder/plus/src/welsCodecTrace.cpp
@@ -57,14 +57,14 @@
   return 0;
 }
 
-int32_t  CWelsTraceBase::Trace (const int kLevel, const str_t* kpFormat, va_list pVl) {
+int32_t  CWelsTraceBase::Trace (const int kLevel, const char* kpFormat, va_list pVl) {
   if (kLevel & m_iLevel) {
-    str_t chBuf[MAX_LOG_SIZE] = {0};
+    char chBuf[MAX_LOG_SIZE] = {0};
     const int32_t kLen	= strlen ("[DECODER]: ");
 
-    WelsStrncpy (chBuf, MAX_LOG_SIZE, (const str_t*)"[DECODER]: ");
+    WelsStrncpy (chBuf, MAX_LOG_SIZE, (const char*)"[DECODER]: ");
 
-    WelsVsnprintf ((chBuf + kLen),  MAX_LOG_SIZE - kLen, (const str_t*)kpFormat, pVl);
+    WelsVsnprintf ((chBuf + kLen),  MAX_LOG_SIZE - kLen, (const char*)kpFormat, pVl);
 
     WriteString (kLevel, chBuf);
   }
@@ -72,8 +72,8 @@
   return 0;
 }
 
-CWelsTraceFile::CWelsTraceFile (const str_t* pFileName) {
-  m_pTraceFile = WelsFopen (pFileName, (const str_t*)"wt");
+CWelsTraceFile::CWelsTraceFile (const char* pFileName) {
+  m_pTraceFile = WelsFopen (pFileName, (const char*)"wt");
 }
 
 CWelsTraceFile::~CWelsTraceFile() {
@@ -83,9 +83,9 @@
   }
 }
 
-int32_t CWelsTraceFile::WriteString (int32_t iLevel, const str_t* pStr) {
+int32_t CWelsTraceFile::WriteString (int32_t iLevel, const char* pStr) {
   int  iRC = 0;
-  const static str_t chEnter[16] = "\n";
+  const static char chEnter[16] = "\n";
   if (m_pTraceFile) {
     iRC += WelsFwrite (pStr, 1, strlen (pStr), m_pTraceFile);
     iRC += WelsFwrite (chEnter, 1, strlen (chEnter), m_pTraceFile);
@@ -97,7 +97,7 @@
 
 #ifdef _WIN32
 
-int32_t CWelsTraceWinDgb::WriteString (int32_t iLevel, const str_t* pStr) {
+int32_t CWelsTraceWinDgb::WriteString (int32_t iLevel, const char* pStr) {
   OutputDebugStringA (pStr);
 
   return strlen (pStr);
@@ -134,7 +134,7 @@
   return 0;
 }
 
-int32_t  CWelsCodecTrace::WriteString (int32_t iLevel, const str_t* pStr) {
+int32_t  CWelsCodecTrace::WriteString (int32_t iLevel, const char* pStr) {
   {
     switch (iLevel) {
     case WELS_LOG_ERROR:
--- a/codec/decoder/plus/src/welsDecoderExt.cpp
+++ b/codec/decoder/plus/src/welsDecoderExt.cpp
@@ -87,12 +87,12 @@
   :	m_pDecContext (NULL),
     m_pTrace (NULL) {
 #ifdef OUTPUT_BIT_STREAM
-  str_t chFileName[1024] = { 0 };  //for .264
+  char chFileName[1024] = { 0 };  //for .264
   int iBufUsed = 0;
   int iBufLeft = 1023;
   int iCurUsed;
 
-  str_t chFileNameSize[1024] = { 0 }; //for .len
+  char chFileNameSize[1024] = { 0 }; //for .len
   int iBufUsedSize = 0;
   int iBufLeftSize = 1023;
   int iCurUsedSize;
--- a/codec/encoder/core/inc/encoder.h
+++ b/codec/encoder/core/inc/encoder.h
@@ -81,12 +81,12 @@
  * \brief	Dump reconstruction for dependency layer
  */
 
-extern "C" void DumpDependencyRec (SPicture* pSrcPic, const str_t* kpFileName, const int8_t kiDid);
+extern "C" void DumpDependencyRec (SPicture* pSrcPic, const char* kpFileName, const int8_t kiDid);
 
 /*!
  * \brief	Dump the reconstruction pictures
  */
-void DumpRecFrame (SPicture* pSrcPic, const str_t* kpFileName);
+void DumpRecFrame (SPicture* pSrcPic, const char* kpFileName);
 
 
 /*!
--- a/codec/encoder/core/inc/memory_align.h
+++ b/codec/encoder/core/inc/memory_align.h
@@ -46,9 +46,9 @@
 CMemoryAlign (const uint32_t kuiCacheLineSize);
 virtual ~CMemoryAlign();
 
-void* WelsMallocz (const uint32_t kuiSize, const str_t* kpTag);
-void* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag);
-void WelsFree (void* pPointer, const str_t* kpTag);
+void* WelsMallocz (const uint32_t kuiSize, const char* kpTag);
+void* WelsMalloc (const uint32_t kuiSize, const char* kpTag);
+void WelsFree (void* pPointer, const char* kpTag);
 const uint32_t WelsGetCacheLineSize() const;
 #if defined(MEMORY_MONITOR)
 const uint32_t WelsGetMemoryUsage() const;
--- a/codec/encoder/core/inc/param_svc.h
+++ b/codec/encoder/core/inc/param_svc.h
@@ -102,7 +102,7 @@
 float		fOutputFrameRate;		// output frame rate
 
 #ifdef ENABLE_FRAME_DUMP
-str_t		sRecFileName[MAX_FNAME_LEN];	// file to be constructed
+char		sRecFileName[MAX_FNAME_LEN];	// file to be constructed
 #endif//ENABLE_FRAME_DUMP
 } SDLayerParam;
 
@@ -127,7 +127,7 @@
   int32_t iHeight;
 } SUsedPicRect;	// the rect in input picture that encoder actually used
 
-str_t*       pCurPath; // record current lib path such as:/pData/pData/com.wels.enc/lib/
+char*       pCurPath; // record current lib path such as:/pData/pData/com.wels.enc/lib/
 
 float		fMaxFrameRate;		// maximal frame rate [Hz / fps]
 int32_t		iInputCsp;			// color space of input sequence
--- a/codec/encoder/core/inc/property.h
+++ b/codec/encoder/core/inc/property.h
@@ -51,7 +51,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetCodeName (str_t* pBuf, int32_t iSize);
+int32_t GetCodeName (char* pBuf, int32_t iSize);
 
 /*!
  * \brief	get library/module name
@@ -59,7 +59,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetLibName (str_t* pBuf, int32_t iSize);
+int32_t GetLibName (char* pBuf, int32_t iSize);
 
 /*!
  * \brief	get version number
@@ -67,7 +67,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetVerNum (str_t* pBuf, int32_t iSize);
+int32_t GetVerNum (char* pBuf, int32_t iSize);
 
 /*!
  * \brief	get identify information
@@ -75,6 +75,6 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetIdentInfo (str_t* pBuf, int32_t iSize);
+int32_t GetIdentInfo (char* pBuf, int32_t iSize);
 }
 #endif//WELS_DECODER_PROPERTY_H__
--- a/codec/encoder/core/inc/utils.h
+++ b/codec/encoder/core/inc/utils.h
@@ -65,7 +65,7 @@
  *	Function pointer declaration for various tool sets
  */
 // wels log output
-typedef void (*PWelsLogCallbackFunc) (void* pCtx, const int32_t iLevel, const str_t* kpFmt, va_list argv);
+typedef void (*PWelsLogCallbackFunc) (void* pCtx, const int32_t iLevel, const char* kpFmt, va_list argv);
 
 // wels psnr calc
 typedef float (*PWelsPsnrFunc) (const void* kpTarPic,
@@ -78,13 +78,13 @@
 extern PWelsLogCallbackFunc	wlog;
 
 #ifdef __GNUC__
-extern void WelsLog (void* pCtx, int32_t iLevel, const str_t* kpFmt, ...) __attribute__ ((__format__ (__printf__, 3,
+extern void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...) __attribute__ ((__format__ (__printf__, 3,
     4)));
 #else
-extern void WelsLog (void* pCtx, int32_t iLevel, const str_t* kpFmt, ...);
+extern void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...);
 #endif
 
-extern const str_t* g_sWelsLogTags[];
+extern const char* g_sWelsLogTags[];
 
 /*!
  *************************************************************************************
@@ -100,8 +100,8 @@
  * \note	N/A
  *************************************************************************************
  */
-void WelsLogDefault (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv);
-void WelsLogNil (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv);
+void WelsLogDefault (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv);
+void WelsLogNil (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv);
 
 
 /*!
@@ -155,7 +155,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void WelsReopenTraceFile (void* pCtx, str_t* pCurPath);
+void WelsReopenTraceFile (void* pCtx, char* pCurPath);
 
 /*
  *	PSNR calculation routines
--- a/codec/encoder/core/inc/wels_const.h
+++ b/codec/encoder/core/inc/wels_const.h
@@ -44,7 +44,7 @@
 
 // Miscellaneous sizing infos
 #ifndef MAX_FNAME_LEN
-#define MAX_FNAME_LEN		256	// maximal length of file name in str_t size
+#define MAX_FNAME_LEN		256	// maximal length of file name in char size
 #endif//MAX_FNAME_LEN
 
 #ifndef WELS_LOG_BUF_SIZE
--- a/codec/encoder/core/inc/wels_preprocess.h
+++ b/codec/encoder/core/inc/wels_preprocess.h
@@ -92,7 +92,7 @@
   int32_t DestroyIface (void* pEncCtx);
 
  protected:
-  void* QueryFunction (const str_t* pName);
+  void* QueryFunction (const char* pName);
 
  private:
   void* m_pVpLib;
--- a/codec/encoder/core/src/encoder.cpp
+++ b/codec/encoder/core/src/encoder.cpp
@@ -314,7 +314,7 @@
  * \brief	Dump reconstruction for dependency layer
  */
 
-extern "C" void DumpDependencyRec (SPicture* pCurPicture, const str_t* kpFileName, const int8_t kiDid) {
+extern "C" void DumpDependencyRec (SPicture* pCurPicture, const char* kpFileName, const int8_t kiDid) {
   WelsFileHandle* pDumpRecFile = NULL;
   static bool bDependencyRecFlag[MAX_DEPENDENCY_LAYER]	= {0};
   int32_t iWrittenSize											= 0;
@@ -326,7 +326,7 @@
     if (strlen (kpFileName) > 0)	// confirmed_safe_unsafe_usage
       pDumpRecFile = WelsFopen (kpFileName, "ab");
     else {
-      str_t sDependencyRecFileName[16] = {0};
+      char sDependencyRecFileName[16] = {0};
       WelsSnprintf (sDependencyRecFileName, 16, "rec%d.yuv", kiDid);	// confirmed_safe_unsafe_usage
       pDumpRecFile	= WelsFopen (sDependencyRecFileName, "ab");
     }
@@ -336,7 +336,7 @@
     if (strlen (kpFileName) > 0) {	// confirmed_safe_unsafe_usage
       pDumpRecFile	= WelsFopen (kpFileName, "wb");
     } else {
-      str_t sDependencyRecFileName[16] = {0};
+      char sDependencyRecFileName[16] = {0};
       WelsSnprintf (sDependencyRecFileName, 16, "rec%d.yuv", kiDid);	// confirmed_safe_unsafe_usage
       pDumpRecFile	= WelsFopen (sDependencyRecFileName, "wb");
     }
@@ -382,7 +382,7 @@
  * \brief	Dump the reconstruction pictures
  */
 
-void DumpRecFrame (SPicture* pCurPicture, const str_t* kpFileName) {
+void DumpRecFrame (SPicture* pCurPicture, const char* kpFileName) {
   WelsFileHandle* pDumpRecFile				= NULL;
   static bool bRecFlag	= false;
   int32_t iWrittenSize			= 0;
--- a/codec/encoder/core/src/encoder_data_tables.cpp
+++ b/codec/encoder/core/src/encoder_data_tables.cpp
@@ -86,7 +86,7 @@
 
 // extern at mb_cache.h
 
-const str_t* g_sWelsLogTags[] = {
+const char* g_sWelsLogTags[] = {
   "ERR",
   "WARN",
   "INFO",
--- a/codec/encoder/core/src/encoder_ext.cpp
+++ b/codec/encoder/core/src/encoder_ext.cpp
@@ -2082,7 +2082,7 @@
   // for logs
 #ifdef ENABLE_TRACE_FILE
   if (wlog == WelsLogDefault) {
-    str_t fname[MAX_FNAME_LEN] = {0};
+    char fname[MAX_FNAME_LEN] = {0};
 
     WelsSnprintf (fname, MAX_FNAME_LEN, "wels_svc_encoder_trace.txt");
 
--- a/codec/encoder/core/src/memory_align.cpp
+++ b/codec/encoder/core/src/memory_align.cpp
@@ -66,7 +66,7 @@
 #endif//MEMORY_CHECK
 }
 
-void* CMemoryAlign::WelsMallocz (const uint32_t kuiSize, const str_t* kpTag) {
+void* CMemoryAlign::WelsMallocz (const uint32_t kuiSize, const char* kpTag) {
   void* pPointer = WelsMalloc (kuiSize, kpTag);
   if (NULL == pPointer) {
     return NULL;
@@ -77,7 +77,7 @@
   return pPointer;
 }
 
-void* CMemoryAlign::WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
+void* CMemoryAlign::WelsMalloc (const uint32_t kuiSize, const char* kpTag) {
   const int32_t kiSizeOfVoidPointer	= sizeof (void**);
   const int32_t kiSizeOfInt				= sizeof (int32_t);
   const int32_t kiAlignedBytes		= m_nCacheLineSize - 1;
@@ -114,7 +114,7 @@
   return pAlignedBuffer;
 }
 
-void CMemoryAlign::WelsFree (void* pPointer, const str_t* kpTag) {
+void CMemoryAlign::WelsFree (void* pPointer, const char* kpTag) {
   if (pPointer) {
 #ifdef MEMORY_MONITOR
     const int32_t kiMemoryLength = * ((int32_t*) ((uint8_t*)pPointer - sizeof (void**) - sizeof (
--- a/codec/encoder/core/src/property.cpp
+++ b/codec/encoder/core/src/property.cpp
@@ -58,7 +58,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetCodeName (str_t* pBuf, int32_t iSize) {
+int32_t GetCodeName (char* pBuf, int32_t iSize) {
   int32_t iLen = 0;
 
   if (NULL == pBuf)
@@ -79,7 +79,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetLibName (str_t* pBuf, int32_t iSize) {
+int32_t GetLibName (char* pBuf, int32_t iSize) {
   int32_t iLen = 0;
 
   if (NULL == pBuf)
@@ -100,7 +100,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetVerNum (str_t* pBuf, int32_t iSize) {
+int32_t GetVerNum (char* pBuf, int32_t iSize) {
   int32_t iLen = 0;
 
   if (NULL == pBuf)
@@ -121,7 +121,7 @@
  * \param	iSize	size of pBuffer overall
  * \return	actual size of pBuffer used; 0 returned in failure
  */
-int32_t GetIdentInfo (str_t* pBuf, int32_t iSize) {
+int32_t GetIdentInfo (char* pBuf, int32_t iSize) {
   int32_t iLen = 0;
 
   if (NULL == pBuf)
--- a/codec/encoder/core/src/slice_multi_threading.cpp
+++ b/codec/encoder/core/src/slice_multi_threading.cpp
@@ -438,7 +438,7 @@
   iIdx = 0;
   while (iIdx < iThreadNum) {
 #if defined(__GNUC__) && !defined(_WIN32)	// for posix threading
-    str_t name[SEM_NAME_MAX] = {0};
+    char name[SEM_NAME_MAX] = {0};
     WELS_THREAD_ERROR_CODE err = 0;
 #endif//__GNUC__
     pSmt->pThreadPEncCtx[iIdx].pWelsPEncCtx	= (void*) (*ppCtx);
@@ -568,7 +568,7 @@
       WelsEventDestroy (&pSmt->pFinUpdateMbListEvent[iIdx]);
 #endif//DYNAMIC_SLICE_ASSIGN && TRY_SLICING_BALANCE
 #else
-    str_t ename[SEM_NAME_MAX] = {0};
+    char ename[SEM_NAME_MAX] = {0};
     // length of semaphore name should be system constrained at least on mac 10.7
     WelsSnprintf (ename, SEM_NAME_MAX, "sc%d%p", iIdx, (void*) (*ppCtx));
     WelsEventClose (pSmt->pSliceCodedEvent[iIdx], ename);
@@ -1219,7 +1219,7 @@
       if (dwAffinityMask & dwProcessAffinity) { // check if cpu is available
         dw = SetThreadAffinityMask (pCtx->pSliceThreading->pThreadHandles[iIdx], dwAffinityMask);  //1 << iIdx
         if (dw == 0) {
-          str_t str[64] = {0};
+          char str[64] = {0};
           WelsSnprintf (str, 64, "SetThreadAffinityMask iIdx:%d", iIdx);
         }
       }
--- a/codec/encoder/core/src/utils.cpp
+++ b/codec/encoder/core/src/utils.cpp
@@ -57,8 +57,8 @@
 
 namespace WelsSVCEnc {
 
-void WelsLogDefault (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv);
-void WelsLogNil (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv);
+void WelsLogDefault (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv);
+void WelsLogNil (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv);
 
 float WelsCalcPsnr (const void* kpTarPic,
                     const int32_t kiTarStride,
@@ -86,7 +86,7 @@
  * \param	kiLevel		log iLevel
  * \return  tag of log iLevel
  */
-static inline str_t* GetLogTag (const int32_t kiLevel, int32_t* pBit) {
+static inline char* GetLogTag (const int32_t kiLevel, int32_t* pBit) {
   int32_t iShift	= 0;
   int32_t iVal		= 0;
   bool	bFound	= false;
@@ -107,7 +107,7 @@
 
   if (bFound) {
     *pBit	= iShift;
-    return (str_t*)g_sWelsLogTags[iShift];
+    return (char*)g_sWelsLogTags[iShift];
   }
   return NULL;
 }
@@ -126,7 +126,7 @@
  * \note	N/A
  *************************************************************************************
  */
-void WelsLogDefault (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv) {
+void WelsLogDefault (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv) {
   sWelsEncCtx* pEncCtx	= (sWelsEncCtx*)pCtx;
   iWelsLogLevel		 iVal	= (kiLevel & g_iLevelLog);
 
@@ -133,7 +133,7 @@
   if (0 == iVal || NULL == pEncCtx) {	// such iLevel not enabled
     return;
   } else {
-    str_t pBuf[WELS_LOG_BUF_SIZE + 1] = {0};
+    char pBuf[WELS_LOG_BUF_SIZE + 1] = {0};
     const int32_t kiBufSize = sizeof (pBuf) / sizeof (pBuf[0]) - 1;
     int32_t iCurUsed = 0;
     int32_t iBufUsed = 0;
@@ -205,7 +205,7 @@
     // fixed stack corruption issue on vs2008
     if (iBufLeft > 0) {
       int32_t i_shift = 0;
-      str_t* pStr = NULL;
+      char* pStr = NULL;
       pStr	= GetLogTag (kiLevel, &i_shift);
       if (NULL != pStr) {
         iCurUsed = WelsSnprintf (&pBuf[iBufUsed], iBufLeft, "%s ", pStr);
@@ -242,7 +242,7 @@
 #endif//ENABLE_TRACE_FILE
   }
 }
-void WelsLogNil (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv) {
+void WelsLogNil (void* pCtx, const int32_t kiLevel, const char* kpFmtStr, va_list argv) {
   // NULL implementation
 }
 
@@ -258,7 +258,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void WelsReopenTraceFile (void* pCtx, str_t* pCurPath) {
+void WelsReopenTraceFile (void* pCtx, char* pCurPath) {
 #ifdef ENABLE_TRACE_FILE
   sWelsEncCtx* pEncCtx	= (sWelsEncCtx*)pCtx;
   if (wlog == WelsLogDefault) {
@@ -330,11 +330,11 @@
   wlog	= _log;
 }
 
-void WelsLogCall (void* pCtx, int32_t iLevel, const str_t* kpFmt, va_list vl) {
+void WelsLogCall (void* pCtx, int32_t iLevel, const char* kpFmt, va_list vl) {
   wlog (pCtx, iLevel, kpFmt, vl);
 }
 
-void WelsLog (void* pCtx, int32_t iLevel, const str_t* kpFmt, ...) {
+void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...) {
   va_list vl;
   va_start (vl, kpFmt);
   WelsLogCall (pCtx, iLevel, kpFmt, vl);
--- a/codec/encoder/core/src/wels_preprocess.cpp
+++ b/codec/encoder/core/src/wels_preprocess.cpp
@@ -86,14 +86,14 @@
 
 #ifndef NO_DYNAMIC_VP
 #if defined(_WIN32)
-  const str_t WelsVPLib[] = "welsvp.dll";
+  const char WelsVPLib[] = "welsvp.dll";
   HMODULE shModule = LoadLibrary (WelsVPLib);
   if (!shModule)
     WelsLog (pEncCtx, WELS_LOG_ERROR, "welsvp load lib dynamic failed module=%x\n", shModule);
 
 #elif defined(MACOS)
-  const str_t WelsVPLib[] = "welsvp.bundle";
-  str_t pCurPath[256];
+  const char WelsVPLib[] = "welsvp.bundle";
+  char pCurPath[256];
   GetCurrentModulePath (pCurPath, 256);
   strlcat (pCurPath, WelsVPLib, 256);
   CFBundleRef shModule = LoadBundle (pCurPath);
@@ -101,7 +101,7 @@
     WelsLog (pEncCtx, WELS_LOG_ERROR, "welsvp load lib dynamic failed module=%x\n", shModule);
 
 #elif defined(__GNUC__)
-  const str_t WelsVPLib[] = "./libwelsvp.so";
+  const char WelsVPLib[] = "./libwelsvp.so";
   void* shModule = NULL;
   shModule = dlopen (WelsVPLib, RTLD_LAZY);
   if (shModule == NULL)
@@ -132,7 +132,7 @@
 #endif
 }
 
-void* CWelsLib::QueryFunction (const str_t* pName) {
+void* CWelsLib::QueryFunction (const char* pName) {
   void* pFunc = NULL;
 
 #ifndef NO_DYNAMIC_VP
--- a/codec/encoder/plus/inc/welsCodecTrace.h
+++ b/codec/encoder/plus/inc/welsCodecTrace.h
@@ -36,7 +36,7 @@
 #include <stdarg.h>
 #include "typedefs.h"
 
-typedef int32_t (*CM_WELS_TRACE) (const str_t* format, ...);
+typedef int32_t (*CM_WELS_TRACE) (const char* format, ...);
 
 class welsCodecTrace {
  public:
@@ -43,8 +43,8 @@
   welsCodecTrace();
   ~welsCodecTrace();
 
-  static void TraceString (int32_t iLevel, const str_t* kpStrFormat);
-  static void CODEC_TRACE (void* pIgnore, const int32_t kiLevel, const str_t* kpStrFormat, va_list vl);
+  static void TraceString (int32_t iLevel, const char* kpStrFormat);
+  static void CODEC_TRACE (void* pIgnore, const int32_t kiLevel, const char* kpStrFormat, va_list vl);
 
   void SetTraceLevel (const int32_t kiLevel);
   int32_t WelsTraceModuleIsExist();
--- a/codec/encoder/plus/src/welsCodecTrace.cpp
+++ b/codec/encoder/plus/src/welsCodecTrace.cpp
@@ -86,7 +86,7 @@
   return m_WelsTraceExistFlag;
 }
 
-void welsCodecTrace::TraceString (int32_t iLevel, const str_t* str) {
+void welsCodecTrace::TraceString (int32_t iLevel, const char* str) {
   switch (iLevel) {
   case WELS_LOG_ERROR:
     if (m_fpErrorTrace)
@@ -113,13 +113,13 @@
 
 #define MAX_LOG_SIZE	1024
 
-void welsCodecTrace::CODEC_TRACE (void* ignore, const int32_t iLevel, const str_t* Str_Format, va_list vl) {
+void welsCodecTrace::CODEC_TRACE (void* ignore, const int32_t iLevel, const char* Str_Format, va_list vl) {
 //		if(g_traceLevel < iLevel)
   if (m_iTraceLevel < iLevel) {
     return;
   }
 
-  str_t pBuf[MAX_LOG_SIZE] = {0};
+  char pBuf[MAX_LOG_SIZE] = {0};
   const int32_t len	= strlen ("[ENCODER]: ");	// confirmed_safe_unsafe_usage
 
 
--- a/codec/encoder/plus/src/welsEncoderExt.cpp
+++ b/codec/encoder/plus/src/welsEncoderExt.cpp
@@ -74,12 +74,12 @@
 #endif//REC_FRAME_COUNT
 
 #ifdef OUTPUT_BIT_STREAM
-  str_t strStreamFileName[1024] = { 0 };  //for .264
+  char strStreamFileName[1024] = { 0 };  //for .264
   int32_t iBufferUsed = 0;
   int32_t iBufferLeft = 1023;
   int32_t iCurUsed;
 
-  str_t strLenFileName[1024] = { 0 }; //for .len
+  char strLenFileName[1024] = { 0 }; //for .len
   int32_t iBufferUsedSize = 0;
   int32_t iBufferLeftSize = 1023;
   int32_t iCurUsedSize;
@@ -578,7 +578,7 @@
         WelsFclose (m_pFileBsSize);
         m_pFileBsSize = NULL;
       }
-      str_t strStreamFileName[128] = {0};
+      char strStreamFileName[128] = {0};
       int32_t iLen = WelsSnprintf (strStreamFileName, 128, "adj%d_w%d.264", m_iSwitchTimes,
                                    m_pEncContext->pSvcParam->iActualPicWidth);
       m_pFileBs = WelsFopen (strStreamFileName, "wb");
@@ -910,7 +910,7 @@
   break;
   case ENCODER_OPTION_CURRENT_PATH: {
     if (m_pEncContext->pSvcParam != NULL) {
-      str_t* path = static_cast<str_t*> (pOption);
+      char* path = static_cast<char*> (pOption);
       m_pEncContext->pSvcParam->pCurPath = path;
     }
   }
@@ -991,7 +991,7 @@
 void CWelsH264SVCEncoder::DumpSrcPicture (const uint8_t* pSrc) {
 #ifdef DUMP_SRC_PICTURE
   FILE* pFile = NULL;
-  str_t strFileName[256] = {0};
+  char strFileName[256] = {0};
   const int32_t iDataLength = m_iMaxPicWidth * m_iMaxPicHeight;
 
   WelsStrncpy (strFileName, 256, "pic_in_");	// confirmed_safe_unsafe_usage
--- a/codec/processing/src/common/memory.cpp
+++ b/codec/processing/src/common/memory.cpp
@@ -35,7 +35,7 @@
 WELSVP_NAMESPACE_BEGIN
 /////////////////////////////////////////////////////////////////////////////////
 
-void* WelsMalloc (const uint32_t kuiSize, str_t* pTag) {
+void* WelsMalloc (const uint32_t kuiSize, char* pTag) {
   const int32_t kiSizeVoidPointer	= sizeof (void**);
   const int32_t kiSizeInt32		= sizeof (int32_t);
   const int32_t kiAlignedBytes	= ALIGNBYTES - 1;
@@ -59,7 +59,7 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
-void WelsFree (void* pPointer, str_t* pTag) {
+void WelsFree (void* pPointer, char* pTag) {
   if (pPointer) {
     ::free (* (((void**) pPointer) - 1));
   }
@@ -67,7 +67,7 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
-void* InternalReallocate (void* pPointer, const uint32_t kuiSize, str_t* pTag) {
+void* InternalReallocate (void* pPointer, const uint32_t kuiSize, char* pTag) {
   uint32_t iOldSize = 0;
   uint8_t* pNew = NULL;
   if (pPointer != NULL)
@@ -91,7 +91,7 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
-void* WelsRealloc (void* pPointer, uint32_t* pRealSize, const uint32_t kuiSize, str_t* pTag) {
+void* WelsRealloc (void* pPointer, uint32_t* pRealSize, const uint32_t kuiSize, char* pTag) {
   const uint32_t kuiOldSize = *pRealSize;
   uint32_t kuiNewSize = 0;
   void* pLocalPointer = NULL;
--- a/codec/processing/src/common/memory.h
+++ b/codec/processing/src/common/memory.h
@@ -70,7 +70,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void* WelsMalloc (const uint32_t kuiSize, str_t* pTag = NULL);
+void* WelsMalloc (const uint32_t kuiSize, char* pTag = NULL);
 
 /*!
 *************************************************************************************
@@ -84,7 +84,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void WelsFree (void* pPointer, str_t* pTag = NULL);
+void WelsFree (void* pPointer, char* pTag = NULL);
 
 /*!
 *************************************************************************************
@@ -100,7 +100,7 @@
 * \note	N/A
 *************************************************************************************
 */
-void* WelsRealloc (void*  pPointer, uint32_t* pRealSize, const uint32_t kuiSize, str_t* pTag = NULL);
+void* WelsRealloc (void*  pPointer, uint32_t* pRealSize, const uint32_t kuiSize, char* pTag = NULL);
 
 //////////////////////////////////////////////////////////////////////////////////////
 WELSVP_NAMESPACE_END
--- a/codec/processing/src/common/typedef.h
+++ b/codec/processing/src/common/typedef.h
@@ -73,8 +73,6 @@
 
 #endif
 
-typedef char    str_t    ; // [comment]: specific use plain char only for character parameters
-
 enum {
   FALSE = 0,
   TRUE  = !FALSE