/*! * \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 * ************************************************************************************* */ #if defined(MT_ENABLED) #include <assert.h>#ifdef __GNUC__#include <semaphore.h>#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#endif//__GNUC__#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" #if defined(X86_ASM)#include "cpu.h"#endif//X86_ASM #if defined(DYNAMIC_SLICE_ASSIGN) || defined(MT_DEBUG)#include "measure_time.h"#endif//DYNAMIC_SLICE_ASSIGNnamespace 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_T     bLeft;    BOOL_T     bTop;    BOOL_T     bLeftTop;    BOOL_T     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; #if defined(X86_ASM)  WelsEmms();#endif //X86_ASM   while (iSliceIdx < kiSliceCount) {    fAvI[iSliceIdx]	= 1.0f * pCountMbInSlice[iSliceIdx] / pSliceTime[iSliceIdx];#if defined(ENABLE_TRACE_MT)    WelsLog (NULL, WELS_LOG_DEBUG, "[MT] CalcSliceComplexRatio(), pSliceConsumeTime[%d]= %d us, slice_run= %d\n", iSliceIdx,             pSliceTime[iSliceIdx], pCountMbInSlice[iSliceIdx]);#endif//ENABLE_TRACE_MT    fSumAv += fAvI[iSliceIdx];     ++ iSliceIdx;  }  while (-- iSliceIdx >= 0) {    pRatioList[iSliceIdx] = fAvI[iSliceIdx] / fSumAv;  }} #if defined(MT_ENABLED) && defined(DYNAMIC_SLICE_ASSIGN) && defined(NOT_ABSOLUTE_BALANCING)int32_t NeedDynamicAdjust (void* pConsumeTime, const int32_t iSliceNum) {#if !defined(USE_RMSE_SLICE_COMPLEXITY_RATIO_FOR_BALANCING)  const float fRatioLower	= TOLERANT_BALANCING_RATIO_LOWER (uiSliceNum);  const float fRatioUpper	= TOLERANT_BALANCING_RATIO_UPPER (uiSliceNum);#endif//USE_RMSE_SLICE_COMPLEXITY_RATIO_FOR_BALANCING  uint32_t* pSliceConsume	= (uint32_t*)pConsumeTime;  uint32_t uiTotalConsume	= 0;  int32_t iSliceIdx		= 0;  int32_t iNeedAdj		= false; #if defined(X86_ASM)  WelsEmms();#endif //X86_ASM   while (iSliceIdx < iSliceNum) {    uiTotalConsume += pSliceConsume[iSliceIdx] + pSliceConsume[1 + iSliceIdx];    iSliceIdx += 2;  }  if (uiTotalConsume == 0) {#if defined(ENABLE_TRACE_MT)    WelsLog (NULL, WELS_LOG_DEBUG, "[MT] NeedDynamicAdjust(), herein do no adjust due first picture, iCountSliceNum= %d\n",             iSliceNum);#endif//ENABLE_TRACE_MT    return false;  }   iSliceIdx = 0;#if defined(USE_RMSE_SLICE_COMPLEXITY_RATIO_FOR_BALANCING)  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;#if defined(ENABLE_TRACE_MT)  WelsLog (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);#endif//ENABLE_TRACE_MT#else  do {    const float kfRatio = 1.0f * pSliceConsume[uiSliceIdx] / uiTotalConsume;    if (kfRatio + EPSN < fRatioLower || kfRatio > ratio_upper + EPSN) {#if defined(ENABLE_TRACE_MT)      WelsLog (NULL, WELS_LOG_DEBUG,               "[MT] NeedDynamicAdjust(), herein adjustment decision is made by pSlice consume time not balanced at all, uiSliceIdx= %d, comp_ratio= %.6f, pSliceConsumeTime= %d, total_consume_time= %d, iCountSliceNum= %d\n",               uiSliceIdx, kfRatio, pSliceConsume[uiSliceIdx], uiTotalConsume, uiSliceNum);#endif//ENABLE_TRACE_MT      iNeedAdj = true;      break;    }    ++ uiSliceIdx;  } while (uiSliceIdx + 1 < uiSliceNum);#endif//USE_RMSE_SLICE_COMPLEXITY_RATIO_FOR_BALANCING   return iNeedAdj;}#endif//.. #if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)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;  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; #if defined(X86_ASM)  WelsEmms();#endif //X86_ASM #if defined(ENABLE_TRACE_MT)  WelsLog (pCtx, WELS_LOG_DEBUG, "[MT] DynamicAdjustSlicing(), iDid= %d, iCountNumMb= %d\n", iCurDid, kiCountNumMb);#endif//ENABLE_TRACE_MT   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;#if defined(ENABLE_TRACE_MT)    WelsLog (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);#endif//ENABLE_TRACE_MT    ++ iSliceIdx;    iMaximalMbNum	= iMbNumLeft - (kiCountSliceNum - iSliceIdx - 1) * iMinimalMbNum;	// get maximal num_mb in left parts  }  iRunLen[iSliceIdx] = iMbNumLeft;#if defined(ENABLE_TRACE_MT)  WelsLog (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);#endif//ENABLE_TRACE_MT    if (DynamicAdjustSlicePEncCtxAll (pSliceCtx, iRunLen) == 0) {    const int32_t kiThreadNum	= pCtx->pSvcParam->iCountThreadsNum;    int32_t iThreadIdx			= 0;    do {#ifdef _WIN32      WelsEventSignal (&pCtx->pSliceThreading->pUpdateMbListEvent[iThreadIdx]);#else      WelsEventSignal (pCtx->pSliceThreading->pUpdateMbListEvent[iThreadIdx]);#endif//_WIN32      ++ iThreadIdx;    } while (iThreadIdx < kiThreadNum);     WelsMultipleEventsWaitAllBlocking (kiThreadNum, &pCtx->pSliceThreading->pFinUpdateMbListEvent[0]);  }}#endif//#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE) #ifdef PACKING_ONE_SLICE_PER_LAYERvoid ResetEnvMt (sWelsEncCtx* pCtx) {  const int16_t kiSliceCount = pCtx->iMaxSliceCount;  int32_t iIdx = 0;   while (iIdx < kiSliceCount) {    SWelsSliceBs* pSliceBs	= &pCtx->pSliceBs[iIdx];    pSliceBs->uiBsPos		= 0;    ++ iIdx;  }}#endif//PACKING_ONE_SLICE_PER_LAYER 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;   if (NULL == ppCtx || NULL == pCodingParam || NULL == *ppCtx || iCountBsLen <= 0)    return 1;   pMa	= (*ppCtx)->pMemAlign;  pPara = pCodingParam;  iNumSpatialLayers	= pPara->iNumDependencyLayer;  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))  pSmt->pThreadHandles	= (WELS_THREAD_HANDLE*)pMa->WelsMalloc (sizeof (WELS_THREAD_HANDLE) * iThreadNum,                          "pThreadHandles");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pThreadHandles), FreeMemorySvc (ppCtx)) #ifdef _WIN32  pSmt->pSliceCodedEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum, "pSliceCodedEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pSliceCodedEvent), FreeMemorySvc (ppCtx))  pSmt->pReadySliceCodingEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum,                                  "pReadySliceCodingEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pReadySliceCodingEvent), FreeMemorySvc (ppCtx))  pSmt->pFinSliceCodingEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum, "pFinSliceCodingEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pFinSliceCodingEvent), FreeMemorySvc (ppCtx))#endif//_WIN32 #if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)#if defined(__GNUC__)  pSmt->pUpdateMbListThrdHandles	= (WELS_THREAD_HANDLE*)pMa->WelsMalloc (sizeof (WELS_THREAD_HANDLE) * iThreadNum,                                    "pUpdateMbListThrdHandles");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pUpdateMbListThrdHandles), FreeMemorySvc (ppCtx))#endif//__GNUC__#ifdef _WIN32  pSmt->pUpdateMbListEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum, "pUpdateMbListEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pUpdateMbListEvent), FreeMemorySvc (ppCtx))  pSmt->pFinUpdateMbListEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum, "pFinUpdateMbListEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pFinUpdateMbListEvent), FreeMemorySvc (ppCtx))#endif//_WIN32#endif//#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE) #ifdef _WIN32  pSmt->pExitEncodeEvent	= (WELS_EVENT*)pMa->WelsMalloc (sizeof (WELS_EVENT) * iThreadNum, "pExitEncodeEvent");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pExitEncodeEvent), FreeMemorySvc (ppCtx))#endif//_WIN32 #if defined(DYNAMIC_SLICE_ASSIGN) || defined(MT_DEBUG)  iIdx = 0;  while (iIdx < iNumSpatialLayers) {    SMulSliceOption* pMso	= &pPara->sDependencyLayers[iIdx].sMso;    const int32_t kiSliceNum = pMso->sSliceArgument.iSliceNum;    if (pMso->uiSliceMode == SM_FIXEDSLCNUM_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))#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)      pSmt->pSliceComplexRatio[iIdx]	= (float*)pMa->WelsMalloc (kiSliceNum * sizeof (float), "pSliceComplexRatio[]");      WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pSliceComplexRatio[iIdx]), FreeMemorySvc (ppCtx))#endif//TRY_SLICING_BALANCE    } else {      pSmt->pSliceConsumeTime[iIdx]	= NULL;#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)      pSmt->pSliceComplexRatio[iIdx]	= NULL;#endif//TRY_SLICING_BALANCE    }    ++ iIdx;  }  // NULL for pSliceConsumeTime[iIdx]: iIdx from iNumSpatialLayers to MAX_DEPENDENCY_LAYERS#endif//#if defined(DYNAMIC_SLICE_ASSIGN) || defined(MT_DEBUG) #ifdef MT_DEBUG  // file handle for MT debug  pSmt->pFSliceDiff = NULL;   if (pSmt->pFSliceDiff) {    fclose (pSmt->pFSliceDiff);    pSmt->pFSliceDiff = NULL;  }#ifdef _WIN32  pSmt->pFSliceDiff	= fopen (".\\slice_time.txt", "wt+");#else  pSmt->pFSliceDiff	= fopen ("/tmp/slice_time.txt", "wt+");#endif//_WIN32#endif//MT_DEBUG #if defined(ENABLE_TRACE_MT)  WelsLog ((*ppCtx), WELS_LOG_INFO, "encpEncCtx= 0x%p\n", (void*) (*ppCtx));#endif//ENABLE_TRACE_MT   iIdx = 0;  while (iIdx < iThreadNum) {#ifdef __GNUC__	// for posix threading    str_t name[SEM_NAME_MAX] = {0};    int32_t used_len = 0;    WELS_THREAD_ERROR_CODE err = 0;#endif//__GNUC__    pSmt->pThreadPEncCtx[iIdx].pWelsPEncCtx	= (void*) (*ppCtx);    pSmt->pThreadPEncCtx[iIdx].iSliceIndex	= iIdx;    pSmt->pThreadPEncCtx[iIdx].iThreadIndex	= iIdx;    pSmt->pThreadHandles[iIdx]				= 0; #if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)#ifdef _WIN32    WelsEventInit (&pSmt->pUpdateMbListEvent[iIdx]);    WelsEventInit (&pSmt->pFinUpdateMbListEvent[iIdx]);#else    // length of semaphore name should be system constrained at least on mac 10.7    SNPRINTF (name, SEM_NAME_MAX, "ud%d%p", iIdx, (void*) (*ppCtx));    err = WelsEventOpen (&pSmt->pUpdateMbListEvent[iIdx], name);#if defined(ENABLE_TRACE_MT)    WelsLog ((*ppCtx), WELS_LOG_INFO, "[MT] Open pUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);#endif    used_len = SNPRINTF (name, SEM_NAME_MAX, "fu%d%p", iIdx, (void*) (*ppCtx));    name[used_len] = '\0';    err = WelsEventOpen (&pSmt->pFinUpdateMbListEvent[iIdx], name);#if defined(ENABLE_TRACE_MT)    WelsLog ((*ppCtx), WELS_LOG_INFO, "[MT] Open pFinUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);#endif#endif//_WIN32#endif//#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE) #ifdef _WIN32    WelsEventInit (&pSmt->pSliceCodedEvent[iIdx]);    WelsEventInit (&pSmt->pReadySliceCodingEvent[iIdx]);    WelsEventInit (&pSmt->pFinSliceCodingEvent[iIdx]);    WelsEventInit (&pSmt->pExitEncodeEvent[iIdx]);#else    used_len = SNPRINTF (name, SEM_NAME_MAX, "sc%d%p", iIdx, (void*) (*ppCtx));    name[used_len] = '\0';    err = WelsEventOpen (&pSmt->pSliceCodedEvent[iIdx], name);#if defined(ENABLE_TRACE_MT)    WelsLog ((*ppCtx), WELS_LOG_INFO, "[MT] Open pSliceCodedEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno);#endif    used_len = SNPRINTF (name, SEM_NAME_MAX, "rc%d%p", iIdx, (void*) (*ppCtx));    name[used_len] = '\0';    err = WelsEventOpen (&pSmt->pReadySliceCodingEvent[iIdx], name);#if defined(ENABLE_TRACE_MT)    WelsLog ((*ppCtx), WELS_LOG_INFO, "[MT] Open pReadySliceCodingEvent%d = 0x%p named(%s) ret%d err%d\n", iIdx,             (void*)pSmt->pReadySliceCodingEvent[iIdx]), (void*) (*ppCtx), err, errno);#endif#endif//_WIN32     ++ iIdx;  } #ifdef PACKING_ONE_SLICE_PER_LAYER  pSmt->pCountBsSizeInPartition	= (uint32_t*)pMa->WelsMalloc (sizeof (uint32_t) * iThreadNum, "pCountBsSizeInPartition");  WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pSmt->pCountBsSizeInPartition), FreeMemorySvc (ppCtx))

Lines 1–500 of 1506. Load more