ref: d52c64a2a56ce6de6055d8908b0b9d8f4c3018cc
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 "fmo.h" #include "memory_align.h" #include "error_code.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 (ERR_INFO_INVALID_PARAM, (NULL == pFmo || NULL == pPps)) uiNumSliceGroups = pPps->uiNumSliceGroups; iMbNum = pFmo->iCountMbNum; WELS_VERIFY_RETURN_IF (ERR_INFO_INVALID_PARAM, (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 ERR_NONE; // 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; int32_t i = 0; WELS_VERIFY_RETURN_IF (ERR_INFO_INVALID_PARAM, (NULL == pFmo || NULL == pPps)) uiNumSliceGroups = pPps->uiNumSliceGroups; iMbNum = pFmo->iCountMbNum; WELS_VERIFY_RETURN_IF (ERR_INFO_INVALID_PARAM, (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 ERR_NONE; // 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, CMemoryAlign* pMa) { int32_t iNumMb = 0; int32_t iErr = 0; bool bResolutionChanged = false; // the cases we would not like WELS_VERIFY_RETURN_IF (ERR_INFO_INVALID_PARAM, (NULL == pFmo || NULL == kpPps)) iNumMb = pFmo->iCountMbNum; iNumMb = kiMbWidth * kiMbHeight; if (0 == iNumMb) return ERR_INFO_INVALID_PARAM; pMa->WelsFree (pFmo->pMbAllocMap, "_fmo->pMbAllocMap"); pFmo->pMbAllocMap = (uint8_t*)pMa->WelsMallocz (iNumMb * sizeof (uint8_t), "_fmo->pMbAllocMap"); WELS_VERIFY_RETURN_IF (ERR_INFO_OUT_OF_MEMORY, (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 ERR_NONE; } 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 ERR_INFO_UNSUPPORTED_FMOTYPE; } } 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, CMemoryAlign* pMa) { return FmoGenerateSliceGroup (pFmo, pPps, kiMbWidth, kiMbHeight, pMa); } /*! * \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 UninitFmoList (PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail, CMemoryAlign* pMa) { 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) { pMa->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 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 FmoParamUpdate (PFmo pFmo, PSps pSps, PPps pPps, int32_t* pActiveFmoNum, CMemoryAlign* pMa) { 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, pMa)) { 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