/*! * \copy *     Copyright (c)  2009-2013, 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	utils.c * * \brief	common tool/function utilization * * \date	03/10/2009 Created * ************************************************************************************* */#if defined(_WIN32)#include <windows.h>#include <sys/types.h>#include <sys/timeb.h>#ifndef _MSC_VER#include <sys/time.h>#endif#else#include <sys/time.h>#endif #include "utils.h"#include "property.h"#include "encoder_context.h"#include "property.h"#include "crt_util_safe_x.h"	// Safe CRT routines like utils for cross platforms  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); float WelsCalcPsnr (const void* kpTarPic,                    const int32_t kiTarStride,                    const void* kpRefPic,                    const int32_t kiRefStride,                    const int32_t kiWidth,                    const int32_t kiHeight); // to fill default routines#ifdef ENABLE_TRACE_FILEPWelsLogCallbackFunc wlog	= WelsLogDefault;#elsePWelsLogCallbackFunc wlog	= WelsLogNil;#endif iWelsLogLevel		g_iLevelLog	= WELS_LOG_DEFAULT;	// default log iLevelint32_t			g_iSizeLogBuf	= 1024;			// pBuffer size for each log output /* *	Log output routines */ /*! * \brief	get log tag * \param	kiLevel		log iLevel * \return  tag of log iLevel */static inline str_t* GetLogTag (const int32_t kiLevel, int32_t* pBit) {  int32_t iShift	= 0;  int32_t iVal		= 0;  bool	bFound	= false;   if (kiLevel <= 0 || kiLevel > (1 << (WELS_LOG_LEVEL_COUNT - 1)) || NULL == pBit)    return NULL;   for (;;) {    if (iShift >= WELS_LOG_LEVEL_COUNT)      break;    iVal	= (1 << iShift);    if (iVal == kiLevel) {      bFound	= true;      break;    }    ++ iShift;  }   if (bFound) {    *pBit	= iShift;    return (str_t*)g_sWelsLogTags[iShift];  }  return NULL;} /*! ************************************************************************************* * \brief	System trace log output in Wels * * \param	pCtx	instance pointer * \param	kiLevel	log iLevel ( WELS_LOG_QUIET, ERROR, WARNING, INFO, DEBUG ) * \param	kpFmtStr	formated string to mount * \param 	argv	pData string argument * * \return	NONE * * \note	N/A ************************************************************************************* */void WelsLogDefault (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv) {  sWelsEncCtx* pEncCtx	= (sWelsEncCtx*)pCtx;  iWelsLogLevel		 iVal	= (kiLevel & g_iLevelLog);   if (0 == iVal || NULL == pEncCtx) {	// such iLevel not enabled    return;  } else {    str_t 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;    int32_t iBufLeft = kiBufSize - iBufUsed;     if (pEncCtx) {      SWelsTime tTime;       WelsGetTimeOfDay(&tTime);      iCurUsed = WelsSnprintf (&pBuf[iBufUsed], iBufLeft, "[0x%p @ ", pEncCtx);	// confirmed_safe_unsafe_usage      if (iCurUsed >= 0) {        iBufUsed += iCurUsed;        iBufLeft -= iCurUsed;      }       if (iBufLeft > 0) {        iCurUsed = GetCodeName (&pBuf[iBufUsed], iBufLeft);        if (iCurUsed > 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }        pBuf[iBufUsed] = ' ';        ++ iBufUsed;        -- iBufLeft;         iCurUsed = GetLibName (&pBuf[iBufUsed], iBufLeft);        if (iCurUsed > 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }        pBuf[iBufUsed] = ' ';        ++ iBufUsed;        -- iBufLeft;         pBuf[iBufUsed] = 'v';        ++ iBufUsed;        -- iBufLeft;        iCurUsed = GetVerNum (&pBuf[iBufUsed], iBufLeft);        if (iCurUsed > 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }        pBuf[iBufUsed] = ' ';        ++ iBufUsed;        -- iBufLeft;      }       if (iBufLeft > 0) {        iCurUsed = WelsStrftime (&pBuf[iBufUsed], iBufLeft, "%y-%m-%d %H:%M:%S", &tTime);        if (iCurUsed > 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }      } else {        return;      }       if (iBufLeft > 0) {        iCurUsed = WelsSnprintf (&pBuf[iBufUsed], iBufLeft, ".%3.3u]: ", tTime.millitm);	// confirmed_safe_unsafe_usage        if (iCurUsed >= 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }      } else {        return;      }    }     // fixed stack corruption issue on vs2008    if (iBufLeft > 0) {      int32_t i_shift = 0;      str_t* pStr = NULL;      pStr	= GetLogTag (kiLevel, &i_shift);      if (NULL != pStr) {        iCurUsed = WelsSnprintf (&pBuf[iBufUsed], iBufLeft, "%s ", pStr);        if (iCurUsed >= 0) {          iBufUsed += iCurUsed;          iBufLeft -= iCurUsed;        }      }    }    if (iBufLeft > 0) {      iCurUsed = WelsVsnprintf (&pBuf[iBufUsed], iBufLeft, kpFmtStr, argv);	// confirmed_safe_unsafe_usage      if (iCurUsed > 0) {        iBufUsed += iCurUsed;        iBufLeft -= iCurUsed;      }    }#ifdef ENABLE_TRACE_FILE    if (NULL != pEncCtx && NULL != pEncCtx->pFileLog) {      if (pEncCtx->uiSizeLog > MAX_TRACE_LOG_SIZE) {        if (0 == WelsFseek (pEncCtx->pFileLog, 0L, SEEK_SET))          pEncCtx->uiSizeLog = 0;      }      if (iBufUsed > 0 && iBufUsed < WELS_LOG_BUF_SIZE) {        iCurUsed = WelsFwrite (pBuf, 1, iBufUsed, pEncCtx->pFileLog);        WelsFflush (pEncCtx->pFileLog);        if (iCurUsed == iBufUsed)          pEncCtx->uiSizeLog += iBufUsed;      }    } else {#if defined(_WIN32) && defined(_DEBUG)      OutputDebugStringA (pBuf);#endif    }#endif//ENABLE_TRACE_FILE  }}void WelsLogNil (void* pCtx, const int32_t kiLevel, const str_t* kpFmtStr, va_list argv) {  // NULL implementation} /*!************************************************************************************** \brief	reopen log file when finish setting current path** \param	pCtx		context pCtx* \param	pCurPath	current path string** \return	NONE** \note	N/A**************************************************************************************/void WelsReopenTraceFile (void* pCtx, str_t* pCurPath) {#ifdef ENABLE_TRACE_FILE  sWelsEncCtx* pEncCtx	= (sWelsEncCtx*)pCtx;  if (wlog == WelsLogDefault) {    if (pEncCtx->pFileLog != NULL) {      WelsFclose (pEncCtx->pFileLog);      pEncCtx->pFileLog = NULL;    }    pEncCtx->uiSizeLog	= 0;    pEncCtx->pFileLog	= WelsFopen ("wels_encoder_trace.txt", "wt+");	// confirmed_safe_unsafe_usage  }#endif//ENABLE_TRACE_FILE} /*! ************************************************************************************* * \brief	set log iLevel from external call * * \param	iLevel	iLevel of log * * \return	NONE * * \note	can be able to control log iLevel dynamically ************************************************************************************* */void WelsSetLogLevel (const int32_t kiLevel) {  iWelsLogLevel iVal = 0;  if (kiLevel & WELS_LOG_ERROR) {    iVal |= WELS_LOG_ERROR;  }  if (kiLevel & WELS_LOG_WARNING) {    iVal |= WELS_LOG_WARNING;  }  if (kiLevel & WELS_LOG_INFO) {    iVal |= WELS_LOG_INFO;  }  if (kiLevel & WELS_LOG_DEBUG) {    iVal |= WELS_LOG_DEBUG;  }  g_iLevelLog	= iVal;} /*! ************************************************************************************* * \brief	get log iLevel from external call * * \param	N/A * * \return	current iLevel of log used in codec internal * * \note	can be able to get log iLevel of internal codec applicable ************************************************************************************* */int32_t WelsGetLogLevel (void) {  return g_iLevelLog;} /*! ************************************************************************************* * \brief	set log callback from external call * * \param	_log	log function routine * * \return	NONE * * \note	N/A ************************************************************************************* */void WelsSetLogCallback (PWelsLogCallbackFunc _log) {  wlog	= _log;} void WelsLogCall (void* pCtx, int32_t iLevel, const str_t* kpFmt, va_list vl) {  wlog (pCtx, iLevel, kpFmt, vl);} void WelsLog (void* pCtx, int32_t iLevel, const str_t* kpFmt, ...) {  va_list vl;  va_start (vl, kpFmt);  WelsLogCall (pCtx, iLevel, kpFmt, vl);  va_end (vl);} #ifndef CALC_PSNR#define CONST_FACTOR_PSNR	(10.0 / log(10.0))	// for good computation#define CALC_PSNR(w, h, s)	((float)(CONST_FACTOR_PSNR * log( 65025.0 * w * h / iSqe )))#endif//CALC_PSNR /* *	PSNR calculation routines *//*! ************************************************************************************* * \brief	PSNR calculation utilization in Wels * * \param	pTarPic		target picture to be calculated in Picture pData format * \param	iTarStride	stride of target picture pData pBuffer * \param 	pRefPic		base referencing picture samples * \param	iRefStride	stride of reference picture pData pBuffer * \param	iWidth		picture iWidth in pixel * \param	iHeight		picture iHeight in pixel * * \return	actual PSNR result; * * \note	N/A ************************************************************************************* */float WelsCalcPsnr (const void* kpTarPic,                    const int32_t kiTarStride,                    const void* kpRefPic,                    const int32_t kiRefStride,                    const int32_t kiWidth,                    const int32_t kiHeight) {  int64_t	iSqe = 0;  int32_t x, y;  uint8_t* pTar = (uint8_t*)kpTarPic;  uint8_t* pRef = (uint8_t*)kpRefPic;   if (NULL == pTar || NULL == pRef)    return (-1.0f);   for (y = 0; y < kiHeight; ++ y) {	// OPTable !!    for (x = 0; x < kiWidth; ++ x) {      const int32_t kiT = pTar[y * kiTarStride + x] - pRef[y * kiRefStride + x];      iSqe	+= kiT * kiT;    }  }  if (0 == iSqe) {    return (99.99f);  }  return CALC_PSNR (kiWidth, kiHeight, iSqe);}  }