230 lines
9.4 KiB
C++
230 lines
9.4 KiB
C++
/*!
|
|
* \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 encoder_context.h
|
|
*
|
|
* \brief Main pData to be operated over Wels encoder all modules
|
|
*
|
|
* \date 2/4/2009 Created
|
|
*
|
|
*************************************************************************************
|
|
*/
|
|
#ifndef WELS_ENCODER_CONTEXT_H__
|
|
#define WELS_ENCODER_CONTEXT_H__
|
|
|
|
#include <stdio.h>
|
|
#include "typedefs.h"
|
|
#include "param_svc.h"
|
|
#include "nal_encap.h"
|
|
#include "picture.h"
|
|
#include "dq_map.h"
|
|
#include "stat.h"
|
|
#include "macros.h"
|
|
#include "rc.h"
|
|
#include "as264_common.h"
|
|
#include "wels_preprocess.h"
|
|
#include "wels_func_ptr_def.h"
|
|
#include "crt_util_safe_x.h"
|
|
#include "utils.h"
|
|
|
|
#include "mt_defs.h" // for multiple threadin,
|
|
#include "WelsThreadLib.h"
|
|
|
|
namespace WelsSVCEnc {
|
|
|
|
/*
|
|
* reference list for each quality layer in SVC
|
|
*/
|
|
typedef struct TagRefList {
|
|
SPicture* pShortRefList[1 + MAX_SHORT_REF_COUNT]; // reference list 0 - int16_t
|
|
SPicture* pLongRefList[1 + MAX_REF_PIC_COUNT]; // reference list 1 - int32_t
|
|
SPicture* pNextBuffer;
|
|
SPicture* pRef[1 + MAX_REF_PIC_COUNT]; // plus 1 for swap intend
|
|
uint8_t uiShortRefCount;
|
|
uint8_t uiLongRefCount; // dependend on pRef pic module
|
|
} SRefList;
|
|
|
|
typedef struct TagLTRState {
|
|
// LTR mark feedback
|
|
uint32_t uiLtrMarkState; // LTR mark state, indicate whether there is a LTR mark feedback unsolved
|
|
int32_t iLtrMarkFbFrameNum;// the unsolved LTR mark feedback, the marked iFrameNum feedback from decoder
|
|
|
|
// LTR used as recovery reference
|
|
int32_t iLastRecoverFrameNum; // reserve the last LTR or IDR recover iFrameNum
|
|
int32_t
|
|
iLastCorFrameNumDec; // reserved the last correct position in decoder side, use to select valid LTR to recover or to decide the LTR mark validation
|
|
int32_t
|
|
iCurFrameNumInDec; // current iFrameNum in decoder side, use to select valid LTR to recover or to decide the LTR mark validation
|
|
|
|
// LTR mark
|
|
int32_t iLTRMarkMode; // direct mark or delay mark
|
|
int32_t iLTRMarkSuccessNum; //successful marked num, for mark mode switch
|
|
int32_t iCurLtrIdx;// current int32_t term reference index to mark
|
|
int32_t iLastLtrIdx[MAX_TEMPORAL_LAYER_NUM];
|
|
int32_t iSceneLtrIdx;// related to Scene LTR, used by screen content
|
|
|
|
uint32_t uiLtrMarkInterval;// the interval from the last int32_t term pRef mark
|
|
|
|
bool bLTRMarkingFlag; //decide whether current frame marked as LTR
|
|
bool bLTRMarkEnable; //when LTR is confirmed and the interval is no smaller than the marking period
|
|
bool bReceivedT0LostFlag; // indicate whether a t0 lost feedback is recieved, for LTR recovery
|
|
} SLTRState;
|
|
|
|
typedef struct TagSpatialPicIndex {
|
|
SPicture* pSrc; // I420 based and after color space converted
|
|
int32_t iDid; // dependency id
|
|
} SSpatialPicIndex;
|
|
|
|
typedef struct TagStrideTables {
|
|
int32_t* pStrideDecBlockOffset[MAX_DEPENDENCY_LAYER][2]; // [iDid][tid==0][24 x 4]: luma+chroma= 24 x 4
|
|
int32_t* pStrideEncBlockOffset[MAX_DEPENDENCY_LAYER]; // [iDid][24 x 4]: luma+chroma= 24 x 4
|
|
int16_t* pMbIndexX[MAX_DEPENDENCY_LAYER]; // [iDid][iMbX]: map for iMbX in each spatial layer coding
|
|
int16_t* pMbIndexY[MAX_DEPENDENCY_LAYER]; // [iDid][iMbY]: map for iMbY in each spatial layer coding
|
|
} SStrideTables;
|
|
|
|
typedef struct TagWelsEncCtx {
|
|
SLogContext sLogCtx;
|
|
// Input
|
|
SWelsSvcCodingParam* pSvcParam; // SVC parameter, WelsSVCParamConfig in svc_param_settings.h
|
|
SWelsSliceBs* pSliceBs; // bitstream buffering for various slices, [uiSliceIdx]
|
|
|
|
int32_t* pSadCostMb;
|
|
/* MVD cost tables for Inter MB */
|
|
int32_t iMvRange;
|
|
uint16_t* pMvdCostTable; //[52]; // adaptive to spatial layers
|
|
int32_t iMvdCostTableSize; //the size of above table
|
|
int32_t iMvdCostTableStride; //the stride of above table
|
|
SMVUnitXY*
|
|
pMvUnitBlock4x4; // (*pMvUnitBlock4x4[2])[MB_BLOCK4x4_NUM]; // for store each 4x4 blocks' mv unit, the two swap after different d layer
|
|
int8_t*
|
|
pRefIndexBlock4x4; // (*pRefIndexBlock4x4[2])[MB_BLOCK8x8_NUM]; // for store each 4x4 blocks' pRef index, the two swap after different d layer
|
|
int8_t* pNonZeroCountBlocks; // (*pNonZeroCountBlocks)[MB_LUMA_CHROMA_BLOCK4x4_NUM];
|
|
int8_t*
|
|
pIntra4x4PredModeBlocks; // (*pIntra4x4PredModeBlocks)[INTRA_4x4_MODE_NUM]; //last byte is not used; the first 4 byte is for the bottom 12,13,14,15 4x4 block intra mode, and 3 byte for (3,7,11)
|
|
|
|
SMB** ppMbListD; // [MAX_DEPENDENCY_LAYER];
|
|
SStrideTables* pStrideTab; // stride tables for internal coding used
|
|
SWelsFuncPtrList* pFuncList;
|
|
|
|
SSliceThreading* pSliceThreading;
|
|
|
|
// SSlice context
|
|
SSliceCtx* pSliceCtxList;// slice context table for each dependency quality layer
|
|
// pointers
|
|
SPicture* pEncPic; // pointer to current picture to be encoded
|
|
SPicture* pDecPic; // pointer to current picture being reconstructed
|
|
SPicture* pRefPic; // pointer to current reference picture
|
|
|
|
SDqLayer*
|
|
pCurDqLayer; // DQ layer context used to being encoded currently, for reference base layer to refer: pCurDqLayer->pRefLayer if applicable
|
|
SDqLayer** ppDqLayerList; // overall DQ layers encoded for storage
|
|
|
|
SRefList** ppRefPicListExt; // reference picture list for SVC
|
|
SPicture* pRefList0[16];
|
|
SLTRState* pLtr;//[MAX_DEPENDENCY_LAYER];
|
|
bool bCurFrameMarkedAsSceneLtr;
|
|
// Derived
|
|
int32_t iCodingIndex;
|
|
int32_t iFrameIndex; // count how many frames elapsed during coding context currently
|
|
int32_t iFrameNum; // current frame number coding
|
|
int32_t iPOC; // frame iPOC
|
|
EWelsSliceType eSliceType; // currently coding slice type
|
|
EWelsNalUnitType eNalType; // NAL type
|
|
EWelsNalRefIdc eNalPriority; // NAL_Reference_Idc currently
|
|
EWelsNalRefIdc eLastNalPriority; // NAL_Reference_Idc in last frame
|
|
uint8_t iNumRef0;
|
|
|
|
uint8_t uiDependencyId; // Idc of dependecy layer to be coded
|
|
uint8_t uiTemporalId; // Idc of temporal layer to be coded
|
|
bool bNeedPrefixNalFlag; // whether add prefix nal
|
|
bool bEncCurFrmAsIdrFlag;
|
|
|
|
// Rate control routine
|
|
SWelsSvcRc* pWelsSvcRc;
|
|
int32_t iSkipFrameFlag; //_GOM_RC_
|
|
int32_t iGlobalQp; // global qp
|
|
|
|
// VAA
|
|
SVAAFrameInfo* pVaa; // VAA information of reference
|
|
CWelsPreProcess* pVpp;
|
|
|
|
SWelsSPS* pSpsArray; // MAX_SPS_COUNT by standard compatible
|
|
SWelsSPS* pSps;
|
|
SWelsPPS* pPPSArray; // MAX_PPS_COUNT by standard compatible
|
|
SWelsPPS* pPps;
|
|
/* SVC only */
|
|
SSubsetSps* pSubsetArray; // MAX_SPS_COUNT by standard compatible
|
|
SSubsetSps* pSubsetSps;
|
|
int32_t iSpsNum; // number of pSps used
|
|
int32_t iPpsNum; // number of pPps used
|
|
|
|
// Output
|
|
SWelsEncoderOutput* pOut; // for NAL raw pData (need allocating memory for sNalList internal)
|
|
uint8_t* pFrameBs; // restoring bitstream pBuffer of all NALs in a frame
|
|
int32_t iFrameBsSize; // count size of frame bs in bytes allocated
|
|
int32_t iPosBsBuffer; // current writing position of frame bs pBuffer
|
|
|
|
SSpatialPicIndex sSpatialIndexMap[MAX_DEPENDENCY_LAYER];
|
|
|
|
bool bLongTermRefFlag[MAX_DEPENDENCY_LAYER][MAX_TEMPORAL_LEVEL + 1/*+LONG_TERM_REF_NUM*/];
|
|
|
|
int16_t iMaxSliceCount;// maximal count number of slices for all layers observation
|
|
int16_t iActiveThreadsNum; // number of threads active so far
|
|
|
|
/*
|
|
* DQ layer idc map for svc encoding, might be a better scheme than that of design before,
|
|
* can aware idc of referencing layer and that idc of successive layer to be coded
|
|
*/
|
|
/* SVC only */
|
|
SDqIdc*
|
|
pDqIdcMap; // overall DQ map of full scalability in specific frame (All full D/T/Q layers involved) // pDqIdcMap[dq_index] for each SDqIdc pData
|
|
|
|
SParaSetOffset sPSOVector;
|
|
CMemoryAlign* pMemAlign;
|
|
|
|
#if defined(STAT_OUTPUT)
|
|
// overall stat pData, refer to SStatData in stat.h, in case avc to use stat[0][0]
|
|
SStatData sStatData [ MAX_DEPENDENCY_LAYER ] [ MAX_QUALITY_LEVEL ];
|
|
SStatSliceInfo sPerInfo;
|
|
#endif//STAT_OUTPUT
|
|
|
|
int32_t iEncoderError;
|
|
WELS_MUTEX mutexEncoderError;
|
|
int32_t iDropNumber;
|
|
|
|
#ifdef ENABLE_FRAME_DUMP
|
|
bool bDependencyRecFlag[MAX_DEPENDENCY_LAYER];
|
|
bool bRecFlag;
|
|
#endif
|
|
} sWelsEncCtx/*, *PWelsEncCtx*/;
|
|
}
|
|
#endif//sWelsEncCtx_H__
|