/*! * \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	decoder.c * * \brief	Interfaces implementation introduced in decoder system architecture * * \date	03/10/2009 Created * ************************************************************************************* */#include "codec_def.h"#include "decoder.h"#include "cpu.h"#include "au_parser.h"#include "get_intra_predictor.h"#include "rec_mb.h"#include "mc.h"#include "decode_mb_aux.h"#include "manage_dec_ref.h"#include "decoder_core.h"#include "deblocking.h"#include "expand_pic.h"#include "decode_slice.h"#include "error_concealment.h"#include "memory_align.h" namespace WelsDec { extern PPicture AllocPicture (PWelsDecoderContext pCtx, const int32_t kiPicWidth, const int32_t kiPicHeight); extern void FreePicture (PPicture pPic); static int32_t CreatePicBuff (PWelsDecoderContext pCtx, PPicBuff* ppPicBuf, const int32_t kiSize,                              const int32_t kiPicWidth, const int32_t kiPicHeight) {  PPicBuff pPicBuf = NULL;  int32_t iPicIdx = 0;  if (kiSize <= 0 || kiPicWidth <= 0 || kiPicHeight <= 0) {    return 1;  }   pPicBuf	= (PPicBuff)WelsMallocz (sizeof (SPicBuff), "PPicBuff");   if (NULL == pPicBuf) {    return 1;  }   pPicBuf->ppPic = (PPicture*)WelsMallocz (kiSize * sizeof (PPicture), "PPicture*");   if (NULL == pPicBuf->ppPic) {    pPicBuf->iCapacity = 0;    DestroyPicBuff (&pPicBuf);    return 1;  }   for (iPicIdx = 0; iPicIdx < kiSize; ++ iPicIdx) {    PPicture pPic = AllocPicture (pCtx, kiPicWidth, kiPicHeight);    if (NULL == pPic) {      // init capacity first for free memory      pPicBuf->iCapacity = iPicIdx;      DestroyPicBuff (&pPicBuf);      return 1;    }    pPicBuf->ppPic[iPicIdx] = pPic;  } // initialize context in queue  pPicBuf->iCapacity	 = kiSize;  pPicBuf->iCurrentIdx = 0;  * ppPicBuf			 = pPicBuf;   return 0;} static int32_t IncreasePicBuff (PWelsDecoderContext pCtx, PPicBuff* ppPicBuf, const int32_t kiOldSize,                                const int32_t kiPicWidth, const int32_t kiPicHeight, const int32_t kiNewSize) {  PPicBuff pPicOldBuf = *ppPicBuf;  PPicBuff pPicNewBuf = NULL;  int32_t iPicIdx = 0;  if (kiOldSize <= 0 || kiNewSize <= 0 || kiPicWidth <= 0 || kiPicHeight <= 0) {    return 1;  }   pPicNewBuf	= (PPicBuff)WelsMallocz (sizeof (SPicBuff), "PPicBuff");   if (NULL == pPicNewBuf) {    return 1;  }   pPicNewBuf->ppPic = (PPicture*)WelsMallocz (kiNewSize * sizeof (PPicture), "PPicture*");   if (NULL == pPicNewBuf->ppPic) {    pPicNewBuf->iCapacity = 0;    DestroyPicBuff (&pPicNewBuf);    return 1;  }   // increase new PicBuf  for (iPicIdx = kiOldSize; iPicIdx < kiNewSize; ++ iPicIdx) {    PPicture pPic = AllocPicture (pCtx, kiPicWidth, kiPicHeight);    if (NULL == pPic) {      // Set maximum capacity as the new malloc memory at the tail      pPicNewBuf->iCapacity = iPicIdx;      DestroyPicBuff (&pPicNewBuf);      return 1;    }    pPicNewBuf->ppPic[iPicIdx] = pPic;  }   // copy old PicBuf to new PicBuf  memcpy (pPicNewBuf->ppPic, pPicOldBuf->ppPic, kiOldSize * sizeof (PPicture)); // initialize context in queue  pPicNewBuf->iCapacity	 = kiNewSize;  pPicNewBuf->iCurrentIdx = pPicOldBuf->iCurrentIdx;  * ppPicBuf			 = pPicNewBuf;   for (int32_t i = 0; i < pPicNewBuf->iCapacity; i++) {    pPicNewBuf->ppPic[i]->bUsedAsRef = false;    pPicNewBuf->ppPic[i]->bIsLongRef = false;    pPicNewBuf->ppPic[i]->uiRefCount = 0;    pPicNewBuf->ppPic[i]->bAvailableFlag = true;    pPicNewBuf->ppPic[i]->bIsComplete = false;  }// remove old PicBuf  if (pPicOldBuf->ppPic != NULL) {    WelsFree (pPicOldBuf->ppPic, "pPicOldBuf->queue");    pPicOldBuf->ppPic	= NULL;  }  pPicOldBuf->iCapacity	= 0;  pPicOldBuf->iCurrentIdx = 0;  WelsFree (pPicOldBuf, "pPicOldBuf");  pPicOldBuf = NULL;  return 0;} static int32_t DecreasePicBuff (PWelsDecoderContext pCtx, PPicBuff* ppPicBuf, const int32_t kiOldSize,                                const int32_t kiPicWidth, const int32_t kiPicHeight, const int32_t kiNewSize) {  PPicBuff pPicOldBuf = *ppPicBuf;  PPicBuff pPicNewBuf = NULL;  int32_t iPicIdx = 0;  if (kiOldSize <= 0 || kiNewSize <= 0 || kiPicWidth <= 0 || kiPicHeight <= 0) {    return 1;  }   pPicNewBuf	= (PPicBuff)WelsMallocz (sizeof (SPicBuff), "PPicBuff");   if (NULL == pPicNewBuf) {    return 1;  }   pPicNewBuf->ppPic = (PPicture*)WelsMallocz (kiNewSize * sizeof (PPicture), "PPicture*");   if (NULL == pPicNewBuf->ppPic) {    pPicNewBuf->iCapacity	 = 0;    DestroyPicBuff (&pPicNewBuf);    return 1;  }   int32_t iPrevPicIdx = -1;  for (iPrevPicIdx = 0; iPrevPicIdx < kiOldSize; ++iPrevPicIdx) {    if (pCtx->pPreviousDecodedPictureInDpb == pPicOldBuf->ppPic[iPrevPicIdx]) {      break;    }  }  int32_t iDelIdx;  if (iPrevPicIdx < kiOldSize && iPrevPicIdx >= kiNewSize) {    // found pPreviousDecodedPictureInDpb,    pPicNewBuf->ppPic[0] = pPicOldBuf->ppPic[iPrevPicIdx];    pPicNewBuf->iCurrentIdx = 0;    memcpy (pPicNewBuf->ppPic + 1, pPicOldBuf->ppPic, (kiNewSize - 1) * sizeof (PPicture));    iDelIdx = kiNewSize - 1;  } else {    memcpy (pPicNewBuf->ppPic, pPicOldBuf->ppPic, kiNewSize * sizeof (PPicture));    pPicNewBuf->iCurrentIdx = iPrevPicIdx < kiNewSize ? iPrevPicIdx : 0;    iDelIdx = kiNewSize;  }   for (iPicIdx = iDelIdx; iPicIdx < kiOldSize; iPicIdx++) {    if (iPrevPicIdx != iPicIdx) {      if (pPicOldBuf->ppPic[iPicIdx] != NULL) {        FreePicture (pPicOldBuf->ppPic[iPicIdx]);        pPicOldBuf->ppPic[iPicIdx] = NULL;      }    }  }   // initialize context in queue  pPicNewBuf->iCapacity	 = kiNewSize;  *ppPicBuf			 = pPicNewBuf;   for (int32_t i = 0; i < pPicNewBuf->iCapacity; i++) {    pPicNewBuf->ppPic[i]->bUsedAsRef = false;    pPicNewBuf->ppPic[i]->bIsLongRef = false;    pPicNewBuf->ppPic[i]->uiRefCount = 0;    pPicNewBuf->ppPic[i]->bAvailableFlag = true;    pPicNewBuf->ppPic[i]->bIsComplete = false;  }  // remove old PicBuf  if (pPicOldBuf->ppPic != NULL) {    WelsFree (pPicOldBuf->ppPic, "pPicOldBuf->queue");    pPicOldBuf->ppPic	= NULL;  }  pPicOldBuf->iCapacity	= 0;  pPicOldBuf->iCurrentIdx = 0;  WelsFree (pPicOldBuf, "pPicOldBuf");  pPicOldBuf = NULL;   return 0;} void DestroyPicBuff (PPicBuff* ppPicBuf) {  PPicBuff pPicBuf = NULL;   if (NULL == ppPicBuf || NULL == *ppPicBuf)    return;   pPicBuf = *ppPicBuf;  while (pPicBuf->ppPic != NULL) {    int32_t iPicIdx = 0;    while (iPicIdx < pPicBuf->iCapacity) {      PPicture pPic = pPicBuf->ppPic[iPicIdx];      if (pPic != NULL) {        FreePicture (pPic);      }      pPic = NULL;      ++ iPicIdx;    }     WelsFree (pPicBuf->ppPic, "pPicBuf->queue");     pPicBuf->ppPic	= NULL;  }  pPicBuf->iCapacity	= 0;  pPicBuf->iCurrentIdx = 0;   WelsFree (pPicBuf, "pPicBuf");   pPicBuf = NULL;  *ppPicBuf = NULL;}/* * fill data fields in default for decoder context */void WelsDecoderDefaults (PWelsDecoderContext pCtx, SLogContext* pLogCtx) {  int32_t iCpuCores               = 1;  memset (pCtx, 0, sizeof (SWelsDecoderContext));	// fill zero first  pCtx->sLogCtx = *pLogCtx;   pCtx->pArgDec                   = NULL;   pCtx->eOutputColorFormat		= videoFormatI420;	// yuv in default  pCtx->bHaveGotMemory			= false;	// not ever request memory blocks for decoder context related  pCtx->uiCpuFlag					= 0;   pCtx->bAuReadyFlag				= 0; // au data is not ready  pCtx->bCabacInited = false;   pCtx->uiCpuFlag = WelsCPUFeatureDetect (&iCpuCores);   pCtx->iImgWidthInPixel		= 0;  pCtx->iImgHeightInPixel		= 0;		// alloc picture data when picture size is available  pCtx->iLastImgWidthInPixel		= 0;  pCtx->iLastImgHeightInPixel		= 0;  pCtx->bFreezeOutput = true;   pCtx->iFrameNum				= -1;  pCtx->iPrevFrameNum			= -1;  pCtx->iErrorCode			= ERR_NONE;   pCtx->pDec					= NULL;   WelsResetRefPic (pCtx);   pCtx->iActiveFmoNum			= 0;   pCtx->pPicBuff[LIST_0]		= NULL;  pCtx->pPicBuff[LIST_1]		= NULL;   pCtx->bAvcBasedFlag			= true;  pCtx->eErrorConMethod = ERROR_CON_SLICE_MV_COPY_CROSS_IDR_FREEZE_RES_CHANGE;  pCtx->pPreviousDecodedPictureInDpb = NULL;  pCtx->sDecoderStatistics.iAvgLumaQp = -1;  pCtx->bSpsLatePps = false;  pCtx->bUseScalingList = false;  pCtx->iSpsErrorIgnored = 0;  pCtx->iSubSpsErrorIgnored = 0;  pCtx->iPpsErrorIgnored = 0;  pCtx->iPPSInvalidNum = 0;  pCtx->iPPSLastInvalidId = -1;  pCtx->iSPSInvalidNum = 0;  pCtx->iSPSLastInvalidId = -1;  pCtx->iSubSPSInvalidNum = 0;  pCtx->iSubSPSLastInvalidId = -1;} /* *	destory_mb_blocks */  /* *	get size of reference picture list in target layer incoming, = (iNumRefFrames */static inline int32_t GetTargetRefListSize (PWelsDecoderContext pCtx) {  int32_t iNumRefFrames	= 0;  // +2 for EC MV Copy buffer exchange  if ((pCtx == NULL) || (pCtx->pSps == NULL)) {    iNumRefFrames = MAX_REF_PIC_COUNT + 2;  } else {    iNumRefFrames = pCtx->pSps->iNumRefFrames + 2;  } #ifdef LONG_TERM_REF  //pic_queue size minimum set 2  if (iNumRefFrames < 2) {    iNumRefFrames = 2;  }#endif   return iNumRefFrames;} /* *	request memory blocks for decoder avc part */int32_t WelsRequestMem (PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight) {  const int32_t kiPicWidth	= kiMbWidth << 4;  const int32_t kiPicHeight	= kiMbHeight << 4;  int32_t iErr = ERR_NONE;   int32_t iListIdx			= 0;	//, mb_blocks	= 0;  int32_t	iPicQueueSize		= 0;	// adaptive size of picture queue, = (pSps->iNumRefFrames x 2)  bool  bNeedChangePicQueue	= true;   WELS_VERIFY_RETURN_IF (ERR_INFO_INVALID_PARAM, (NULL == pCtx || kiPicWidth <= 0 || kiPicHeight <= 0))   // Fixed the issue about different gop size over last, 5/17/2010  // get picture queue size currently  iPicQueueSize	= GetTargetRefListSize (pCtx);	// adaptive size of picture queue, = (pSps->iNumRefFrames x 2)  pCtx->iPicQueueNumber = iPicQueueSize;  if (pCtx->pPicBuff[LIST_0] != NULL      && pCtx->pPicBuff[LIST_0]->iCapacity ==      iPicQueueSize)	// comparing current picture queue size requested and previous allocation picture queue    bNeedChangePicQueue	= false;  // HD based pic buffer need consider memory size consumed when switch from 720p to other lower size  WELS_VERIFY_RETURN_IF (ERR_NONE, pCtx->bHaveGotMemory && (kiPicWidth == pCtx->iImgWidthInPixel                         && kiPicHeight == pCtx->iImgHeightInPixel) && (!bNeedChangePicQueue))	// have same scaled buffer   // sync update pRefList  WelsResetRefPic (pCtx);	// added to sync update ref list due to pictures are free   if (pCtx->bHaveGotMemory && (kiPicWidth == pCtx->iImgWidthInPixel && kiPicHeight == pCtx->iImgHeightInPixel)      && pCtx->pPicBuff[LIST_0] != NULL && pCtx->pPicBuff[LIST_0]->iCapacity != iPicQueueSize) {    // currently only active for LIST_0 due to have no B frames    WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,             "WelsRequestMem(): memory re-alloc for no resolution change (size = %d * %d), ref list size change from %d to %d",             kiPicWidth, kiPicHeight, pCtx->pPicBuff[LIST_0]->iCapacity, iPicQueueSize);    if (pCtx->pPicBuff[LIST_0]->iCapacity < iPicQueueSize) {      iErr = IncreasePicBuff (pCtx, &pCtx->pPicBuff[LIST_0], pCtx->pPicBuff[LIST_0]->iCapacity, kiPicWidth, kiPicHeight,                              iPicQueueSize);    } else {      iErr = DecreasePicBuff (pCtx, &pCtx->pPicBuff[LIST_0], pCtx->pPicBuff[LIST_0]->iCapacity, kiPicWidth, kiPicHeight,                              iPicQueueSize);    }  } else {    if (pCtx->bHaveGotMemory)      WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,               "WelsRequestMem(): memory re-alloc for resolution change, size change from %d * %d to %d * %d, ref list size change from %d to %d",               pCtx->iImgWidthInPixel, pCtx->iImgHeightInPixel, kiPicWidth, kiPicHeight, pCtx->pPicBuff[LIST_0]->iCapacity,               iPicQueueSize);    else      WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "WelsRequestMem(): memory alloc size = %d * %d, ref list size = %d",               kiPicWidth, kiPicHeight, iPicQueueSize);    // for Recycled_Pic_Queue    for (iListIdx = LIST_0; iListIdx < LIST_A; ++ iListIdx) {      PPicBuff* ppPic = &pCtx->pPicBuff[iListIdx];      if (NULL != ppPic && NULL != *ppPic) {        DestroyPicBuff (ppPic);      }    }     pCtx->pPreviousDecodedPictureInDpb = NULL;     // currently only active for LIST_0 due to have no B frames    iErr = CreatePicBuff (pCtx, &pCtx->pPicBuff[LIST_0], iPicQueueSize, kiPicWidth, kiPicHeight);  }   if (iErr != ERR_NONE)    return iErr;    pCtx->iImgWidthInPixel	= kiPicWidth;	// target width of image to be reconstruted while decoding  pCtx->iImgHeightInPixel	= kiPicHeight;	// target height of image to be reconstruted while decoding   pCtx->bHaveGotMemory	= true;			// global memory for decoder context related is requested  pCtx->pDec		        = NULL;			// need prefetch a new pic due to spatial size changed   if (pCtx->pCabacDecEngine == NULL)    pCtx->pCabacDecEngine = (SWelsCabacDecEngine*) WelsMallocz (sizeof (SWelsCabacDecEngine), "pCtx->pCabacDecEngine");  WELS_VERIFY_RETURN_IF (ERR_INFO_OUT_OF_MEMORY, (NULL == pCtx->pCabacDecEngine))  return ERR_NONE;} /* *	free memory blocks in avc */void WelsFreeMem (PWelsDecoderContext pCtx) {  int32_t iListIdx = 0;   /* TODO: free memory blocks introduced in avc */  ResetFmoList (pCtx);   WelsResetRefPic (pCtx);   // for sPicBuff  for (iListIdx = LIST_0; iListIdx < LIST_A; ++ iListIdx) {    PPicBuff* pPicBuff = &pCtx->pPicBuff[iListIdx];    if (NULL != pPicBuff && NULL != *pPicBuff) {      DestroyPicBuff (pPicBuff);    }  }   // added for safe memory  pCtx->iImgWidthInPixel	= 0;  pCtx->iImgHeightInPixel = 0;  pCtx->iLastImgWidthInPixel	= 0;  pCtx->iLastImgHeightInPixel = 0;  pCtx->bFreezeOutput = true;  pCtx->bHaveGotMemory	= false;  WelsFree (pCtx->pCabacDecEngine, "pCtx->pCabacDecEngine");} /*! * \brief	Open decoder */int32_t WelsOpenDecoder (PWelsDecoderContext pCtx) {  // function pointers  //initial MC function pointer--  int iRet = ERR_NONE;  InitMcFunc (& (pCtx->sMcFunc), pCtx->uiCpuFlag);   InitExpandPictureFunc (& (pCtx->sExpandPicFunc), pCtx->uiCpuFlag);  AssignFuncPointerForRec (pCtx);   // vlc tables  InitVlcTable (&pCtx->sVlcTable);   // startup memory  iRet = WelsInitMemory (pCtx);  if (ERR_NONE != iRet)    return iRet; #ifdef LONG_TERM_REF  pCtx->bParamSetsLostFlag = true;#else  pCtx->bReferenceLostAtT0Flag	= true;	// should be true to waiting IDR at incoming AU bits following, 6/4/2010#endif //LONG_TERM_REF  pCtx->bNewSeqBegin = true;  pCtx->bPrintFrameErrorTraceFlag = true;  pCtx->iIgnoredErrorInfoPacketCount = 0;  return iRet;} /*! * \brief	Close decoder */void WelsCloseDecoder (PWelsDecoderContext pCtx) {  WelsFreeMem (pCtx);   WelsFreeMemory (pCtx); 

Lines 1–500 of 1022. Load more