ref: bc3c63c4319949a9da0257d4a195de43987a5db5
dir: /codec/decoder/core/src/fmo.cpp/
/*!
* \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 fmo.c
*
* \brief Flexible Macroblock Ordering implementation
*
* \date 2/4/2009 Created
*
*************************************************************************************
*/
#include <string.h>
#include "fmo.h"
#include "macros.h"
#include "utils.h"
#include "mem_align.h"
namespace WelsDec {
/*!
* \brief Generate MB allocated map for interleaved slice group (TYPE 0)
*
* \param pFmo fmo context
* \param pPps pps context
*
* \return 0 - successful; none 0 - failed
*/
static inline int32_t FmoGenerateMbAllocMapType0( PFmo pFmo, PPps pPps )
{
uint32_t uiNumSliceGroups = 0;
int32_t iMbNum = 0;
int32_t i = 0;
WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == pPps ) )
uiNumSliceGroups = pPps->uiNumSliceGroups;
iMbNum = pFmo->iCountMbNum;
WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo->pMbAllocMap || iMbNum <= 0 || uiNumSliceGroups >= MAX_SLICEGROUP_IDS ) )
do
{
uint8_t uiGroup = 0;
do {
const int32_t kiRunIdx = pPps->uiRunLength[uiGroup];
int32_t j = 0;
do {
pFmo->pMbAllocMap[i+j] = uiGroup;
++ j;
} while(j < kiRunIdx && i + j < iMbNum);
i += kiRunIdx;
++ uiGroup;
} while(uiGroup < uiNumSliceGroups && i < iMbNum);
}while(i < iMbNum);
return 0; // well here
}
/*!
* \brief Generate MB allocated map for dispersed slice group (TYPE 1)
*
* \param pFmo fmo context
* \param pPps pps context
* \param iMbWidth MB width
*
* \return 0 - successful; none 0 - failed
*/
static inline int32_t FmoGenerateMbAllocMapType1( PFmo pFmo, PPps pPps, const int32_t kiMbWidth )
{
uint32_t uiNumSliceGroups = 0;
int32_t iMbNum = 0;
int16_t i = 0;
WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == pPps ) )
uiNumSliceGroups = pPps->uiNumSliceGroups;
iMbNum = pFmo->iCountMbNum;
WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo->pMbAllocMap || iMbNum <= 0 || kiMbWidth == 0 || uiNumSliceGroups >= MAX_SLICEGROUP_IDS ) )
do
{
pFmo->pMbAllocMap[i] = (uint8_t)(((i % kiMbWidth)+(((i / kiMbWidth)*uiNumSliceGroups)>>1)) % uiNumSliceGroups);
++ i;
}while (i < iMbNum);
return 0; // well here
}
/*!
* \brief Generate MB allocated map for various type of slice group cases (TYPE 0, .., 6)
*
* \param pFmo fmo context
* \param pPps pps context
* \param kiMbWidth MB width
* \param kiMbHeight MB height
*
* \return 0 - successful; none 0 - failed
*/
static inline int32_t FmoGenerateSliceGroup( PFmo pFmo, const PPps kpPps, const int32_t kiMbWidth, const int32_t kiMbHeight )
{
int32_t iNumMb = 0;
int32_t iErr = 0;
bool_t bResolutionChanged = false;
// the cases we would not like
WELS_VERIFY_RETURN_IF( 1, ( NULL == pFmo || NULL == kpPps ) )
iNumMb = pFmo->iCountMbNum;
iNumMb = kiMbWidth * kiMbHeight;
if ( 0 == iNumMb )
return 1;
WelsFree(pFmo->pMbAllocMap, "_fmo->pMbAllocMap");
pFmo->pMbAllocMap = (uint8_t *)WelsMalloc( iNumMb * sizeof(uint8_t), "_fmo->pMbAllocMap" );
WELS_VERIFY_RETURN_IF( 1, (NULL == pFmo->pMbAllocMap) ) // out of memory
pFmo->iCountMbNum = iNumMb;
if ( kpPps->uiNumSliceGroups < 2 && iNumMb > 0) // only one slice group, exactly it is single slice based
{
memset ( pFmo->pMbAllocMap, 0, iNumMb * sizeof(int8_t)); // for safe
pFmo->iSliceGroupCount = 1;
return 0;
}
if ( bResolutionChanged || ((int32_t)kpPps->uiSliceGroupMapType != pFmo->iSliceGroupType)
|| ((int32_t)kpPps->uiNumSliceGroups != pFmo->iSliceGroupCount) )
{
switch ( kpPps->uiSliceGroupMapType )
{
case 0:
iErr = FmoGenerateMbAllocMapType0( pFmo, kpPps );
break;
case 1:
iErr = FmoGenerateMbAllocMapType1( pFmo, kpPps, kiMbWidth );
break;
case 2:
case 3:
case 4:
case 5:
case 6:
// Reserve for others slice group type
iErr = 1;
break;
default:
return 1;
}
}
if ( 0 == iErr ) // well now
{
pFmo->iSliceGroupCount = kpPps->uiNumSliceGroups;
pFmo->iSliceGroupType = kpPps->uiSliceGroupMapType;
}
return iErr;
}
/*!
* \brief Initialize Wels Flexible Macroblock Ordering (FMO)
*
* \param pFmo Wels fmo to be initialized
* \param pPps pps argument
* \param kiMbWidth mb width
* \param kiMbHeight mb height
*
* \return 0 - successful; none 0 - failed;
*/
int32_t InitFmo( PFmo pFmo, PPps pPps, const int32_t kiMbWidth, const int32_t kiMbHeight )
{
return FmoGenerateSliceGroup( pFmo, pPps, kiMbWidth, kiMbHeight );
}
/*!
* \brief Uninitialize Wels Flexible Macroblock Ordering (FMO) list
*
* \param pFmo Wels base fmo ptr to be uninitialized
* \param kiCnt count number of PPS per list
* \param kiAvail count available number of PPS in list
*
* \return NONE
*/
void_t UninitFmoList( PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail )
{
PFmo pIter = pFmo;
int32_t i = 0;
int32_t iFreeNodes = 0;
if ( NULL == pIter || kiAvail <= 0 || kiCnt < kiAvail )
return;
while ( i < kiCnt ) {
if ( pIter != NULL && pIter->bActiveFlag )
{
if ( NULL != pIter->pMbAllocMap )
{
WelsFree( pIter->pMbAllocMap, "pIter->pMbAllocMap" );
pIter->pMbAllocMap = NULL;
}
pIter->iSliceGroupCount = 0;
pIter->iSliceGroupType = -1;
pIter->iCountMbNum = 0;
pIter->bActiveFlag = false;
++ iFreeNodes;
if ( iFreeNodes >= kiAvail )
break;
}
++ pIter;
++ i;
}
}
/*!
* \brief detect parameter sets are changed or not
*
* \param pFmo fmo context
* \param kiCountNumMb (iMbWidth * iMbHeight) in Sps
* \param iSliceGroupType slice group type if fmo is exactly enabled
* \param iSliceGroupCount slice group count if fmo is exactly enabled
*
* \return true - changed or not initialized yet; false - not change at all
*/
bool_t FmoParamSetsChanged( PFmo pFmo, const int32_t kiCountNumMb, const int32_t kiSliceGroupType, const int32_t kiSliceGroupCount )
{
WELS_VERIFY_RETURN_IF( false, (NULL == pFmo) )
return ( (!pFmo->bActiveFlag)
|| (kiCountNumMb != pFmo->iCountMbNum)
|| (kiSliceGroupType != pFmo->iSliceGroupType)
|| (kiSliceGroupCount != pFmo->iSliceGroupCount) );
}
/*!
* \brief update/insert FMO parameter unit
*
* \param _fmo FMO context
* \param _sps PSps
* \param _pps PPps
* \param pActiveFmoNum int32_t* [in/out]
*
* \return true - update/insert successfully; false - failed;
*/
bool_t FmoParamUpdate( PFmo pFmo, PSps pSps, PPps pPps, int32_t *pActiveFmoNum )
{
const uint32_t kuiMbWidth = pSps->iMbWidth;
const uint32_t kuiMbHeight= pSps->iMbHeight;
if ( FmoParamSetsChanged( pFmo,
kuiMbWidth * kuiMbHeight,
pPps->uiSliceGroupMapType,
pPps->uiNumSliceGroups ) )
{
if ( InitFmo( pFmo, pPps, kuiMbWidth, kuiMbHeight ) )
{
return false;
}
else
{
if ( !pFmo->bActiveFlag && *pActiveFmoNum < MAX_PPS_COUNT )
{
++ (*pActiveFmoNum);
pFmo->bActiveFlag = true;
}
}
}
return true;
}
/*!
* \brief Convert kMbXy to slice group idc correspondingly
*
* \param pFmo Wels fmo context
* \param kMbXy kMbXy to be converted
*
* \return slice group idc - successful; -1 - failed;
*/
int32_t FmoMbToSliceGroup( PFmo pFmo, const MB_XY_T kiMbXy )
{
const int32_t kiMbNum = pFmo->iCountMbNum;
const uint8_t* kpMbMap = pFmo->pMbAllocMap;
if ( kiMbXy < 0 || kiMbXy >= kiMbNum || kpMbMap == NULL)
return -1;
return kpMbMap[ kiMbXy ];
}
/*!
* \brief Get successive mb to be processed with given current kMbXy
*
* \param pFmo Wels fmo context
* \param kMbXy current kMbXy
*
* \return iNextMb - successful; -1 - failed;
*/
MB_XY_T FmoNextMb( PFmo pFmo, const MB_XY_T kiMbXy )
{
const int32_t kiTotalMb = pFmo->iCountMbNum;
const uint8_t* kpMbMap = pFmo->pMbAllocMap;
MB_XY_T iNextMb = kiMbXy;
const uint8_t kuiSliceGroupIdc = (uint8_t)FmoMbToSliceGroup( pFmo, kiMbXy );
if (kuiSliceGroupIdc == (uint8_t)(-1))
return -1;
do {
++ iNextMb;
if (iNextMb >= kiTotalMb){
iNextMb = -1;
break;
}
if (kpMbMap[iNextMb] == kuiSliceGroupIdc){
break;
}
} while( 1 );
// -1: No further MB in this slice (could be end of picture)
return iNextMb;
}
} // namespace WelsDec