/*! * \copy *     Copyright (c)  2010-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	slice_multi_threading.h * * \brief	pSlice based multiple threading * * \date	04/16/2010 Created * ************************************************************************************* */  #include <assert.h>#if !defined(_WIN32)#include <semaphore.h>#include <unistd.h>#endif//!_WIN32#ifndef SEM_NAME_MAX// length of semaphore name should be system constrained at least on mac 10.7#define  SEM_NAME_MAX 32#endif//SEM_NAME_MAX#include "slice_multi_threading.h"#include "mt_defs.h"#include "nal_encap.h"#include "utils.h"#include "encoder.h"#include "svc_encode_slice.h"#include "deblocking.h"#include "svc_enc_golomb.h"#include "crt_util_safe_x.h"	// for safe crt like calls#include "rc.h" #include "cpu.h" #include "measure_time.h" #if defined(ENABLE_TRACE_MT)#define MT_TRACE_LOG(x, ...) WelsLog(x, __VA_ARGS__)#else#define MT_TRACE_LOG(x, ...)#endif namespace WelsSVCEnc {void UpdateMbListNeighborParallel (SSliceCtx* pSliceCtx,                                   SMB* pMbList,                                   const int32_t uiSliceIdc) {  const uint8_t* kpMbMap			= pSliceCtx->pOverallMbMap;  const int32_t kiMbWidth			= pSliceCtx->iMbWidth;  int32_t iIdx						= pSliceCtx->pFirstMbInSlice[uiSliceIdc];  const int32_t kiEndMbInSlice	= iIdx + pSliceCtx->pCountMbNumInSlice[uiSliceIdc] - 1;   do {    SMB* pMb							= &pMbList[iIdx];    uint32_t uiNeighborAvailFlag	= 0;    const int32_t kiMbXY				= pMb->iMbXY;    const int32_t kiMbX				= pMb->iMbX;    const int32_t kiMbY				= pMb->iMbY;    bool     bLeft;    bool     bTop;    bool     bLeftTop;    bool     bRightTop;    int32_t   iLeftXY, iTopXY, iLeftTopXY, iRightTopXY;     iLeftXY = kiMbXY - 1;    iTopXY = kiMbXY - kiMbWidth;    iLeftTopXY = iTopXY - 1;    iRightTopXY = iTopXY + 1;     bLeft = (kiMbX > 0) && (uiSliceIdc == kpMbMap[iLeftXY]);    bTop = (kiMbY > 0) && (uiSliceIdc == kpMbMap[iTopXY]);    bLeftTop = (kiMbX > 0) && (kiMbY > 0) && (uiSliceIdc == kpMbMap[iLeftTopXY]);    bRightTop = (kiMbX < (kiMbWidth - 1)) && (kiMbY > 0) && (uiSliceIdc == kpMbMap[iRightTopXY]);     if (bLeft) {      uiNeighborAvailFlag |= LEFT_MB_POS;    }    if (bTop) {      uiNeighborAvailFlag |= TOP_MB_POS;    }    if (bLeftTop) {      uiNeighborAvailFlag |= TOPLEFT_MB_POS;    }    if (bRightTop) {      uiNeighborAvailFlag |= TOPRIGHT_MB_POS;    }    pMb->uiNeighborAvail	= (uint8_t)uiNeighborAvailFlag;    pMb->uiSliceIdc		= uiSliceIdc;     ++ iIdx;  } while (iIdx <= kiEndMbInSlice);} void CalcSliceComplexRatio (void* pRatio, SSliceCtx* pSliceCtx, uint32_t* pSliceConsume) {  float* pRatioList			= (float*)pRatio;  float fAvI[MAX_SLICES_NUM];  float fSumAv				= .0f;  uint32_t* pSliceTime		= (uint32_t*)pSliceConsume;  int32_t* pCountMbInSlice	= (int32_t*)pSliceCtx->pCountMbNumInSlice;  const int32_t kiSliceCount	= pSliceCtx->iSliceNumInFrame;  int32_t iSliceIdx			= 0;   WelsEmms();   while (iSliceIdx < kiSliceCount) {    fAvI[iSliceIdx]	= 1.0f * pCountMbInSlice[iSliceIdx] / pSliceTime[iSliceIdx];    MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, "[MT] CalcSliceComplexRatio(), pSliceConsumeTime[%d]= %d us, slice_run= %d\n", iSliceIdx,               pSliceTime[iSliceIdx], pCountMbInSlice[iSliceIdx]);    fSumAv += fAvI[iSliceIdx];     ++ iSliceIdx;  }  while (-- iSliceIdx >= 0) {    pRatioList[iSliceIdx] = fAvI[iSliceIdx] / fSumAv;  }} int32_t NeedDynamicAdjust (void* pConsumeTime, const int32_t iSliceNum) {  uint32_t* pSliceConsume	= (uint32_t*)pConsumeTime;  uint32_t uiTotalConsume	= 0;  int32_t iSliceIdx		= 0;  int32_t iNeedAdj		= false;   WelsEmms();   while (iSliceIdx < iSliceNum) {    uiTotalConsume += pSliceConsume[iSliceIdx] + pSliceConsume[1 + iSliceIdx];    iSliceIdx += 2;  }  if (uiTotalConsume == 0) {    MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, "[MT] NeedDynamicAdjust(), herein do no adjust due first picture, iCountSliceNum= %d\n",               iSliceNum);    return false;  }   iSliceIdx = 0;  float fThr				= EPSN;	// threshold for various cores cases  float fRmse				= .0f;	// root mean square error of pSlice consume ratios  const float kfMeanRatio	= 1.0f / iSliceNum;  do {    const float fRatio = 1.0f * pSliceConsume[iSliceIdx] / uiTotalConsume;    const float fDiffRatio = fRatio - kfMeanRatio;    fRmse += (fDiffRatio * fDiffRatio);    ++ iSliceIdx;  } while (iSliceIdx + 1 < iSliceNum);  fRmse = sqrtf (fRmse / iSliceNum);  if (iSliceNum >= 8) {    fThr += THRESHOLD_RMSE_CORE8;  } else if (iSliceNum >= 4) {    fThr += THRESHOLD_RMSE_CORE4;  } else if (iSliceNum >= 2) {    fThr += THRESHOLD_RMSE_CORE2;  } else    fThr = 1.0f;  if (fRmse > fThr)    iNeedAdj	= true;  MT_TRACE_LOG (NULL, WELS_LOG_DEBUG,             "[MT] NeedDynamicAdjust(), herein adjustment decision is made (iNeedAdj= %d) by: fRmse of pSlice complexity ratios %.6f, the corresponding threshold %.6f, iCountSliceNum %d\n",             iNeedAdj, fRmse, fThr, iSliceNum);   return iNeedAdj;} void DynamicAdjustSlicing (sWelsEncCtx* pCtx,                           SDqLayer* pCurDqLayer,                           void* pComplexRatio,                           int32_t iCurDid) {  SSliceCtx* pSliceCtx	= pCurDqLayer->pSliceEncCtx;  const int32_t kiCountSliceNum	= pSliceCtx->iSliceNumInFrame;  const int32_t kiCountNumMb		= pSliceCtx->iMbNumInFrame;  int32_t iMinimalMbNum			= pSliceCtx->iMbWidth;	// in theory we need only 1 SMB, here let it as one SMB row required  int32_t iMaximalMbNum			= 0;	// dynamically assign later  float* pSliceComplexRatio	= (float*)pComplexRatio;  int32_t iMbNumLeft					= kiCountNumMb;  int32_t iRunLen[MAX_THREADS_NUM]	= {0};  int32_t iSliceIdx					= 0;   int32_t iNumMbInEachGom = 0;  SWelsSvcRc* pWelsSvcRc = &pCtx->pWelsSvcRc[iCurDid];  if (pCtx->pSvcParam->bEnableRc) {    iNumMbInEachGom = pWelsSvcRc->iNumberMbGom;     if (iNumMbInEachGom <= 0) {      WelsLog (pCtx, WELS_LOG_ERROR,               "[MT] DynamicAdjustSlicing(), invalid iNumMbInEachGom= %d from RC, iDid= %d, iCountNumMb= %d\n", iNumMbInEachGom,               iCurDid, kiCountNumMb);      return;    }     // do not adjust in case no extra iNumMbInEachGom based left for slicing adjustment,    // extra MB of non integrated GOM assigned at the last pSlice in default, keep up on early initial result.    if (iNumMbInEachGom * kiCountSliceNum >= kiCountNumMb) {      return;    }    iMinimalMbNum	= iNumMbInEachGom;  }   if (kiCountSliceNum < 2 || (kiCountSliceNum & 0x01))	// we need suppose uiSliceNum is even for multiple threading    return;   iMaximalMbNum	= kiCountNumMb - (kiCountSliceNum - 1) * iMinimalMbNum;   WelsEmms();   MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG, "[MT] DynamicAdjustSlicing(), iDid= %d, iCountNumMb= %d\n", iCurDid, kiCountNumMb);   iSliceIdx	= 0;  while (iSliceIdx + 1 < kiCountSliceNum) {    int32_t iNumMbAssigning = (int32_t) (kiCountNumMb * pSliceComplexRatio[iSliceIdx] + EPSN);     // GOM boundary aligned    if (pCtx->pSvcParam->bEnableRc) {      iNumMbAssigning = (int32_t) (1.0f * iNumMbAssigning / iNumMbInEachGom + 0.5f + EPSN) * iNumMbInEachGom;    }     // make sure one GOM at least in each pSlice for safe    if (iNumMbAssigning < iMinimalMbNum)      iNumMbAssigning	= iMinimalMbNum;    else if (iNumMbAssigning > iMaximalMbNum)      iNumMbAssigning	= iMaximalMbNum;     assert (iNumMbAssigning > 0);     iMbNumLeft -= iNumMbAssigning;    if (iMbNumLeft <= 0) {	// error due to we can not support slice_skip now yet, do not adjust this time      assert (0);      return;    }    iRunLen[iSliceIdx]	= iNumMbAssigning;    MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG,             "[MT] DynamicAdjustSlicing(), uiSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d\n",             iSliceIdx, pSliceComplexRatio[iSliceIdx], pSliceCtx->pCountMbNumInSlice[iSliceIdx], iNumMbAssigning);    ++ iSliceIdx;    iMaximalMbNum	= iMbNumLeft - (kiCountSliceNum - iSliceIdx - 1) * iMinimalMbNum;	// get maximal num_mb in left parts  }  iRunLen[iSliceIdx] = iMbNumLeft;  MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG,                "[MT] DynamicAdjustSlicing(), iSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d\n",                iSliceIdx, pSliceComplexRatio[iSliceIdx], pSliceCtx->pCountMbNumInSlice[iSliceIdx], iMbNumLeft);    if (DynamicAdjustSlicePEncCtxAll (pSliceCtx, iRunLen) == 0) {    const int32_t kiThreadNum	= pCtx->pSvcParam->iCountThreadsNum;    int32_t iThreadIdx			= 0;    do {      WelsEventSignal (&pCtx->pSliceThreading->pUpdateMbListEvent[iThreadIdx]);      WelsEventSignal (&pCtx->pSliceThreading->pThreadMasterEvent[iThreadIdx]);      ++ iThreadIdx;    } while (iThreadIdx < kiThreadNum);     WelsMultipleEventsWaitAllBlocking (kiThreadNum, &pCtx->pSliceThreading->pFinUpdateMbListEvent[0]);  }}  int32_t RequestMtResource (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingParam, const int32_t iCountBsLen,                           const int32_t iTargetSpatialBsSize) {  CMemoryAlign* pMa			= NULL;  SWelsSvcCodingParam* pPara = NULL;  SSliceThreading* pSmt		= NULL;  SWelsSliceBs* pSliceB		= NULL;  uint8_t* pBsBase			= NULL;  int32_t iNumSpatialLayers	= 0;  int32_t iThreadNum			= 0;  int32_t iIdx					= 0;  int32_t iSliceBsBufferSize = 0;  int16_t iMaxSliceNum		= 1;  int32_t iReturn = ENC_RETURN_SUCCESS;   if (NULL == ppCtx || NULL == pCodingParam || NULL == *ppCtx || iCountBsLen <= 0)    return 1;   pMa	= (*ppCtx)->pMemAlign;  pPara = pCodingParam;  iNumSpatialLayers	= pPara->iSpatialLayerNum;  iThreadNum	= pPara->iCountThreadsNum;  iMaxSliceNum = (*ppCtx)->iMaxSliceCount;   pSmt	= (SSliceThreading*)pMa->WelsMalloc (sizeof (SSliceThreading), "SSliceThreading");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt), FreeMemorySvc (ppCtx))  (*ppCtx)->pSliceThreading	= pSmt;  pSmt->pThreadPEncCtx	= (SSliceThreadPrivateData*)pMa->WelsMalloc (sizeof (SSliceThreadPrivateData) * iThreadNum,                          "pThreadPEncCtx");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pThreadPEncCtx), FreeMemorySvc (ppCtx)) #ifdef _WIN32  // Dummy event namespace, the windows events don't actually use this  WelsSnprintf (pSmt->eventNamespace, sizeof(pSmt->eventNamespace), "%p", (void*) *ppCtx);#else  WelsSnprintf (pSmt->eventNamespace, sizeof(pSmt->eventNamespace), "%p%x", (void*) *ppCtx, getpid());#endif//!_WIN32   iIdx = 0;  while (iIdx < iNumSpatialLayers) {    SSliceConfig* pMso	= &pPara->sDependencyLayers[iIdx].sSliceCfg;    const int32_t kiSliceNum = pMso->sSliceArgument.uiSliceNum;    if (((pMso->uiSliceMode == SM_FIXEDSLCNUM_SLICE)||(pMso->uiSliceMode == SM_AUTO_SLICE)) && pPara->iMultipleThreadIdc > 1        && pPara->iMultipleThreadIdc >= kiSliceNum) {      pSmt->pSliceConsumeTime[iIdx]	= (uint32_t*)pMa->WelsMallocz (kiSliceNum * sizeof (uint32_t), "pSliceConsumeTime[]");      WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pSliceConsumeTime[iIdx]), FreeMemorySvc (ppCtx))      pSmt->pSliceComplexRatio[iIdx]	= (float*)pMa->WelsMalloc (kiSliceNum * sizeof (float), "pSliceComplexRatio[]");      WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pSliceComplexRatio[iIdx]), FreeMemorySvc (ppCtx))    } else {      pSmt->pSliceConsumeTime[iIdx]	= NULL;      pSmt->pSliceComplexRatio[iIdx]	= NULL;    }    ++ iIdx;  }  // NULL for pSliceConsumeTime[iIdx]: iIdx from iNumSpatialLayers to MAX_DEPENDENCY_LAYERS #ifdef MT_DEBUG  // file handle for MT debug  pSmt->pFSliceDiff = NULL;   if (pSmt->pFSliceDiff) {    fclose (pSmt->pFSliceDiff);    pSmt->pFSliceDiff = NULL;  }  pSmt->pFSliceDiff	= fopen ("slice_time.txt", "wt+");#endif//MT_DEBUG   MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "encpEncCtx= 0x%p\n", (void*) *ppCtx);   char name[SEM_NAME_MAX] = {0};  WELS_GCC_UNUSED WELS_THREAD_ERROR_CODE err = 0;   iIdx = 0;  while (iIdx < iThreadNum) {    pSmt->pThreadPEncCtx[iIdx].pWelsPEncCtx	= (void*) *ppCtx;    pSmt->pThreadPEncCtx[iIdx].iSliceIndex	= iIdx;    pSmt->pThreadPEncCtx[iIdx].iThreadIndex	= iIdx;    pSmt->pThreadHandles[iIdx]				= 0;     WelsSnprintf (name, SEM_NAME_MAX, "ee%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pExitEncodeEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pExitEncodeEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);    WelsSnprintf (name, SEM_NAME_MAX, "tm%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pThreadMasterEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pThreadMasterEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);    // length of semaphore name should be system constrained at least on mac 10.7    WelsSnprintf (name, SEM_NAME_MAX, "ud%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pUpdateMbListEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);    WelsSnprintf (name, SEM_NAME_MAX, "fu%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pFinUpdateMbListEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pFinUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);    WelsSnprintf (name, SEM_NAME_MAX, "sc%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pSliceCodedEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);    WelsSnprintf (name, SEM_NAME_MAX, "rc%d%s", iIdx, pSmt->eventNamespace);    err = WelsEventOpen (&pSmt->pReadySliceCodingEvent[iIdx], name);    MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pReadySliceCodingEvent%d = 0x%p named(%s) ret%d err%d\n", iIdx,                  (void*)pSmt->pReadySliceCodingEvent[iIdx], name, err, errno);     ++ iIdx;  }   WelsSnprintf (name, SEM_NAME_MAX, "scm%s", pSmt->eventNamespace);  err = WelsEventOpen (&pSmt->pSliceCodedMasterEvent, name);  MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedMasterEvent named(%s) ret%d err%d\n", name, err, errno);   (*ppCtx)->pSliceBs	= (SWelsSliceBs*)pMa->WelsMalloc (sizeof (SWelsSliceBs) * iMaxSliceNum, "pSliceBs");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pSliceBs), FreeMemorySvc (ppCtx))   pBsBase		= (*ppCtx)->pFrameBs + iCountBsLen;  pSliceB	= (*ppCtx)->pSliceBs;  iSliceBsBufferSize	= iTargetSpatialBsSize;  iIdx = 0;  while (iIdx < iMaxSliceNum) {    pSliceB->pBsBuffer  = (uint8_t*)pMa->WelsMalloc (iSliceBsBufferSize, "pSliceB->pBsBuffer");     WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSliceB->pBsBuffer), FreeMemorySvc (ppCtx))    pSliceB->uiSize	= iSliceBsBufferSize;     if (iIdx > 0) {      pSliceB->pBs		= pBsBase;      pSliceB->uiBsPos	= 0;      pBsBase				+= iSliceBsBufferSize;    } else {      pSliceB->pBs		= NULL;      pSliceB->uiBsPos	= 0;    }    ++ pSliceB;    ++ iIdx;  }   iReturn = WelsMutexInit (&pSmt->mutexSliceNumUpdate);  WELS_VERIFY_RETURN_PROC_IF (1, (WELS_THREAD_ERROR_OK != iReturn), FreeMemorySvc (ppCtx))   iReturn = WelsMutexInit (&(*ppCtx)->mutexEncoderError);  WELS_VERIFY_RETURN_PROC_IF (1, (WELS_THREAD_ERROR_OK != iReturn), FreeMemorySvc (ppCtx))   MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "RequestMtResource(), iThreadNum=%d, iCountSliceNum= %d\n", pPara->iCountThreadsNum,                iMaxSliceNum);   return 0;} void ReleaseMtResource (sWelsEncCtx** ppCtx) {  SWelsSliceBs* pSliceB			= NULL;  SWelsSvcCodingParam* pCodingParam	= NULL;  SSliceThreading* pSmt			= NULL;  CMemoryAlign* pMa				= NULL;  int32_t iIdx						= 0;  int32_t iThreadNum				= 0;  int16_t uiSliceNum				= 0;   if (NULL == ppCtx || NULL == *ppCtx)    return;   pMa			= (*ppCtx)->pMemAlign;  pCodingParam		= (*ppCtx)->pSvcParam;  uiSliceNum	= (*ppCtx)->iMaxSliceCount;  iThreadNum	= (*ppCtx)->pSvcParam->iCountThreadsNum;  pSmt		= (*ppCtx)->pSliceThreading;   if (NULL == pSmt)    return;   char ename[SEM_NAME_MAX] = {0};  while (iIdx < iThreadNum) {    // length of semaphore name should be system constrained at least on mac 10.7    WelsSnprintf (ename, SEM_NAME_MAX, "ee%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pExitEncodeEvent[iIdx], ename);    WelsSnprintf (ename, SEM_NAME_MAX, "tm%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pThreadMasterEvent[iIdx], ename);    WelsSnprintf (ename, SEM_NAME_MAX, "sc%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pSliceCodedEvent[iIdx], ename);    WelsSnprintf (ename, SEM_NAME_MAX, "rc%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pReadySliceCodingEvent[iIdx], ename);    WelsSnprintf (ename, SEM_NAME_MAX, "ud%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pUpdateMbListEvent[iIdx], ename);    WelsSnprintf (ename, SEM_NAME_MAX, "fu%d%s", iIdx, pSmt->eventNamespace);    WelsEventClose (&pSmt->pFinUpdateMbListEvent[iIdx], ename);     ++ iIdx;  }  WelsSnprintf (ename, SEM_NAME_MAX, "scm%s", pSmt->eventNamespace);  WelsEventClose (&pSmt->pSliceCodedMasterEvent, ename);   WelsMutexDestroy (&pSmt->mutexSliceNumUpdate);  WelsMutexDestroy (&((*ppCtx)->mutexEncoderError));   if (pSmt->pThreadPEncCtx != NULL) {    pMa->WelsFree (pSmt->pThreadPEncCtx, "pThreadPEncCtx");    pSmt->pThreadPEncCtx = NULL;  }   pSliceB = (*ppCtx)->pSliceBs;  iIdx = 0;  while (pSliceB != NULL && iIdx < uiSliceNum) {    if (pSliceB->pBsBuffer) {      pMa->WelsFree (pSliceB->pBsBuffer, "pSliceB->pBsBuffer");      pSliceB->pBsBuffer = NULL;      pSliceB->uiSize = 0;    }    ++ iIdx;    ++ pSliceB;  }  if ((*ppCtx)->pSliceBs != NULL) {    pMa->WelsFree ((*ppCtx)->pSliceBs, "pSliceBs");    (*ppCtx)->pSliceBs = NULL;  }  iIdx = 0;  while (iIdx < pCodingParam->iSpatialLayerNum) {    if (pSmt->pSliceConsumeTime[iIdx]) {      pMa->WelsFree (pSmt->pSliceConsumeTime[iIdx], "pSliceConsumeTime[]");      pSmt->pSliceConsumeTime[iIdx] = NULL;    }    if (pSmt->pSliceComplexRatio[iIdx] != NULL) {      pMa->WelsFree (pSmt->pSliceComplexRatio[iIdx], "pSliceComplexRatio[]");      pSmt->pSliceComplexRatio[iIdx] = NULL;

Lines 1–500 of 1145. Load more