generic-library/openh264
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #1015 from huili2/astyle_all_UT

Browse Source 
astyle all
This commit is contained in:
ruil2 2014-06-26 10:25:56 +08:00
commit e1152f9483
85 changed files with 4734 additions and 4529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
codec/api/svc/codec_app_def.h
View File

@ -413,9 +413,9 @@ typedef struct TagLevelInfo {
ELevelIdc uiLevelIdc; //the level info ELevelIdc uiLevelIdc; //the level info
} SLevelInfo; } SLevelInfo;
typedef struct TagDeliveryStatus{ typedef struct TagDeliveryStatus {
int iDropNum; //the number of video frames that are dropped continuously before delivery to encoder, which is used by screen content. int iDropNum; //the number of video frames that are dropped continuously before delivery to encoder, which is used by screen content.
int iDropFrameType; // the frame type that is dropped int iDropFrameType; // the frame type that is dropped
int iDropFrameSize; // the frame size that is dropped int iDropFrameSize; // the frame size that is dropped
}SDeliveryStatus; } SDeliveryStatus;
#endif//WELS_VIDEO_CODEC_APPLICATION_DEFINITION_H__ #endif//WELS_VIDEO_CODEC_APPLICATION_DEFINITION_H__

2
codec/build/iOS/dec/demo/demo/DEMOAppDelegate.h
View File

@ -34,6 +34,6 @@
@interface DEMOAppDelegate : UIResponder <UIApplicationDelegate> @interface DEMOAppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window; @property (strong, nonatomic) UIWindow* window;
@end @end

17
codec/build/iOS/dec/demo/demo/DEMOViewController.h
View File

@ -32,18 +32,17 @@
#import <UIKit/UIKit.h> #import <UIKit/UIKit.h>
@interface DEMOViewController : UIViewController @interface DEMOViewController : UIViewController {
{ BOOL bEnableFlag;
BOOL bEnableFlag;
} }
@property (strong, nonatomic) NSMutableArray *resFileArray; @property (strong, nonatomic) NSMutableArray* resFileArray;
@property (retain, nonatomic)UIAlertView *statusIndication; @property (retain, nonatomic)UIAlertView* statusIndication;
@property (assign, nonatomic) NSUInteger selectedRow; @property (assign, nonatomic) NSUInteger selectedRow;
- (IBAction)startDecoderAll:(id)sender; - (IBAction)startDecoderAll: (id)sender;
- (IBAction)startDecoderOne:(id)sender; - (IBAction)startDecoderOne: (id)sender;
@property (weak, nonatomic) IBOutlet UITextField *currentSelectedFileTF; @property (weak, nonatomic) IBOutlet UITextField* currentSelectedFileTF;
//unwind segue //unwind segue
- (IBAction)unwindSegueForShowResourceViewController:(UIStoryboardSegue *)segue; - (IBAction)unwindSegueForShowResourceViewController: (UIStoryboardSegue*)segue;
@end @end

2
codec/build/iOS/dec/demo/demo/DEMOViewControllerShowResource.h
View File

@ -33,6 +33,6 @@
#import <UIKit/UIKit.h> #import <UIKit/UIKit.h>
@interface DEMOViewControllerShowResource : UITableViewController @interface DEMOViewControllerShowResource : UITableViewController
@property (strong, nonatomic) NSMutableArray *resFileArray; @property (strong, nonatomic) NSMutableArray* resFileArray;
@property (assign, nonatomic) NSUInteger selectedRow; @property (assign, nonatomic) NSUInteger selectedRow;
@end @end

2
codec/build/iOS/enc/encDemo/encDemo/AppDelegate.h
View File

@ -34,6 +34,6 @@
@interface AppDelegate : UIResponder <UIApplicationDelegate> @interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window; @property (strong, nonatomic) UIWindow* window;
@end @end

6
codec/build/iOS/enc/encDemo/encDemo/ViewController.h
View File

@ -33,12 +33,12 @@
#import <UIKit/UIKit.h> #import <UIKit/UIKit.h>
@interface ViewController : UIViewController { @interface ViewController : UIViewController {
UILabel * statusText_; UILabel* statusText_;
} }
@property (retain, nonatomic) IBOutlet UILabel * statusText; @property (retain, nonatomic) IBOutlet UILabel* statusText;
-(IBAction) buttonPressed:(id)sender; - (IBAction) buttonPressed: (id)sender;
@end @end

4
codec/common/inc/deblocking_common.h
View File

@ -56,10 +56,10 @@ void DeblockLumaEq4V_AArch64_neon (uint8_t* pPixY, int32_t iStride, int32_t iAlp
void DeblockLumaLt4H_AArch64_neon (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc); void DeblockLumaLt4H_AArch64_neon (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc);
void DeblockLumaEq4H_AArch64_neon (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockLumaEq4H_AArch64_neon (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta);
void DeblockChromaLt4V_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4V_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* pTC); int8_t* pTC);
void DeblockChromaEq4V_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockChromaEq4V_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
void DeblockChromaLt4H_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4H_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* pTC); int8_t* pTC);
void DeblockChromaEq4H_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockChromaEq4H_AArch64_neon (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)

20
codec/console/enc/src/welsenc.cpp
View File

@ -161,7 +161,8 @@ int ParseLayerConfig (CReadConfig& cRdLayerCfg, const int iLayer, SEncParamExt&
return -1; return -1;
} }
if (pDLayer->iMaxSpatialBitrate < pDLayer->iSpatialBitrate) { if (pDLayer->iMaxSpatialBitrate < pDLayer->iSpatialBitrate) {
fprintf (stderr, "Invalid max spatial(#%d) bitrate(%d) setting::: < layerBitrate(%d)!\n", iLayer, pDLayer->iMaxSpatialBitrate, pDLayer->iSpatialBitrate); fprintf (stderr, "Invalid max spatial(#%d) bitrate(%d) setting::: < layerBitrate(%d)!\n", iLayer,
pDLayer->iMaxSpatialBitrate, pDLayer->iSpatialBitrate);
return -1; return -1;
} }
} }
@ -436,7 +437,7 @@ int ParseCommandLine (int argc, char** argv, SSourcePicture* pSrcPic, SEncParamE
pSvcParam.iLtrMarkPeriod = atoi (argv[n++]); pSvcParam.iLtrMarkPeriod = atoi (argv[n++]);
else if (!strcmp (pCommand, "-threadIdc") && (n < argc)) else if (!strcmp (pCommand, "-threadIdc") && (n < argc))
pSvcParam.iMultipleThreadIdc= atoi (argv[n++]); pSvcParam.iMultipleThreadIdc = atoi (argv[n++]);
else if (!strcmp (pCommand, "-deblockIdc") && (n < argc)) else if (!strcmp (pCommand, "-deblockIdc") && (n < argc))
pSvcParam.iLoopFilterDisableIdc = atoi (argv[n++]); pSvcParam.iLoopFilterDisableIdc = atoi (argv[n++]);
@ -454,15 +455,14 @@ int ParseCommandLine (int argc, char** argv, SSourcePicture* pSrcPic, SEncParamE
g_LevelSetting = atoi (argv[n++]); g_LevelSetting = atoi (argv[n++]);
else if (!strcmp (pCommand, "-tarb") && (n < argc)) else if (!strcmp (pCommand, "-tarb") && (n < argc))
pSvcParam.iTargetBitrate = 1000*atoi (argv[n++]); pSvcParam.iTargetBitrate = 1000 * atoi (argv[n++]);
else if (!strcmp (pCommand, "-maxbrTotal") && (n < argc)) else if (!strcmp (pCommand, "-maxbrTotal") && (n < argc))
pSvcParam.iMaxBitrate = 1000*atoi (argv[n++]); pSvcParam.iMaxBitrate = 1000 * atoi (argv[n++]);
else if (!strcmp (pCommand, "-numl") && (n < argc)) { else if (!strcmp (pCommand, "-numl") && (n < argc)) {
pSvcParam.iSpatialLayerNum = atoi (argv[n++]); pSvcParam.iSpatialLayerNum = atoi (argv[n++]);
} } else if (!strcmp (pCommand, "-lconfig") && (n < argc)) {
else if (!strcmp (pCommand, "-lconfig") && (n < argc)) {
unsigned int iLayer = atoi (argv[n++]); unsigned int iLayer = atoi (argv[n++]);
sFileSet.strLayerCfgFile[iLayer].assign (argv[n++]); sFileSet.strLayerCfgFile[iLayer].assign (argv[n++]);
CReadConfig cRdLayerCfg (sFileSet.strLayerCfgFile[iLayer]); CReadConfig cRdLayerCfg (sFileSet.strLayerCfgFile[iLayer]);
@ -630,7 +630,7 @@ int FillSpecificParameters (SEncParamExt& sParam) {
return 0; return 0;
} }
int ProcessEncoding(ISVCEncoder* pPtrEnc, int argc, char** argv,bool bConfigFile) { int ProcessEncoding (ISVCEncoder* pPtrEnc, int argc, char** argv, bool bConfigFile) {
int iRet = 0; int iRet = 0;
if (pPtrEnc == NULL) if (pPtrEnc == NULL)
@ -677,7 +677,7 @@ int ProcessEncoding(ISVCEncoder* pPtrEnc, int argc, char** argv,bool bConfigFile
pSrcPic->uiTimeStamp = 0; pSrcPic->uiTimeStamp = 0;
// if configure file exit, reading configure file firstly // if configure file exit, reading configure file firstly
if(bConfigFile){ if (bConfigFile) {
iParsedNum = 2; iParsedNum = 2;
cRdCfg.Openf (argv[1]); cRdCfg.Openf (argv[1]);
if (!cRdCfg.ExistFile()) { if (!cRdCfg.ExistFile()) {
@ -969,7 +969,7 @@ int main (int argc, char** argv)
} else { } else {
if (!strstr (argv[1], ".cfg")) { // check configuration type (like .cfg?) if (!strstr (argv[1], ".cfg")) { // check configuration type (like .cfg?)
if (argc > 2) { if (argc > 2) {
iRet = ProcessEncoding(pSVCEncoder, argc, argv,false); iRet = ProcessEncoding (pSVCEncoder, argc, argv, false);
if (iRet != 0) if (iRet != 0)
goto exit; goto exit;
} else if (argc == 2 && ! strcmp (argv[1], "-h")) } else if (argc == 2 && ! strcmp (argv[1], "-h"))
@ -979,7 +979,7 @@ int main (int argc, char** argv)
goto exit; goto exit;
} }
} else { } else {
iRet = ProcessEncoding(pSVCEncoder, argc, argv,true); iRet = ProcessEncoding (pSVCEncoder, argc, argv, true);
if (iRet > 0) if (iRet > 0)
goto exit; goto exit;
} }

328
codec/decoder/core/inc/decoder_context.h
View File

@ -58,11 +58,11 @@
namespace WelsDec { namespace WelsDec {
typedef struct TagDataBuffer { typedef struct TagDataBuffer {
uint8_t* pHead; uint8_t* pHead;
uint8_t* pEnd; uint8_t* pEnd;
uint8_t* pStartPos; uint8_t* pStartPos;
uint8_t* pCurPos; uint8_t* pCurPos;
} SDataBuffer; } SDataBuffer;
//#ifdef __cplusplus //#ifdef __cplusplus
@ -83,40 +83,40 @@ typedef void (*PExpandPictureFunc) (uint8_t* pDst, const int32_t kiStride, const
/**/ /**/
typedef struct TagRefPic { typedef struct TagRefPic {
PPicture pRefList[LIST_A][MAX_REF_PIC_COUNT]; // reference picture marking plus FIFO scheme PPicture pRefList[LIST_A][MAX_REF_PIC_COUNT]; // reference picture marking plus FIFO scheme
PPicture pShortRefList[LIST_A][MAX_SHORT_REF_COUNT]; PPicture pShortRefList[LIST_A][MAX_SHORT_REF_COUNT];
PPicture pLongRefList[LIST_A][MAX_LONG_REF_COUNT]; PPicture pLongRefList[LIST_A][MAX_LONG_REF_COUNT];
uint8_t uiRefCount[LIST_A]; uint8_t uiRefCount[LIST_A];
uint8_t uiShortRefCount[LIST_A]; uint8_t uiShortRefCount[LIST_A];
uint8_t uiLongRefCount[LIST_A]; // dependend on ref pic module uint8_t uiLongRefCount[LIST_A]; // dependend on ref pic module
int32_t iMaxLongTermFrameIdx; int32_t iMaxLongTermFrameIdx;
} SRefPic, *PRefPic; } SRefPic, *PRefPic;
typedef void (*PWelsMcFunc) (const uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, typedef void (*PWelsMcFunc) (const uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int16_t iMvX, int16_t iMvY, int32_t iWidth, int32_t iHeight); int16_t iMvX, int16_t iMvY, int32_t iWidth, int32_t iHeight);
typedef struct TagMcFunc { typedef struct TagMcFunc {
PWelsMcFunc pMcLumaFunc; PWelsMcFunc pMcLumaFunc;
PWelsMcFunc pMcChromaFunc; PWelsMcFunc pMcChromaFunc;
} SMcFunc; } SMcFunc;
typedef void (*PCopyFunc) (uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS); typedef void (*PCopyFunc) (uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS);
typedef struct TagCopyFunc { typedef struct TagCopyFunc {
PCopyFunc pCopyLumaFunc; PCopyFunc pCopyLumaFunc;
PCopyFunc pCopyChromaFunc; PCopyFunc pCopyChromaFunc;
} SCopyFunc; } SCopyFunc;
//deblock module defination //deblock module defination
struct TagDeblockingFunc; struct TagDeblockingFunc;
typedef struct tagDeblockingFilter { typedef struct tagDeblockingFilter {
uint8_t* pCsData[3]; // pointer to reconstructed picture data uint8_t* pCsData[3]; // pointer to reconstructed picture data
int32_t iCsStride[2]; // Cs stride int32_t iCsStride[2]; // Cs stride
ESliceType eSliceType; ESliceType eSliceType;
int8_t iSliceAlphaC0Offset; int8_t iSliceAlphaC0Offset;
int8_t iSliceBetaOffset; int8_t iSliceBetaOffset;
int8_t iChromaQP; int8_t iChromaQP;
int8_t iLumaQP; int8_t iLumaQP;
struct TagDeblockingFunc* pLoopf; struct TagDeblockingFunc* pLoopf;
} SDeblockingFilter, *PDeblockingFilter; } SDeblockingFilter, *PDeblockingFilter;
typedef void (*PDeblockingFilterMbFunc) (PDqLayer pCurDqLayer, PDeblockingFilter filter, int32_t boundry_flag); typedef void (*PDeblockingFilterMbFunc) (PDqLayer pCurDqLayer, PDeblockingFilter filter, int32_t boundry_flag);
@ -129,21 +129,21 @@ typedef void (*PChromaDeblockingEQ4Func) (uint8_t* iSampleCb, uint8_t* iSampleCr
int32_t iBeta); int32_t iBeta);
typedef struct TagDeblockingFunc { typedef struct TagDeblockingFunc {
PLumaDeblockingLT4Func pfLumaDeblockingLT4Ver; PLumaDeblockingLT4Func pfLumaDeblockingLT4Ver;
PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Ver; PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Ver;
PLumaDeblockingLT4Func pfLumaDeblockingLT4Hor; PLumaDeblockingLT4Func pfLumaDeblockingLT4Hor;
PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Hor; PLumaDeblockingEQ4Func pfLumaDeblockingEQ4Hor;
PChromaDeblockingLT4Func pfChromaDeblockingLT4Ver; PChromaDeblockingLT4Func pfChromaDeblockingLT4Ver;
PChromaDeblockingEQ4Func pfChromaDeblockingEQ4Ver; PChromaDeblockingEQ4Func pfChromaDeblockingEQ4Ver;
PChromaDeblockingLT4Func pfChromaDeblockingLT4Hor; PChromaDeblockingLT4Func pfChromaDeblockingLT4Hor;
PChromaDeblockingEQ4Func pfChromaDeblockingEQ4Hor; PChromaDeblockingEQ4Func pfChromaDeblockingEQ4Hor;
} SDeblockingFunc, *PDeblockingFunc; } SDeblockingFunc, *PDeblockingFunc;
typedef void (*PWelsNonZeroCountFunc) (int8_t* pNonZeroCount); typedef void (*PWelsNonZeroCountFunc) (int8_t* pNonZeroCount);
typedef struct TagBlockFunc { typedef struct TagBlockFunc {
PWelsNonZeroCountFunc pWelsSetNonZeroCountFunc; PWelsNonZeroCountFunc pWelsSetNonZeroCountFunc;
} SBlockFunc; } SBlockFunc;
typedef void (*PWelsFillNeighborMbInfoIntra4x4Func) (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, typedef void (*PWelsFillNeighborMbInfoIntra4x4Func) (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
@ -153,10 +153,10 @@ typedef int32_t (*PWelsParseIntra4x4ModeFunc) (PNeighAvail pNeighAvail, int8_t*
typedef int32_t (*PWelsParseIntra16x16ModeFunc) (PNeighAvail pNeighAvail, PBitStringAux pBs, PDqLayer pCurDqLayer); typedef int32_t (*PWelsParseIntra16x16ModeFunc) (PNeighAvail pNeighAvail, PBitStringAux pBs, PDqLayer pCurDqLayer);
enum { enum {
OVERWRITE_NONE = 0, OVERWRITE_NONE = 0,
OVERWRITE_PPS = 1, OVERWRITE_PPS = 1,
OVERWRITE_SPS = 1 << 1, OVERWRITE_SPS = 1 << 1,
OVERWRITE_SUBSETSPS = 1 << 2 OVERWRITE_SUBSETSPS = 1 << 2
}; };
/* /*
@ -164,173 +164,173 @@ enum {
*/ */
typedef struct TagWelsDecoderContext { typedef struct TagWelsDecoderContext {
SLogContext sLogCtx; SLogContext sLogCtx;
// Input // Input
void* pArgDec; // structured arguments for decoder, reserved here for extension in the future void* pArgDec; // structured arguments for decoder, reserved here for extension in the future
SDataBuffer sRawData; SDataBuffer sRawData;
// Configuration // Configuration
SDecodingParam* pParam; SDecodingParam* pParam;
uint32_t uiCpuFlag; // CPU compatibility detected uint32_t uiCpuFlag; // CPU compatibility detected
int32_t iOutputColorFormat; // color space format to be outputed int32_t iOutputColorFormat; // color space format to be outputed
VIDEO_BITSTREAM_TYPE eVideoType; //indicate the type of video to decide whether or not to do qp_delta error detection. VIDEO_BITSTREAM_TYPE eVideoType; //indicate the type of video to decide whether or not to do qp_delta error detection.
bool bErrorResilienceFlag; // error resilience flag bool bErrorResilienceFlag; // error resilience flag
bool bHaveGotMemory; // global memory for decoder context related ever requested? bool bHaveGotMemory; // global memory for decoder context related ever requested?
int32_t iImgWidthInPixel; // width of image in pixel reconstruction picture to be output int32_t iImgWidthInPixel; // width of image in pixel reconstruction picture to be output
int32_t iImgHeightInPixel;// height of image in pixel reconstruction picture to be output int32_t iImgHeightInPixel;// height of image in pixel reconstruction picture to be output
// Derived common elements // Derived common elements
SNalUnitHeader sCurNalHead; SNalUnitHeader sCurNalHead;
ESliceType eSliceType; // Slice type ESliceType eSliceType; // Slice type
int32_t iFrameNum; int32_t iFrameNum;
int32_t iPrevFrameNum; // frame number of previous frame well decoded for non-truncated mode yet int32_t iPrevFrameNum; // frame number of previous frame well decoded for non-truncated mode yet
bool bLastHasMmco5; // bool bLastHasMmco5; //
int32_t iErrorCode; // error code return while decoding in case packets lost int32_t iErrorCode; // error code return while decoding in case packets lost
SFmo sFmoList[MAX_PPS_COUNT]; // list for FMO storage SFmo sFmoList[MAX_PPS_COUNT]; // list for FMO storage
PFmo pFmo; // current fmo context after parsed slice_header PFmo pFmo; // current fmo context after parsed slice_header
int32_t iActiveFmoNum; // active count number of fmo context in list int32_t iActiveFmoNum; // active count number of fmo context in list
/*needed info by decode slice level and mb level*/ /*needed info by decode slice level and mb level*/
int32_t int32_t
iDecBlockOffsetArray[24]; // address talbe for sub 4x4 block in intra4x4_mb, so no need to caculta the address every time. iDecBlockOffsetArray[24]; // address talbe for sub 4x4 block in intra4x4_mb, so no need to caculta the address every time.
struct { struct {
int8_t* pMbType[LAYER_NUM_EXCHANGEABLE]; /* mb type */ int8_t* pMbType[LAYER_NUM_EXCHANGEABLE]; /* mb type */
int16_t (*pMv[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM][MV_A]; //[LAYER_NUM_EXCHANGEABLE MB_BLOCK4x4_NUM*] int16_t (*pMv[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM][MV_A]; //[LAYER_NUM_EXCHANGEABLE MB_BLOCK4x4_NUM*]
int8_t (*pRefIndex[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM]; int8_t (*pRefIndex[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_BLOCK4x4_NUM];
int8_t* pLumaQp[LAYER_NUM_EXCHANGEABLE]; /*mb luma_qp*/ int8_t* pLumaQp[LAYER_NUM_EXCHANGEABLE]; /*mb luma_qp*/
int8_t* pChromaQp[LAYER_NUM_EXCHANGEABLE]; /*mb chroma_qp*/ int8_t* pChromaQp[LAYER_NUM_EXCHANGEABLE]; /*mb chroma_qp*/
int8_t (*pNzc[LAYER_NUM_EXCHANGEABLE])[24]; int8_t (*pNzc[LAYER_NUM_EXCHANGEABLE])[24];
int8_t (*pNzcRs[LAYER_NUM_EXCHANGEABLE])[24]; int8_t (*pNzcRs[LAYER_NUM_EXCHANGEABLE])[24];
int16_t (*pScaledTCoeff[LAYER_NUM_EXCHANGEABLE])[MB_COEFF_LIST_SIZE]; /*need be aligned*/ int16_t (*pScaledTCoeff[LAYER_NUM_EXCHANGEABLE])[MB_COEFF_LIST_SIZE]; /*need be aligned*/
int8_t (*pIntraPredMode[LAYER_NUM_EXCHANGEABLE])[8]; //0~3 top4x4 ; 4~6 left 4x4; 7 intra16x16 int8_t (*pIntraPredMode[LAYER_NUM_EXCHANGEABLE])[8]; //0~3 top4x4 ; 4~6 left 4x4; 7 intra16x16
int8_t (*pIntra4x4FinalMode[LAYER_NUM_EXCHANGEABLE])[MB_BLOCK4x4_NUM]; int8_t (*pIntra4x4FinalMode[LAYER_NUM_EXCHANGEABLE])[MB_BLOCK4x4_NUM];
int8_t* pChromaPredMode[LAYER_NUM_EXCHANGEABLE]; int8_t* pChromaPredMode[LAYER_NUM_EXCHANGEABLE];
int8_t* pCbp[LAYER_NUM_EXCHANGEABLE]; int8_t* pCbp[LAYER_NUM_EXCHANGEABLE];
uint8_t (*pMotionPredFlag[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_PARTITION_SIZE]; // 8x8 uint8_t (*pMotionPredFlag[LAYER_NUM_EXCHANGEABLE][LIST_A])[MB_PARTITION_SIZE]; // 8x8
int8_t (*pSubMbType[LAYER_NUM_EXCHANGEABLE])[MB_SUB_PARTITION_SIZE]; int8_t (*pSubMbType[LAYER_NUM_EXCHANGEABLE])[MB_SUB_PARTITION_SIZE];
int32_t* pSliceIdc[LAYER_NUM_EXCHANGEABLE]; // using int32_t for slice_idc int32_t* pSliceIdc[LAYER_NUM_EXCHANGEABLE]; // using int32_t for slice_idc
int8_t* pResidualPredFlag[LAYER_NUM_EXCHANGEABLE]; int8_t* pResidualPredFlag[LAYER_NUM_EXCHANGEABLE];
int8_t* pInterPredictionDoneFlag[LAYER_NUM_EXCHANGEABLE]; int8_t* pInterPredictionDoneFlag[LAYER_NUM_EXCHANGEABLE];
bool* pMbCorrectlyDecodedFlag[LAYER_NUM_EXCHANGEABLE]; bool* pMbCorrectlyDecodedFlag[LAYER_NUM_EXCHANGEABLE];
uint32_t iMbWidth; uint32_t iMbWidth;
uint32_t iMbHeight; uint32_t iMbHeight;
} sMb; } sMb;
// reconstruction picture // reconstruction picture
PPicture pDec; //pointer to current picture being reconstructed PPicture pDec; //pointer to current picture being reconstructed
// reference pictures // reference pictures
SRefPic sRefPic; SRefPic sRefPic;
SVlcTable sVlcTable; // vlc table SVlcTable sVlcTable; // vlc table
SBitStringAux sBs; SBitStringAux sBs;
int32_t iMaxBsBufferSizeInByte; //actual memory size for BS buffer int32_t iMaxBsBufferSizeInByte; //actual memory size for BS buffer
/* Global memory external */ /* Global memory external */
SPosOffset sFrameCrop; SPosOffset sFrameCrop;
SSps sSpsBuffer[MAX_SPS_COUNT + 1]; SSps sSpsBuffer[MAX_SPS_COUNT + 1];
SPps sPpsBuffer[MAX_PPS_COUNT + 1]; SPps sPpsBuffer[MAX_PPS_COUNT + 1];
PSliceHeader pSliceHeader; PSliceHeader pSliceHeader;
PPicBuff pPicBuff[LIST_A]; // Initially allocated memory for pictures which are used in decoding. PPicBuff pPicBuff[LIST_A]; // Initially allocated memory for pictures which are used in decoding.
int32_t iPicQueueNumber; int32_t iPicQueueNumber;
SSubsetSps sSubsetSpsBuffer[MAX_SPS_COUNT + 1]; SSubsetSps sSubsetSpsBuffer[MAX_SPS_COUNT + 1];
SNalUnit sPrefixNal; SNalUnit sPrefixNal;
PAccessUnit pAccessUnitList; // current access unit list to be performed PAccessUnit pAccessUnitList; // current access unit list to be performed
PSps pActiveLayerSps[MAX_LAYER_NUM]; PSps pActiveLayerSps[MAX_LAYER_NUM];
PSps pSps; // used by current AU PSps pSps; // used by current AU
PPps pPps; // used by current AU PPps pPps; // used by current AU
// Memory for pAccessUnitList is dynamically held till decoder destruction. // Memory for pAccessUnitList is dynamically held till decoder destruction.
PDqLayer pCurDqLayer; // current DQ layer representation, also carry reference base layer if applicable PDqLayer pCurDqLayer; // current DQ layer representation, also carry reference base layer if applicable
PDqLayer pDqLayersList[LAYER_NUM_EXCHANGEABLE]; // DQ layers list with memory allocated PDqLayer pDqLayersList[LAYER_NUM_EXCHANGEABLE]; // DQ layers list with memory allocated
int32_t iPicWidthReq; // picture width have requested the memory int32_t iPicWidthReq; // picture width have requested the memory
int32_t iPicHeightReq; // picture height have requested the memory int32_t iPicHeightReq; // picture height have requested the memory
uint8_t uiTargetDqId; // maximal DQ ID in current access unit, meaning target layer ID uint8_t uiTargetDqId; // maximal DQ ID in current access unit, meaning target layer ID
bool bAvcBasedFlag; // For decoding bitstream: bool bAvcBasedFlag; // For decoding bitstream:
bool bEndOfStreamFlag; // Flag on end of stream requested by external application layer bool bEndOfStreamFlag; // Flag on end of stream requested by external application layer
bool bInstantDecFlag; // Flag for no-delay decoding bool bInstantDecFlag; // Flag for no-delay decoding
bool bInitialDqLayersMem; // dq layers related memory is available? bool bInitialDqLayersMem; // dq layers related memory is available?
bool bOnlyOneLayerInCurAuFlag; //only one layer in current AU: 1 bool bOnlyOneLayerInCurAuFlag; //only one layer in current AU: 1
// for EC parameter sets // for EC parameter sets
bool bSpsExistAheadFlag; // whether does SPS NAL exist ahead of sequence? bool bSpsExistAheadFlag; // whether does SPS NAL exist ahead of sequence?
bool bSubspsExistAheadFlag;// whether does Subset SPS NAL exist ahead of sequence? bool bSubspsExistAheadFlag;// whether does Subset SPS NAL exist ahead of sequence?
bool bPpsExistAheadFlag; // whether does PPS NAL exist ahead of sequence? bool bPpsExistAheadFlag; // whether does PPS NAL exist ahead of sequence?
bool bSpsAvailFlags[MAX_SPS_COUNT]; bool bSpsAvailFlags[MAX_SPS_COUNT];
bool bSubspsAvailFlags[MAX_SPS_COUNT]; bool bSubspsAvailFlags[MAX_SPS_COUNT];
bool bPpsAvailFlags[MAX_PPS_COUNT]; bool bPpsAvailFlags[MAX_PPS_COUNT];
bool bReferenceLostAtT0Flag; bool bReferenceLostAtT0Flag;
int32_t iTotalNumMbRec; //record current number of decoded MB int32_t iTotalNumMbRec; //record current number of decoded MB
#ifdef LONG_TERM_REF #ifdef LONG_TERM_REF
bool bParamSetsLostFlag; //sps or pps do not exist or not correct bool bParamSetsLostFlag; //sps or pps do not exist or not correct
bool bool
bCurAuContainLtrMarkSeFlag; //current AU has the LTR marking syntax element, mark the previous frame or self bCurAuContainLtrMarkSeFlag; //current AU has the LTR marking syntax element, mark the previous frame or self
int32_t iFrameNumOfAuMarkedLtr; //if bCurAuContainLtrMarkSeFlag==true, SHOULD set this variable int32_t iFrameNumOfAuMarkedLtr; //if bCurAuContainLtrMarkSeFlag==true, SHOULD set this variable
uint16_t uiCurIdrPicId; uint16_t uiCurIdrPicId;
#endif #endif
bool bNewSeqBegin; bool bNewSeqBegin;
bool bNextNewSeqBegin; bool bNextNewSeqBegin;
int iOverwriteFlags; int iOverwriteFlags;
int32_t iErrorConMethod; // int32_t iErrorConMethod; //
PPicture pPreviousDecodedPictureInDpb; //pointer to previously decoded picture in DPB for error concealment PPicture pPreviousDecodedPictureInDpb; //pointer to previously decoded picture in DPB for error concealment
PGetIntraPredFunc pGetI16x16LumaPredFunc[7]; //h264_predict_copy_16x16; PGetIntraPredFunc pGetI16x16LumaPredFunc[7]; //h264_predict_copy_16x16;
PGetIntraPredFunc pGetI4x4LumaPredFunc[14]; // h264_predict_4x4_t PGetIntraPredFunc pGetI4x4LumaPredFunc[14]; // h264_predict_4x4_t
PGetIntraPredFunc pGetIChromaPredFunc[7]; // h264_predict_8x8_t PGetIntraPredFunc pGetIChromaPredFunc[7]; // h264_predict_8x8_t
PIdctResAddPredFunc pIdctResAddPredFunc; PIdctResAddPredFunc pIdctResAddPredFunc;
SMcFunc sMcFunc; SMcFunc sMcFunc;
//For error concealment //For error concealment
SCopyFunc sCopyFunc; SCopyFunc sCopyFunc;
/* For Deblocking */ /* For Deblocking */
SDeblockingFunc sDeblockingFunc; SDeblockingFunc sDeblockingFunc;
SExpandPicFunc sExpandPicFunc; SExpandPicFunc sExpandPicFunc;
/* For Block */ /* For Block */
SBlockFunc sBlockFunc; SBlockFunc sBlockFunc;
int32_t iCurSeqIntervalTargetDependId; int32_t iCurSeqIntervalTargetDependId;
int32_t iCurSeqIntervalMaxPicWidth; int32_t iCurSeqIntervalMaxPicWidth;
int32_t iCurSeqIntervalMaxPicHeight; int32_t iCurSeqIntervalMaxPicHeight;
PWelsFillNeighborMbInfoIntra4x4Func pFillInfoCacheIntra4x4Func; PWelsFillNeighborMbInfoIntra4x4Func pFillInfoCacheIntra4x4Func;
PWelsParseIntra4x4ModeFunc pParseIntra4x4ModeFunc; PWelsParseIntra4x4ModeFunc pParseIntra4x4ModeFunc;
PWelsParseIntra16x16ModeFunc pParseIntra16x16ModeFunc; PWelsParseIntra16x16ModeFunc pParseIntra16x16ModeFunc;
//feedback whether or not have VCL in current AU, and the temporal ID //feedback whether or not have VCL in current AU, and the temporal ID
int32_t iFeedbackVclNalInAu; int32_t iFeedbackVclNalInAu;
int32_t iFeedbackTidInAu; int32_t iFeedbackTidInAu;
bool bAuReadyFlag; // true: one au is ready for decoding; false: default value bool bAuReadyFlag; // true: one au is ready for decoding; false: default value
//trace handle //trace handle
void* pTraceHandle; void* pTraceHandle;
//Save the last nal header info //Save the last nal header info
SNalUnitHeaderExt sLastNalHdrExt; SNalUnitHeaderExt sLastNalHdrExt;
SSliceHeader sLastSliceHeader; SSliceHeader sLastSliceHeader;
} SWelsDecoderContext, *PWelsDecoderContext; } SWelsDecoderContext, *PWelsDecoderContext;
static inline void ResetActiveSPSForEachLayer (PWelsDecoderContext pCtx) { static inline void ResetActiveSPSForEachLayer (PWelsDecoderContext pCtx) {
for (int i = 0; i < MAX_LAYER_NUM; i++) { for (int i = 0; i < MAX_LAYER_NUM; i++) {
pCtx->pActiveLayerSps[i] = NULL; pCtx->pActiveLayerSps[i] = NULL;
} }
} }
//#ifdef __cplusplus //#ifdef __cplusplus
//} //}

216
codec/decoder/core/inc/error_code.h
View File

@ -43,12 +43,12 @@
namespace WelsDec { namespace WelsDec {
typedef enum TagWelsErr { typedef enum TagWelsErr {
ERR_NONE = 0, ERR_NONE = 0,
ERR_INVALID_PARAMETERS = 1, ERR_INVALID_PARAMETERS = 1,
ERR_MALLOC_FAILED = 2, ERR_MALLOC_FAILED = 2,
ERR_API_FAILED = 3, ERR_API_FAILED = 3,
ERR_BOUND = 31, ERR_BOUND = 31,
} EWelsErr; } EWelsErr;
/* /*
@ -62,13 +62,13 @@ typedef enum TagWelsErr {
/* ERR_LEVEL */ /* ERR_LEVEL */
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
enum { enum {
ERR_LEVEL_ACCESS_UNIT = 1, ERR_LEVEL_ACCESS_UNIT = 1,
ERR_LEVEL_NAL_UNIT_HEADER, ERR_LEVEL_NAL_UNIT_HEADER,
ERR_LEVEL_PREFIX_NAL, ERR_LEVEL_PREFIX_NAL,
ERR_LEVEL_PARAM_SETS, ERR_LEVEL_PARAM_SETS,
ERR_LEVEL_SLICE_HEADER, ERR_LEVEL_SLICE_HEADER,
ERR_LEVEL_SLICE_DATA, ERR_LEVEL_SLICE_DATA,
ERR_LEVEL_MB_DATA, ERR_LEVEL_MB_DATA,
}; };
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
@ -79,108 +79,108 @@ enum {
#define ERR_INFO_SYNTAX_BASE 1001 #define ERR_INFO_SYNTAX_BASE 1001
#define ERR_INFO_LOGIC_BASE 10001 #define ERR_INFO_LOGIC_BASE 10001
enum { enum {
/* Error from common system level: 1-1000 */ /* Error from common system level: 1-1000 */
ERR_INFO_OUT_OF_MEMORY = ERR_INFO_COMMON_BASE, ERR_INFO_OUT_OF_MEMORY = ERR_INFO_COMMON_BASE,
ERR_INFO_INVALID_ACCESS, ERR_INFO_INVALID_ACCESS,
ERR_INFO_INVALID_PTR, ERR_INFO_INVALID_PTR,
ERR_INFO_INVALID_PARAM, ERR_INFO_INVALID_PARAM,
ERR_INFO_FILE_NO_FOUND, ERR_INFO_FILE_NO_FOUND,
ERR_INFO_PATH_NO_FOUND, ERR_INFO_PATH_NO_FOUND,
ERR_INFO_ACCESS_DENIED, ERR_INFO_ACCESS_DENIED,
ERR_INFO_NOT_READY, ERR_INFO_NOT_READY,
ERR_INFO_WRITE_FAULT, ERR_INFO_WRITE_FAULT,
ERR_INFO_READ_FAULT, ERR_INFO_READ_FAULT,
ERR_INFO_READ_OVERFLOW, ERR_INFO_READ_OVERFLOW,
ERR_INFO_READ_LEADING_ZERO, ERR_INFO_READ_LEADING_ZERO,
/* Error from H.264 syntax elements parser: 1001-10000 */ /* Error from H.264 syntax elements parser: 1001-10000 */
ERR_INFO_NO_PREFIX_CODE = ERR_INFO_SYNTAX_BASE, // No start prefix code indication ERR_INFO_NO_PREFIX_CODE = ERR_INFO_SYNTAX_BASE, // No start prefix code indication
ERR_INFO_NO_PARAM_SETS, // No SPS and/ PPS before sequence header ERR_INFO_NO_PARAM_SETS, // No SPS and/ PPS before sequence header
ERR_INFO_PARAM_SETS_NOT_INTEGRATED, // Parameters sets (sps/pps) are not integrated at all before to decode VCL nal ERR_INFO_PARAM_SETS_NOT_INTEGRATED, // Parameters sets (sps/pps) are not integrated at all before to decode VCL nal
ERR_INFO_SPS_ID_OVERFLOW, ERR_INFO_SPS_ID_OVERFLOW,
ERR_INFO_PPS_ID_OVERFLOW, ERR_INFO_PPS_ID_OVERFLOW,
ERR_INFO_INVALID_PROFILE_IDC, ERR_INFO_INVALID_PROFILE_IDC,
ERR_INFO_UNMATCHED_LEVEL_IDC, ERR_INFO_UNMATCHED_LEVEL_IDC,
ERR_INFO_INVALID_POC_TYPE, ERR_INFO_INVALID_POC_TYPE,
ERR_INFO_INVALID_MB_SIZE_INFO, ERR_INFO_INVALID_MB_SIZE_INFO,
ERR_INFO_REF_COUNT_OVERFLOW, ERR_INFO_REF_COUNT_OVERFLOW,
ERR_INFO_CROPPING_NO_SUPPORTED, ERR_INFO_CROPPING_NO_SUPPORTED,
ERR_INFO_INVALID_SLICEGROUP, ERR_INFO_INVALID_SLICEGROUP,
ERR_INFO_INVALID_SLICEGROUP_MAP_TYPE, ERR_INFO_INVALID_SLICEGROUP_MAP_TYPE,
ERR_INFO_INVALID_FRAME_NUM, ERR_INFO_INVALID_FRAME_NUM,
ERR_INFO_INVALID_IDR_PIC_ID, ERR_INFO_INVALID_IDR_PIC_ID,
ERR_INFO_INVALID_REDUNDANT_PIC_CNT, ERR_INFO_INVALID_REDUNDANT_PIC_CNT,
ERR_INFO_INVALID_MAX_NUM_REF_FRAMES, ERR_INFO_INVALID_MAX_NUM_REF_FRAMES,
ERR_INFO_INVALID_MAX_MB_SIZE, ERR_INFO_INVALID_MAX_MB_SIZE,
ERR_INFO_INVALID_FIRST_MB_IN_SLICE, ERR_INFO_INVALID_FIRST_MB_IN_SLICE,
ERR_INFO_INVALID_NUM_REF_IDX_L0_ACTIVE_MINUS1, ERR_INFO_INVALID_NUM_REF_IDX_L0_ACTIVE_MINUS1,
ERR_INFO_INVALID_SLICE_ALPHA_C0_OFFSET_DIV2, ERR_INFO_INVALID_SLICE_ALPHA_C0_OFFSET_DIV2,
ERR_INFO_INVALID_SLICE_BETA_OFFSET_DIV2, ERR_INFO_INVALID_SLICE_BETA_OFFSET_DIV2,
ERR_INFO_FMO_INIT_FAIL, ERR_INFO_FMO_INIT_FAIL,
ERR_INFO_SLICE_TYPE_OVERFLOW, ERR_INFO_SLICE_TYPE_OVERFLOW,
ERR_INFO_INVALID_QP, ERR_INFO_INVALID_QP,
ERR_INFO_INVALID_PIC_INIT_QS, ERR_INFO_INVALID_PIC_INIT_QS,
ERR_INFO_INVALID_CHROMA_QP_INDEX_OFFSET, ERR_INFO_INVALID_CHROMA_QP_INDEX_OFFSET,
ERR_INFO_INVALID_PIC_INIT_QP, ERR_INFO_INVALID_PIC_INIT_QP,
ERR_INFO_INVALID_LOG2_MAX_FRAME_NUM_MINUS4, ERR_INFO_INVALID_LOG2_MAX_FRAME_NUM_MINUS4,
ERR_INFO_INVALID_LOG2_MAX_PIC_ORDER_CNT_LSB_MINUS4, ERR_INFO_INVALID_LOG2_MAX_PIC_ORDER_CNT_LSB_MINUS4,
ERR_INFO_INVALID_NUM_REF_FRAME_IN_PIC_ORDER_CNT_CYCLE, ERR_INFO_INVALID_NUM_REF_FRAME_IN_PIC_ORDER_CNT_CYCLE,
ERR_INFO_INVALID_DBLOCKING_IDC, ERR_INFO_INVALID_DBLOCKING_IDC,
ERR_INFO_INVALID_MB_TYPE, ERR_INFO_INVALID_MB_TYPE,
ERR_INFO_INVALID_SPS_ID, ERR_INFO_INVALID_SPS_ID,
ERR_INFO_INVALID_PPS_ID, ERR_INFO_INVALID_PPS_ID,
ERR_INFO_INVALID_SUB_MB_TYPE, ERR_INFO_INVALID_SUB_MB_TYPE,
ERR_INFO_UNAVAILABLE_TOP_BLOCK_FOR_INTRA, ERR_INFO_UNAVAILABLE_TOP_BLOCK_FOR_INTRA,
ERR_INFO_UNAVAILABLE_LEFT_BLOCK_FOR_INTRA, ERR_INFO_UNAVAILABLE_LEFT_BLOCK_FOR_INTRA,
ERR_INFO_INVALID_REF_INDEX, ERR_INFO_INVALID_REF_INDEX,
ERR_INFO_INVALID_CBP, ERR_INFO_INVALID_CBP,
ERR_INFO_DQUANT_OUT_OF_RANGE, ERR_INFO_DQUANT_OUT_OF_RANGE,
ERR_INFO_CAVLC_INVALID_PREFIX, ERR_INFO_CAVLC_INVALID_PREFIX,
ERR_INFO_CAVLC_INVALID_LEVEL, ERR_INFO_CAVLC_INVALID_LEVEL,
ERR_INFO_CAVLC_INVALID_TOTAL_COEFF_OR_TRAILING_ONES, ERR_INFO_CAVLC_INVALID_TOTAL_COEFF_OR_TRAILING_ONES,
ERR_INFO_CAVLC_INVALID_ZERO_LEFT, ERR_INFO_CAVLC_INVALID_ZERO_LEFT,
ERR_INFO_CAVLC_INVALID_RUN_BEFORE, ERR_INFO_CAVLC_INVALID_RUN_BEFORE,
ERR_INFO_MV_OUT_OF_RANGE, ERR_INFO_MV_OUT_OF_RANGE,
ERR_INFO_INVALID_I4x4_PRED_MODE, ERR_INFO_INVALID_I4x4_PRED_MODE,
ERR_INFO_INVALID_I16x16_PRED_MODE, ERR_INFO_INVALID_I16x16_PRED_MODE,
ERR_INFO_INVALID_I_CHROMA_PRED_MODE, ERR_INFO_INVALID_I_CHROMA_PRED_MODE,
ERR_INFO_UNSUPPORTED_NON_BASELINE, ERR_INFO_UNSUPPORTED_NON_BASELINE,
ERR_INFO_UNSUPPORTED_FMOTYPE, ERR_INFO_UNSUPPORTED_FMOTYPE,
ERR_INFO_UNSUPPORTED_MBAFF, ERR_INFO_UNSUPPORTED_MBAFF,
ERR_INFO_UNSUPPORTED_ILP, ERR_INFO_UNSUPPORTED_ILP,
ERR_INFO_UNSUPPORTED_CABAC_EL, ERR_INFO_UNSUPPORTED_CABAC_EL,
ERR_INFO_UNSUPPORTED_SPSI, ERR_INFO_UNSUPPORTED_SPSI,
ERR_INFO_UNSUPPORTED_MGS, ERR_INFO_UNSUPPORTED_MGS,
ERR_INFO_UNSUPPORTED_BIPRED, ERR_INFO_UNSUPPORTED_BIPRED,
ERR_INFO_UNSUPPORTED_WP, ERR_INFO_UNSUPPORTED_WP,
ERR_INFO_FRAMES_LOST, ERR_INFO_FRAMES_LOST,
ERR_INFO_DEPENDENCY_SPATIAL_LAYER_LOST, ERR_INFO_DEPENDENCY_SPATIAL_LAYER_LOST,
ERR_INFO_DEPENDENCY_QUALIT_LAYER_LOST, ERR_INFO_DEPENDENCY_QUALIT_LAYER_LOST,
ERR_INFO_REFERENCE_PIC_LOST, ERR_INFO_REFERENCE_PIC_LOST,
ERR_INFO_INVALID_REORDERING, ERR_INFO_INVALID_REORDERING,
ERR_INFO_INVALID_MARKING, ERR_INFO_INVALID_MARKING,
ERR_INFO_FMO_NOT_SUPPORTED_IN_BASE_LAYER, ERR_INFO_FMO_NOT_SUPPORTED_IN_BASE_LAYER,
ERR_INFO_INVALID_ESS, ERR_INFO_INVALID_ESS,
ERR_INFO_INVALID_SLICE_TYPE, ERR_INFO_INVALID_SLICE_TYPE,
ERR_INFO_INVALID_REF_MARKING, ERR_INFO_INVALID_REF_MARKING,
ERR_INFO_INVALID_REF_REORDERING, ERR_INFO_INVALID_REF_REORDERING,
/* Error from corresponding logic, 10001-65535 */ /* Error from corresponding logic, 10001-65535 */
ERR_INFO_NO_IDR_PIC = ERR_INFO_LOGIC_BASE, // NO IDR picture available before sequence header ERR_INFO_NO_IDR_PIC = ERR_INFO_LOGIC_BASE, // NO IDR picture available before sequence header
ERR_INFO_EC_NO_NEIGHBOUR_MBS, ERR_INFO_EC_NO_NEIGHBOUR_MBS,
ERR_INFO_EC_UNEXPECTED_MB_TYPE, ERR_INFO_EC_UNEXPECTED_MB_TYPE,
ERR_INFO_EC_NO_ENOUGH_NEIGHBOUR_MBS, ERR_INFO_EC_NO_ENOUGH_NEIGHBOUR_MBS,
//for LTR //for LTR
ERR_INFO_INVALID_MMCO_OPCODE_BASE, ERR_INFO_INVALID_MMCO_OPCODE_BASE,
ERR_INFO_INVALID_MMCO_SHORT2UNUSED, ERR_INFO_INVALID_MMCO_SHORT2UNUSED,
EER_INFO_INVALID_MMCO_LONG2UNUSED, EER_INFO_INVALID_MMCO_LONG2UNUSED,
ERR_INFO_INVALID_MMCO_SHOART2LONG, ERR_INFO_INVALID_MMCO_SHOART2LONG,
ERR_INFO_INVALID_MMCO_REF_NUM_OVERFLOW, ERR_INFO_INVALID_MMCO_REF_NUM_OVERFLOW,
ERR_INFO_INVALID_MMCO_REF_NUM_NOT_ENOUGH, ERR_INFO_INVALID_MMCO_REF_NUM_NOT_ENOUGH,
ERR_INFO_INVALID_MMCO_LONG_TERM_IDX_EXCEED_MAX, ERR_INFO_INVALID_MMCO_LONG_TERM_IDX_EXCEED_MAX,
}; };
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------

12
codec/decoder/core/inc/fmo.h
View File

@ -54,12 +54,12 @@ namespace WelsDec {
* \brief Wels Flexible Macroblock Ordering (FMO) * \brief Wels Flexible Macroblock Ordering (FMO)
*/ */
typedef struct TagFmo { typedef struct TagFmo {
uint8_t* pMbAllocMap; uint8_t* pMbAllocMap;
int32_t iCountMbNum; int32_t iCountMbNum;
int32_t iSliceGroupCount; int32_t iSliceGroupCount;
int32_t iSliceGroupType; int32_t iSliceGroupType;
bool bActiveFlag; bool bActiveFlag;
uint8_t uiReserved[3]; // reserved padding bytes uint8_t uiReserved[3]; // reserved padding bytes
} SFmo, *PFmo; } SFmo, *PFmo;

16
codec/decoder/core/inc/mb_cache.h
View File

@ -65,15 +65,15 @@ extern const uint8_t g_kuiCacheNzcScanIdx[24];
extern const uint8_t g_kuiScan4[16]; extern const uint8_t g_kuiScan4[16];
typedef struct TagNeighborAvail { typedef struct TagNeighborAvail {
int32_t iTopAvail; int32_t iTopAvail;
int32_t iLeftAvail; int32_t iLeftAvail;
int32_t iRightTopAvail; int32_t iRightTopAvail;
int32_t iLeftTopAvail; //used for check intra_pred_mode avail or not //1: avail; 0: unavail int32_t iLeftTopAvail; //used for check intra_pred_mode avail or not //1: avail; 0: unavail
int32_t iLeftType; int32_t iLeftType;
int32_t iTopType; int32_t iTopType;
int32_t iLeftTopType; int32_t iLeftTopType;
int32_t iRightTopType; int32_t iRightTopType;
} SNeighAvail, *PNeighAvail; } SNeighAvail, *PNeighAvail;
} // namespace WelsDec } // namespace WelsDec

46
codec/decoder/core/inc/nal_prefix.h
View File

@ -44,41 +44,41 @@ namespace WelsDec {
/* NAL Unix Header in AVC, refer to Page 56 in JVT X201wcm */ /* NAL Unix Header in AVC, refer to Page 56 in JVT X201wcm */
typedef struct TagNalUnitHeader { typedef struct TagNalUnitHeader {
uint8_t uiForbiddenZeroBit; uint8_t uiForbiddenZeroBit;
uint8_t uiNalRefIdc; uint8_t uiNalRefIdc;
ENalUnitType eNalUnitType; ENalUnitType eNalUnitType;
uint8_t uiReservedOneByte; // only padding usage uint8_t uiReservedOneByte; // only padding usage
} SNalUnitHeader, *PNalUnitHeader; } SNalUnitHeader, *PNalUnitHeader;
/* NAL Unit Header in scalable extension syntax, refer to Page 390 in JVT X201wcm */ /* NAL Unit Header in scalable extension syntax, refer to Page 390 in JVT X201wcm */
typedef struct TagNalUnitHeaderExt { typedef struct TagNalUnitHeaderExt {
SNalUnitHeader sNalUnitHeader; SNalUnitHeader sNalUnitHeader;
// uint8_t reserved_one_bit; // uint8_t reserved_one_bit;
bool bIdrFlag; bool bIdrFlag;
uint8_t uiPriorityId; uint8_t uiPriorityId;
int8_t iNoInterLayerPredFlag; // change as int8_t to support 3 values probably in encoder int8_t iNoInterLayerPredFlag; // change as int8_t to support 3 values probably in encoder
uint8_t uiDependencyId; uint8_t uiDependencyId;
uint8_t uiQualityId; uint8_t uiQualityId;
uint8_t uiTemporalId; uint8_t uiTemporalId;
bool bUseRefBasePicFlag; bool bUseRefBasePicFlag;
bool bDiscardableFlag; bool bDiscardableFlag;
bool bOutputFlag; bool bOutputFlag;
uint8_t uiReservedThree2Bits; uint8_t uiReservedThree2Bits;
// Derived variable(s) // Derived variable(s)
uint8_t uiLayerDqId; uint8_t uiLayerDqId;
bool bNalExtFlag; bool bNalExtFlag;
} SNalUnitHeaderExt, *PNalUnitHeaderExt; } SNalUnitHeaderExt, *PNalUnitHeaderExt;
/* Prefix NAL Unix syntax, refer to Page 392 in JVT X201wcm */ /* Prefix NAL Unix syntax, refer to Page 392 in JVT X201wcm */
typedef struct TagPrefixNalUnit { typedef struct TagPrefixNalUnit {
SRefBasePicMarking sRefPicBaseMarking; SRefBasePicMarking sRefPicBaseMarking;
bool bStoreRefBasePicFlag; bool bStoreRefBasePicFlag;
bool bPrefixNalUnitAdditionalExtFlag; bool bPrefixNalUnitAdditionalExtFlag;
bool bPrefixNalUnitExtFlag; bool bPrefixNalUnitExtFlag;
bool bPrefixNalCorrectFlag; bool bPrefixNalCorrectFlag;
} SPrefixNalUnit, *PPrefixNalUnit; } SPrefixNalUnit, *PPrefixNalUnit;
} // namespace WelsDec } // namespace WelsDec

36
codec/decoder/core/inc/nalu.h
View File

@ -45,18 +45,18 @@ namespace WelsDec {
/* NAL Unit Structure */ /* NAL Unit Structure */
typedef struct TagNalUnit { typedef struct TagNalUnit {
SNalUnitHeaderExt sNalHeaderExt; SNalUnitHeaderExt sNalHeaderExt;
union { union {
struct SVclNal { struct SVclNal {
SSliceHeaderExt sSliceHeaderExt; SSliceHeaderExt sSliceHeaderExt;
SBitStringAux sSliceBitsRead; SBitStringAux sSliceBitsRead;
uint8_t* pNalPos; // save the address of slice nal for GPU function uint8_t* pNalPos; // save the address of slice nal for GPU function
int32_t iNalLength; // save the nal length for GPU function int32_t iNalLength; // save the nal length for GPU function
bool bSliceHeaderExtFlag; bool bSliceHeaderExtFlag;
} sVclNal; } sVclNal;
SPrefixNalUnit sPrefixNal; SPrefixNalUnit sPrefixNal;
} sNalData; } sNalData;
} SNalUnit, *PNalUnit; } SNalUnit, *PNalUnit;
@ -64,14 +64,14 @@ typedef struct TagNalUnit {
/* Access Unit structure */ /* Access Unit structure */
typedef struct TagAccessUnits { typedef struct TagAccessUnits {
PNalUnit* pNalUnitsList; // list of NAL Units pointer in this AU PNalUnit* pNalUnitsList; // list of NAL Units pointer in this AU
uint32_t uiAvailUnitsNum; // Number of NAL Units available in each AU list based current bitstream, uint32_t uiAvailUnitsNum; // Number of NAL Units available in each AU list based current bitstream,
uint32_t uiActualUnitsNum; // actual number of NAL units belong to current au uint32_t uiActualUnitsNum; // actual number of NAL units belong to current au
// While available number exceeds count size below, need realloc extra NAL Units for list space. // While available number exceeds count size below, need realloc extra NAL Units for list space.
uint32_t uiCountUnitsNum; // Count size number of malloced NAL Units in each AU list uint32_t uiCountUnitsNum; // Count size number of malloced NAL Units in each AU list
uint32_t uiStartPos; uint32_t uiStartPos;
uint32_t uiEndPos; uint32_t uiEndPos;
bool bCompletedAuFlag; // Indicate whether it is a completed AU bool bCompletedAuFlag; // Indicate whether it is a completed AU
} SAccessUnit, *PAccessUnit; } SAccessUnit, *PAccessUnit;
} // namespace WelsDec } // namespace WelsDec

180
codec/decoder/core/inc/parameter_sets.h
View File

@ -40,66 +40,66 @@
namespace WelsDec { namespace WelsDec {
typedef struct TagLevelLimits { typedef struct TagLevelLimits {
int32_t iMaxMBPS; // Max macroblock processing rate(MB/s) int32_t iMaxMBPS; // Max macroblock processing rate(MB/s)
int32_t iMaxFS; // Max frame sizea(MBs) int32_t iMaxFS; // Max frame sizea(MBs)
int32_t iMaxDPBMbs;// Max decoded picture buffer size(MBs) int32_t iMaxDPBMbs;// Max decoded picture buffer size(MBs)
int32_t iMaxBR; // Max video bit rate int32_t iMaxBR; // Max video bit rate
int32_t iMaxCPB; // Max CPB size int32_t iMaxCPB; // Max CPB size
int16_t iMinVmv; // Vertical MV component range upper bound int16_t iMinVmv; // Vertical MV component range upper bound
int16_t iMaxVmv; // Vertical MV component range lower bound int16_t iMaxVmv; // Vertical MV component range lower bound
int16_t iMinCR; // Min compression ration int16_t iMinCR; // Min compression ration
int16_t iMaxMvsPer2Mb; // Max number of motion vectors per two consecutive MBs int16_t iMaxMvsPer2Mb; // Max number of motion vectors per two consecutive MBs
} SLevelLimits; } SLevelLimits;
/* Sequence Parameter Set, refer to Page 57 in JVT X201wcm */ /* Sequence Parameter Set, refer to Page 57 in JVT X201wcm */
typedef struct TagSps { typedef struct TagSps {
int32_t iSpsId; int32_t iSpsId;
uint32_t iMbWidth; uint32_t iMbWidth;
uint32_t iMbHeight; uint32_t iMbHeight;
uint32_t uiTotalMbCount; //used in decode_slice_data() uint32_t uiTotalMbCount; //used in decode_slice_data()
uint32_t uiLog2MaxFrameNum; uint32_t uiLog2MaxFrameNum;
uint32_t uiPocType; uint32_t uiPocType;
/* POC type 0 */ /* POC type 0 */
int32_t iLog2MaxPocLsb; int32_t iLog2MaxPocLsb;
/* POC type 1 */ /* POC type 1 */
int32_t iOffsetForNonRefPic; int32_t iOffsetForNonRefPic;
int32_t iOffsetForTopToBottomField; int32_t iOffsetForTopToBottomField;
int32_t iNumRefFramesInPocCycle; int32_t iNumRefFramesInPocCycle;
int8_t iOffsetForRefFrame[256]; int8_t iOffsetForRefFrame[256];
int32_t iNumRefFrames; int32_t iNumRefFrames;
SPosOffset sFrameCrop; SPosOffset sFrameCrop;
ProfileIdc uiProfileIdc; ProfileIdc uiProfileIdc;
uint8_t uiLevelIdc; uint8_t uiLevelIdc;
uint8_t uiChromaFormatIdc; uint8_t uiChromaFormatIdc;
uint8_t uiChromaArrayType; uint8_t uiChromaArrayType;
uint8_t uiBitDepthLuma; uint8_t uiBitDepthLuma;
uint8_t uiBitDepthChroma; uint8_t uiBitDepthChroma;
/* TO BE CONTINUE: POC type 1 */ /* TO BE CONTINUE: POC type 1 */
bool bDeltaPicOrderAlwaysZeroFlag; bool bDeltaPicOrderAlwaysZeroFlag;
bool bGapsInFrameNumValueAllowedFlag; bool bGapsInFrameNumValueAllowedFlag;
bool bFrameMbsOnlyFlag; bool bFrameMbsOnlyFlag;
bool bMbaffFlag; // MB Adapative Frame Field bool bMbaffFlag; // MB Adapative Frame Field
bool bDirect8x8InferenceFlag; bool bDirect8x8InferenceFlag;
bool bFrameCroppingFlag; bool bFrameCroppingFlag;
bool bVuiParamPresentFlag; bool bVuiParamPresentFlag;
// bool bTimingInfoPresentFlag; // bool bTimingInfoPresentFlag;
// bool bFixedFrameRateFlag; // bool bFixedFrameRateFlag;
bool bConstraintSet0Flag; bool bConstraintSet0Flag;
bool bConstraintSet1Flag; bool bConstraintSet1Flag;
bool bConstraintSet2Flag; bool bConstraintSet2Flag;
bool bConstraintSet3Flag; bool bConstraintSet3Flag;
bool bSeparateColorPlaneFlag; bool bSeparateColorPlaneFlag;
bool bQpPrimeYZeroTransfBypassFlag; bool bQpPrimeYZeroTransfBypassFlag;
bool bSeqScalingMatrixPresentFlag; bool bSeqScalingMatrixPresentFlag;
bool bSeqScalingListPresentFlag[12]; bool bSeqScalingListPresentFlag[12];
const SLevelLimits* pSLevelLimits; const SLevelLimits* pSLevelLimits;
} SSps, *PSps; } SSps, *PSps;
@ -117,63 +117,63 @@ typedef struct TagSps {
/* Sequence Parameter Set extension syntax, refer to Page 391 in JVT X201wcm */ /* Sequence Parameter Set extension syntax, refer to Page 391 in JVT X201wcm */
typedef struct TagSpsSvcExt { typedef struct TagSpsSvcExt {
SPosOffset sSeqScaledRefLayer; SPosOffset sSeqScaledRefLayer;
uint8_t uiExtendedSpatialScalability; // ESS uint8_t uiExtendedSpatialScalability; // ESS
uint8_t uiChromaPhaseXPlus1Flag; uint8_t uiChromaPhaseXPlus1Flag;
uint8_t uiChromaPhaseYPlus1; uint8_t uiChromaPhaseYPlus1;
uint8_t uiSeqRefLayerChromaPhaseXPlus1Flag; uint8_t uiSeqRefLayerChromaPhaseXPlus1Flag;
uint8_t uiSeqRefLayerChromaPhaseYPlus1; uint8_t uiSeqRefLayerChromaPhaseYPlus1;
bool bInterLayerDeblockingFilterCtrlPresentFlag; bool bInterLayerDeblockingFilterCtrlPresentFlag;
bool bSeqTCoeffLevelPredFlag; bool bSeqTCoeffLevelPredFlag;
bool bAdaptiveTCoeffLevelPredFlag; bool bAdaptiveTCoeffLevelPredFlag;
bool bSliceHeaderRestrictionFlag; bool bSliceHeaderRestrictionFlag;
} SSpsSvcExt, *PSpsSvcExt; } SSpsSvcExt, *PSpsSvcExt;
/* Subset sequence parameter set syntax, refer to Page 391 in JVT X201wcm */ /* Subset sequence parameter set syntax, refer to Page 391 in JVT X201wcm */
typedef struct TagSubsetSps { typedef struct TagSubsetSps {
SSps sSps; SSps sSps;
SSpsSvcExt sSpsSvcExt; SSpsSvcExt sSpsSvcExt;
bool bSvcVuiParamPresentFlag; bool bSvcVuiParamPresentFlag;
bool bAdditionalExtension2Flag; bool bAdditionalExtension2Flag;
bool bAdditionalExtension2DataFlag; bool bAdditionalExtension2DataFlag;
} SSubsetSps, *PSubsetSps; } SSubsetSps, *PSubsetSps;
/* Picture parameter set syntax, refer to Page 59 in JVT X201wcm */ /* Picture parameter set syntax, refer to Page 59 in JVT X201wcm */
typedef struct TagPps { typedef struct TagPps {
int32_t iSpsId; int32_t iSpsId;
int32_t iPpsId; int32_t iPpsId;
uint32_t uiNumSliceGroups; uint32_t uiNumSliceGroups;
uint32_t uiSliceGroupMapType; uint32_t uiSliceGroupMapType;
/* slice_group_map_type = 0 */ /* slice_group_map_type = 0 */
uint32_t uiRunLength[MAX_SLICEGROUP_IDS]; uint32_t uiRunLength[MAX_SLICEGROUP_IDS];
/* slice_group_map_type = 2 */ /* slice_group_map_type = 2 */
uint32_t uiTopLeft[MAX_SLICEGROUP_IDS]; uint32_t uiTopLeft[MAX_SLICEGROUP_IDS];
uint32_t uiBottomRight[MAX_SLICEGROUP_IDS]; uint32_t uiBottomRight[MAX_SLICEGROUP_IDS];
/* slice_group_map_type = 3, 4 or 5 */ /* slice_group_map_type = 3, 4 or 5 */
uint32_t uiSliceGroupChangeRate; uint32_t uiSliceGroupChangeRate;
/* slice_group_map_type = 6 */ /* slice_group_map_type = 6 */
uint32_t uiPicSizeInMapUnits; uint32_t uiPicSizeInMapUnits;
uint32_t uiSliceGroupId[MAX_SLICEGROUP_IDS]; uint32_t uiSliceGroupId[MAX_SLICEGROUP_IDS];
uint32_t uiNumRefIdxL0Active; uint32_t uiNumRefIdxL0Active;
uint32_t uiNumRefIdxL1Active; uint32_t uiNumRefIdxL1Active;
int32_t iPicInitQp; int32_t iPicInitQp;
int32_t iPicInitQs; int32_t iPicInitQs;
int32_t iChromaQpIndexOffset; int32_t iChromaQpIndexOffset;
bool bEntropyCodingModeFlag; bool bEntropyCodingModeFlag;
bool bPicOrderPresentFlag; bool bPicOrderPresentFlag;
/* slice_group_map_type = 3, 4 or 5 */ /* slice_group_map_type = 3, 4 or 5 */
bool bSliceGroupChangeDirectionFlag; bool bSliceGroupChangeDirectionFlag;
bool bDeblockingFilterControlPresentFlag; bool bDeblockingFilterControlPresentFlag;
bool bConstainedIntraPredFlag; bool bConstainedIntraPredFlag;
bool bRedundantPicCntPresentFlag; bool bRedundantPicCntPresentFlag;
bool bWeightedPredFlag; bool bWeightedPredFlag;
uint8_t uiWeightedBipredIdc; uint8_t uiWeightedBipredIdc;
} SPps, *PPps; } SPps, *PPps;

88
codec/decoder/core/inc/parse_mb_syn_cavlc.h
View File

@ -56,82 +56,82 @@ namespace WelsDec {
#define CHROMA_AC 5 #define CHROMA_AC 5
typedef struct TagReadBitsCache { typedef struct TagReadBitsCache {
uint32_t uiCache32Bit; uint32_t uiCache32Bit;
uint8_t uiRemainBits; uint8_t uiRemainBits;
uint8_t* pBuf; uint8_t* pBuf;
} SReadBitsCache; } SReadBitsCache;
#define SHIFT_BUFFER(pBitsCache) { pBitsCache->pBuf+=2; pBitsCache->uiRemainBits += 16; pBitsCache->uiCache32Bit |= (((pBitsCache->pBuf[2] << 8) | pBitsCache->pBuf[3]) << (32 - pBitsCache->uiRemainBits)); } #define SHIFT_BUFFER(pBitsCache) { pBitsCache->pBuf+=2; pBitsCache->uiRemainBits += 16; pBitsCache->uiCache32Bit |= (((pBitsCache->pBuf[2] << 8) | pBitsCache->pBuf[3]) << (32 - pBitsCache->uiRemainBits)); }
#define POP_BUFFER(pBitsCache, iCount) { pBitsCache->uiCache32Bit <<= iCount; pBitsCache->uiRemainBits -= iCount; } #define POP_BUFFER(pBitsCache, iCount) { pBitsCache->uiCache32Bit <<= iCount; pBitsCache->uiRemainBits -= iCount; }
static const uint8_t g_kuiZigzagScan[16] = { //4*4block residual zig-zag scan order static const uint8_t g_kuiZigzagScan[16] = { //4*4block residual zig-zag scan order
0, 1, 4, 8, 0, 1, 4, 8,
5, 2, 3, 6, 5, 2, 3, 6,
9, 12, 13, 10, 9, 12, 13, 10,
7, 11, 14, 15, 7, 11, 14, 15,
}; };
typedef struct TagI16PredInfo { typedef struct TagI16PredInfo {
int8_t iPredMode; int8_t iPredMode;
int8_t iLeftAvail; int8_t iLeftAvail;
int8_t iTopAvail; int8_t iTopAvail;
int8_t iLeftTopAvail; int8_t iLeftTopAvail;
} SI16PredInfo; } SI16PredInfo;
static const SI16PredInfo g_ksI16PredInfo[4] = { static const SI16PredInfo g_ksI16PredInfo[4] = {
{I16_PRED_V, 0, 1, 0}, {I16_PRED_V, 0, 1, 0},
{I16_PRED_H, 1, 0, 0}, {I16_PRED_H, 1, 0, 0},
{ 0, 0, 0, 0}, { 0, 0, 0, 0},
{I16_PRED_P, 1, 1, 1}, {I16_PRED_P, 1, 1, 1},
}; };
static const SI16PredInfo g_ksChromaPredInfo[4] = { static const SI16PredInfo g_ksChromaPredInfo[4] = {
{ 0, 0, 0, 0}, { 0, 0, 0, 0},
{C_PRED_H, 1, 0, 0}, {C_PRED_H, 1, 0, 0},
{C_PRED_V, 0, 1, 0}, {C_PRED_V, 0, 1, 0},
{C_PRED_P, 1, 1, 1}, {C_PRED_P, 1, 1, 1},
}; };
typedef struct TagI4PredInfo { typedef struct TagI4PredInfo {
int8_t iPredMode; int8_t iPredMode;
int8_t iLeftAvail; int8_t iLeftAvail;
int8_t iTopAvail; int8_t iTopAvail;
int8_t iLeftTopAvail; int8_t iLeftTopAvail;
// int8_t right_top_avail; //when right_top unavailable but top avail, we can pad the right-top with the rightmost pixel of top // int8_t right_top_avail; //when right_top unavailable but top avail, we can pad the right-top with the rightmost pixel of top
} SI4PredInfo; } SI4PredInfo;
static const SI4PredInfo g_ksI4PredInfo[9] = { static const SI4PredInfo g_ksI4PredInfo[9] = {
{ I4_PRED_V, 0, 1, 0}, { I4_PRED_V, 0, 1, 0},
{ I4_PRED_H, 1, 0, 0}, { I4_PRED_H, 1, 0, 0},
{ 0, 0, 0, 0}, { 0, 0, 0, 0},
{I4_PRED_DDL, 0, 1, 0}, {I4_PRED_DDL, 0, 1, 0},
{I4_PRED_DDR, 1, 1, 1}, {I4_PRED_DDR, 1, 1, 1},
{ I4_PRED_VR, 1, 1, 1}, { I4_PRED_VR, 1, 1, 1},
{ I4_PRED_HD, 1, 1, 1}, { I4_PRED_HD, 1, 1, 1},
{ I4_PRED_VL, 0, 1, 0}, { I4_PRED_VL, 0, 1, 0},
{ I4_PRED_HU, 1, 0, 0}, { I4_PRED_HU, 1, 0, 0},
}; };
static const uint8_t g_kuiI16CbpTable[6] = {0, 16, 32, 15, 31, 47}; //reference to JM static const uint8_t g_kuiI16CbpTable[6] = {0, 16, 32, 15, 31, 47}; //reference to JM
typedef struct TagPartMbInfo { typedef struct TagPartMbInfo {
MbType iType; MbType iType;
int8_t iPartCount; //P_16*16, P_16*8, P_8*16, P_8*8 based on 8*8 block; P_8*4, P_4*8, P_4*4 based on 4*4 block int8_t iPartCount; //P_16*16, P_16*8, P_8*16, P_8*8 based on 8*8 block; P_8*4, P_4*8, P_4*4 based on 4*4 block
int8_t iPartWidth; //based on 4*4 block int8_t iPartWidth; //based on 4*4 block
} SPartMbInfo; } SPartMbInfo;
static const SPartMbInfo g_ksInterMbTypeInfo[5] = { static const SPartMbInfo g_ksInterMbTypeInfo[5] = {
{MB_TYPE_16x16, 1, 4}, {MB_TYPE_16x16, 1, 4},
{MB_TYPE_16x8, 2, 4}, {MB_TYPE_16x8, 2, 4},
{MB_TYPE_8x16, 2, 2}, {MB_TYPE_8x16, 2, 2},
{MB_TYPE_8x8, 4, 4}, {MB_TYPE_8x8, 4, 4},
{MB_TYPE_8x8_REF0, 4, 4}, //ref0--ref_idx not present in bit-stream and default as 0 {MB_TYPE_8x8_REF0, 4, 4}, //ref0--ref_idx not present in bit-stream and default as 0
}; };
static const SPartMbInfo g_ksInterSubMbTypeInfo[4] = { static const SPartMbInfo g_ksInterSubMbTypeInfo[4] = {
{SUB_MB_TYPE_8x8, 1, 2}, {SUB_MB_TYPE_8x8, 1, 2},
{SUB_MB_TYPE_8x4, 2, 2}, {SUB_MB_TYPE_8x4, 2, 2},
{SUB_MB_TYPE_4x8, 2, 1}, {SUB_MB_TYPE_4x8, 2, 1},
{SUB_MB_TYPE_4x4, 4, 1}, {SUB_MB_TYPE_4x4, 4, 1},
}; };
void GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer); void GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer);

6
codec/decoder/core/inc/pic_queue.h
View File

@ -43,9 +43,9 @@ namespace WelsDec {
typedef struct TagPicBuff { typedef struct TagPicBuff {
PPicture* ppPic; PPicture* ppPic;
int32_t iCapacity; // capacity size of queue int32_t iCapacity; // capacity size of queue
int32_t iCurrentIdx; int32_t iCurrentIdx;
} SPicBuff, *PPicBuff; } SPicBuff, *PPicBuff;
/* /*

48
codec/decoder/core/inc/picture.h
View File

@ -43,36 +43,36 @@ namespace WelsDec {
* It is used to express reference picture, also consequent reconstruction picture for output * It is used to express reference picture, also consequent reconstruction picture for output
*/ */
typedef struct TagPicture { typedef struct TagPicture {
/************************************payload data*********************************/ /************************************payload data*********************************/
uint8_t* pBuffer[4]; // pointer to the first allocated byte, basical offset of buffer, dimension: uint8_t* pBuffer[4]; // pointer to the first allocated byte, basical offset of buffer, dimension:
uint8_t* pData[4]; // pointer to picture planes respectively uint8_t* pData[4]; // pointer to picture planes respectively
int32_t iLinesize[4];// linesize of picture planes respectively used currently int32_t iLinesize[4];// linesize of picture planes respectively used currently
int32_t iPlanes; // How many planes are introduced due to color space format? int32_t iPlanes; // How many planes are introduced due to color space format?
// picture information // picture information
/*******************************from other standard syntax****************************/ /*******************************from other standard syntax****************************/
/*from sps*/ /*from sps*/
int32_t iWidthInPixel; // picture width in pixel int32_t iWidthInPixel; // picture width in pixel
int32_t iHeightInPixel;// picture height in pixel int32_t iHeightInPixel;// picture height in pixel
/*from slice header*/ /*from slice header*/
int32_t iFramePoc; // frame POC int32_t iFramePoc; // frame POC
/*******************************sef_definition for misc use****************************/ /*******************************sef_definition for misc use****************************/
bool bUsedAsRef; //for ref pic management bool bUsedAsRef; //for ref pic management
bool bIsLongRef; // long term reference frame flag //for ref pic management bool bIsLongRef; // long term reference frame flag //for ref pic management
uint8_t uiRefCount; uint8_t uiRefCount;
bool bAvailableFlag; // indicate whether it is available in this picture memory block. bool bAvailableFlag; // indicate whether it is available in this picture memory block.
/*******************************for future use****************************/ /*******************************for future use****************************/
uint8_t uiTemporalId; uint8_t uiTemporalId;
uint8_t uiSpatialId; uint8_t uiSpatialId;
uint8_t uiQualityId; uint8_t uiQualityId;
int32_t iFrameNum; // frame number //for ref pic management int32_t iFrameNum; // frame number //for ref pic management
int32_t iLongTermFrameIdx; //id for long term ref pic int32_t iLongTermFrameIdx; //id for long term ref pic
int32_t iSpsId; //against mosaic caused by cross-IDR interval reference. int32_t iSpsId; //against mosaic caused by cross-IDR interval reference.
int32_t iPpsId; int32_t iPpsId;
} SPicture, *PPicture; // "Picture" declaration is comflict with Mac system } SPicture, *PPicture; // "Picture" declaration is comflict with Mac system
} // namespace WelsDec } // namespace WelsDec

220
codec/decoder/core/inc/slice.h
View File

@ -46,157 +46,157 @@ namespace WelsDec {
* Reference picture list reordering syntax, refer to page 64 in JVT X201wcm * Reference picture list reordering syntax, refer to page 64 in JVT X201wcm
*/ */
typedef struct TagRefPicListReorderSyntax { typedef struct TagRefPicListReorderSyntax {
struct { struct {
uint32_t uiAbsDiffPicNumMinus1; uint32_t uiAbsDiffPicNumMinus1;
uint16_t uiLongTermPicNum; uint16_t uiLongTermPicNum;
uint16_t uiReorderingOfPicNumsIdc; uint16_t uiReorderingOfPicNumsIdc;
} sReorderingSyn[LIST_A][MAX_REF_PIC_COUNT]; } sReorderingSyn[LIST_A][MAX_REF_PIC_COUNT];
bool bRefPicListReorderingFlag[LIST_A]; bool bRefPicListReorderingFlag[LIST_A];
} SRefPicListReorderSyn, *PRefPicListReorderSyn; } SRefPicListReorderSyn, *PRefPicListReorderSyn;
/* /*
* Prediction weight table syntax, refer to page 65 in JVT X201wcm * Prediction weight table syntax, refer to page 65 in JVT X201wcm
*/ */
typedef struct TagPredWeightTabSyntax { typedef struct TagPredWeightTabSyntax {
uint32_t uiLumaLog2WeightDenom; uint32_t uiLumaLog2WeightDenom;
uint32_t uiChromaLog2WeightDenom; uint32_t uiChromaLog2WeightDenom;
struct { struct {
int32_t iLumaWeight[MAX_REF_PIC_COUNT]; int32_t iLumaWeight[MAX_REF_PIC_COUNT];
int32_t iLumaOffset[MAX_REF_PIC_COUNT]; int32_t iLumaOffset[MAX_REF_PIC_COUNT];
int32_t iChromaWeight[MAX_REF_PIC_COUNT][2]; int32_t iChromaWeight[MAX_REF_PIC_COUNT][2];
int32_t iChromaOffset[MAX_REF_PIC_COUNT][2]; int32_t iChromaOffset[MAX_REF_PIC_COUNT][2];
bool bLumaWeightFlag; bool bLumaWeightFlag;
bool bChromaWeightFlag; bool bChromaWeightFlag;
} sPredList[LIST_A]; } sPredList[LIST_A];
} SPredWeightTabSyn; } SPredWeightTabSyn;
/* Decoded reference picture marking syntax, refer to Page 66 in JVT X201wcm */ /* Decoded reference picture marking syntax, refer to Page 66 in JVT X201wcm */
typedef struct TagRefPicMarking { typedef struct TagRefPicMarking {
struct { struct {
uint32_t uiMmcoType; uint32_t uiMmcoType;
int32_t iShortFrameNum; int32_t iShortFrameNum;
int32_t iDiffOfPicNum; int32_t iDiffOfPicNum;
uint32_t uiLongTermPicNum; uint32_t uiLongTermPicNum;
int32_t iLongTermFrameIdx; int32_t iLongTermFrameIdx;
int32_t iMaxLongTermFrameIdx; int32_t iMaxLongTermFrameIdx;
} sMmcoRef[MAX_MMCO_COUNT]; } sMmcoRef[MAX_MMCO_COUNT];
bool bNoOutputOfPriorPicsFlag; bool bNoOutputOfPriorPicsFlag;
bool bLongTermRefFlag; bool bLongTermRefFlag;
bool bAdaptiveRefPicMarkingModeFlag; bool bAdaptiveRefPicMarkingModeFlag;
} SRefPicMarking, *PRefPicMarking; } SRefPicMarking, *PRefPicMarking;
/* Decode reference base picture marking syntax in Page 396 of JVT X201wcm */ /* Decode reference base picture marking syntax in Page 396 of JVT X201wcm */
typedef struct TagRefBasePicMarkingSyn { typedef struct TagRefBasePicMarkingSyn {
struct { struct {
uint32_t uiMmcoType; uint32_t uiMmcoType;
int32_t iShortFrameNum; int32_t iShortFrameNum;
uint32_t uiDiffOfPicNums; uint32_t uiDiffOfPicNums;
uint32_t uiLongTermPicNum; //should uint32_t, cover larger range of iFrameNum. uint32_t uiLongTermPicNum; //should uint32_t, cover larger range of iFrameNum.
} mmco_base[MAX_MMCO_COUNT]; // MAX_REF_PIC for reference picture based on frame } mmco_base[MAX_MMCO_COUNT]; // MAX_REF_PIC for reference picture based on frame
bool bAdaptiveRefBasePicMarkingModeFlag; bool bAdaptiveRefBasePicMarkingModeFlag;
} SRefBasePicMarking, *PRefBasePicMarking; } SRefBasePicMarking, *PRefBasePicMarking;
/* Header of slice syntax elements, refer to Page 63 in JVT X201wcm */ /* Header of slice syntax elements, refer to Page 63 in JVT X201wcm */
typedef struct TagSliceHeaders { typedef struct TagSliceHeaders {
/*****************************slice header syntax and generated****************************/ /*****************************slice header syntax and generated****************************/
int32_t iFirstMbInSlice; int32_t iFirstMbInSlice;
int32_t iFrameNum; int32_t iFrameNum;
int32_t iPicOrderCntLsb; int32_t iPicOrderCntLsb;
int32_t iDeltaPicOrderCntBottom; int32_t iDeltaPicOrderCntBottom;
int32_t iDeltaPicOrderCnt[2]; int32_t iDeltaPicOrderCnt[2];
int32_t iRedundantPicCnt; int32_t iRedundantPicCnt;
int32_t uiRefCount[LIST_A]; int32_t uiRefCount[LIST_A];
int32_t iSliceQpDelta; //no use for iSliceQp is used directly int32_t iSliceQpDelta; //no use for iSliceQp is used directly
int32_t iSliceQp; int32_t iSliceQp;
int32_t iSliceQsDelta; // For SP/SI slices int32_t iSliceQsDelta; // For SP/SI slices
uint32_t uiDisableDeblockingFilterIdc; uint32_t uiDisableDeblockingFilterIdc;
int32_t iSliceAlphaC0Offset; int32_t iSliceAlphaC0Offset;
int32_t iSliceBetaOffset; int32_t iSliceBetaOffset;
int32_t iSliceGroupChangeCycle; int32_t iSliceGroupChangeCycle;
PSps pSps; PSps pSps;
PPps pPps; PPps pPps;
int32_t iSpsId; int32_t iSpsId;
int32_t iPpsId; int32_t iPpsId;
/*********************got from other layer for efficency if possible*********************/ /*********************got from other layer for efficency if possible*********************/
SRefPicListReorderSyn pRefPicListReordering; // Reference picture list reordering syntaxs SRefPicListReorderSyn pRefPicListReordering; // Reference picture list reordering syntaxs
SPredWeightTabSyn sPredWeightTable; SPredWeightTabSyn sPredWeightTable;
int32_t iCabacInitIdc; int32_t iCabacInitIdc;
int32_t iMbWidth; //from? int32_t iMbWidth; //from?
int32_t iMbHeight; //from? int32_t iMbHeight; //from?
SRefPicMarking sRefMarking; // Decoded reference picture marking syntaxs SRefPicMarking sRefMarking; // Decoded reference picture marking syntaxs
uint16_t uiIdrPicId; uint16_t uiIdrPicId;
ESliceType eSliceType; ESliceType eSliceType;
bool bNumRefIdxActiveOverrideFlag; bool bNumRefIdxActiveOverrideFlag;
bool bFieldPicFlag; //not supported in base profile bool bFieldPicFlag; //not supported in base profile
bool bBottomFiledFlag; //not supported in base profile bool bBottomFiledFlag; //not supported in base profile
uint8_t uiPadding1Byte; uint8_t uiPadding1Byte;
bool bSpForSwitchFlag; // For SP/SI slices bool bSpForSwitchFlag; // For SP/SI slices
int16_t iPadding2Bytes; int16_t iPadding2Bytes;
} SSliceHeader, *PSliceHeader; } SSliceHeader, *PSliceHeader;
/* Slice header in scalable extension syntax, refer to Page 394 in JVT X201wcm */ /* Slice header in scalable extension syntax, refer to Page 394 in JVT X201wcm */
typedef struct TagSliceHeaderExt { typedef struct TagSliceHeaderExt {
SSliceHeader sSliceHeader; SSliceHeader sSliceHeader;
PSubsetSps pSubsetSps; PSubsetSps pSubsetSps;
uint32_t uiNumMbsInSlice; uint32_t uiNumMbsInSlice;
uint32_t uiDisableInterLayerDeblockingFilterIdc; uint32_t uiDisableInterLayerDeblockingFilterIdc;
int32_t iInterLayerSliceAlphaC0Offset; int32_t iInterLayerSliceAlphaC0Offset;
int32_t iInterLayerSliceBetaOffset; int32_t iInterLayerSliceBetaOffset;
//SPosOffset sScaledRefLayer; //SPosOffset sScaledRefLayer;
int32_t iScaledRefLayerPicWidthInSampleLuma; int32_t iScaledRefLayerPicWidthInSampleLuma;
int32_t iScaledRefLayerPicHeightInSampleLuma; int32_t iScaledRefLayerPicHeightInSampleLuma;
SRefBasePicMarking sRefBasePicMarking; SRefBasePicMarking sRefBasePicMarking;
bool bBasePredWeightTableFlag; bool bBasePredWeightTableFlag;
bool bStoreRefBasePicFlag; bool bStoreRefBasePicFlag;
bool bConstrainedIntraResamplingFlag; bool bConstrainedIntraResamplingFlag;
bool bSliceSkipFlag; bool bSliceSkipFlag;
bool bAdaptiveBaseModeFlag; bool bAdaptiveBaseModeFlag;
bool bDefaultBaseModeFlag; bool bDefaultBaseModeFlag;
bool bAdaptiveMotionPredFlag; bool bAdaptiveMotionPredFlag;
bool bDefaultMotionPredFlag; bool bDefaultMotionPredFlag;
bool bAdaptiveResidualPredFlag; bool bAdaptiveResidualPredFlag;
bool bDefaultResidualPredFlag; bool bDefaultResidualPredFlag;
bool bTCoeffLevelPredFlag; bool bTCoeffLevelPredFlag;
uint8_t uiRefLayerChromaPhaseXPlus1Flag; uint8_t uiRefLayerChromaPhaseXPlus1Flag;
uint8_t uiRefLayerChromaPhaseYPlus1; uint8_t uiRefLayerChromaPhaseYPlus1;
uint8_t uiRefLayerDqId; uint8_t uiRefLayerDqId;
uint8_t uiScanIdxStart; uint8_t uiScanIdxStart;
uint8_t uiScanIdxEnd; uint8_t uiScanIdxEnd;
} SSliceHeaderExt, *PSliceHeaderExt; } SSliceHeaderExt, *PSliceHeaderExt;
typedef struct TagSlice { typedef struct TagSlice {
/*******************************slice_header****************************/ /*******************************slice_header****************************/
SSliceHeaderExt sSliceHeaderExt; SSliceHeaderExt sSliceHeaderExt;
/*******************************use for future****************************/ /*******************************use for future****************************/
// for Macroblock coding within slice // for Macroblock coding within slice
int32_t iLastMbQp; // stored qp for last mb coded, maybe more efficient for mb skip detection etc. int32_t iLastMbQp; // stored qp for last mb coded, maybe more efficient for mb skip detection etc.
/*******************************slice_data****************************/ /*******************************slice_data****************************/
/*slice_data_ext()*/ /*slice_data_ext()*/
int32_t iMbSkipRun; int32_t iMbSkipRun;
int32_t iTotalMbInCurSlice; //record the total number of MB in current slice. int32_t iTotalMbInCurSlice; //record the total number of MB in current slice.
/*slice_data_ext() generate*/ /*slice_data_ext() generate*/
/*******************************misc use****************************/ /*******************************misc use****************************/
bool bSliceHeaderExtFlag; // Indicate which slice header is used, avc or ext? bool bSliceHeaderExtFlag; // Indicate which slice header is used, avc or ext?
/*************got from other layer for effiency if possible***************/ /*************got from other layer for effiency if possible***************/
/*from lower layer: slice header*/ /*from lower layer: slice header*/
uint8_t eSliceType; uint8_t eSliceType;
uint8_t uiPadding[2]; uint8_t uiPadding[2];
} SSlice, *PSlice; } SSlice, *PSlice;
} // namespace WelsDec } // namespace WelsDec

100
codec/decoder/core/inc/vlc_decoder.h
View File

@ -39,10 +39,10 @@
namespace WelsDec { namespace WelsDec {
typedef struct TagVlcTable { typedef struct TagVlcTable {
const uint8_t (*kpCoeffTokenVlcTable[4][8])[2]; const uint8_t (*kpCoeffTokenVlcTable[4][8])[2];
const uint8_t (*kpChromaCoeffTokenVlcTable)[2]; const uint8_t (*kpChromaCoeffTokenVlcTable)[2];
const uint8_t (*kpZeroTable[7])[2]; const uint8_t (*kpZeroTable[7])[2];
const uint8_t (*kpTotalZerosTable[2][15])[2]; const uint8_t (*kpTotalZerosTable[2][15])[2];
} SVlcTable; } SVlcTable;
// for data sharing cross modules and try to reduce size of binary generated // for data sharing cross modules and try to reduce size of binary generated
@ -117,58 +117,58 @@ extern const uint8_t g_kuiZeroLeftBitNumMap[16];
#endif #endif
static inline void InitVlcTable (SVlcTable* pVlcTable) { static inline void InitVlcTable (SVlcTable* pVlcTable) {
pVlcTable->kpChromaCoeffTokenVlcTable = g_kuiVlcChromaTable; pVlcTable->kpChromaCoeffTokenVlcTable = g_kuiVlcChromaTable;
pVlcTable->kpCoeffTokenVlcTable[0][0] = g_kuiVlcTable_0; pVlcTable->kpCoeffTokenVlcTable[0][0] = g_kuiVlcTable_0;
pVlcTable->kpCoeffTokenVlcTable[0][1] = g_kuiVlcTable_1; pVlcTable->kpCoeffTokenVlcTable[0][1] = g_kuiVlcTable_1;
pVlcTable->kpCoeffTokenVlcTable[0][2] = g_kuiVlcTable_2; pVlcTable->kpCoeffTokenVlcTable[0][2] = g_kuiVlcTable_2;
pVlcTable->kpCoeffTokenVlcTable[0][3] = g_kuiVlcTable_3; pVlcTable->kpCoeffTokenVlcTable[0][3] = g_kuiVlcTable_3;
pVlcTable->kpCoeffTokenVlcTable[1][0] = g_kuiVlcTable_0_0; pVlcTable->kpCoeffTokenVlcTable[1][0] = g_kuiVlcTable_0_0;
pVlcTable->kpCoeffTokenVlcTable[1][1] = g_kuiVlcTable_0_1; pVlcTable->kpCoeffTokenVlcTable[1][1] = g_kuiVlcTable_0_1;
pVlcTable->kpCoeffTokenVlcTable[1][2] = g_kuiVlcTable_0_2; pVlcTable->kpCoeffTokenVlcTable[1][2] = g_kuiVlcTable_0_2;
pVlcTable->kpCoeffTokenVlcTable[1][3] = g_kuiVlcTable_0_3; pVlcTable->kpCoeffTokenVlcTable[1][3] = g_kuiVlcTable_0_3;
pVlcTable->kpCoeffTokenVlcTable[2][0] = g_kuiVlcTable_1_0; pVlcTable->kpCoeffTokenVlcTable[2][0] = g_kuiVlcTable_1_0;
pVlcTable->kpCoeffTokenVlcTable[2][1] = g_kuiVlcTable_1_1; pVlcTable->kpCoeffTokenVlcTable[2][1] = g_kuiVlcTable_1_1;
pVlcTable->kpCoeffTokenVlcTable[2][2] = g_kuiVlcTable_1_2; pVlcTable->kpCoeffTokenVlcTable[2][2] = g_kuiVlcTable_1_2;
pVlcTable->kpCoeffTokenVlcTable[2][3] = g_kuiVlcTable_1_3; pVlcTable->kpCoeffTokenVlcTable[2][3] = g_kuiVlcTable_1_3;
pVlcTable->kpCoeffTokenVlcTable[3][0] = g_kuiVlcTable_2_0; pVlcTable->kpCoeffTokenVlcTable[3][0] = g_kuiVlcTable_2_0;
pVlcTable->kpCoeffTokenVlcTable[3][1] = g_kuiVlcTable_2_1; pVlcTable->kpCoeffTokenVlcTable[3][1] = g_kuiVlcTable_2_1;
pVlcTable->kpCoeffTokenVlcTable[3][2] = g_kuiVlcTable_2_2; pVlcTable->kpCoeffTokenVlcTable[3][2] = g_kuiVlcTable_2_2;
pVlcTable->kpCoeffTokenVlcTable[3][3] = g_kuiVlcTable_2_3; pVlcTable->kpCoeffTokenVlcTable[3][3] = g_kuiVlcTable_2_3;
pVlcTable->kpCoeffTokenVlcTable[3][4] = g_kuiVlcTable_2_4; pVlcTable->kpCoeffTokenVlcTable[3][4] = g_kuiVlcTable_2_4;
pVlcTable->kpCoeffTokenVlcTable[3][5] = g_kuiVlcTable_2_5; pVlcTable->kpCoeffTokenVlcTable[3][5] = g_kuiVlcTable_2_5;
pVlcTable->kpCoeffTokenVlcTable[3][6] = g_kuiVlcTable_2_6; pVlcTable->kpCoeffTokenVlcTable[3][6] = g_kuiVlcTable_2_6;
pVlcTable->kpCoeffTokenVlcTable[3][7] = g_kuiVlcTable_2_7; pVlcTable->kpCoeffTokenVlcTable[3][7] = g_kuiVlcTable_2_7;
pVlcTable->kpZeroTable[0] = g_kuiZeroLeftTable0; pVlcTable->kpZeroTable[0] = g_kuiZeroLeftTable0;
pVlcTable->kpZeroTable[1] = g_kuiZeroLeftTable1; pVlcTable->kpZeroTable[1] = g_kuiZeroLeftTable1;
pVlcTable->kpZeroTable[2] = g_kuiZeroLeftTable2; pVlcTable->kpZeroTable[2] = g_kuiZeroLeftTable2;
pVlcTable->kpZeroTable[3] = g_kuiZeroLeftTable3; pVlcTable->kpZeroTable[3] = g_kuiZeroLeftTable3;
pVlcTable->kpZeroTable[4] = g_kuiZeroLeftTable4; pVlcTable->kpZeroTable[4] = g_kuiZeroLeftTable4;
pVlcTable->kpZeroTable[5] = g_kuiZeroLeftTable5; pVlcTable->kpZeroTable[5] = g_kuiZeroLeftTable5;
pVlcTable->kpZeroTable[6] = g_kuiZeroLeftTable6; pVlcTable->kpZeroTable[6] = g_kuiZeroLeftTable6;
pVlcTable->kpTotalZerosTable[0][0] = g_kuiTotalZerosTable0; pVlcTable->kpTotalZerosTable[0][0] = g_kuiTotalZerosTable0;
pVlcTable->kpTotalZerosTable[0][1] = g_kuiTotalZerosTable1; pVlcTable->kpTotalZerosTable[0][1] = g_kuiTotalZerosTable1;
pVlcTable->kpTotalZerosTable[0][2] = g_kuiTotalZerosTable2; pVlcTable->kpTotalZerosTable[0][2] = g_kuiTotalZerosTable2;
pVlcTable->kpTotalZerosTable[0][3] = g_kuiTotalZerosTable3; pVlcTable->kpTotalZerosTable[0][3] = g_kuiTotalZerosTable3;
pVlcTable->kpTotalZerosTable[0][4] = g_kuiTotalZerosTable4; pVlcTable->kpTotalZerosTable[0][4] = g_kuiTotalZerosTable4;
pVlcTable->kpTotalZerosTable[0][5] = g_kuiTotalZerosTable5; pVlcTable->kpTotalZerosTable[0][5] = g_kuiTotalZerosTable5;
pVlcTable->kpTotalZerosTable[0][6] = g_kuiTotalZerosTable6; pVlcTable->kpTotalZerosTable[0][6] = g_kuiTotalZerosTable6;
pVlcTable->kpTotalZerosTable[0][7] = g_kuiTotalZerosTable7; pVlcTable->kpTotalZerosTable[0][7] = g_kuiTotalZerosTable7;
pVlcTable->kpTotalZerosTable[0][8] = g_kuiTotalZerosTable8; pVlcTable->kpTotalZerosTable[0][8] = g_kuiTotalZerosTable8;
pVlcTable->kpTotalZerosTable[0][9] = g_kuiTotalZerosTable9; pVlcTable->kpTotalZerosTable[0][9] = g_kuiTotalZerosTable9;
pVlcTable->kpTotalZerosTable[0][10] = g_kuiTotalZerosTable10; pVlcTable->kpTotalZerosTable[0][10] = g_kuiTotalZerosTable10;
pVlcTable->kpTotalZerosTable[0][11] = g_kuiTotalZerosTable11; pVlcTable->kpTotalZerosTable[0][11] = g_kuiTotalZerosTable11;
pVlcTable->kpTotalZerosTable[0][12] = g_kuiTotalZerosTable12; pVlcTable->kpTotalZerosTable[0][12] = g_kuiTotalZerosTable12;
pVlcTable->kpTotalZerosTable[0][13] = g_kuiTotalZerosTable13; pVlcTable->kpTotalZerosTable[0][13] = g_kuiTotalZerosTable13;
pVlcTable->kpTotalZerosTable[0][14] = g_kuiTotalZerosTable14; pVlcTable->kpTotalZerosTable[0][14] = g_kuiTotalZerosTable14;
pVlcTable->kpTotalZerosTable[1][0] = g_kuiTotalZerosChromaTable0; pVlcTable->kpTotalZerosTable[1][0] = g_kuiTotalZerosChromaTable0;
pVlcTable->kpTotalZerosTable[1][1] = g_kuiTotalZerosChromaTable1; pVlcTable->kpTotalZerosTable[1][1] = g_kuiTotalZerosChromaTable1;
pVlcTable->kpTotalZerosTable[1][2] = g_kuiTotalZerosChromaTable2; pVlcTable->kpTotalZerosTable[1][2] = g_kuiTotalZerosChromaTable2;
} }

164
codec/decoder/core/inc/wels_common_basis.h
View File

@ -51,55 +51,55 @@ extern __align16 (const uint16_t, g_kuiDequantCoeff[52][8]);
/* Profile IDC */ /* Profile IDC */
typedef uint8_t ProfileIdc; typedef uint8_t ProfileIdc;
enum { enum {
PRO_BASELINE = 66, PRO_BASELINE = 66,
PRO_MAIN = 77, PRO_MAIN = 77,
PRO_EXTENDED = 88, PRO_EXTENDED = 88,
PRO_HIGH = 100, PRO_HIGH = 100,
PRO_HIGH10 = 110, PRO_HIGH10 = 110,
PRO_HIGH422 = 122, PRO_HIGH422 = 122,
PRO_HIGH444 = 144, PRO_HIGH444 = 144,
PRO_CAVLC444 = 244, PRO_CAVLC444 = 244,
PRO_SCALABLE_BASELINE = 83, PRO_SCALABLE_BASELINE = 83,
PRO_SCALABLE_HIGH = 86, PRO_SCALABLE_HIGH = 86,
}; };
/* /*
* NAL Unit Type (5 Bits) * NAL Unit Type (5 Bits)
*/ */
typedef enum TagNalUnitType { typedef enum TagNalUnitType {
NAL_UNIT_UNSPEC_0 = 0, NAL_UNIT_UNSPEC_0 = 0,
NAL_UNIT_CODED_SLICE = 1, NAL_UNIT_CODED_SLICE = 1,
NAL_UNIT_CODED_SLICE_DPA = 2, NAL_UNIT_CODED_SLICE_DPA = 2,
NAL_UNIT_CODED_SLICE_DPB = 3, NAL_UNIT_CODED_SLICE_DPB = 3,
NAL_UNIT_CODED_SLICE_DPC = 4, NAL_UNIT_CODED_SLICE_DPC = 4,
NAL_UNIT_CODED_SLICE_IDR = 5, NAL_UNIT_CODED_SLICE_IDR = 5,
NAL_UNIT_SEI = 6, NAL_UNIT_SEI = 6,
NAL_UNIT_SPS = 7, NAL_UNIT_SPS = 7,
NAL_UNIT_PPS = 8, NAL_UNIT_PPS = 8,
NAL_UNIT_AU_DELIMITER = 9, NAL_UNIT_AU_DELIMITER = 9,
NAL_UNIT_END_OF_SEQ = 10, NAL_UNIT_END_OF_SEQ = 10,
NAL_UNIT_END_OF_STR = 11, NAL_UNIT_END_OF_STR = 11,
NAL_UNIT_FILLER_DATA = 12, NAL_UNIT_FILLER_DATA = 12,
NAL_UNIT_SPS_EXT = 13, NAL_UNIT_SPS_EXT = 13,
NAL_UNIT_PREFIX = 14, NAL_UNIT_PREFIX = 14,
NAL_UNIT_SUBSET_SPS = 15, NAL_UNIT_SUBSET_SPS = 15,
NAL_UNIT_RESV_16 = 16, NAL_UNIT_RESV_16 = 16,
NAL_UNIT_RESV_17 = 17, NAL_UNIT_RESV_17 = 17,
NAL_UNIT_RESV_18 = 18, NAL_UNIT_RESV_18 = 18,
NAL_UNIT_AUX_CODED_SLICE = 19, NAL_UNIT_AUX_CODED_SLICE = 19,
NAL_UNIT_CODED_SLICE_EXT = 20, NAL_UNIT_CODED_SLICE_EXT = 20,
NAL_UNIT_RESV_21 = 21, NAL_UNIT_RESV_21 = 21,
NAL_UNIT_RESV_22 = 22, NAL_UNIT_RESV_22 = 22,
NAL_UNIT_RESV_23 = 23, NAL_UNIT_RESV_23 = 23,
NAL_UNIT_UNSPEC_24 = 24, NAL_UNIT_UNSPEC_24 = 24,
NAL_UNIT_UNSPEC_25 = 25, NAL_UNIT_UNSPEC_25 = 25,
NAL_UNIT_UNSPEC_26 = 26, NAL_UNIT_UNSPEC_26 = 26,
NAL_UNIT_UNSPEC_27 = 27, NAL_UNIT_UNSPEC_27 = 27,
NAL_UNIT_UNSPEC_28 = 28, NAL_UNIT_UNSPEC_28 = 28,
NAL_UNIT_UNSPEC_29 = 29, NAL_UNIT_UNSPEC_29 = 29,
NAL_UNIT_UNSPEC_30 = 30, NAL_UNIT_UNSPEC_30 = 30,
NAL_UNIT_UNSPEC_31 = 31 NAL_UNIT_UNSPEC_31 = 31
} ENalUnitType; } ENalUnitType;
static const uint8_t g_kuiEmulationPreventionThreeByte = 0x03; static const uint8_t g_kuiEmulationPreventionThreeByte = 0x03;
@ -109,10 +109,10 @@ static const uint8_t g_kuiEmulationPreventionThreeByte = 0x03;
*/ */
typedef uint8_t NalRefIdc; typedef uint8_t NalRefIdc;
enum { enum {
NRI_PRI_LOWEST = 0, NRI_PRI_LOWEST = 0,
NRI_PRI_LOW = 1, NRI_PRI_LOW = 1,
NRI_PRI_HIGH = 2, NRI_PRI_HIGH = 2,
NRI_PRI_HIGHEST = 3 NRI_PRI_HIGHEST = 3
}; };
/* /*
@ -120,9 +120,9 @@ enum {
*/ */
typedef uint8_t VclType; typedef uint8_t VclType;
enum { enum {
NON_VCL = 0, NON_VCL = 0,
VCL = 1, VCL = 1,
NOT_APP = 2 NOT_APP = 2
}; };
/* /*
@ -147,58 +147,58 @@ extern const VclType g_kuiVclTypeMap[32][2];
* meaning mapped version after eSliceType minus 4. * meaning mapped version after eSliceType minus 4.
*/ */
typedef enum TagSliceType { typedef enum TagSliceType {
P_SLICE = 0, P_SLICE = 0,
B_SLICE = 1, B_SLICE = 1,
I_SLICE = 2, I_SLICE = 2,
SP_SLICE = 3, SP_SLICE = 3,
SI_SLICE = 4, SI_SLICE = 4,
UNKNOWN_SLICE = 5 UNKNOWN_SLICE = 5
} ESliceType; } ESliceType;
/* List Index */ /* List Index */
typedef uint8_t ListIndex; typedef uint8_t ListIndex;
enum { enum {
LIST_0 = 0, LIST_0 = 0,
LIST_1 = 1, LIST_1 = 1,
LIST_A = 2 LIST_A = 2
}; };
/* Picture Size */ /* Picture Size */
typedef struct TagPictureSize { typedef struct TagPictureSize {
int32_t iWidth; int32_t iWidth;
int32_t iHeight; int32_t iHeight;
} SPictureSize; } SPictureSize;
/* Motion Vector components */ /* Motion Vector components */
typedef uint8_t MvComp; typedef uint8_t MvComp;
enum { enum {
MV_X = 0, MV_X = 0,
MV_Y = 1, MV_Y = 1,
MV_A = 2 MV_A = 2
}; };
/* Chroma Components */ /* Chroma Components */
typedef uint8_t ChromaComp; typedef uint8_t ChromaComp;
enum { enum {
CHROMA_CB = 0, CHROMA_CB = 0,
CHROMA_CR = 1, CHROMA_CR = 1,
CHROMA_A = 2 CHROMA_A = 2
}; };
/* Position Offset structure */ /* Position Offset structure */
typedef struct TagPosOffset { typedef struct TagPosOffset {
int32_t iLeftOffset; int32_t iLeftOffset;
int32_t iTopOffset; int32_t iTopOffset;
int32_t iRightOffset; int32_t iRightOffset;
int32_t iBottomOffset; int32_t iBottomOffset;
} SPosOffset; } SPosOffset;
enum EMbPosition { // enum EMbPosition { //
MB_LEFT = 0x01, // A MB_LEFT = 0x01, // A
MB_TOP = 0x02, // B MB_TOP = 0x02, // B
MB_TOPRIGHT = 0x04, // C MB_TOPRIGHT = 0x04, // C
MB_TOPLEFT = 0x08, // D, MB_TOPLEFT = 0x08, // D,
MB_PRIVATE = 0x10, MB_PRIVATE = 0x10,
}; };
/* MB Type & Sub-MB Type */ /* MB Type & Sub-MB Type */
typedef int32_t MbType; typedef int32_t MbType;
@ -237,13 +237,13 @@ typedef int32_t SubMbType;
* Memory Management Control Operation (MMCO) code * Memory Management Control Operation (MMCO) code
*/ */
enum { enum {
MMCO_END = 0, MMCO_END = 0,
MMCO_SHORT2UNUSED = 1, MMCO_SHORT2UNUSED = 1,
MMCO_LONG2UNUSED = 2, MMCO_LONG2UNUSED = 2,
MMCO_SHORT2LONG = 3, MMCO_SHORT2LONG = 3,
MMCO_SET_MAX_LONG = 4, MMCO_SET_MAX_LONG = 4,
MMCO_RESET = 5, MMCO_RESET = 5,
MMCO_LONG = 6 MMCO_LONG = 6
}; };
/////////intra16x16 Luma /////////intra16x16 Luma

84
codec/decoder/plus/inc/welsDecoderExt.h
View File

@ -56,57 +56,57 @@ namespace WelsDec {
class CWelsDecoder : public ISVCDecoder { class CWelsDecoder : public ISVCDecoder {
public: public:
CWelsDecoder (void); CWelsDecoder (void);
virtual ~CWelsDecoder(); virtual ~CWelsDecoder();
virtual long EXTAPI Initialize (const SDecodingParam* pParam); virtual long EXTAPI Initialize (const SDecodingParam* pParam);
virtual long EXTAPI Uninitialize(); virtual long EXTAPI Uninitialize();
/*************************************************************************** /***************************************************************************
* Description: * Description:
* Decompress one frame, and output I420 or RGB24(in the future) decoded stream and its length. * Decompress one frame, and output I420 or RGB24(in the future) decoded stream and its length.
* Input parameters: * Input parameters:
* Parameter TYPE Description * Parameter TYPE Description
* pSrc unsigned char* the h264 stream to decode * pSrc unsigned char* the h264 stream to decode
* srcLength int the length of h264 steam * srcLength int the length of h264 steam
* pDst unsigned char* buffer pointer of decoded data * pDst unsigned char* buffer pointer of decoded data
* pDstInfo SBufferInfo& information provided to API including width, height, SW/HW option, etc * pDstInfo SBufferInfo& information provided to API including width, height, SW/HW option, etc
* *
* return: if decode frame success return 0, otherwise corresponding error returned. * return: if decode frame success return 0, otherwise corresponding error returned.
***************************************************************************/ ***************************************************************************/
virtual DECODING_STATE EXTAPI DecodeFrame (const unsigned char* kpSrc, virtual DECODING_STATE EXTAPI DecodeFrame (const unsigned char* kpSrc,
const int kiSrcLen, const int kiSrcLen,
unsigned char** ppDst, unsigned char** ppDst,
int* pStride, int* pStride,
int& iWidth, int& iWidth,
int& iHeight); int& iHeight);
virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* kpSrc, virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* kpSrc,
const int kiSrcLen, const int kiSrcLen,
unsigned char** ppDst, unsigned char** ppDst,
SBufferInfo* pDstInfo); SBufferInfo* pDstInfo);
virtual DECODING_STATE EXTAPI DecodeFrameEx (const unsigned char* kpSrc, virtual DECODING_STATE EXTAPI DecodeFrameEx (const unsigned char* kpSrc,
const int kiSrcLen, const int kiSrcLen,
unsigned char* pDst, unsigned char* pDst,
int iDstStride, int iDstStride,
int& iDstLen, int& iDstLen,
int& iWidth, int& iWidth,
int& iHeight, int& iHeight,
int& color_format); int& color_format);
virtual long EXTAPI SetOption (DECODER_OPTION eOptID, void* pOption); virtual long EXTAPI SetOption (DECODER_OPTION eOptID, void* pOption);
virtual long EXTAPI GetOption (DECODER_OPTION eOptID, void* pOption); virtual long EXTAPI GetOption (DECODER_OPTION eOptID, void* pOption);
private: private:
PWelsDecoderContext m_pDecContext; PWelsDecoderContext m_pDecContext;
welsCodecTrace* m_pWelsTrace; welsCodecTrace* m_pWelsTrace;
void InitDecoder (void); void InitDecoder (void);
void UninitDecoder (void); void UninitDecoder (void);
#ifdef OUTPUT_BIT_STREAM #ifdef OUTPUT_BIT_STREAM
WelsFileHandle* m_pFBS; WelsFileHandle* m_pFBS;
WelsFileHandle* m_pFBSSize; WelsFileHandle* m_pFBSSize;
#endif//OUTPUT_BIT_STREAM #endif//OUTPUT_BIT_STREAM
}; };

2
codec/encoder/core/inc/au_set.h
View File

@ -139,6 +139,6 @@ int32_t WelsInitPps (SWelsPPS* pPps,
const uint32_t kuiPpsId, const uint32_t kuiPpsId,
const bool kbDeblockingFilterPresentFlag, const bool kbDeblockingFilterPresentFlag,
const bool kbUsingSubsetSps); const bool kbUsingSubsetSps);
int32_t WelsCheckRefFrameLimitation(SLogContext* pLogCtx,SWelsSvcCodingParam* pParam); int32_t WelsCheckRefFrameLimitation (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam);
} }
#endif//WELS_ACCESS_UNIT_PARSER_H__ #endif//WELS_ACCESS_UNIT_PARSER_H__

26
codec/encoder/core/inc/bit_stream.h
View File

@ -43,12 +43,12 @@ namespace WelsSVCEnc {
* auxiliary struct for bit-stream reading / writing * auxiliary struct for bit-stream reading / writing
*/ */
typedef struct TagBitStringAux { typedef struct TagBitStringAux {
uint8_t* pBuf; // pBuffer to start position uint8_t* pBuf; // pBuffer to start position
uint8_t* pBufEnd; // pBuffer + length uint8_t* pBufEnd; // pBuffer + length
uint8_t* pBufPtr; // current writing position uint8_t* pBufPtr; // current writing position
uint32_t uiCurBits; uint32_t uiCurBits;
int32_t iLeftBits; // count number of available bits left ([1, 8]), int32_t iLeftBits; // count number of available bits left ([1, 8]),
// need pointer to next byte start position in case 0 bit left then 8 instead // need pointer to next byte start position in case 0 bit left then 8 instead
} SBitStringAux; } SBitStringAux;
/*! /*!
@ -61,15 +61,15 @@ typedef struct TagBitStringAux {
* \return iSize of pBuffer pData in byte; failed in -1 return * \return iSize of pBuffer pData in byte; failed in -1 return
*/ */
static inline int32_t InitBits (SBitStringAux* pBs, const uint8_t* kpBuf, const int32_t kiSize) { static inline int32_t InitBits (SBitStringAux* pBs, const uint8_t* kpBuf, const int32_t kiSize) {
uint8_t* ptr = (uint8_t*)kpBuf; uint8_t* ptr = (uint8_t*)kpBuf;
pBs->pBuf = ptr; pBs->pBuf = ptr;
pBs->pBufPtr = ptr; pBs->pBufPtr = ptr;
pBs->pBufEnd = ptr + kiSize; pBs->pBufEnd = ptr + kiSize;
pBs->iLeftBits = 32; pBs->iLeftBits = 32;
pBs->uiCurBits = 0; pBs->uiCurBits = 0;
return kiSize; return kiSize;
} }
} }

21
codec/encoder/core/inc/deblocking.h
View File

@ -50,15 +50,15 @@ namespace WelsSVCEnc {
//struct tagDeblockingFunc; //struct tagDeblockingFunc;
typedef struct TagDeblockingFilter { typedef struct TagDeblockingFilter {
uint8_t* pCsData[3]; // pointer to reconstructed picture pData uint8_t* pCsData[3]; // pointer to reconstructed picture pData
int32_t iCsStride[3]; // Cs iStride int32_t iCsStride[3]; // Cs iStride
int16_t iMbStride; int16_t iMbStride;
int8_t iSliceAlphaC0Offset; int8_t iSliceAlphaC0Offset;
int8_t iSliceBetaOffset; int8_t iSliceBetaOffset;
uint8_t uiLumaQP; uint8_t uiLumaQP;
uint8_t uiChromaQP; uint8_t uiChromaQP;
uint8_t uiFilterIdc; uint8_t uiFilterIdc;
uint8_t uiReserved; uint8_t uiReserved;
} SDeblockingFilter; } SDeblockingFilter;
#if defined(__cplusplus) #if defined(__cplusplus)
@ -71,7 +71,8 @@ void DeblockingBSCalcEnc_neon (int8_t* pNzc, SMVUnitXY* pMv, int32_t iBoundryFla
#endif #endif
#if defined(HAVE_NEON_AARCH64) #if defined(HAVE_NEON_AARCH64)
void WelsNonZeroCount_AArch64_neon (int8_t* pNonZeroCount); void WelsNonZeroCount_AArch64_neon (int8_t* pNonZeroCount);
void DeblockingBSCalcEnc_AArch64_neon (int8_t* pNzc, SMVUnitXY* pMv, int32_t iBoundryFlag, int32_t iMbStride, uint8_t (*pBS)[4][4]); void DeblockingBSCalcEnc_AArch64_neon (int8_t* pNzc, SMVUnitXY* pMv, int32_t iBoundryFlag, int32_t iMbStride,
uint8_t (*pBS)[4][4]);
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
} }

6
codec/encoder/core/inc/dq_map.h
View File

@ -48,9 +48,9 @@ namespace WelsSVCEnc {
*/ */
typedef struct TagDqIdc { typedef struct TagDqIdc {
uint16_t iPpsId; // pPps id uint16_t iPpsId; // pPps id
uint8_t iSpsId; // pSps id uint8_t iSpsId; // pSps id
int8_t uiSpatialId; // spatial id int8_t uiSpatialId; // spatial id
} SDqIdc; } SDqIdc;
} }

234
codec/encoder/core/inc/encoder_context.h
View File

@ -64,159 +64,159 @@ namespace WelsSVCEnc {
* reference list for each quality layer in SVC * reference list for each quality layer in SVC
*/ */
typedef struct TagRefList { typedef struct TagRefList {
SPicture* pShortRefList[1 + MAX_SHORT_REF_COUNT]; // reference list 0 - int16_t 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* pLongRefList[1 + MAX_REF_PIC_COUNT]; // reference list 1 - int32_t
SPicture* pNextBuffer; SPicture* pNextBuffer;
SPicture* pRef[1 + MAX_REF_PIC_COUNT]; // plus 1 for swap intend SPicture* pRef[1 + MAX_REF_PIC_COUNT]; // plus 1 for swap intend
uint8_t uiShortRefCount; uint8_t uiShortRefCount;
uint8_t uiLongRefCount; // dependend on pRef pic module uint8_t uiLongRefCount; // dependend on pRef pic module
} SRefList; } SRefList;
typedef struct TagLTRState { typedef struct TagLTRState {
// LTR mark feedback // LTR mark feedback
uint32_t uiLtrMarkState; // LTR mark state, indicate whether there is a LTR mark feedback unsolved 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 int32_t iLtrMarkFbFrameNum;// the unsolved LTR mark feedback, the marked iFrameNum feedback from decoder
// LTR used as recovery reference // LTR used as recovery reference
int32_t iLastRecoverFrameNum; // reserve the last LTR or IDR recover iFrameNum int32_t iLastRecoverFrameNum; // reserve the last LTR or IDR recover iFrameNum
int32_t 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 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 int32_t
iCurFrameNumInDec; // current iFrameNum in decoder side, use to select valid LTR to recover or to decide the LTR mark validation iCurFrameNumInDec; // current iFrameNum in decoder side, use to select valid LTR to recover or to decide the LTR mark validation
// LTR mark // LTR mark
int32_t iLTRMarkMode; // direct mark or delay mark int32_t iLTRMarkMode; // direct mark or delay mark
int32_t iLTRMarkSuccessNum; //successful marked num, for mark mode switch int32_t iLTRMarkSuccessNum; //successful marked num, for mark mode switch
int32_t iCurLtrIdx;// current int32_t term reference index to mark int32_t iCurLtrIdx;// current int32_t term reference index to mark
int32_t iLastLtrIdx[MAX_TEMPORAL_LAYER_NUM]; int32_t iLastLtrIdx[MAX_TEMPORAL_LAYER_NUM];
int32_t iSceneLtrIdx;// related to Scene LTR, used by screen content int32_t iSceneLtrIdx;// related to Scene LTR, used by screen content
uint32_t uiLtrMarkInterval;// the interval from the last int32_t term pRef mark uint32_t uiLtrMarkInterval;// the interval from the last int32_t term pRef mark
bool bLTRMarkingFlag; //decide whether current frame marked as LTR 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 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 bool bReceivedT0LostFlag; // indicate whether a t0 lost feedback is recieved, for LTR recovery
} SLTRState; } SLTRState;
typedef struct TagSpatialPicIndex { typedef struct TagSpatialPicIndex {
SPicture* pSrc; // I420 based and after color space converted SPicture* pSrc; // I420 based and after color space converted
int32_t iDid; // dependency id int32_t iDid; // dependency id
} SSpatialPicIndex; } SSpatialPicIndex;
typedef struct TagStrideTables { typedef struct TagStrideTables {
int32_t* pStrideDecBlockOffset[MAX_DEPENDENCY_LAYER][2]; // [iDid][tid==0][24 x 4]: luma+chroma= 24 x 4 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 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* 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 int16_t* pMbIndexY[MAX_DEPENDENCY_LAYER]; // [iDid][iMbY]: map for iMbY in each spatial layer coding
} SStrideTables; } SStrideTables;
typedef struct TagWelsEncCtx { typedef struct TagWelsEncCtx {
SLogContext sLogCtx; SLogContext sLogCtx;
// Input // Input
SWelsSvcCodingParam* pSvcParam; // SVC parameter, WelsSVCParamConfig in svc_param_settings.h SWelsSvcCodingParam* pSvcParam; // SVC parameter, WelsSVCParamConfig in svc_param_settings.h
SWelsSliceBs* pSliceBs; // bitstream buffering for various slices, [uiSliceIdx] SWelsSliceBs* pSliceBs; // bitstream buffering for various slices, [uiSliceIdx]
int32_t* pSadCostMb; int32_t* pSadCostMb;
/* MVD cost tables for Inter MB */ /* MVD cost tables for Inter MB */
int32_t iMvRange; int32_t iMvRange;
uint16_t* pMvdCostTableInter; //[52]; // adaptive to spatial layers uint16_t* pMvdCostTableInter; //[52]; // adaptive to spatial layers
SMVUnitXY* SMVUnitXY*
pMvUnitBlock4x4; // (*pMvUnitBlock4x4[2])[MB_BLOCK4x4_NUM]; // for store each 4x4 blocks' mv unit, the two swap after different d layer pMvUnitBlock4x4; // (*pMvUnitBlock4x4[2])[MB_BLOCK4x4_NUM]; // for store each 4x4 blocks' mv unit, the two swap after different d layer
int8_t* int8_t*
pRefIndexBlock4x4; // (*pRefIndexBlock4x4[2])[MB_BLOCK8x8_NUM]; // for store each 4x4 blocks' pRef index, the two swap after different d layer 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* pNonZeroCountBlocks; // (*pNonZeroCountBlocks)[MB_LUMA_CHROMA_BLOCK4x4_NUM];
int8_t* 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) 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]; SMB** ppMbListD; // [MAX_DEPENDENCY_LAYER];
SStrideTables* pStrideTab; // stride tables for internal coding used SStrideTables* pStrideTab; // stride tables for internal coding used
SWelsFuncPtrList* pFuncList; SWelsFuncPtrList* pFuncList;
SSliceThreading* pSliceThreading; SSliceThreading* pSliceThreading;
// SSlice context // SSlice context
SSliceCtx* pSliceCtxList;// slice context table for each dependency quality layer SSliceCtx* pSliceCtxList;// slice context table for each dependency quality layer
// pointers // pointers
SPicture* pEncPic; // pointer to current picture to be encoded SPicture* pEncPic; // pointer to current picture to be encoded
SPicture* pDecPic; // pointer to current picture being reconstructed SPicture* pDecPic; // pointer to current picture being reconstructed
SPicture* pRefPic; // pointer to current reference picture SPicture* pRefPic; // pointer to current reference picture
SDqLayer* SDqLayer*
pCurDqLayer; // DQ layer context used to being encoded currently, for reference base layer to refer: pCurDqLayer->pRefLayer if applicable 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 SDqLayer** ppDqLayerList; // overall DQ layers encoded for storage
SRefList** ppRefPicListExt; // reference picture list for SVC SRefList** ppRefPicListExt; // reference picture list for SVC
SPicture* pRefList0[16]; SPicture* pRefList0[16];
SLTRState* pLtr;//[MAX_DEPENDENCY_LAYER]; SLTRState* pLtr;//[MAX_DEPENDENCY_LAYER];
bool bCurFrameMarkedAsSceneLtr; bool bCurFrameMarkedAsSceneLtr;
// Derived // Derived
int32_t iCodingIndex; int32_t iCodingIndex;
int32_t iFrameIndex; // count how many frames elapsed during coding context currently int32_t iFrameIndex; // count how many frames elapsed during coding context currently
int32_t iFrameNum; // current frame number coding int32_t iFrameNum; // current frame number coding
int32_t iPOC; // frame iPOC int32_t iPOC; // frame iPOC
EWelsSliceType eSliceType; // currently coding slice type EWelsSliceType eSliceType; // currently coding slice type
EWelsNalUnitType eNalType; // NAL type EWelsNalUnitType eNalType; // NAL type
EWelsNalRefIdc eNalPriority; // NAL_Reference_Idc currently EWelsNalRefIdc eNalPriority; // NAL_Reference_Idc currently
EWelsNalRefIdc eLastNalPriority; // NAL_Reference_Idc in last frame EWelsNalRefIdc eLastNalPriority; // NAL_Reference_Idc in last frame
uint8_t iNumRef0; uint8_t iNumRef0;
uint8_t uiDependencyId; // Idc of dependecy layer to be coded uint8_t uiDependencyId; // Idc of dependecy layer to be coded
uint8_t uiTemporalId; // Idc of temporal layer to be coded uint8_t uiTemporalId; // Idc of temporal layer to be coded
bool bNeedPrefixNalFlag; // whether add prefix nal bool bNeedPrefixNalFlag; // whether add prefix nal
bool bEncCurFrmAsIdrFlag; bool bEncCurFrmAsIdrFlag;
// Rate control routine // Rate control routine
SWelsSvcRc* pWelsSvcRc; SWelsSvcRc* pWelsSvcRc;
int32_t iSkipFrameFlag; //_GOM_RC_ int32_t iSkipFrameFlag; //_GOM_RC_
int32_t iGlobalQp; // global qp int32_t iGlobalQp; // global qp
// VAA // VAA
SVAAFrameInfo* pVaa; // VAA information of reference SVAAFrameInfo* pVaa; // VAA information of reference
CWelsPreProcess* pVpp; CWelsPreProcess* pVpp;
SWelsSPS* pSpsArray; // MAX_SPS_COUNT by standard compatible SWelsSPS* pSpsArray; // MAX_SPS_COUNT by standard compatible
SWelsSPS* pSps; SWelsSPS* pSps;
SWelsPPS* pPPSArray; // MAX_PPS_COUNT by standard compatible SWelsPPS* pPPSArray; // MAX_PPS_COUNT by standard compatible
SWelsPPS* pPps; SWelsPPS* pPps;
/* SVC only */ /* SVC only */
SSubsetSps* pSubsetArray; // MAX_SPS_COUNT by standard compatible SSubsetSps* pSubsetArray; // MAX_SPS_COUNT by standard compatible
SSubsetSps* pSubsetSps; SSubsetSps* pSubsetSps;
int32_t iSpsNum; // number of pSps used int32_t iSpsNum; // number of pSps used
int32_t iPpsNum; // number of pPps used int32_t iPpsNum; // number of pPps used
// Output // Output
SWelsEncoderOutput* pOut; // for NAL raw pData (need allocating memory for sNalList internal) SWelsEncoderOutput* pOut; // for NAL raw pData (need allocating memory for sNalList internal)
uint8_t* pFrameBs; // restoring bitstream pBuffer of all NALs in a frame 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 iFrameBsSize; // count size of frame bs in bytes allocated
int32_t iPosBsBuffer; // current writing position of frame bs pBuffer int32_t iPosBsBuffer; // current writing position of frame bs pBuffer
SSpatialPicIndex sSpatialIndexMap[MAX_DEPENDENCY_LAYER]; SSpatialPicIndex sSpatialIndexMap[MAX_DEPENDENCY_LAYER];
bool bLongTermRefFlag[MAX_DEPENDENCY_LAYER][MAX_TEMPORAL_LEVEL + 1/*+LONG_TERM_REF_NUM*/]; 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 iMaxSliceCount;// maximal count number of slices for all layers observation
int16_t iActiveThreadsNum; // number of threads active so far 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, * 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 * can aware idc of referencing layer and that idc of successive layer to be coded
*/ */
/* SVC only */ /* SVC only */
SDqIdc* 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 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; SParaSetOffset sPSOVector;
CMemoryAlign* pMemAlign; CMemoryAlign* pMemAlign;
#if defined(STAT_OUTPUT) #if defined(STAT_OUTPUT)
// overall stat pData, refer to SStatData in stat.h, in case avc to use stat[0][0] // 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 ]; SStatData sStatData [ MAX_DEPENDENCY_LAYER ] [ MAX_QUALITY_LEVEL ];
SStatSliceInfo sPerInfo; SStatSliceInfo sPerInfo;
#endif//STAT_OUTPUT #endif//STAT_OUTPUT
int32_t iEncoderError; int32_t iEncoderError;
WELS_MUTEX mutexEncoderError; WELS_MUTEX mutexEncoderError;
int32_t iDropNumber; int32_t iDropNumber;
} sWelsEncCtx/*, *PWelsEncCtx*/; } sWelsEncCtx/*, *PWelsEncCtx*/;
} }
#endif//sWelsEncCtx_H__ #endif//sWelsEncCtx_H__

78
codec/encoder/core/inc/mb_cache.h
View File

@ -65,79 +65,79 @@ extern const uint8_t g_kuiCache48CountScan4Idx[24];
typedef struct TagDCTCoeff { typedef struct TagDCTCoeff {
//ALIGNED_DECLARE( int16_t, residual_ac[16], 16 ); //I_16x16 //ALIGNED_DECLARE( int16_t, residual_ac[16], 16 ); //I_16x16
int16_t iLumaBlock[16][16]; //based on block4x4 luma DC/AC int16_t iLumaBlock[16][16]; //based on block4x4 luma DC/AC
//ALIGNED_DECLARE( int16_t, iLumaI16x16Dc[16], 16 ); //I_16x16 DC //ALIGNED_DECLARE( int16_t, iLumaI16x16Dc[16], 16 ); //I_16x16 DC
int16_t iLumaI16x16Dc[16]; int16_t iLumaI16x16Dc[16];
//ALIGNED_DECLARE( int16_t, iChromaDc[2][4], 16 ); //chroma DC //ALIGNED_DECLARE( int16_t, iChromaDc[2][4], 16 ); //chroma DC
int16_t iChromaBlock[8][16]; //based on block4x4 chroma DC/AC int16_t iChromaBlock[8][16]; //based on block4x4 chroma DC/AC
int16_t iChromaDc[2][4]; int16_t iChromaDc[2][4];
} SDCTCoeff ; } SDCTCoeff ;
typedef struct TagMbCache { typedef struct TagMbCache {
//the followed pData now is promised aligned to 16 bytes //the followed pData now is promised aligned to 16 bytes
ALIGNED_DECLARE (SMVComponentUnit, sMvComponents, 16); ALIGNED_DECLARE (SMVComponentUnit, sMvComponents, 16);
ALIGNED_DECLARE_MATRIX_1D (iNonZeroCoeffCount, 48, int8_t, 16); // Cache line size ALIGNED_DECLARE_MATRIX_1D (iNonZeroCoeffCount, 48, int8_t, 16); // Cache line size
// int8_t iNonZeroCoeffCount[6 * 8]; // Right luma, Chroma(Left Top Cb, Left btm Cr); must follow by iIntraPredMode! // int8_t iNonZeroCoeffCount[6 * 8]; // Right luma, Chroma(Left Top Cb, Left btm Cr); must follow by iIntraPredMode!
ALIGNED_DECLARE_MATRIX_1D (iIntraPredMode, 48, int8_t, 16); ALIGNED_DECLARE_MATRIX_1D (iIntraPredMode, 48, int8_t, 16);
// must follow with iNonZeroCoeffCount! // must follow with iNonZeroCoeffCount!
int32_t iSadCost[4]; //avail 1; unavail 0 int32_t iSadCost[4]; //avail 1; unavail 0
SMVUnitXY sMbMvp[MB_BLOCK8x8_NUM];// for write bs SMVUnitXY sMbMvp[MB_BLOCK8x8_NUM];// for write bs
//for residual decoding (recovery) at the side of Encoder //for residual decoding (recovery) at the side of Encoder
int16_t* pCoeffLevel; // tmep int16_t* pCoeffLevel; // tmep
//malloc memory for prediction //malloc memory for prediction
uint8_t* pSkipMb; uint8_t* pSkipMb;
//ALIGNED_DECLARE(uint8_t, pMemPredMb[2][256], 16);//One: Best I_16x16 Luma and refine frac_pixel pBuffer; another: PingPong I_8x8&&Inter Cb + Cr //ALIGNED_DECLARE(uint8_t, pMemPredMb[2][256], 16);//One: Best I_16x16 Luma and refine frac_pixel pBuffer; another: PingPong I_8x8&&Inter Cb + Cr
uint8_t* pMemPredMb; uint8_t* pMemPredMb;
uint8_t* pMemPredLuma;// inter && intra share same pointer; uint8_t* pMemPredLuma;// inter && intra share same pointer;
//ALIGNED_DECLARE(uint8_t, pMemPredChroma[2][64*2], 16); //another PingPong pBuffer: Best Cb + Cr; //ALIGNED_DECLARE(uint8_t, pMemPredChroma[2][64*2], 16); //another PingPong pBuffer: Best Cb + Cr;
uint8_t* pMemPredChroma;// inter && intra share same pointer; uint8_t* pMemPredChroma;// inter && intra share same pointer;
uint8_t* pBestPredIntraChroma; //Cb:0~63; Cr:64~127 uint8_t* pBestPredIntraChroma; //Cb:0~63; Cr:64~127
//ALIGNED_DECLARE(uint8_t, pMemPredBlk4[2][16], 16); //I_4x4 //ALIGNED_DECLARE(uint8_t, pMemPredBlk4[2][16], 16); //I_4x4
uint8_t* pMemPredBlk4; uint8_t* pMemPredBlk4;
uint8_t* pBestPredI4x4Blk4;//I_4x4 uint8_t* pBestPredI4x4Blk4;//I_4x4
//ALIGNED_DECLARE(uint8_t, pBufferInterPredMe[4][400], 16);//inter type pBuffer for ME h & v & hv //ALIGNED_DECLARE(uint8_t, pBufferInterPredMe[4][400], 16);//inter type pBuffer for ME h & v & hv
uint8_t* pBufferInterPredMe; // [4][400] is enough because only h&v or v&hv or h&hv. but if both h&v&hv is needed when 8 quart pixel, future we have to use [5][400]. uint8_t* pBufferInterPredMe; // [4][400] is enough because only h&v or v&hv or h&hv. but if both h&v&hv is needed when 8 quart pixel, future we have to use [5][400].
//no scan4[] order, just as memory order to store //no scan4[] order, just as memory order to store
//ALIGNED_DECLARE(bool, pPrevIntra4x4PredModeFlag[16], 16);//if 1, means no rem_intra4x4_pred_mode; if 0, means rem_intra4x4_pred_mode != 0 //ALIGNED_DECLARE(bool, pPrevIntra4x4PredModeFlag[16], 16);//if 1, means no rem_intra4x4_pred_mode; if 0, means rem_intra4x4_pred_mode != 0
bool* pPrevIntra4x4PredModeFlag; bool* pPrevIntra4x4PredModeFlag;
//ALIGNED_DECLARE(int8_t, pRemIntra4x4PredModeFlag[16], 16);//-1 as default; if pPrevIntra4x4PredModeFlag==0, //ALIGNED_DECLARE(int8_t, pRemIntra4x4PredModeFlag[16], 16);//-1 as default; if pPrevIntra4x4PredModeFlag==0,
//pRemIntra4x4PredModeFlag or added by 1 is the best pred_mode //pRemIntra4x4PredModeFlag or added by 1 is the best pred_mode
int8_t* pRemIntra4x4PredModeFlag; int8_t* pRemIntra4x4PredModeFlag;
int32_t iSadCostSkip[4]; //avail 1; unavail 0 int32_t iSadCostSkip[4]; //avail 1; unavail 0
bool bMbTypeSkip[4]; //1: skip; 0: non-skip bool bMbTypeSkip[4]; //1: skip; 0: non-skip
int32_t* pEncSad; int32_t* pEncSad;
//for residual encoding at the side of Encoder //for residual encoding at the side of Encoder
SDCTCoeff* pDct; SDCTCoeff* pDct;
uint8_t uiNeighborIntra; // LEFT_MB_POS:0x01, TOP_MB_POS:0x02, TOPLEFT_MB_POS = 0x04 ,TOPRIGHT_MB_POS = 0x08; uint8_t uiNeighborIntra; // LEFT_MB_POS:0x01, TOP_MB_POS:0x02, TOPLEFT_MB_POS = 0x04 ,TOPRIGHT_MB_POS = 0x08;
uint8_t uiLumaI16x16Mode; uint8_t uiLumaI16x16Mode;
uint8_t uiChmaI8x8Mode; uint8_t uiChmaI8x8Mode;
bool bCollocatedPredFlag;//denote if current MB is collocated predicted (MV==0). bool bCollocatedPredFlag;//denote if current MB is collocated predicted (MV==0).
uint32_t uiRefMbType; uint32_t uiRefMbType;
struct { struct {
/* pointer of current mb location in original frame */ /* pointer of current mb location in original frame */
uint8_t* pEncMb[3]; uint8_t* pEncMb[3];
/* pointer of current mb location in recovery frame */ /* pointer of current mb location in recovery frame */
uint8_t* pDecMb[3]; uint8_t* pDecMb[3];
/* pointer of co-located mb location in reference frame */ /* pointer of co-located mb location in reference frame */
uint8_t* pRefMb[3]; uint8_t* pRefMb[3];
//for SVC //for SVC
uint8_t* pCsMb[3];//locating current mb's CS in whole frame uint8_t* pCsMb[3];//locating current mb's CS in whole frame
// int16_t *p_rs[3];//locating current mb's RS in whole frame // int16_t *p_rs[3];//locating current mb's RS in whole frame
} SPicData; } SPicData;
} SMbCache; } SMbCache;
}//end of namespace }//end of namespace

48
codec/encoder/core/inc/md.h
View File

@ -84,43 +84,43 @@ extern const int8_t g_kiMapModeIntraChroma[7];
// if we want keep total sizeof(SWelsMD) <= 256, we maybe need to seperate three member of SWelsME. // if we want keep total sizeof(SWelsMD) <= 256, we maybe need to seperate three member of SWelsME.
typedef struct TagWelsMD { typedef struct TagWelsMD {
int32_t iLambda; int32_t iLambda;
uint16_t* pMvdCost; uint16_t* pMvdCost;
int32_t iCostLuma; int32_t iCostLuma;
int32_t iCostChroma;//satd+lambda(best_pred_mode) //i_sad_chroma; int32_t iCostChroma;//satd+lambda(best_pred_mode) //i_sad_chroma;
int32_t iSadPredMb; int32_t iSadPredMb;
uint8_t uiRef; //uiRefIndex appointed by Encoder, used for MC uint8_t uiRef; //uiRefIndex appointed by Encoder, used for MC
bool bMdUsingSad; bool bMdUsingSad;
uint16_t uiReserved; uint16_t uiReserved;
int32_t iCostSkipMb; int32_t iCostSkipMb;
int32_t iSadPredSkip; int32_t iSadPredSkip;
int32_t iMbPixX; // pixel position of MB in horizontal axis int32_t iMbPixX; // pixel position of MB in horizontal axis
int32_t iMbPixY; // pixel position of MB in vertical axis int32_t iMbPixY; // pixel position of MB in vertical axis
int32_t iBlock8x8StaticIdc[4]; int32_t iBlock8x8StaticIdc[4];
//NO B frame in our Wels, we can ignore list1 //NO B frame in our Wels, we can ignore list1
struct { struct {
SWelsME sMe16x16; //adjust each SWelsME for 8 D-word! SWelsME sMe16x16; //adjust each SWelsME for 8 D-word!
SWelsME sMe8x8[4]; SWelsME sMe8x8[4];
SWelsME sMe16x8[2]; SWelsME sMe16x8[2];
SWelsME sMe8x16[2]; SWelsME sMe8x16[2];
// SMVUnitXY i_mvbs[MB_BLOCK8x8_NUM]; //scaled MVB // SMVUnitXY i_mvbs[MB_BLOCK8x8_NUM]; //scaled MVB
} sMe; } sMe;
} SWelsMD; } SWelsMD;
typedef struct TagMeRefinePointer { typedef struct TagMeRefinePointer {
uint8_t* pHalfPixH; uint8_t* pHalfPixH;
uint8_t* pHalfPixV; uint8_t* pHalfPixV;
uint8_t* pHalfPixHV; uint8_t* pHalfPixHV;
uint8_t* pQuarPixBest; uint8_t* pQuarPixBest;
uint8_t* pQuarPixTmp; uint8_t* pQuarPixTmp;
} SMeRefinePointer; } SMeRefinePointer;

26
codec/encoder/core/inc/memory_align.h
View File

@ -43,30 +43,30 @@ namespace WelsSVCEnc {
class CMemoryAlign { class CMemoryAlign {
public: public:
CMemoryAlign (const uint32_t kuiCacheLineSize); CMemoryAlign (const uint32_t kuiCacheLineSize);
virtual ~CMemoryAlign(); virtual ~CMemoryAlign();
void* WelsMallocz (const uint32_t kuiSize, const char* kpTag); void* WelsMallocz (const uint32_t kuiSize, const char* kpTag);
void* WelsMalloc (const uint32_t kuiSize, const char* kpTag); void* WelsMalloc (const uint32_t kuiSize, const char* kpTag);
void WelsFree (void* pPointer, const char* kpTag); void WelsFree (void* pPointer, const char* kpTag);
const uint32_t WelsGetCacheLineSize() const; const uint32_t WelsGetCacheLineSize() const;
const uint32_t WelsGetMemoryUsage() const; const uint32_t WelsGetMemoryUsage() const;
private: private:
// private copy & assign constructors adding to fix klocwork scan issues // private copy & assign constructors adding to fix klocwork scan issues
CMemoryAlign (const CMemoryAlign& kcMa); CMemoryAlign (const CMemoryAlign& kcMa);
CMemoryAlign& operator= (const CMemoryAlign& kcMa); CMemoryAlign& operator= (const CMemoryAlign& kcMa);
protected: protected:
uint32_t m_nCacheLineSize; uint32_t m_nCacheLineSize;
#ifdef MEMORY_MONITOR #ifdef MEMORY_MONITOR
uint32_t m_nMemoryUsageInBytes; uint32_t m_nMemoryUsageInBytes;
#endif//MEMORY_MONITOR #endif//MEMORY_MONITOR
#ifdef MEMORY_CHECK #ifdef MEMORY_CHECK
FILE* m_fpMemChkPoint; FILE* m_fpMemChkPoint;
uint32_t m_nCountRequestNum; uint32_t m_nCountRequestNum;
#endif//MEMORY_CHECK #endif//MEMORY_CHECK
}; };

42
codec/encoder/core/inc/mt_defs.h
View File

@ -59,36 +59,36 @@
#define THRESHOLD_RMSE_CORE2 0.0200f // v1.1: 0.0200f; v1.0: 0.04f #define THRESHOLD_RMSE_CORE2 0.0200f // v1.1: 0.0200f; v1.0: 0.04f
typedef struct TagSliceThreadPrivateData { typedef struct TagSliceThreadPrivateData {
void* pWelsPEncCtx; void* pWelsPEncCtx;
SLayerBSInfo* pLayerBs; SLayerBSInfo* pLayerBs;
int32_t iSliceIndex; // slice index, zero based int32_t iSliceIndex; // slice index, zero based
int32_t iThreadIndex; // thread index, zero based int32_t iThreadIndex; // thread index, zero based
// for dynamic slicing mode // for dynamic slicing mode
int32_t iStartMbIndex; // inclusive int32_t iStartMbIndex; // inclusive
int32_t iEndMbIndex; // exclusive int32_t iEndMbIndex; // exclusive
} SSliceThreadPrivateData; } SSliceThreadPrivateData;
typedef struct TagSliceThreading { typedef struct TagSliceThreading {
SSliceThreadPrivateData* pThreadPEncCtx;// thread context, [iThreadIdx] SSliceThreadPrivateData* pThreadPEncCtx;// thread context, [iThreadIdx]
char eventNamespace[100]; char eventNamespace[100];
WELS_THREAD_HANDLE pThreadHandles[MAX_THREADS_NUM];// thread handles, [iThreadIdx] WELS_THREAD_HANDLE pThreadHandles[MAX_THREADS_NUM];// thread handles, [iThreadIdx]
WELS_EVENT pSliceCodedEvent[MAX_THREADS_NUM];// events for slice coded state, [iThreadIdx] WELS_EVENT pSliceCodedEvent[MAX_THREADS_NUM];// events for slice coded state, [iThreadIdx]
WELS_EVENT pSliceCodedMasterEvent; // events for signalling that some event in pSliceCodedEvent has been signalled WELS_EVENT pSliceCodedMasterEvent; // events for signalling that some event in pSliceCodedEvent has been signalled
WELS_EVENT pReadySliceCodingEvent[MAX_THREADS_NUM]; // events for slice coding ready, [iThreadIdx] WELS_EVENT pReadySliceCodingEvent[MAX_THREADS_NUM]; // events for slice coding ready, [iThreadIdx]
WELS_EVENT pUpdateMbListEvent[MAX_THREADS_NUM]; // signal to update mb list neighbor for various slices WELS_EVENT pUpdateMbListEvent[MAX_THREADS_NUM]; // signal to update mb list neighbor for various slices
WELS_EVENT pFinUpdateMbListEvent[MAX_THREADS_NUM]; // signal to indicate finish updating mb list WELS_EVENT pFinUpdateMbListEvent[MAX_THREADS_NUM]; // signal to indicate finish updating mb list
WELS_EVENT pExitEncodeEvent[MAX_THREADS_NUM]; // event for exit encoding event WELS_EVENT pExitEncodeEvent[MAX_THREADS_NUM]; // event for exit encoding event
WELS_EVENT WELS_EVENT
pThreadMasterEvent[MAX_THREADS_NUM]; // event for indicating that some event has been signalled to the thread pThreadMasterEvent[MAX_THREADS_NUM]; // event for indicating that some event has been signalled to the thread
WELS_MUTEX mutexSliceNumUpdate; // for dynamic slicing mode MT WELS_MUTEX mutexSliceNumUpdate; // for dynamic slicing mode MT
uint32_t* pSliceConsumeTime[MAX_DEPENDENCY_LAYER]; // consuming time for each slice, [iSpatialIdx][uiSliceIdx] uint32_t* pSliceConsumeTime[MAX_DEPENDENCY_LAYER]; // consuming time for each slice, [iSpatialIdx][uiSliceIdx]
int32_t* pSliceComplexRatio[MAX_DEPENDENCY_LAYER]; // *INT_MULTIPLY int32_t* pSliceComplexRatio[MAX_DEPENDENCY_LAYER]; // *INT_MULTIPLY
#ifdef MT_DEBUG #ifdef MT_DEBUG
FILE* pFSliceDiff; // file handle for debug FILE* pFSliceDiff; // file handle for debug
#endif//MT_DEBUG #endif//MT_DEBUG
} SSliceThreading; } SSliceThreading;

40
codec/encoder/core/inc/nal_encap.h
View File

@ -52,29 +52,29 @@ namespace WelsSVCEnc {
* Raw payload pData for NAL unit, AVC/SVC compatible * Raw payload pData for NAL unit, AVC/SVC compatible
*/ */
typedef struct TagWelsNalRaw { typedef struct TagWelsNalRaw {
uint8_t* pRawData; // pRawNal payload for slice pData uint8_t* pRawData; // pRawNal payload for slice pData
int32_t iPayloadSize; // size of pRawNal pData int32_t iPayloadSize; // size of pRawNal pData
SNalUnitHeaderExt sNalExt; // NAL header information SNalUnitHeaderExt sNalExt; // NAL header information
int32_t iStartPos; //NAL start position in buffer int32_t iStartPos; //NAL start position in buffer
} SWelsNalRaw; } SWelsNalRaw;
/* /*
* Encoder majoy output pData * Encoder majoy output pData
*/ */
typedef struct TagWelsEncoderOutput { typedef struct TagWelsEncoderOutput {
uint8_t* pBsBuffer; // overall bitstream pBuffer allocation for a coded picture, recycling use intend. uint8_t* pBsBuffer; // overall bitstream pBuffer allocation for a coded picture, recycling use intend.
uint32_t uiSize; // size of allocation pBuffer above uint32_t uiSize; // size of allocation pBuffer above
SBitStringAux sBsWrite; SBitStringAux sBsWrite;
// SWelsNalRaw raw_nals[MAX_DEPENDENCY_LAYER*2+MAX_DEPENDENCY_LAYER*MAX_QUALITY_LEVEL]; // AVC: max up to SPS+PPS+max_slice_idc (2 + 8) for FMO; // SWelsNalRaw raw_nals[MAX_DEPENDENCY_LAYER*2+MAX_DEPENDENCY_LAYER*MAX_QUALITY_LEVEL]; // AVC: max up to SPS+PPS+max_slice_idc (2 + 8) for FMO;
SWelsNalRaw* sNalList; // nal list, adaptive for AVC/SVC in case single slice, multiple slices or fmo SWelsNalRaw* sNalList; // nal list, adaptive for AVC/SVC in case single slice, multiple slices or fmo
int32_t* pNalLen; int32_t* pNalLen;
int32_t iCountNals; // count number of NAL in list int32_t iCountNals; // count number of NAL in list
// SVC: num_sps (MAX_D) + num_pps (MAX_D) + num_vcl (MAX_D * MAX_Q) // SVC: num_sps (MAX_D) + num_pps (MAX_D) + num_vcl (MAX_D * MAX_Q)
int32_t iNalIndex; // coding NAL currently, 0 based int32_t iNalIndex; // coding NAL currently, 0 based
// bool bAnnexBFlag; // annexeb flag, to figure it pOut the packetization mode whether need 4 bytes (0 0 0 1) of start code prefix // bool bAnnexBFlag; // annexeb flag, to figure it pOut the packetization mode whether need 4 bytes (0 0 0 1) of start code prefix
} SWelsEncoderOutput; } SWelsEncoderOutput;
@ -82,21 +82,21 @@ typedef struct TagWelsEncoderOutput {
//#define MT_DEBUG_BS_WR 0 // for MT debugging if needed //#define MT_DEBUG_BS_WR 0 // for MT debugging if needed
typedef struct TagWelsSliceBs { typedef struct TagWelsSliceBs {
uint8_t* pBs; // output bitstream, pBitStringAux not needed for slice 0 due to no dependency of pFrameBs available uint8_t* pBs; // output bitstream, pBitStringAux not needed for slice 0 due to no dependency of pFrameBs available
uint32_t uiBsPos; // position of output bitstream uint32_t uiBsPos; // position of output bitstream
uint8_t* pBsBuffer; // overall bitstream pBuffer allocation for a coded slice, recycling use intend. uint8_t* pBsBuffer; // overall bitstream pBuffer allocation for a coded slice, recycling use intend.
uint32_t uiSize; // size of allocation pBuffer above uint32_t uiSize; // size of allocation pBuffer above
SBitStringAux sBsWrite; SBitStringAux sBsWrite;
SWelsNalRaw sNalList[2]; // nal list, PREFIX NAL(if applicable) + SLICE NAL SWelsNalRaw sNalList[2]; // nal list, PREFIX NAL(if applicable) + SLICE NAL
// int32_t iCountNals; // count number of NAL in list // int32_t iCountNals; // count number of NAL in list
int32_t iNalLen[2]; int32_t iNalLen[2];
int32_t iNalIndex; // coding NAL currently, 0 based int32_t iNalIndex; // coding NAL currently, 0 based
// bool bAnnexBFlag; // annexeb flag, to figure it pOut the packetization mode whether need 4 bytes (0 0 0 1) of start code prefix // bool bAnnexBFlag; // annexeb flag, to figure it pOut the packetization mode whether need 4 bytes (0 0 0 1) of start code prefix
#if MT_DEBUG_BS_WR #if MT_DEBUG_BS_WR
bool bSliceCodedFlag; bool bSliceCodedFlag;
#endif//MT_DEBUG_BS_WR #endif//MT_DEBUG_BS_WR
} SWelsSliceBs; } SWelsSliceBs;

18
codec/encoder/core/inc/nal_prefix.h
View File

@ -43,20 +43,20 @@ namespace WelsSVCEnc {
/* NAL Unix Header in AVC, refer to Page 56 in JVT X201wcm */ /* NAL Unix Header in AVC, refer to Page 56 in JVT X201wcm */
typedef struct TagNalUnitHeader { typedef struct TagNalUnitHeader {
uint8_t uiForbiddenZeroBit; uint8_t uiForbiddenZeroBit;
uint8_t uiNalRefIdc; uint8_t uiNalRefIdc;
EWelsNalUnitType eNalUnitType; EWelsNalUnitType eNalUnitType;
uint8_t uiReservedOneByte; uint8_t uiReservedOneByte;
} SNalUnitHeader, *PNalUnitHeader; } SNalUnitHeader, *PNalUnitHeader;
/* NAL Unit Header in scalable extension syntax, refer to Page 390 in JVT X201wcm */ /* NAL Unit Header in scalable extension syntax, refer to Page 390 in JVT X201wcm */
typedef struct TagNalUnitHeaderExt { typedef struct TagNalUnitHeaderExt {
SNalUnitHeader sNalHeader; SNalUnitHeader sNalHeader;
bool bIdrFlag; bool bIdrFlag;
uint8_t uiDependencyId; uint8_t uiDependencyId;
uint8_t uiTemporalId; uint8_t uiTemporalId;
bool bDiscardableFlag; bool bDiscardableFlag;
} SNalUnitHeaderExt, *PNalUnitHeaderExt; } SNalUnitHeaderExt, *PNalUnitHeaderExt;

706
codec/encoder/core/inc/param_svc.h
View File

@ -64,32 +64,32 @@ extern const uint8_t g_kuiTemporalIdListTable[MAX_TEMPORAL_LEVEL][MAX_GOP_SIZE
* \return 2 based scaling factor * \return 2 based scaling factor
*/ */
static inline uint32_t GetLogFactor (float base, float upper) { static inline uint32_t GetLogFactor (float base, float upper) {
const double dLog2factor = log10 (1.0 * upper / base) / log10 (2.0); const double dLog2factor = log10 (1.0 * upper / base) / log10 (2.0);
const double dEpsilon = 0.0001; const double dEpsilon = 0.0001;
const double dRound = floor (dLog2factor + 0.5); const double dRound = floor (dLog2factor + 0.5);
if (dLog2factor < dRound + dEpsilon && dRound < dLog2factor + dEpsilon) { if (dLog2factor < dRound + dEpsilon && dRound < dLog2factor + dEpsilon) {
return (uint32_t) (dRound); return (uint32_t) (dRound);
} }
return UINT_MAX; return UINT_MAX;
} }
/* /*
* Dependency Layer Parameter * Dependency Layer Parameter
*/ */
typedef struct TagDLayerParam { typedef struct TagDLayerParam {
int32_t iActualWidth; // input source picture actual width int32_t iActualWidth; // input source picture actual width
int32_t iActualHeight; // input source picture actual height int32_t iActualHeight; // input source picture actual height
int32_t iTemporalResolution; int32_t iTemporalResolution;
int32_t iDecompositionStages; int32_t iDecompositionStages;
uint8_t uiCodingIdx2TemporalId[ (1 << MAX_TEMPORAL_LEVEL) + 1]; uint8_t uiCodingIdx2TemporalId[ (1 << MAX_TEMPORAL_LEVEL) + 1];
int8_t iHighestTemporalId; int8_t iHighestTemporalId;
float fInputFrameRate; // input frame rate float fInputFrameRate; // input frame rate
float fOutputFrameRate; // output frame rate float fOutputFrameRate; // output frame rate
#ifdef ENABLE_FRAME_DUMP #ifdef ENABLE_FRAME_DUMP
char sRecFileName[MAX_FNAME_LEN]; // file to be constructed char sRecFileName[MAX_FNAME_LEN]; // file to be constructed
#endif//ENABLE_FRAME_DUMP #endif//ENABLE_FRAME_DUMP
} SSpatialLayerInternal; } SSpatialLayerInternal;
@ -97,424 +97,424 @@ typedef struct TagDLayerParam {
* Cisco OpenH264 Encoder Parameter Configuration * Cisco OpenH264 Encoder Parameter Configuration
*/ */
typedef struct TagWelsSvcCodingParam: SEncParamExt { typedef struct TagWelsSvcCodingParam: SEncParamExt {
SSpatialLayerInternal sDependencyLayers[MAX_DEPENDENCY_LAYER]; SSpatialLayerInternal sDependencyLayers[MAX_DEPENDENCY_LAYER];
/* General */ /* General */
uint32_t uiGopSize; // GOP size (at maximal frame rate: 16) uint32_t uiGopSize; // GOP size (at maximal frame rate: 16)
struct { struct {
int32_t iLeft; int32_t iLeft;
int32_t iTop; int32_t iTop;
int32_t iWidth; int32_t iWidth;
int32_t iHeight; int32_t iHeight;
} SUsedPicRect; // the rect in input picture that encoder actually used } SUsedPicRect; // the rect in input picture that encoder actually used
char* pCurPath; // record current lib path such as:/pData/pData/com.wels.enc/lib/ char* pCurPath; // record current lib path such as:/pData/pData/com.wels.enc/lib/
bool bDeblockingParallelFlag; // deblocking filter parallelization control flag bool bDeblockingParallelFlag; // deblocking filter parallelization control flag
short short
iCountThreadsNum; // # derived from disable_multiple_slice_idc (=0 or >1) means; iCountThreadsNum; // # derived from disable_multiple_slice_idc (=0 or >1) means;
int8_t iDecompStages; // GOP size dependency int8_t iDecompStages; // GOP size dependency
int32_t iMaxNumRefFrame; int32_t iMaxNumRefFrame;
public: public:
TagWelsSvcCodingParam() { TagWelsSvcCodingParam() {
FillDefault(); FillDefault();
} }
~TagWelsSvcCodingParam() {} ~TagWelsSvcCodingParam() {}
static void FillDefault (SEncParamExt& param) { static void FillDefault (SEncParamExt& param) {
memset (&param, 0, sizeof (param)); memset (&param, 0, sizeof (param));
param.uiIntraPeriod = 0; // intra period (multiple of GOP size as desired) param.uiIntraPeriod = 0; // intra period (multiple of GOP size as desired)
param.iNumRefFrame = AUTO_REF_PIC_COUNT;// number of reference frame used param.iNumRefFrame = AUTO_REF_PIC_COUNT;// number of reference frame used
param.iPicWidth = 0; // actual input picture width param.iPicWidth = 0; // actual input picture width
param.iPicHeight = 0; // actual input picture height param.iPicHeight = 0; // actual input picture height
param.fMaxFrameRate = MAX_FRAME_RATE; // maximal frame rate [Hz / fps] param.fMaxFrameRate = MAX_FRAME_RATE; // maximal frame rate [Hz / fps]
param.iInputCsp = videoFormatI420; // input sequence color space in default param.iInputCsp = videoFormatI420; // input sequence color space in default
param.uiFrameToBeCoded = (uint32_t) - 1; // frame to be encoded (at input frame rate) param.uiFrameToBeCoded = (uint32_t) - 1; // frame to be encoded (at input frame rate)
param.iTargetBitrate = 0; // overall target bitrate introduced in RC module param.iTargetBitrate = 0; // overall target bitrate introduced in RC module
param.iMaxBitrate = MAX_BIT_RATE; param.iMaxBitrate = MAX_BIT_RATE;
param.iMultipleThreadIdc = 1; param.iMultipleThreadIdc = 1;
param.iLTRRefNum = 0; param.iLTRRefNum = 0;
param.iLtrMarkPeriod = 30; //the min distance of two int32_t references param.iLtrMarkPeriod = 30; //the min distance of two int32_t references
param.bEnableSSEI = true; param.bEnableSSEI = true;
param.bEnableFrameCroppingFlag = true; // enable frame cropping flag: true alwayse in application param.bEnableFrameCroppingFlag = true; // enable frame cropping flag: true alwayse in application
// false: Streaming Video Sharing; true: Video Conferencing Meeting; // false: Streaming Video Sharing; true: Video Conferencing Meeting;
/* Deblocking loop filter */ /* Deblocking loop filter */
param.iLoopFilterDisableIdc = 0; // 0: on, 1: off, 2: on except for slice boundaries param.iLoopFilterDisableIdc = 0; // 0: on, 1: off, 2: on except for slice boundaries
param.iLoopFilterAlphaC0Offset = 0; // AlphaOffset: valid range [-6, 6], default 0 param.iLoopFilterAlphaC0Offset = 0; // AlphaOffset: valid range [-6, 6], default 0
param.iLoopFilterBetaOffset = 0; // BetaOffset: valid range [-6, 6], default 0 param.iLoopFilterBetaOffset = 0; // BetaOffset: valid range [-6, 6], default 0
/* Rate Control */ /* Rate Control */
param.iRCMode = RC_QUALITY_MODE; param.iRCMode = RC_QUALITY_MODE;
param.iPaddingFlag = 0; param.iPaddingFlag = 0;
param.bEnableDenoise = false; // denoise control param.bEnableDenoise = false; // denoise control
param.bEnableSceneChangeDetect = true; // scene change detection control param.bEnableSceneChangeDetect = true; // scene change detection control
param.bEnableBackgroundDetection = true; // background detection control param.bEnableBackgroundDetection = true; // background detection control
param.bEnableAdaptiveQuant = true; // adaptive quantization control param.bEnableAdaptiveQuant = true; // adaptive quantization control
param.bEnableFrameSkip = true; // frame skipping param.bEnableFrameSkip = true; // frame skipping
param.bEnableLongTermReference = false; // long term reference control param.bEnableLongTermReference = false; // long term reference control
param.bEnableSpsPpsIdAddition = true; // pSps pPps id addition control param.bEnableSpsPpsIdAddition = true; // pSps pPps id addition control
param.bPrefixNalAddingCtrl = false; // prefix NAL adding control param.bPrefixNalAddingCtrl = false; // prefix NAL adding control
param.iSpatialLayerNum = 1; // number of dependency(Spatial/CGS) layers used to be encoded param.iSpatialLayerNum = 1; // number of dependency(Spatial/CGS) layers used to be encoded
param.iTemporalLayerNum = 1; // number of temporal layer specified param.iTemporalLayerNum = 1; // number of temporal layer specified
param.iMaxQp = 51; param.iMaxQp = 51;
param.iMinQp = 0; param.iMinQp = 0;
param.iUsageType = CAMERA_VIDEO_REAL_TIME; param.iUsageType = CAMERA_VIDEO_REAL_TIME;
param.uiMaxNalSize = 0; param.uiMaxNalSize = 0;
for (int32_t iLayer = 0; iLayer < MAX_SPATIAL_LAYER_NUM; iLayer++) { for (int32_t iLayer = 0; iLayer < MAX_SPATIAL_LAYER_NUM; iLayer++) {
param.sSpatialLayers[iLayer].uiProfileIdc = PRO_BASELINE; param.sSpatialLayers[iLayer].uiProfileIdc = PRO_BASELINE;
param.sSpatialLayers[iLayer].uiLevelIdc = LEVEL_5_0; param.sSpatialLayers[iLayer].uiLevelIdc = LEVEL_5_0;
param.sSpatialLayers[iLayer].iDLayerQp = SVC_QUALITY_BASE_QP; param.sSpatialLayers[iLayer].iDLayerQp = SVC_QUALITY_BASE_QP;
param.sSpatialLayers[iLayer].fFrameRate = param.fMaxFrameRate; param.sSpatialLayers[iLayer].fFrameRate = param.fMaxFrameRate;
param.sSpatialLayers[iLayer].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; param.sSpatialLayers[iLayer].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 1500; param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 1500;
param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceNum = 1; param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceNum = 1;
const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP);
for (int32_t idx = 0; idx < kiLesserSliceNum; idx++)
param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceMbNum[idx] = 960;
}
}
void FillDefault() {
FillDefault (*this);
uiGopSize = 1; // GOP size (at maximal frame rate: 16)
iMaxNumRefFrame = 1;
SUsedPicRect.iLeft =
SUsedPicRect.iTop =
SUsedPicRect.iWidth =
SUsedPicRect.iHeight = 0; // the rect in input picture that encoder actually used
pCurPath = NULL; // record current lib path such as:/pData/pData/com.wels.enc/lib/
bDeblockingParallelFlag = false; // deblocking filter parallelization control flag
iCountThreadsNum = 1; // # derived from disable_multiple_slice_idc (=0 or >1) means;
iDecompStages = 0; // GOP size dependency, unknown here and be revised later
memset (sDependencyLayers, 0, sizeof (SSpatialLayerInternal)*MAX_DEPENDENCY_LAYER);
memset (sSpatialLayers, 0 , sizeof (SSpatialLayerConfig)*MAX_SPATIAL_LAYER_NUM);
//init multi-slice
sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 1500;
sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 1;
const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP); const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP);
for (int32_t idx = 0; idx < kiLesserSliceNum; idx++) for (int32_t idx = 0; idx < kiLesserSliceNum; idx++)
sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceMbNum[idx] = 960; param.sSpatialLayers[iLayer].sSliceCfg.sSliceArgument.uiSliceMbNum[idx] = 960;
sSpatialLayers[0].iDLayerQp = SVC_QUALITY_BASE_QP;
} }
}
int32_t ParamBaseTranscode (const SEncParamBase& pCodingParam) { void FillDefault() {
FillDefault (*this);
uiGopSize = 1; // GOP size (at maximal frame rate: 16)
iMaxNumRefFrame = 1;
SUsedPicRect.iLeft =
SUsedPicRect.iTop =
SUsedPicRect.iWidth =
SUsedPicRect.iHeight = 0; // the rect in input picture that encoder actually used
iInputCsp = pCodingParam.iInputCsp; // color space of input sequence pCurPath = NULL; // record current lib path such as:/pData/pData/com.wels.enc/lib/
fMaxFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
iTargetBitrate = pCodingParam.iTargetBitrate;
iUsageType = pCodingParam.iUsageType;
iPicWidth = pCodingParam.iPicWidth;
iPicHeight = pCodingParam.iPicHeight;
SUsedPicRect.iLeft = 0; bDeblockingParallelFlag = false; // deblocking filter parallelization control flag
SUsedPicRect.iTop = 0;
SUsedPicRect.iWidth = ((iPicWidth >> 1) << 1);
SUsedPicRect.iHeight = ((iPicHeight >> 1) << 1);
iRCMode = pCodingParam.iRCMode; // rc mode iCountThreadsNum = 1; // # derived from disable_multiple_slice_idc (=0 or >1) means;
int8_t iIdxSpatial = 0; iDecompStages = 0; // GOP size dependency, unknown here and be revised later
EProfileIdc uiProfileIdc = PRO_BASELINE;
SSpatialLayerInternal* pDlp = &sDependencyLayers[0]; memset (sDependencyLayers, 0, sizeof (SSpatialLayerInternal)*MAX_DEPENDENCY_LAYER);
memset (sSpatialLayers, 0 , sizeof (SSpatialLayerConfig)*MAX_SPATIAL_LAYER_NUM);
while (iIdxSpatial < iSpatialLayerNum) {
sSpatialLayers->uiProfileIdc = uiProfileIdc; //init multi-slice
sSpatialLayers[iIdxSpatial].fFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate, sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
MIN_FRAME_RATE, MAX_FRAME_RATE); sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 1500;
pDlp->fInputFrameRate = sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 1;
pDlp->fOutputFrameRate = WELS_CLIP3 (sSpatialLayers[iIdxSpatial].fFrameRate, MIN_FRAME_RATE,
MAX_FRAME_RATE); const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP);
for (int32_t idx = 0; idx < kiLesserSliceNum; idx++)
sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceMbNum[idx] = 960;
sSpatialLayers[0].iDLayerQp = SVC_QUALITY_BASE_QP;
}
int32_t ParamBaseTranscode (const SEncParamBase& pCodingParam) {
iInputCsp = pCodingParam.iInputCsp; // color space of input sequence
fMaxFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
iTargetBitrate = pCodingParam.iTargetBitrate;
iUsageType = pCodingParam.iUsageType;
iPicWidth = pCodingParam.iPicWidth;
iPicHeight = pCodingParam.iPicHeight;
SUsedPicRect.iLeft = 0;
SUsedPicRect.iTop = 0;
SUsedPicRect.iWidth = ((iPicWidth >> 1) << 1);
SUsedPicRect.iHeight = ((iPicHeight >> 1) << 1);
iRCMode = pCodingParam.iRCMode; // rc mode
int8_t iIdxSpatial = 0;
EProfileIdc uiProfileIdc = PRO_BASELINE;
SSpatialLayerInternal* pDlp = &sDependencyLayers[0];
while (iIdxSpatial < iSpatialLayerNum) {
sSpatialLayers->uiProfileIdc = uiProfileIdc;
sSpatialLayers[iIdxSpatial].fFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate,
MIN_FRAME_RATE, MAX_FRAME_RATE);
pDlp->fInputFrameRate =
pDlp->fOutputFrameRate = WELS_CLIP3 (sSpatialLayers[iIdxSpatial].fFrameRate, MIN_FRAME_RATE,
MAX_FRAME_RATE);
#ifdef ENABLE_FRAME_DUMP #ifdef ENABLE_FRAME_DUMP
pDlp->sRecFileName[0] = '\0'; // file to be constructed pDlp->sRecFileName[0] = '\0'; // file to be constructed
#endif//ENABLE_FRAME_DUMP #endif//ENABLE_FRAME_DUMP
pDlp->iActualWidth = sSpatialLayers[iIdxSpatial].iVideoWidth = iPicWidth; pDlp->iActualWidth = sSpatialLayers[iIdxSpatial].iVideoWidth = iPicWidth;
pDlp->iActualHeight = sSpatialLayers[iIdxSpatial].iVideoHeight = iPicHeight; pDlp->iActualHeight = sSpatialLayers[iIdxSpatial].iVideoHeight = iPicHeight;
sSpatialLayers->iSpatialBitrate = sSpatialLayers->iSpatialBitrate =
sSpatialLayers[iIdxSpatial].iSpatialBitrate = pCodingParam.iTargetBitrate; // target bitrate for current spatial layer sSpatialLayers[iIdxSpatial].iSpatialBitrate = pCodingParam.iTargetBitrate; // target bitrate for current spatial layer
sSpatialLayers->iDLayerQp = SVC_QUALITY_BASE_QP; sSpatialLayers->iDLayerQp = SVC_QUALITY_BASE_QP;
uiProfileIdc = PRO_SCALABLE_BASELINE; uiProfileIdc = PRO_SCALABLE_BASELINE;
++ pDlp; ++ pDlp;
++ iIdxSpatial; ++ iIdxSpatial;
}
SetActualPicResolution();
return 0;
} }
void GetBaseParams (SEncParamBase* pCodingParam) { SetActualPicResolution();
pCodingParam->iUsageType = iUsageType;
pCodingParam->iInputCsp = iInputCsp; return 0;
pCodingParam->iPicWidth = iPicWidth; }
pCodingParam->iPicHeight = iPicHeight; void GetBaseParams (SEncParamBase* pCodingParam) {
pCodingParam->iTargetBitrate = iTargetBitrate; pCodingParam->iUsageType = iUsageType;
pCodingParam->iRCMode = iRCMode; pCodingParam->iInputCsp = iInputCsp;
pCodingParam->fMaxFrameRate = fMaxFrameRate; pCodingParam->iPicWidth = iPicWidth;
pCodingParam->iPicHeight = iPicHeight;
pCodingParam->iTargetBitrate = iTargetBitrate;
pCodingParam->iRCMode = iRCMode;
pCodingParam->fMaxFrameRate = fMaxFrameRate;
}
int32_t ParamTranscode (const SEncParamExt& pCodingParam) {
float fParamMaxFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
iInputCsp = pCodingParam.iInputCsp; // color space of input sequence
uiFrameToBeCoded = (uint32_t) -
1; // frame to be encoded (at input frame rate), -1 dependents on length of input sequence
iUsageType = pCodingParam.iUsageType;
iPicWidth = pCodingParam.iPicWidth;
iPicHeight = pCodingParam.iPicHeight;
SUsedPicRect.iLeft = 0;
SUsedPicRect.iTop = 0;
SUsedPicRect.iWidth = ((iPicWidth >> 1) << 1);
SUsedPicRect.iHeight = ((iPicHeight >> 1) << 1);
/* Deblocking loop filter */
iLoopFilterDisableIdc = pCodingParam.iLoopFilterDisableIdc; // 0: on, 1: off, 2: on except for slice boundaries,
if (iLoopFilterDisableIdc == 0) // Loop filter requested to be enabled
iLoopFilterDisableIdc = 2; // Disable loop filter on slice boundaries since that's not allowed with multithreading
iLoopFilterAlphaC0Offset = pCodingParam.iLoopFilterAlphaC0Offset; // AlphaOffset: valid range [-6, 6], default 0
iLoopFilterBetaOffset = pCodingParam.iLoopFilterBetaOffset; // BetaOffset: valid range [-6, 6], default 0
bEnableFrameCroppingFlag = pCodingParam.bEnableFrameCroppingFlag;
/* Rate Control */
iRCMode = pCodingParam.iRCMode; // rc mode
iPaddingFlag = pCodingParam.iPaddingFlag;
iTargetBitrate = pCodingParam.iTargetBitrate; // target bitrate
iMaxBitrate = pCodingParam.iMaxBitrate;
if (iMaxBitrate < iTargetBitrate) {
iMaxBitrate = iTargetBitrate;
} }
int32_t ParamTranscode (const SEncParamExt& pCodingParam) {
float fParamMaxFrameRate = WELS_CLIP3 (pCodingParam.fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
iInputCsp = pCodingParam.iInputCsp; // color space of input sequence uiMaxNalSize = pCodingParam.uiMaxNalSize;
uiFrameToBeCoded = (uint32_t) - /* Denoise Control */
1; // frame to be encoded (at input frame rate), -1 dependents on length of input sequence bEnableDenoise = pCodingParam.bEnableDenoise ? true : false; // Denoise Control // only support 0 or 1 now
iUsageType = pCodingParam.iUsageType;
iPicWidth = pCodingParam.iPicWidth;
iPicHeight = pCodingParam.iPicHeight;
SUsedPicRect.iLeft = 0; /* Scene change detection control */
SUsedPicRect.iTop = 0; bEnableSceneChangeDetect = pCodingParam.bEnableSceneChangeDetect;
SUsedPicRect.iWidth = ((iPicWidth >> 1) << 1);
SUsedPicRect.iHeight = ((iPicHeight >> 1) << 1);
/* Deblocking loop filter */ /* Background detection Control */
iLoopFilterDisableIdc = pCodingParam.iLoopFilterDisableIdc; // 0: on, 1: off, 2: on except for slice boundaries, bEnableBackgroundDetection = pCodingParam.bEnableBackgroundDetection ? true : false;
if (iLoopFilterDisableIdc == 0) // Loop filter requested to be enabled
iLoopFilterDisableIdc = 2; // Disable loop filter on slice boundaries since that's not allowed with multithreading
iLoopFilterAlphaC0Offset = pCodingParam.iLoopFilterAlphaC0Offset; // AlphaOffset: valid range [-6, 6], default 0
iLoopFilterBetaOffset = pCodingParam.iLoopFilterBetaOffset; // BetaOffset: valid range [-6, 6], default 0
bEnableFrameCroppingFlag = pCodingParam.bEnableFrameCroppingFlag; /* Adaptive quantization control */
bEnableAdaptiveQuant = pCodingParam.bEnableAdaptiveQuant ? true : false;
/* Rate Control */ /* Frame skipping */
iRCMode = pCodingParam.iRCMode; // rc mode bEnableFrameSkip = pCodingParam.bEnableFrameSkip ? true : false;
iPaddingFlag = pCodingParam.iPaddingFlag;
iTargetBitrate = pCodingParam.iTargetBitrate; // target bitrate /* Enable int32_t term reference */
iMaxBitrate = pCodingParam.iMaxBitrate; bEnableLongTermReference = pCodingParam.bEnableLongTermReference ? true : false;
if (iMaxBitrate < iTargetBitrate) { iLtrMarkPeriod = pCodingParam.iLtrMarkPeriod;
iMaxBitrate = iTargetBitrate;
}
uiMaxNalSize = pCodingParam.uiMaxNalSize; iMultipleThreadIdc = pCodingParam.iMultipleThreadIdc;
/* Denoise Control */
bEnableDenoise = pCodingParam.bEnableDenoise ? true : false; // Denoise Control // only support 0 or 1 now
/* Scene change detection control */ /* For ssei information */
bEnableSceneChangeDetect = pCodingParam.bEnableSceneChangeDetect; bEnableSSEI = pCodingParam.bEnableSSEI;
/* Background detection Control */ /* Layer definition */
bEnableBackgroundDetection = pCodingParam.bEnableBackgroundDetection ? true : false; iSpatialLayerNum = (int8_t)WELS_CLIP3 (pCodingParam.iSpatialLayerNum, 1,
MAX_DEPENDENCY_LAYER); // number of dependency(Spatial/CGS) layers used to be encoded
iTemporalLayerNum = (int8_t)WELS_CLIP3 (pCodingParam.iTemporalLayerNum, 1,
MAX_TEMPORAL_LEVEL); // number of temporal layer specified
/* Adaptive quantization control */ uiGopSize = 1 << (iTemporalLayerNum - 1); // Override GOP size based temporal layer
bEnableAdaptiveQuant = pCodingParam.bEnableAdaptiveQuant ? true : false; iDecompStages = iTemporalLayerNum - 1; // WELS_LOG2( uiGopSize );// GOP size dependency
uiIntraPeriod = pCodingParam.uiIntraPeriod;// intra period (multiple of GOP size as desired)
if (uiIntraPeriod == (uint32_t) (-1))
uiIntraPeriod = 0;
else if (uiIntraPeriod & (uiGopSize - 1)) // none multiple of GOP size
uiIntraPeriod = ((uiIntraPeriod + uiGopSize - 1) / uiGopSize) * uiGopSize;
/* Frame skipping */ if (iUsageType == SCREEN_CONTENT_REAL_TIME) {
bEnableFrameSkip = pCodingParam.bEnableFrameSkip ? true : false; if (bEnableLongTermReference) {
iLTRRefNum = WELS_CLIP3 (pCodingParam.iLTRRefNum, 1, LONG_TERM_REF_NUM_SCREEN);
/* Enable int32_t term reference */ if (iNumRefFrame == AUTO_REF_PIC_COUNT)
bEnableLongTermReference = pCodingParam.bEnableLongTermReference ? true : false; iNumRefFrame = WELS_MAX (1, WELS_LOG2 (uiGopSize)) + iLTRRefNum;
iLtrMarkPeriod = pCodingParam.iLtrMarkPeriod;
iMultipleThreadIdc = pCodingParam.iMultipleThreadIdc;
/* For ssei information */
bEnableSSEI = pCodingParam.bEnableSSEI;
/* Layer definition */
iSpatialLayerNum = (int8_t)WELS_CLIP3 (pCodingParam.iSpatialLayerNum, 1,
MAX_DEPENDENCY_LAYER); // number of dependency(Spatial/CGS) layers used to be encoded
iTemporalLayerNum = (int8_t)WELS_CLIP3 (pCodingParam.iTemporalLayerNum, 1,
MAX_TEMPORAL_LEVEL); // number of temporal layer specified
uiGopSize = 1 << (iTemporalLayerNum - 1); // Override GOP size based temporal layer
iDecompStages = iTemporalLayerNum - 1; // WELS_LOG2( uiGopSize );// GOP size dependency
uiIntraPeriod = pCodingParam.uiIntraPeriod;// intra period (multiple of GOP size as desired)
if (uiIntraPeriod == (uint32_t) (-1))
uiIntraPeriod = 0;
else if (uiIntraPeriod & (uiGopSize - 1)) // none multiple of GOP size
uiIntraPeriod = ((uiIntraPeriod + uiGopSize - 1) / uiGopSize) * uiGopSize;
if (iUsageType == SCREEN_CONTENT_REAL_TIME) {
if (bEnableLongTermReference) {
iLTRRefNum = WELS_CLIP3 (pCodingParam.iLTRRefNum, 1, LONG_TERM_REF_NUM_SCREEN);
if (iNumRefFrame == AUTO_REF_PIC_COUNT)
iNumRefFrame = WELS_MAX (1, WELS_LOG2 (uiGopSize)) + iLTRRefNum;
} else {
iLTRRefNum = 0;
if (iNumRefFrame == AUTO_REF_PIC_COUNT)
iNumRefFrame = WELS_MAX (1, uiGopSize >> 1);
}
} else { } else {
iLTRRefNum = bEnableLongTermReference ? WELS_CLIP3 (pCodingParam.iLTRRefNum, 1, LONG_TERM_REF_NUM) : 0; iLTRRefNum = 0;
if (iNumRefFrame == AUTO_REF_PIC_COUNT) {
iNumRefFrame = ((uiGopSize >> 1) > 1) ? ((uiGopSize >> 1) + iLTRRefNum) : (MIN_REF_PIC_COUNT + iLTRRefNum); if (iNumRefFrame == AUTO_REF_PIC_COUNT)
iNumRefFrame = WELS_CLIP3 (iNumRefFrame, MIN_REF_PIC_COUNT, MAX_REFERENCE_PICTURE_COUNT_NUM); iNumRefFrame = WELS_MAX (1, uiGopSize >> 1);
}
} }
if (iNumRefFrame > iMaxNumRefFrame) } else {
iMaxNumRefFrame = iNumRefFrame; iLTRRefNum = bEnableLongTermReference ? WELS_CLIP3 (pCodingParam.iLTRRefNum, 1, LONG_TERM_REF_NUM) : 0;
iLtrMarkPeriod = pCodingParam.iLtrMarkPeriod; if (iNumRefFrame == AUTO_REF_PIC_COUNT) {
iNumRefFrame = ((uiGopSize >> 1) > 1) ? ((uiGopSize >> 1) + iLTRRefNum) : (MIN_REF_PIC_COUNT + iLTRRefNum);
iNumRefFrame = WELS_CLIP3 (iNumRefFrame, MIN_REF_PIC_COUNT, MAX_REFERENCE_PICTURE_COUNT_NUM);
}
}
if (iNumRefFrame > iMaxNumRefFrame)
iMaxNumRefFrame = iNumRefFrame;
iLtrMarkPeriod = pCodingParam.iLtrMarkPeriod;
bPrefixNalAddingCtrl = pCodingParam.bPrefixNalAddingCtrl; bPrefixNalAddingCtrl = pCodingParam.bPrefixNalAddingCtrl;
bEnableSpsPpsIdAddition = bEnableSpsPpsIdAddition =
pCodingParam.bEnableSpsPpsIdAddition;//For SVC meeting application, to avoid mosaic issue caused by cross-IDR reference. pCodingParam.bEnableSpsPpsIdAddition;//For SVC meeting application, to avoid mosaic issue caused by cross-IDR reference.
//SHOULD enable this feature. //SHOULD enable this feature.
SSpatialLayerInternal* pDlp = &sDependencyLayers[0]; SSpatialLayerInternal* pDlp = &sDependencyLayers[0];
SSpatialLayerConfig* pSpatialLayer = &sSpatialLayers[0]; SSpatialLayerConfig* pSpatialLayer = &sSpatialLayers[0];
float fMaxFr = .0f; float fMaxFr = .0f;
EProfileIdc uiProfileIdc = PRO_BASELINE; EProfileIdc uiProfileIdc = PRO_BASELINE;
int8_t iIdxSpatial = 0; int8_t iIdxSpatial = 0;
while (iIdxSpatial < iSpatialLayerNum) { while (iIdxSpatial < iSpatialLayerNum) {
pSpatialLayer->uiProfileIdc = (pCodingParam.sSpatialLayers[iIdxSpatial].uiProfileIdc == PRO_UNKNOWN) ? uiProfileIdc : pSpatialLayer->uiProfileIdc = (pCodingParam.sSpatialLayers[iIdxSpatial].uiProfileIdc == PRO_UNKNOWN) ? uiProfileIdc :
pCodingParam.sSpatialLayers[iIdxSpatial].uiProfileIdc; pCodingParam.sSpatialLayers[iIdxSpatial].uiProfileIdc;
pSpatialLayer->uiLevelIdc = (pCodingParam.sSpatialLayers[iIdxSpatial].uiLevelIdc == LEVEL_UNKNOWN) ? LEVEL_5_0 : pSpatialLayer->uiLevelIdc = (pCodingParam.sSpatialLayers[iIdxSpatial].uiLevelIdc == LEVEL_UNKNOWN) ? LEVEL_5_0 :
pCodingParam.sSpatialLayers[iIdxSpatial].uiLevelIdc; pCodingParam.sSpatialLayers[iIdxSpatial].uiLevelIdc;
float fLayerFrameRate = WELS_CLIP3 (pCodingParam.sSpatialLayers[iIdxSpatial].fFrameRate, float fLayerFrameRate = WELS_CLIP3 (pCodingParam.sSpatialLayers[iIdxSpatial].fFrameRate,
MIN_FRAME_RATE, fParamMaxFrameRate); MIN_FRAME_RATE, fParamMaxFrameRate);
pSpatialLayer->fFrameRate = pSpatialLayer->fFrameRate =
pDlp->fInputFrameRate = pDlp->fInputFrameRate =
pDlp->fOutputFrameRate = WELS_CLIP3 (fLayerFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE); pDlp->fOutputFrameRate = WELS_CLIP3 (fLayerFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
if (pDlp->fInputFrameRate > fMaxFr + EPSN) if (pDlp->fInputFrameRate > fMaxFr + EPSN)
fMaxFr = pDlp->fInputFrameRate; fMaxFr = pDlp->fInputFrameRate;
#ifdef ENABLE_FRAME_DUMP #ifdef ENABLE_FRAME_DUMP
pDlp->sRecFileName[0] = '\0'; // file to be constructed pDlp->sRecFileName[0] = '\0'; // file to be constructed
#endif//ENABLE_FRAME_DUMP #endif//ENABLE_FRAME_DUMP
pSpatialLayer->iVideoWidth = pCodingParam.sSpatialLayers[iIdxSpatial].iVideoWidth; // frame width pSpatialLayer->iVideoWidth = pCodingParam.sSpatialLayers[iIdxSpatial].iVideoWidth; // frame width
pSpatialLayer->iVideoHeight = pCodingParam.sSpatialLayers[iIdxSpatial].iVideoHeight;// frame height pSpatialLayer->iVideoHeight = pCodingParam.sSpatialLayers[iIdxSpatial].iVideoHeight;// frame height
pSpatialLayer->iSpatialBitrate = pSpatialLayer->iSpatialBitrate =
pCodingParam.sSpatialLayers[iIdxSpatial].iSpatialBitrate; // target bitrate for current spatial layer pCodingParam.sSpatialLayers[iIdxSpatial].iSpatialBitrate; // target bitrate for current spatial layer
//multi slice //multi slice
pSpatialLayer->sSliceCfg.uiSliceMode = pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.uiSliceMode; pSpatialLayer->sSliceCfg.uiSliceMode = pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.uiSliceMode;
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint
= (uint32_t) (pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceSizeConstraint); = (uint32_t) (pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceSizeConstraint);
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum
= pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceNum; = pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceNum;
const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP); const int32_t kiLesserSliceNum = ((MAX_SLICES_NUM < MAX_SLICES_NUM_TMP) ? MAX_SLICES_NUM : MAX_SLICES_NUM_TMP);
memcpy (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum, memcpy (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum,
pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceMbNum, // confirmed_safe_unsafe_usage pCodingParam.sSpatialLayers[iIdxSpatial].sSliceCfg.sSliceArgument.uiSliceMbNum, // confirmed_safe_unsafe_usage
kiLesserSliceNum * sizeof (uint32_t)) ; kiLesserSliceNum * sizeof (uint32_t)) ;
pSpatialLayer->iDLayerQp = pCodingParam.sSpatialLayers[iIdxSpatial].iDLayerQp; pSpatialLayer->iDLayerQp = pCodingParam.sSpatialLayers[iIdxSpatial].iDLayerQp;
uiProfileIdc = PRO_SCALABLE_BASELINE; uiProfileIdc = PRO_SCALABLE_BASELINE;
++ pDlp; ++ pDlp;
++ pSpatialLayer; ++ pSpatialLayer;
++ iIdxSpatial; ++ iIdxSpatial;
}
fMaxFrameRate = fMaxFr;
SetActualPicResolution();
return 0;
} }
fMaxFrameRate = fMaxFr;
SetActualPicResolution();
return 0;
}
// assuming that the width/height ratio of all spatial layers are the same // assuming that the width/height ratio of all spatial layers are the same
void SetActualPicResolution() { void SetActualPicResolution() {
int32_t iSpatialIdx = iSpatialLayerNum - 1; int32_t iSpatialIdx = iSpatialLayerNum - 1;
for (; iSpatialIdx >= 0; iSpatialIdx --) { for (; iSpatialIdx >= 0; iSpatialIdx --) {
SSpatialLayerInternal* pDlayerInternal = &sDependencyLayers[iSpatialIdx]; SSpatialLayerInternal* pDlayerInternal = &sDependencyLayers[iSpatialIdx];
SSpatialLayerConfig* pDlayer = &sSpatialLayers[iSpatialIdx]; SSpatialLayerConfig* pDlayer = &sSpatialLayers[iSpatialIdx];
pDlayerInternal->iActualWidth = pDlayer->iVideoWidth; pDlayerInternal->iActualWidth = pDlayer->iVideoWidth;
pDlayerInternal->iActualHeight = pDlayer->iVideoHeight; pDlayerInternal->iActualHeight = pDlayer->iVideoHeight;
pDlayer->iVideoWidth = WELS_ALIGN (pDlayerInternal->iActualWidth, MB_WIDTH_LUMA); pDlayer->iVideoWidth = WELS_ALIGN (pDlayerInternal->iActualWidth, MB_WIDTH_LUMA);
pDlayer->iVideoHeight = WELS_ALIGN (pDlayerInternal->iActualHeight, MB_HEIGHT_LUMA); pDlayer->iVideoHeight = WELS_ALIGN (pDlayerInternal->iActualHeight, MB_HEIGHT_LUMA);
}
} }
}
/*! /*!
* \brief determined key coding tables for temporal scalability, uiProfileIdc etc for each spatial layer settings * \brief determined key coding tables for temporal scalability, uiProfileIdc etc for each spatial layer settings
* \param SWelsSvcCodingParam, and carried with known GOP size, max, input and output frame rate of each spatial * \param SWelsSvcCodingParam, and carried with known GOP size, max, input and output frame rate of each spatial
* \return NONE (should ensure valid parameter before this procedure) * \return NONE (should ensure valid parameter before this procedure)
*/ */
void DetermineTemporalSettings() { void DetermineTemporalSettings() {
const int32_t iDecStages = WELS_LOG2 ( const int32_t iDecStages = WELS_LOG2 (
uiGopSize); // (int8_t)GetLogFactor(1.0f, 1.0f * pcfg->uiGopSize); //log2(uiGopSize) uiGopSize); // (int8_t)GetLogFactor(1.0f, 1.0f * pcfg->uiGopSize); //log2(uiGopSize)
const uint8_t* pTemporalIdList = &g_kuiTemporalIdListTable[iDecStages][0]; const uint8_t* pTemporalIdList = &g_kuiTemporalIdListTable[iDecStages][0];
SSpatialLayerInternal* pDlp = &sDependencyLayers[0]; SSpatialLayerInternal* pDlp = &sDependencyLayers[0];
SSpatialLayerConfig* pSpatialLayer = &sSpatialLayers[0]; SSpatialLayerConfig* pSpatialLayer = &sSpatialLayers[0];
EProfileIdc uiProfileIdc = PRO_BASELINE; EProfileIdc uiProfileIdc = PRO_BASELINE;
int8_t i = 0; int8_t i = 0;
while (i < iSpatialLayerNum) { while (i < iSpatialLayerNum) {
const uint32_t kuiLogFactorInOutRate = GetLogFactor (pDlp->fOutputFrameRate, pDlp->fInputFrameRate); const uint32_t kuiLogFactorInOutRate = GetLogFactor (pDlp->fOutputFrameRate, pDlp->fInputFrameRate);
const uint32_t kuiLogFactorMaxInRate = GetLogFactor (pDlp->fInputFrameRate, fMaxFrameRate); const uint32_t kuiLogFactorMaxInRate = GetLogFactor (pDlp->fInputFrameRate, fMaxFrameRate);
int32_t iNotCodedMask = 0; int32_t iNotCodedMask = 0;
int8_t iMaxTemporalId = 0; int8_t iMaxTemporalId = 0;
memset (pDlp->uiCodingIdx2TemporalId, INVALID_TEMPORAL_ID, sizeof (pDlp->uiCodingIdx2TemporalId)); memset (pDlp->uiCodingIdx2TemporalId, INVALID_TEMPORAL_ID, sizeof (pDlp->uiCodingIdx2TemporalId));
pSpatialLayer->uiProfileIdc = uiProfileIdc; // PRO_BASELINE, PRO_SCALABLE_BASELINE; pSpatialLayer->uiProfileIdc = uiProfileIdc; // PRO_BASELINE, PRO_SCALABLE_BASELINE;
iNotCodedMask = (1 << (kuiLogFactorInOutRate + kuiLogFactorMaxInRate)) - 1; iNotCodedMask = (1 << (kuiLogFactorInOutRate + kuiLogFactorMaxInRate)) - 1;
for (uint32_t uiFrameIdx = 0; uiFrameIdx <= uiGopSize; ++ uiFrameIdx) { for (uint32_t uiFrameIdx = 0; uiFrameIdx <= uiGopSize; ++ uiFrameIdx) {
if (0 == (uiFrameIdx & iNotCodedMask)) { if (0 == (uiFrameIdx & iNotCodedMask)) {
const int8_t kiTemporalId = pTemporalIdList[uiFrameIdx]; const int8_t kiTemporalId = pTemporalIdList[uiFrameIdx];
pDlp->uiCodingIdx2TemporalId[uiFrameIdx] = kiTemporalId; pDlp->uiCodingIdx2TemporalId[uiFrameIdx] = kiTemporalId;
if (kiTemporalId > iMaxTemporalId) { if (kiTemporalId > iMaxTemporalId) {
iMaxTemporalId = kiTemporalId; iMaxTemporalId = kiTemporalId;
}
} }
} }
pDlp->iHighestTemporalId = iMaxTemporalId;
pDlp->iTemporalResolution = kuiLogFactorMaxInRate + kuiLogFactorInOutRate;
pDlp->iDecompositionStages = iDecStages - kuiLogFactorMaxInRate - kuiLogFactorInOutRate;
uiProfileIdc = PRO_SCALABLE_BASELINE;
++ pDlp;
++ pSpatialLayer;
++ i;
} }
iDecompStages = (int8_t)iDecStages;
pDlp->iHighestTemporalId = iMaxTemporalId;
pDlp->iTemporalResolution = kuiLogFactorMaxInRate + kuiLogFactorInOutRate;
pDlp->iDecompositionStages = iDecStages - kuiLogFactorMaxInRate - kuiLogFactorInOutRate;
uiProfileIdc = PRO_SCALABLE_BASELINE;
++ pDlp;
++ pSpatialLayer;
++ i;
} }
iDecompStages = (int8_t)iDecStages;
}
} SWelsSvcCodingParam; } SWelsSvcCodingParam;
static inline int32_t FreeCodingParam (SWelsSvcCodingParam** pParam, CMemoryAlign* pMa) { static inline int32_t FreeCodingParam (SWelsSvcCodingParam** pParam, CMemoryAlign* pMa) {
if (pParam == NULL || *pParam == NULL || pMa == NULL) if (pParam == NULL || *pParam == NULL || pMa == NULL)
return 1; return 1;
pMa->WelsFree (*pParam, "SWelsSvcCodingParam"); pMa->WelsFree (*pParam, "SWelsSvcCodingParam");
*pParam = NULL; *pParam = NULL;
return 0; return 0;
} }
static inline int32_t AllocCodingParam (SWelsSvcCodingParam** pParam, CMemoryAlign* pMa) { static inline int32_t AllocCodingParam (SWelsSvcCodingParam** pParam, CMemoryAlign* pMa) {
if (pParam == NULL || pMa == NULL) if (pParam == NULL || pMa == NULL)
return 1; return 1;
if (*pParam != NULL) { if (*pParam != NULL) {
FreeCodingParam (pParam, pMa); FreeCodingParam (pParam, pMa);
} }
SWelsSvcCodingParam* pCodingParam = (SWelsSvcCodingParam*)pMa->WelsMalloc (sizeof (SWelsSvcCodingParam), SWelsSvcCodingParam* pCodingParam = (SWelsSvcCodingParam*)pMa->WelsMalloc (sizeof (SWelsSvcCodingParam),
"SWelsSvcCodingParam"); "SWelsSvcCodingParam");
if (NULL == pCodingParam) if (NULL == pCodingParam)
return 1; return 1;
*pParam = pCodingParam; *pParam = pCodingParam;
return 0; return 0;
} }
}//end of namespace WelsSVCEnc }//end of namespace WelsSVCEnc

88
codec/encoder/core/inc/parameter_sets.h
View File

@ -41,48 +41,48 @@ namespace WelsSVCEnc {
/* Sequence Parameter Set, refer to Page 57 in JVT X201wcm */ /* Sequence Parameter Set, refer to Page 57 in JVT X201wcm */
typedef struct TagWelsSPS { typedef struct TagWelsSPS {
uint32_t uiSpsId; uint32_t uiSpsId;
int16_t iMbWidth; int16_t iMbWidth;
int16_t iMbHeight; int16_t iMbHeight;
uint32_t uiLog2MaxFrameNum; uint32_t uiLog2MaxFrameNum;
// uint32_t uiPocType; // uint32_t uiPocType;
/* POC type 0 */ /* POC type 0 */
int32_t iLog2MaxPocLsb; int32_t iLog2MaxPocLsb;
/* POC type 1 */ /* POC type 1 */
// int32_t iOffsetForNonRefPic; // int32_t iOffsetForNonRefPic;
// int32_t iOffsetForTopToBottomField; // int32_t iOffsetForTopToBottomField;
// int32_t iNumRefFramesInPocCycle; // int32_t iNumRefFramesInPocCycle;
// int8_t iOffsetForRefFrame[256]; // int8_t iOffsetForRefFrame[256];
SCropOffset sFrameCrop; SCropOffset sFrameCrop;
int16_t iNumRefFrames; int16_t iNumRefFrames;
// uint32_t uiNumUnitsInTick; // uint32_t uiNumUnitsInTick;
// uint32_t uiTimeScale; // uint32_t uiTimeScale;
uint8_t uiProfileIdc; uint8_t uiProfileIdc;
uint8_t iLevelIdc; uint8_t iLevelIdc;
// uint8_t uiChromaFormatIdc; // uint8_t uiChromaFormatIdc;
// uint8_t uiChromaArrayType; //support =1 // uint8_t uiChromaArrayType; //support =1
// uint8_t uiBitDepthLuma; //=8, only used in decoder, encoder in general_***; it can be removed when removed general up_sample // uint8_t uiBitDepthLuma; //=8, only used in decoder, encoder in general_***; it can be removed when removed general up_sample
// uint8_t uiBitDepthChroma; //=8 // uint8_t uiBitDepthChroma; //=8
/* TO BE CONTINUE: POC type 1 */ /* TO BE CONTINUE: POC type 1 */
// bool bDeltaPicOrderAlwaysZeroFlag; // bool bDeltaPicOrderAlwaysZeroFlag;
// bool bGapsInFrameNumValueAllowedFlag; //=true // bool bGapsInFrameNumValueAllowedFlag; //=true
// bool bFrameMbsOnlyFlag; // bool bFrameMbsOnlyFlag;
// bool bMbaffFlag; // MB Adapative Frame Field // bool bMbaffFlag; // MB Adapative Frame Field
// bool bDirect8x8InferenceFlag; // bool bDirect8x8InferenceFlag;
bool bFrameCroppingFlag; bool bFrameCroppingFlag;
// bool bVuiParamPresentFlag; // bool bVuiParamPresentFlag;
// bool bTimingInfoPresentFlag; // bool bTimingInfoPresentFlag;
// bool bFixedFrameRateFlag; // bool bFixedFrameRateFlag;
bool bConstraintSet0Flag; bool bConstraintSet0Flag;
bool bConstraintSet1Flag; bool bConstraintSet1Flag;
bool bConstraintSet2Flag; bool bConstraintSet2Flag;
bool bConstraintSet3Flag; bool bConstraintSet3Flag;
// bool bSeparateColorPlaneFlag; // =false,: only used in decoder, encoder in general_***; it can be removed when removed general up_sample // bool bSeparateColorPlaneFlag; // =false,: only used in decoder, encoder in general_***; it can be removed when removed general up_sample
} SWelsSPS, *PWelsSPS; } SWelsSPS, *PWelsSPS;
@ -92,21 +92,21 @@ typedef struct TagWelsSPS {
typedef struct TagSpsSvcExt { typedef struct TagSpsSvcExt {
// SCropOffset sSeqScaledRefLayer; // SCropOffset sSeqScaledRefLayer;
uint8_t iExtendedSpatialScalability; // ESS uint8_t iExtendedSpatialScalability; // ESS
// uint8_t uiChromaPhaseXPlus1Flag; // uint8_t uiChromaPhaseXPlus1Flag;
// uint8_t uiChromaPhaseYPlus1; // uint8_t uiChromaPhaseYPlus1;
// uint8_t uiSeqRefLayerChromaPhaseXPlus1Flag; // uint8_t uiSeqRefLayerChromaPhaseXPlus1Flag;
// uint8_t uiSeqRefLayerChromaPhaseYPlus1; // uint8_t uiSeqRefLayerChromaPhaseYPlus1;
// bool bInterLayerDeblockingFilterCtrlPresentFlag; // bool bInterLayerDeblockingFilterCtrlPresentFlag;
bool bSeqTcoeffLevelPredFlag; bool bSeqTcoeffLevelPredFlag;
bool bAdaptiveTcoeffLevelPredFlag; bool bAdaptiveTcoeffLevelPredFlag;
bool bSliceHeaderRestrictionFlag; bool bSliceHeaderRestrictionFlag;
} SSpsSvcExt, *PSpsSvcExt; } SSpsSvcExt, *PSpsSvcExt;
/* Subset sequence parameter set syntax, refer to Page 391 in JVT X201wcm */ /* Subset sequence parameter set syntax, refer to Page 391 in JVT X201wcm */
typedef struct TagSubsetSps { typedef struct TagSubsetSps {
SWelsSPS pSps; SWelsSPS pSps;
SSpsSvcExt sSpsSvcExt; SSpsSvcExt sSpsSvcExt;
// bool bSvcVuiParamPresentFlag; // bool bSvcVuiParamPresentFlag;
// bool bAdditionalExtension2Flag; // bool bAdditionalExtension2Flag;
@ -115,40 +115,40 @@ typedef struct TagSubsetSps {
/* Picture parameter set syntax, refer to Page 59 in JVT X201wcm */ /* Picture parameter set syntax, refer to Page 59 in JVT X201wcm */
typedef struct TagWelsPPS { typedef struct TagWelsPPS {
uint32_t iSpsId; uint32_t iSpsId;
uint32_t iPpsId; uint32_t iPpsId;
#if !defined(DISABLE_FMO_FEATURE) #if !defined(DISABLE_FMO_FEATURE)
uint32_t uiNumSliceGroups; uint32_t uiNumSliceGroups;
uint32_t uiSliceGroupMapType; uint32_t uiSliceGroupMapType;
/* uiSliceGroupMapType = 0 */ /* uiSliceGroupMapType = 0 */
uint32_t uiRunLength[MAX_SLICEGROUP_IDS]; uint32_t uiRunLength[MAX_SLICEGROUP_IDS];
/* uiSliceGroupMapType = 2 */ /* uiSliceGroupMapType = 2 */
uint32_t uiTopLeft[MAX_SLICEGROUP_IDS]; uint32_t uiTopLeft[MAX_SLICEGROUP_IDS];
uint32_t uiBottomRight[MAX_SLICEGROUP_IDS]; uint32_t uiBottomRight[MAX_SLICEGROUP_IDS];
/* uiSliceGroupMapType = 3, 4 or 5 */ /* uiSliceGroupMapType = 3, 4 or 5 */
/* uiSliceGroupMapType = 3, 4 or 5 */ /* uiSliceGroupMapType = 3, 4 or 5 */
bool bSliceGroupChangeDirectionFlag; bool bSliceGroupChangeDirectionFlag;
uint32_t uiSliceGroupChangeRate; uint32_t uiSliceGroupChangeRate;
/* uiSliceGroupMapType = 6 */ /* uiSliceGroupMapType = 6 */
uint32_t uiPicSizeInMapUnits; uint32_t uiPicSizeInMapUnits;
uint32_t uiSliceGroupId[MAX_SLICEGROUP_IDS]; uint32_t uiSliceGroupId[MAX_SLICEGROUP_IDS];
#endif//!DISABLE_FMO_FEATURE #endif//!DISABLE_FMO_FEATURE
// uint32_t uiNumRefIdxL0Active; // uint32_t uiNumRefIdxL0Active;
// uint32_t uiNumRefIdxL1Active; // uint32_t uiNumRefIdxL1Active;
int8_t iPicInitQp; int8_t iPicInitQp;
int8_t iPicInitQs; int8_t iPicInitQs;
uint8_t uiChromaQpIndexOffset; uint8_t uiChromaQpIndexOffset;
/* potential application for High profile */ /* potential application for High profile */
// int32_t iSecondChromaQpIndexOffset; // int32_t iSecondChromaQpIndexOffset;
// /* potential application for High profile */ // /* potential application for High profile */
// bool bPicOrderPresentFlag; // bool bPicOrderPresentFlag;
bool bDeblockingFilterControlPresentFlag; bool bDeblockingFilterControlPresentFlag;
// bool bConstainedIntraPredFlag; // bool bConstainedIntraPredFlag;
// bool bRedundantPicCntPresentFlag; // bool bRedundantPicCntPresentFlag;

82
codec/encoder/core/inc/picture.h
View File

@ -41,19 +41,19 @@
namespace WelsSVCEnc { namespace WelsSVCEnc {
#define LIST_SIZE 0x10000 //(256*256) #define LIST_SIZE 0x10000 //(256*256)
typedef struct TagScreenBlockFeatureStorage { typedef struct TagScreenBlockFeatureStorage {
//Input //Input
uint16_t* pFeatureOfBlockPointer; // Pointer to pFeatureOfBlock uint16_t* pFeatureOfBlockPointer; // Pointer to pFeatureOfBlock
int32_t iIs16x16; //Feature block size int32_t iIs16x16; //Feature block size
uint8_t uiFeatureStrategyIndex;// index of hash strategy uint8_t uiFeatureStrategyIndex;// index of hash strategy
//Modify //Modify
uint32_t* pTimesOfFeatureValue; // times of every value in Feature uint32_t* pTimesOfFeatureValue; // times of every value in Feature
uint16_t** uint16_t**
pLocationOfFeature; // uint16_t *pLocationOfFeature[LIST_SIZE], pLocationOfFeature[i] saves all the location(x,y) whose Feature = i; pLocationOfFeature; // uint16_t *pLocationOfFeature[LIST_SIZE], pLocationOfFeature[i] saves all the location(x,y) whose Feature = i;
uint16_t* pLocationPointer; // buffer of position array uint16_t* pLocationPointer; // buffer of position array
int32_t iActualListSize; // actual list size int32_t iActualListSize; // actual list size
uint32_t uiSadCostThreshold[BLOCK_SIZE_ALL]; uint32_t uiSadCostThreshold[BLOCK_SIZE_ALL];
bool bRefBlockFeatureCalculated; // flag of whether pre-process is done bool bRefBlockFeatureCalculated; // flag of whether pre-process is done
} SScreenBlockFeatureStorage; //should be stored with RefPic, one for each frame } SScreenBlockFeatureStorage; //should be stored with RefPic, one for each frame
/* /*
@ -61,43 +61,43 @@ typedef struct TagScreenBlockFeatureStorage {
* It is used to express reference picture, also consequent reconstruction picture for output * It is used to express reference picture, also consequent reconstruction picture for output
*/ */
typedef struct TagPicture { typedef struct TagPicture {
/************************************payload pData*********************************/ /************************************payload pData*********************************/
uint8_t* pBuffer; // pointer to the first allocated byte, basical offset of pBuffer, dimension: uint8_t* pBuffer; // pointer to the first allocated byte, basical offset of pBuffer, dimension:
uint8_t* pData[3]; // pointer to picture planes respectively uint8_t* pData[3]; // pointer to picture planes respectively
int32_t iLineSize[3]; // iLineSize of picture planes respectively int32_t iLineSize[3]; // iLineSize of picture planes respectively
// picture information // picture information
/*******************************from other standard syntax****************************/ /*******************************from other standard syntax****************************/
/*from pSps*/ /*from pSps*/
int32_t iWidthInPixel; // picture width in pixel int32_t iWidthInPixel; // picture width in pixel
int32_t iHeightInPixel;// picture height in pixel int32_t iHeightInPixel;// picture height in pixel
int32_t iPictureType; // got from sSliceHeader(): eSliceType int32_t iPictureType; // got from sSliceHeader(): eSliceType
int32_t iFramePoc; // frame POC int32_t iFramePoc; // frame POC
float fFrameRate; // MOVE float fFrameRate; // MOVE
int32_t iFrameNum; // frame number //for pRef pic management int32_t iFrameNum; // frame number //for pRef pic management
uint32_t* uiRefMbType; // for iMbWidth*iMbHeight uint32_t* uiRefMbType; // for iMbWidth*iMbHeight
uint8_t* pRefMbQp; // for iMbWidth*iMbHeight uint8_t* pRefMbQp; // for iMbWidth*iMbHeight
int32_t* pMbSkipSad; //for iMbWidth*iMbHeight int32_t* pMbSkipSad; //for iMbWidth*iMbHeight
SMVUnitXY* sMvList; SMVUnitXY* sMvList;
/*******************************sef_definition for misc use****************************/ /*******************************sef_definition for misc use****************************/
int32_t iMarkFrameNum; int32_t iMarkFrameNum;
int32_t iLongTermPicNum; int32_t iLongTermPicNum;
bool bUsedAsRef; //for pRef pic management bool bUsedAsRef; //for pRef pic management
bool bIsLongRef; // long term reference frame flag //for pRef pic management bool bIsLongRef; // long term reference frame flag //for pRef pic management
bool bIsSceneLTR; //long term reference & large scene change bool bIsSceneLTR; //long term reference & large scene change
uint8_t uiRecieveConfirmed; uint8_t uiRecieveConfirmed;
uint8_t uiTemporalId; uint8_t uiTemporalId;
uint8_t uiSpatialId; uint8_t uiSpatialId;
int32_t iFrameAverageQp; int32_t iFrameAverageQp;
/*******************************for screen reference frames****************************/ /*******************************for screen reference frames****************************/
SScreenBlockFeatureStorage* pScreenBlockFeatureStorage; SScreenBlockFeatureStorage* pScreenBlockFeatureStorage;
} SPicture; } SPicture;
/* /*

237
codec/encoder/core/inc/rc.h
View File

@ -56,53 +56,53 @@ namespace WelsSVCEnc {
#define WELS_RC_GOM 1 #define WELS_RC_GOM 1
enum { enum {
BITS_NORMAL, BITS_NORMAL,
BITS_LIMITED, BITS_LIMITED,
BITS_EXCEEDED, BITS_EXCEEDED,
}; };
enum { enum {
//virtual gop size //virtual gop size
VGOP_SIZE = 8, VGOP_SIZE = 8,
//qp information //qp information
GOM_MIN_QP_MODE = 12, GOM_MIN_QP_MODE = 12,
GOM_MAX_QP_MODE = 36, GOM_MAX_QP_MODE = 36,
MAX_LOW_BR_QP = 42, MAX_LOW_BR_QP = 42,
MIN_IDR_QP = 26, MIN_IDR_QP = 26,
MAX_IDR_QP = 32, MAX_IDR_QP = 32,
DELTA_QP = 2, DELTA_QP = 2,
DELTA_QP_BGD_THD = 3, DELTA_QP_BGD_THD = 3,
//frame skip constants //frame skip constants
SKIP_QP_90P = 24, SKIP_QP_90P = 24,
SKIP_QP_180P = 24, SKIP_QP_180P = 24,
SKIP_QP_360P = 31, SKIP_QP_360P = 31,
SKIP_QP_720P = 31, SKIP_QP_720P = 31,
LAST_FRAME_QP_RANGE_UPPER_MODE0 = 3, LAST_FRAME_QP_RANGE_UPPER_MODE0 = 3,
LAST_FRAME_QP_RANGE_LOWER_MODE0 = 2, LAST_FRAME_QP_RANGE_LOWER_MODE0 = 2,
LAST_FRAME_QP_RANGE_UPPER_MODE1 = 5, LAST_FRAME_QP_RANGE_UPPER_MODE1 = 5,
LAST_FRAME_QP_RANGE_LOWER_MODE1 = 3, LAST_FRAME_QP_RANGE_LOWER_MODE1 = 3,
MB_WIDTH_THRESHOLD_90P = 15, MB_WIDTH_THRESHOLD_90P = 15,
MB_WIDTH_THRESHOLD_180P = 30, MB_WIDTH_THRESHOLD_180P = 30,
MB_WIDTH_THRESHOLD_360P = 60, MB_WIDTH_THRESHOLD_360P = 60,
//Mode 0 parameter //Mode 0 parameter
GOM_ROW_MODE0_90P = 2, GOM_ROW_MODE0_90P = 2,
GOM_ROW_MODE0_180P = 2, GOM_ROW_MODE0_180P = 2,
GOM_ROW_MODE0_360P = 4, GOM_ROW_MODE0_360P = 4,
GOM_ROW_MODE0_720P = 4, GOM_ROW_MODE0_720P = 4,
QP_RANGE_MODE0 = 3, QP_RANGE_MODE0 = 3,
//Mode 1 parameter //Mode 1 parameter
GOM_ROW_MODE1_90P = 1, GOM_ROW_MODE1_90P = 1,
GOM_ROW_MODE1_180P = 1, GOM_ROW_MODE1_180P = 1,
GOM_ROW_MODE1_360P = 2, GOM_ROW_MODE1_360P = 2,
GOM_ROW_MODE1_720P = 2, GOM_ROW_MODE1_720P = 2,
QP_RANGE_UPPER_MODE1 = 9, QP_RANGE_UPPER_MODE1 = 9,
QP_RANGE_LOWER_MODE1 = 4, QP_RANGE_LOWER_MODE1 = 4,
QP_RANGE_INTRA_MODE1 = 3, QP_RANGE_INTRA_MODE1 = 3,
}; };
//bits allocation //bits allocation
@ -124,98 +124,98 @@ enum {
#define PADDING_THRESHOLD 5 //*INT_MULTIPLY #define PADDING_THRESHOLD 5 //*INT_MULTIPLY
typedef struct TagRCSlicing { typedef struct TagRCSlicing {
int32_t iComplexityIndexSlice; int32_t iComplexityIndexSlice;
int32_t iCalculatedQpSlice; int32_t iCalculatedQpSlice;
int32_t iStartMbSlice; int32_t iStartMbSlice;
int32_t iEndMbSlice; int32_t iEndMbSlice;
int32_t iTotalQpSlice; int32_t iTotalQpSlice;
int32_t iTotalMbSlice; int32_t iTotalMbSlice;
int32_t iTargetBitsSlice; int32_t iTargetBitsSlice;
int32_t iBsPosSlice; int32_t iBsPosSlice;
int32_t iFrameBitsSlice; int32_t iFrameBitsSlice;
int32_t iGomBitsSlice; int32_t iGomBitsSlice;
int32_t iGomTargetBits; int32_t iGomTargetBits;
//int32_t gom_coded_mb; //int32_t gom_coded_mb;
} SRCSlicing; } SRCSlicing;
typedef struct TagRCTemporal { typedef struct TagRCTemporal {
int32_t iMinBitsTl; int32_t iMinBitsTl;
int32_t iMaxBitsTl; int32_t iMaxBitsTl;
int32_t iTlayerWeight; int32_t iTlayerWeight;
int32_t iGopBitsDq; int32_t iGopBitsDq;
//P frame level R-Q Model //P frame level R-Q Model
int64_t iLinearCmplx; // *INT_MULTIPLY int64_t iLinearCmplx; // *INT_MULTIPLY
int32_t iPFrameNum; int32_t iPFrameNum;
int32_t iFrameCmplxMean; int32_t iFrameCmplxMean;
} SRCTemporal; } SRCTemporal;
typedef struct TagWelsRc { typedef struct TagWelsRc {
int32_t iRcVaryPercentage; int32_t iRcVaryPercentage;
int32_t iRcVaryRatio; int32_t iRcVaryRatio;
int32_t iInitialQp; //initial qp int32_t iInitialQp; //initial qp
int32_t iBitRate; int32_t iBitRate;
int32_t iPreviousBitrate; int32_t iPreviousBitrate;
int32_t iPreviousGopSize; int32_t iPreviousGopSize;
double fFrameRate; double fFrameRate;
int32_t iBitsPerFrame; // *INT_MULTIPLY int32_t iBitsPerFrame; // *INT_MULTIPLY
double dPreviousFps; double dPreviousFps;
// bits allocation and status // bits allocation and status
int32_t iRemainingBits; int32_t iRemainingBits;
int32_t iTargetBits; int32_t iTargetBits;
int32_t iCurrentBitsLevel;//0:normal; 1:limited; 2:exceeded. int32_t iCurrentBitsLevel;//0:normal; 1:limited; 2:exceeded.
int32_t iIdrNum; int32_t iIdrNum;
int32_t iIntraComplexity; int32_t iIntraComplexity;
int32_t iIntraMbCount; int32_t iIntraMbCount;
int8_t iTlOfFrames[VGOP_SIZE]; int8_t iTlOfFrames[VGOP_SIZE];
int32_t iRemainingWeights; int32_t iRemainingWeights;
int32_t iFrameDqBits; int32_t iFrameDqBits;
double* pGomComplexity; double* pGomComplexity;
int32_t* pGomForegroundBlockNum; int32_t* pGomForegroundBlockNum;
int32_t* pCurrentFrameGomSad; int32_t* pCurrentFrameGomSad;
int32_t* pGomCost; int32_t* pGomCost;
int32_t iAverageFrameQp; int32_t iAverageFrameQp;
int32_t iNumberMbFrame; int32_t iNumberMbFrame;
int32_t iNumberMbGom; int32_t iNumberMbGom;
int32_t iSliceNum; int32_t iSliceNum;
int32_t iGomSize; int32_t iGomSize;
int32_t iSkipFrameNum; int32_t iSkipFrameNum;
int32_t iFrameCodedInVGop; int32_t iFrameCodedInVGop;
int32_t iSkipFrameInVGop; int32_t iSkipFrameInVGop;
int32_t iGopNumberInVGop; int32_t iGopNumberInVGop;
int32_t iGopIndexInVGop; int32_t iGopIndexInVGop;
int32_t iSkipQpValue; int32_t iSkipQpValue;
int32_t iQpRangeUpperInFrame; int32_t iQpRangeUpperInFrame;
int32_t iQpRangeLowerInFrame; int32_t iQpRangeLowerInFrame;
int32_t iMinQp; int32_t iMinQp;
int32_t iMaxQp; int32_t iMaxQp;
//int32_t delta_adaptive_qp; //int32_t delta_adaptive_qp;
int32_t iSkipBufferRatio; int32_t iSkipBufferRatio;
int32_t iQStep; // *INT_MULTIPLY int32_t iQStep; // *INT_MULTIPLY
int32_t iFrameDeltaQpUpper; int32_t iFrameDeltaQpUpper;
int32_t iFrameDeltaQpLower; int32_t iFrameDeltaQpLower;
int32_t iLastCalculatedQScale; int32_t iLastCalculatedQScale;
//for skip frame and padding //for skip frame and padding
int32_t iBufferSizeSkip; int32_t iBufferSizeSkip;
int32_t iBufferFullnessSkip; int32_t iBufferFullnessSkip;
int32_t iBufferSizePadding; int32_t iBufferSizePadding;
int32_t iBufferFullnessPadding; int32_t iBufferFullnessPadding;
int32_t iPaddingSize; int32_t iPaddingSize;
int32_t iPaddingBitrateStat; int32_t iPaddingBitrateStat;
bool bSkipFlag; bool bSkipFlag;
SRCSlicing* pSlicingOverRc; SRCSlicing* pSlicingOverRc;
SRCTemporal* pTemporalOverRc; SRCTemporal* pTemporalOverRc;
} SWelsSvcRc; } SWelsSvcRc;
typedef void (*PWelsRCPictureInitFunc) (void* pCtx); typedef void (*PWelsRCPictureInitFunc) (void* pCtx);
@ -225,11 +225,11 @@ typedef void (*PWelsRCMBInfoUpdateFunc) (void* pCtx, SMB* pCurMb, int32_t iCost
typedef void (*PWelsRCMBInitFunc) (void* pCtx, SMB* pCurMb, SSlice* pSlice); typedef void (*PWelsRCMBInitFunc) (void* pCtx, SMB* pCurMb, SSlice* pSlice);
typedef struct WelsRcFunc_s { typedef struct WelsRcFunc_s {
PWelsRCPictureInitFunc pfWelsRcPictureInit; PWelsRCPictureInitFunc pfWelsRcPictureInit;
PWelsRCPictureDelayJudgeFunc pfWelsRcPicDelayJudge; PWelsRCPictureDelayJudgeFunc pfWelsRcPicDelayJudge;
PWelsRCPictureInfoUpdateFunc pfWelsRcPictureInfoUpdate; PWelsRCPictureInfoUpdateFunc pfWelsRcPictureInfoUpdate;
PWelsRCMBInitFunc pfWelsRcMbInit; PWelsRCMBInitFunc pfWelsRcMbInit;
PWelsRCMBInfoUpdateFunc pfWelsRcMbInfoUpdate; PWelsRCMBInfoUpdateFunc pfWelsRcMbInfoUpdate;
} SWelsRcFunc; } SWelsRcFunc;
void WelsRcInitModule (void* pCtx, int32_t iModule); void WelsRcInitModule (void* pCtx, int32_t iModule);
@ -237,3 +237,4 @@ void WelsRcFreeMemory (void* pCtx);
} }
#endif //RC_H #endif //RC_H

18
codec/encoder/core/inc/ref_list_mgr_svc.h
View File

@ -48,21 +48,21 @@
namespace WelsSVCEnc { namespace WelsSVCEnc {
typedef enum { typedef enum {
RECIEVE_UNKOWN = 0, RECIEVE_UNKOWN = 0,
RECIEVE_SUCCESS = 1, RECIEVE_SUCCESS = 1,
RECIEVE_FAILED = 2, RECIEVE_FAILED = 2,
} LTR_MARKING_RECEIVE_STATE; } LTR_MARKING_RECEIVE_STATE;
typedef enum { typedef enum {
LTR_DIRECT_MARK = 0, LTR_DIRECT_MARK = 0,
LTR_DELAY_MARK = 1, LTR_DELAY_MARK = 1,
} LTR_MARKING_PROCESS_MODE; } LTR_MARKING_PROCESS_MODE;
typedef enum { typedef enum {
FRAME_NUM_EQUAL = 0x01, FRAME_NUM_EQUAL = 0x01,
FRAME_NUM_BIGGER = 0x02, FRAME_NUM_BIGGER = 0x02,
FRAME_NUM_SMALLER = 0x04, FRAME_NUM_SMALLER = 0x04,
FRAME_NUM_OVER_MAX = 0x08, FRAME_NUM_OVER_MAX = 0x08,
} COMPARE_FRAME_NUM; } COMPARE_FRAME_NUM;
/* /*

18
codec/encoder/core/inc/set_mb_syn_cavlc.h
View File

@ -49,11 +49,11 @@ namespace WelsSVCEnc {
enum EResidualProperty { enum EResidualProperty {
LUMA_DC = 0, LUMA_DC = 0,
LUMA_AC = 1, LUMA_AC = 1,
LUMA_4x4 = 2, LUMA_4x4 = 2,
CHROMA_DC = 3, CHROMA_DC = 3,
CHROMA_AC = 4 CHROMA_AC = 4
}; };
@ -63,16 +63,16 @@ typedef int32_t (*PCavlcParamCalFunc) (int16_t* pCoff, uint8_t* pRun, int16_t*
int32_t iEndIdx); int32_t iEndIdx);
typedef struct TagCoeffFunc { typedef struct TagCoeffFunc {
PCavlcParamCalFunc pfCavlcParamCal; PCavlcParamCalFunc pfCavlcParamCal;
} SCoeffFunc; } SCoeffFunc;
/* For CAVLC */ /* For CAVLC */
extern SCoeffFunc sCoeffFunc; extern SCoeffFunc sCoeffFunc;
typedef struct TagCavlcTableItem { typedef struct TagCavlcTableItem {
uint16_t uiBits; uint16_t uiBits;
uint8_t uiLen; uint8_t uiLen;
uint8_t uiSuffixLength; uint8_t uiSuffixLength;
} SCavlcTableItem; } SCavlcTableItem;
void InitCoeffFunc (const uint32_t uiCpuFlag); void InitCoeffFunc (const uint32_t uiCpuFlag);

148
codec/encoder/core/inc/slice.h
View File

@ -53,131 +53,131 @@ namespace WelsSVCEnc {
* Reference picture list reordering syntax, refer to page 64 in JVT X201wcm * Reference picture list reordering syntax, refer to page 64 in JVT X201wcm
*/ */
typedef struct TagRefPicListReorderSyntax { typedef struct TagRefPicListReorderSyntax {
struct { struct {
uint32_t uiAbsDiffPicNumMinus1; //uiAbsDiffPicNumMinus1 SHOULD be in the range of [4, (1<<pSps->uiLog2MaxFrameNum)-1], {p104, JVT-X201wcm1} uint32_t uiAbsDiffPicNumMinus1; //uiAbsDiffPicNumMinus1 SHOULD be in the range of [4, (1<<pSps->uiLog2MaxFrameNum)-1], {p104, JVT-X201wcm1}
//but int8_t can't cover the range, SHOULD modify it. //but int8_t can't cover the range, SHOULD modify it.
uint16_t iLongTermPicNum; uint16_t iLongTermPicNum;
uint16_t uiReorderingOfPicNumsIdc; //in order to pack 2-uint16_t into 1-(u)int32_t, so modify the type into uint16_t. uint16_t uiReorderingOfPicNumsIdc; //in order to pack 2-uint16_t into 1-(u)int32_t, so modify the type into uint16_t.
} SReorderingSyntax[MAX_REFERENCE_REORDER_COUNT_NUM]; // MAX_REF_PIC_COUNT } SReorderingSyntax[MAX_REFERENCE_REORDER_COUNT_NUM]; // MAX_REF_PIC_COUNT
} SRefPicListReorderSyntax; } SRefPicListReorderSyntax;
/* Decoded reference picture marking syntax, refer to Page 66 in JVT X201wcm */ /* Decoded reference picture marking syntax, refer to Page 66 in JVT X201wcm */
typedef struct TagRefPicMarking { typedef struct TagRefPicMarking {
struct { struct {
int32_t iMmcoType; int32_t iMmcoType;
int32_t iShortFrameNum; int32_t iShortFrameNum;
int32_t iDiffOfPicNum; int32_t iDiffOfPicNum;
int32_t iLongTermPicNum; int32_t iLongTermPicNum;
int32_t iLongTermFrameIdx; int32_t iLongTermFrameIdx;
int32_t iMaxLongTermFrameIdx; int32_t iMaxLongTermFrameIdx;
} SMmcoRef[MAX_REFERENCE_MMCO_COUNT_NUM]; // MAX_MMCO_COUNT } SMmcoRef[MAX_REFERENCE_MMCO_COUNT_NUM]; // MAX_MMCO_COUNT
// int32_t mmco_index; // int32_t mmco_index;
uint8_t uiMmcoCount; uint8_t uiMmcoCount;
bool bNoOutputOfPriorPicsFlag; bool bNoOutputOfPriorPicsFlag;
bool bLongTermRefFlag; bool bLongTermRefFlag;
bool bAdaptiveRefPicMarkingModeFlag; bool bAdaptiveRefPicMarkingModeFlag;
} SRefPicMarking; } SRefPicMarking;
/* Header of slice syntax elements, refer to Page 63 in JVT X201wcm */ /* Header of slice syntax elements, refer to Page 63 in JVT X201wcm */
typedef struct TagSliceHeader { typedef struct TagSliceHeader {
/*****************************slice header syntax and generated****************************/ /*****************************slice header syntax and generated****************************/
int32_t iFirstMbInSlice; int32_t iFirstMbInSlice;
// uint32_t pic_parameter_set_id; // uint32_t pic_parameter_set_id;
int32_t iFrameNum; int32_t iFrameNum;
int32_t iPicOrderCntLsb; int32_t iPicOrderCntLsb;
// int32_t delta_pic_order_cnt_bottom; // int32_t delta_pic_order_cnt_bottom;
// int32_t delta_pic_order_cnt[2]; // int32_t delta_pic_order_cnt[2];
// int32_t redundant_pic_cnt; // int32_t redundant_pic_cnt;
EWelsSliceType eSliceType; EWelsSliceType eSliceType;
uint8_t uiNumRefIdxL0Active; // uint8_t uiNumRefIdxL0Active; //
//int32_t num_ref_idx_l1_active_minus1 //B frame is not supported //int32_t num_ref_idx_l1_active_minus1 //B frame is not supported
uint8_t uiRefCount; uint8_t uiRefCount;
//Ref_Pic *ref_pic; //Ref_Pic *ref_pic;
uint8_t uiRefIndex; // exact reference picture index for slice uint8_t uiRefIndex; // exact reference picture index for slice
int8_t iSliceQpDelta; int8_t iSliceQpDelta;
// int32_t slice_qp; // int32_t slice_qp;
// int32_t slice_qs_delta; // For SP/SI slices // int32_t slice_qs_delta; // For SP/SI slices
uint8_t uiDisableDeblockingFilterIdc; uint8_t uiDisableDeblockingFilterIdc;
int8_t iSliceAlphaC0Offset; int8_t iSliceAlphaC0Offset;
int8_t iSliceBetaOffset; int8_t iSliceBetaOffset;
#if !defined(DISABLE_FMO_FEATURE) #if !defined(DISABLE_FMO_FEATURE)
int32_t iSliceGroupChangeCycle; int32_t iSliceGroupChangeCycle;
#endif//!DISABLE_FMO_FEATURE #endif//!DISABLE_FMO_FEATURE
SWelsSPS* pSps; SWelsSPS* pSps;
SWelsPPS* pPps; SWelsPPS* pPps;
int32_t iSpsId; int32_t iSpsId;
int32_t iPpsId; int32_t iPpsId;
uint16_t uiIdrPicId; uint16_t uiIdrPicId;
// uint8_t color_plane_id;//from? // uint8_t color_plane_id;//from?
bool bNumRefIdxActiveOverrideFlag; bool bNumRefIdxActiveOverrideFlag;
// bool field_pic_flag; //not supported in base profile // bool field_pic_flag; //not supported in base profile
// bool bottom_field_flag; //not supported in base profile // bool bottom_field_flag; //not supported in base profile
uint8_t uiPadding1Bytes; uint8_t uiPadding1Bytes;
SRefPicMarking sRefMarking; // Decoded reference picture marking syntaxs SRefPicMarking sRefMarking; // Decoded reference picture marking syntaxs
SRefPicListReorderSyntax sRefReordering; // Reference picture list reordering syntaxs SRefPicListReorderSyntax sRefReordering; // Reference picture list reordering syntaxs
} SSliceHeader, *PSliceHeader; } SSliceHeader, *PSliceHeader;
/* SSlice header in scalable extension syntax, refer to Page 394 in JVT X201wcm */ /* SSlice header in scalable extension syntax, refer to Page 394 in JVT X201wcm */
typedef struct TagSliceHeaderExt { typedef struct TagSliceHeaderExt {
SSliceHeader sSliceHeader; SSliceHeader sSliceHeader;
SSubsetSps* pSubsetSps; SSubsetSps* pSubsetSps;
uint32_t uiNumMbsInSlice; uint32_t uiNumMbsInSlice;
bool bStoreRefBasePicFlag; bool bStoreRefBasePicFlag;
bool bConstrainedIntraResamplingFlag; bool bConstrainedIntraResamplingFlag;
bool bSliceSkipFlag; bool bSliceSkipFlag;
bool bAdaptiveBaseModeFlag; bool bAdaptiveBaseModeFlag;
bool bDefaultBaseModeFlag; bool bDefaultBaseModeFlag;
bool bAdaptiveMotionPredFlag; bool bAdaptiveMotionPredFlag;
bool bDefaultMotionPredFlag; bool bDefaultMotionPredFlag;
bool bAdaptiveResidualPredFlag; bool bAdaptiveResidualPredFlag;
bool bDefaultResidualPredFlag; bool bDefaultResidualPredFlag;
bool bTcoeffLevelPredFlag; bool bTcoeffLevelPredFlag;
uint8_t uiDisableInterLayerDeblockingFilterIdc; uint8_t uiDisableInterLayerDeblockingFilterIdc;
} SSliceHeaderExt, *PSliceHeaderExt; } SSliceHeaderExt, *PSliceHeaderExt;
typedef struct TagSlice { typedef struct TagSlice {
// mainly for multiple threads imp. // mainly for multiple threads imp.
SMbCache sMbCacheInfo; // MBCache is introduced within slice dependency SMbCache sMbCacheInfo; // MBCache is introduced within slice dependency
SBitStringAux* pSliceBsa; SBitStringAux* pSliceBsa;
/*******************************sSliceHeader****************************/ /*******************************sSliceHeader****************************/
SSliceHeaderExt sSliceHeaderExt; SSliceHeaderExt sSliceHeaderExt;
SMVUnitXY sMvStartMin; SMVUnitXY sMvStartMin;
SMVUnitXY sMvStartMax; SMVUnitXY sMvStartMax;
SMVUnitXY sMvc[5]; SMVUnitXY sMvc[5];
uint8_t uiMvcNum; uint8_t uiMvcNum;
uint8_t sScaleShift; uint8_t sScaleShift;
uint8_t uiSliceIdx; uint8_t uiSliceIdx;
bool bSliceHeaderExtFlag; // Indicate which slice header is used, avc or ext? bool bSliceHeaderExtFlag; // Indicate which slice header is used, avc or ext?
uint8_t uiLastMbQp; // stored qp for last mb coded, maybe more efficient for mb skip detection etc. uint8_t uiLastMbQp; // stored qp for last mb coded, maybe more efficient for mb skip detection etc.
bool bDynamicSlicingSliceSizeCtrlFlag; bool bDynamicSlicingSliceSizeCtrlFlag;
uint8_t uiAssumeLog2BytePerMb; uint8_t uiAssumeLog2BytePerMb;
uint32_t uiSliceFMECostDown;//TODO: for FME switch under MT, to opt after ME final? uint32_t uiSliceFMECostDown;//TODO: for FME switch under MT, to opt after ME final?
uint8_t uiReservedFillByte; // reserved to meet 4 bytes alignment uint8_t uiReservedFillByte; // reserved to meet 4 bytes alignment
} SSlice, *PSlice; } SSlice, *PSlice;
} }

36
codec/encoder/core/inc/stat.h
View File

@ -47,9 +47,9 @@ namespace WelsSVCEnc {
*/ */
typedef struct TagStatQuality { typedef struct TagStatQuality {
float rYPsnr[5]; float rYPsnr[5];
float rUPsnr[5]; float rUPsnr[5];
float rVPsnr[5]; float rVPsnr[5];
} SStatQuality; } SStatQuality;
@ -59,13 +59,13 @@ typedef struct TagStatQuality {
typedef struct TagComplexityStat { typedef struct TagComplexityStat {
#ifdef FME_TEST #ifdef FME_TEST
int32_t cost_time; int32_t cost_time;
int32_t me_time; int32_t me_time;
int32_t mvp_time; int32_t mvp_time;
int32_t mvb_time; int32_t mvb_time;
#endif #endif
// any else? // any else?
} SComplexityStat; } SComplexityStat;
@ -74,10 +74,10 @@ typedef struct TagComplexityStat {
*/ */
typedef struct TagStatSliceInfo { typedef struct TagStatSliceInfo {
/* per slice info */ /* per slice info */
int32_t iSliceCount[5]; int32_t iSliceCount[5];
int32_t iSliceSize [5]; int32_t iSliceSize [5];
int32_t iMbCount [5][18]; int32_t iMbCount [5][18];
} SStatSliceInfo; } SStatSliceInfo;
@ -86,14 +86,14 @@ typedef struct TagStatSliceInfo {
*/ */
typedef struct TagStatData { typedef struct TagStatData {
// Quality // Quality
SStatQuality sQualityStat; SStatQuality sQualityStat;
// Complexity // Complexity
SComplexityStat sComplexityStat; SComplexityStat sComplexityStat;
// SSlice information output // SSlice information output
SStatSliceInfo sSliceData; SStatSliceInfo sSliceData;
} SStatData; } SStatData;

76
codec/encoder/core/inc/svc_enc_frame.h
View File

@ -59,61 +59,61 @@ typedef struct TagDqLayer SDqLayer;
typedef SDqLayer* pDqLayer; typedef SDqLayer* pDqLayer;
typedef struct TagFeatureSearchPreparation { typedef struct TagFeatureSearchPreparation {
SScreenBlockFeatureStorage* pRefBlockFeature;//point the the ref frame storage SScreenBlockFeatureStorage* pRefBlockFeature;//point the the ref frame storage
uint16_t* pFeatureOfBlock; // Feature of every block (8x8), begin with the point uint16_t* pFeatureOfBlock; // Feature of every block (8x8), begin with the point
uint8_t uiFeatureStrategyIndex;// index of hash strategy uint8_t uiFeatureStrategyIndex;// index of hash strategy
/* for FME frame-level switch */ /* for FME frame-level switch */
bool bFMESwitchFlag; bool bFMESwitchFlag;
uint8_t uiFMEGoodFrameCount; uint8_t uiFMEGoodFrameCount;
int32_t iHighFreMbCount; int32_t iHighFreMbCount;
} SFeatureSearchPreparation; //maintain only one } SFeatureSearchPreparation; //maintain only one
typedef struct TagLayerInfo { typedef struct TagLayerInfo {
SNalUnitHeaderExt sNalHeaderExt; SNalUnitHeaderExt sNalHeaderExt;
SSlice* SSlice*
pSliceInLayer;// Here SSlice identify to Frame on concept, [iSliceIndex], need memory block external side for MT pSliceInLayer;// Here SSlice identify to Frame on concept, [iSliceIndex], need memory block external side for MT
SSubsetSps* pSubsetSpsP; // current pSubsetSps used, memory alloc in external SSubsetSps* pSubsetSpsP; // current pSubsetSps used, memory alloc in external
SWelsSPS* pSpsP; // current pSps based avc used, memory alloc in external SWelsSPS* pSpsP; // current pSps based avc used, memory alloc in external
SWelsPPS* pPpsP; // current pPps used SWelsPPS* pPpsP; // current pPps used
} SLayerInfo; } SLayerInfo;
/* Layer Representation */ /* Layer Representation */
struct TagDqLayer { struct TagDqLayer {
SLayerInfo sLayerInfo; SLayerInfo sLayerInfo;
uint8_t* pCsData[3]; // pointer to reconstructed picture pData uint8_t* pCsData[3]; // pointer to reconstructed picture pData
int32_t iCsStride[3]; // Cs stride int32_t iCsStride[3]; // Cs stride
uint8_t* pEncData[3]; // pData picture to be encoded in current layer uint8_t* pEncData[3]; // pData picture to be encoded in current layer
int32_t iEncStride[3]; // pData picture stride int32_t iEncStride[3]; // pData picture stride
SMB* sMbDataP; // pointer to mb of mbAddr equal to 0 in slice, mb_data_ptr = mb_base_ptr + (1+iMbStride). SMB* sMbDataP; // pointer to mb of mbAddr equal to 0 in slice, mb_data_ptr = mb_base_ptr + (1+iMbStride).
int16_t iMbWidth; // MB width of this picture, equal to pSps.iMbWidth int16_t iMbWidth; // MB width of this picture, equal to pSps.iMbWidth
int16_t iMbHeight; // MB height of this picture, equal to pSps.iMbHeight; int16_t iMbHeight; // MB height of this picture, equal to pSps.iMbHeight;
bool bBaseLayerAvailableFlag; // whether base layer is available for prediction? bool bBaseLayerAvailableFlag; // whether base layer is available for prediction?
uint8_t iLoopFilterDisableIdc; // 0: on, 1: off, 2: on except for slice boundaries uint8_t iLoopFilterDisableIdc; // 0: on, 1: off, 2: on except for slice boundaries
int8_t iLoopFilterAlphaC0Offset;// AlphaOffset: valid range [-6, 6], default 0 int8_t iLoopFilterAlphaC0Offset;// AlphaOffset: valid range [-6, 6], default 0
int8_t iLoopFilterBetaOffset; // BetaOffset: valid range [-6, 6], default 0 int8_t iLoopFilterBetaOffset; // BetaOffset: valid range [-6, 6], default 0
uint8_t uiDisableInterLayerDeblockingFilterIdc; uint8_t uiDisableInterLayerDeblockingFilterIdc;
int8_t iInterLayerSliceAlphaC0Offset; int8_t iInterLayerSliceAlphaC0Offset;
int8_t iInterLayerSliceBetaOffset; int8_t iInterLayerSliceBetaOffset;
bool bDeblockingParallelFlag; //parallel_deblocking_flag bool bDeblockingParallelFlag; //parallel_deblocking_flag
SPicture* pRefPic; // reference picture pointer SPicture* pRefPic; // reference picture pointer
SPicture* pDecPic; // reconstruction picture pointer for layer SPicture* pDecPic; // reconstruction picture pointer for layer
SPicture* pRefOri[MAX_REF_PIC_COUNT]; SPicture* pRefOri[MAX_REF_PIC_COUNT];
SSliceCtx* pSliceEncCtx; // current slice context SSliceCtx* pSliceEncCtx; // current slice context
int32_t* pNumSliceCodedOfPartition; // for dynamic slicing mode int32_t* pNumSliceCodedOfPartition; // for dynamic slicing mode
int32_t* pLastCodedMbIdxOfPartition; // for dynamic slicing mode int32_t* pLastCodedMbIdxOfPartition; // for dynamic slicing mode
int32_t* pLastMbIdxOfPartition; // for dynamic slicing mode int32_t* pLastMbIdxOfPartition; // for dynamic slicing mode
SFeatureSearchPreparation* pFeatureSearchPreparation; SFeatureSearchPreparation* pFeatureSearchPreparation;
SDqLayer* pRefLayer; // pointer to referencing dq_layer of current layer to be decoded SDqLayer* pRefLayer; // pointer to referencing dq_layer of current layer to be decoded
}; };

172
codec/encoder/core/inc/svc_enc_golomb.h
View File

@ -93,138 +93,138 @@ extern const uint32_t g_uiGolombUELength[256];
* Get size of unsigned exp golomb codes * Get size of unsigned exp golomb codes
*/ */
static inline uint32_t BsSizeUE (const uint32_t kiValue) { static inline uint32_t BsSizeUE (const uint32_t kiValue) {
if (256 > kiValue) { if (256 > kiValue) {
return g_uiGolombUELength[kiValue]; return g_uiGolombUELength[kiValue];
} else { } else {
uint32_t n = 0; uint32_t n = 0;
uint32_t iTmpValue = kiValue + 1; uint32_t iTmpValue = kiValue + 1;
if (iTmpValue & 0xffff0000) {
iTmpValue >>= 16;
n += 16;
}
if (iTmpValue & 0xff00) {
iTmpValue >>= 8;
n += 8;
}
//n += (g_uiGolombUELength[iTmpValue] >> 1);
n += (g_uiGolombUELength[iTmpValue - 1] >> 1);
return ((n << 1) + 1);
if (iTmpValue & 0xffff0000) {
iTmpValue >>= 16;
n += 16;
} }
if (iTmpValue & 0xff00) {
iTmpValue >>= 8;
n += 8;
}
//n += (g_uiGolombUELength[iTmpValue] >> 1);
n += (g_uiGolombUELength[iTmpValue - 1] >> 1);
return ((n << 1) + 1);
}
} }
/* /*
* Get size of signed exp golomb codes * Get size of signed exp golomb codes
*/ */
static inline uint32_t BsSizeSE (const int32_t kiValue) { static inline uint32_t BsSizeSE (const int32_t kiValue) {
uint32_t iTmpValue; uint32_t iTmpValue;
if (0 == kiValue) { if (0 == kiValue) {
return 1; return 1;
} else if (0 < kiValue) { } else if (0 < kiValue) {
iTmpValue = (kiValue << 1) - 1; iTmpValue = (kiValue << 1) - 1;
return BsSizeUE (iTmpValue); return BsSizeUE (iTmpValue);
} else { } else {
iTmpValue = ((-kiValue) << 1); iTmpValue = ((-kiValue) << 1);
return BsSizeUE (iTmpValue); return BsSizeUE (iTmpValue);
} }
} }
/* /*
* Get size of truncated exp golomb codes * Get size of truncated exp golomb codes
*/ */
static inline int32_t BsSizeTE (const int32_t kiX, const int32_t kiValue) { static inline int32_t BsSizeTE (const int32_t kiX, const int32_t kiValue) {
return 0; return 0;
} }
static inline int32_t BsWriteBits (SBitStringAux* pBs, int32_t n, const uint32_t kuiValue) { static inline int32_t BsWriteBits (SBitStringAux* pBs, int32_t n, const uint32_t kuiValue) {
if (n < pBs->iLeftBits) { if (n < pBs->iLeftBits) {
pBs->uiCurBits = (pBs->uiCurBits << n) | kuiValue; pBs->uiCurBits = (pBs->uiCurBits << n) | kuiValue;
pBs->iLeftBits -= n; pBs->iLeftBits -= n;
} else { } else {
n -= pBs->iLeftBits; n -= pBs->iLeftBits;
pBs->uiCurBits = (pBs->uiCurBits << pBs->iLeftBits) | (kuiValue >> n); pBs->uiCurBits = (pBs->uiCurBits << pBs->iLeftBits) | (kuiValue >> n);
WRITE_BE_32 (pBs->pBufPtr, pBs->uiCurBits); WRITE_BE_32 (pBs->pBufPtr, pBs->uiCurBits);
pBs->pBufPtr += 4; pBs->pBufPtr += 4;
pBs->uiCurBits = kuiValue & ((1 << n) - 1); pBs->uiCurBits = kuiValue & ((1 << n) - 1);
pBs->iLeftBits = 32 - n; pBs->iLeftBits = 32 - n;
} }
return 0; return 0;
} }
/* /*
* Write 1 bit * Write 1 bit
*/ */
static inline int32_t BsWriteOneBit (SBitStringAux* pBs, const uint32_t kuiValue) { static inline int32_t BsWriteOneBit (SBitStringAux* pBs, const uint32_t kuiValue) {
BsWriteBits (pBs, 1, kuiValue); BsWriteBits (pBs, 1, kuiValue);
return 0; return 0;
} }
static inline void BsFlush (SBitStringAux* pBs) { static inline void BsFlush (SBitStringAux* pBs) {
WRITE_BE_32 (pBs->pBufPtr, pBs->uiCurBits << pBs->iLeftBits); WRITE_BE_32 (pBs->pBufPtr, pBs->uiCurBits << pBs->iLeftBits);
pBs->pBufPtr += 4 - pBs->iLeftBits / 8; pBs->pBufPtr += 4 - pBs->iLeftBits / 8;
pBs->iLeftBits = 32; pBs->iLeftBits = 32;
pBs->uiCurBits = 0; // for future writing safe, 5/19/2010 pBs->uiCurBits = 0; // for future writing safe, 5/19/2010
} }
/* /*
* Write unsigned exp golomb codes * Write unsigned exp golomb codes
*/ */
static inline void BsWriteUE (SBitStringAux* pBs, const uint32_t kuiValue) { static inline void BsWriteUE (SBitStringAux* pBs, const uint32_t kuiValue) {
uint32_t iTmpValue = kuiValue + 1; uint32_t iTmpValue = kuiValue + 1;
if (256 > kuiValue) { if (256 > kuiValue) {
BsWriteBits (pBs, g_uiGolombUELength[kuiValue], kuiValue + 1); BsWriteBits (pBs, g_uiGolombUELength[kuiValue], kuiValue + 1);
} else { } else {
uint32_t n = 0; uint32_t n = 0;
if (iTmpValue & 0xffff0000) { if (iTmpValue & 0xffff0000) {
iTmpValue >>= 16; iTmpValue >>= 16;
n += 16; n += 16;
}
if (iTmpValue & 0xff00) {
iTmpValue >>= 8;
n += 8;
}
//n += (g_uiGolombUELength[iTmpValue] >> 1);
n += (g_uiGolombUELength[iTmpValue - 1] >> 1);
BsWriteBits (pBs, (n << 1) + 1, kuiValue + 1);
} }
return; if (iTmpValue & 0xff00) {
iTmpValue >>= 8;
n += 8;
}
//n += (g_uiGolombUELength[iTmpValue] >> 1);
n += (g_uiGolombUELength[iTmpValue - 1] >> 1);
BsWriteBits (pBs, (n << 1) + 1, kuiValue + 1);
}
return;
} }
/* /*
* Write signed exp golomb codes * Write signed exp golomb codes
*/ */
static inline void BsWriteSE (SBitStringAux* pBs, int32_t iValue) { static inline void BsWriteSE (SBitStringAux* pBs, int32_t iValue) {
uint32_t iTmpValue; uint32_t iTmpValue;
if (0 == iValue) { if (0 == iValue) {
BsWriteOneBit (pBs, 1); BsWriteOneBit (pBs, 1);
} else if (0 < iValue) { } else if (0 < iValue) {
iTmpValue = (iValue << 1) - 1; iTmpValue = (iValue << 1) - 1;
BsWriteUE (pBs, iTmpValue); BsWriteUE (pBs, iTmpValue);
} else { } else {
iTmpValue = ((-iValue) << 1); iTmpValue = ((-iValue) << 1);
BsWriteUE (pBs, iTmpValue); BsWriteUE (pBs, iTmpValue);
} }
return; return;
} }
/* /*
* Write truncated exp golomb codes * Write truncated exp golomb codes
*/ */
static inline void BsWriteTE (SBitStringAux* pBs, const int32_t kiX, const uint32_t kuiValue) { static inline void BsWriteTE (SBitStringAux* pBs, const int32_t kiX, const uint32_t kuiValue) {
if (1 == kiX) { if (1 == kiX) {
BsWriteOneBit (pBs, !kuiValue); BsWriteOneBit (pBs, !kuiValue);
} else { } else {
BsWriteUE (pBs, kuiValue); BsWriteUE (pBs, kuiValue);
} }
} }
@ -232,18 +232,18 @@ static inline void BsWriteTE (SBitStringAux* pBs, const int32_t kiX, const uint3
* Write RBSP trailing bits * Write RBSP trailing bits
*/ */
static inline void BsRbspTrailingBits (SBitStringAux* pBs) { static inline void BsRbspTrailingBits (SBitStringAux* pBs) {
BsWriteOneBit (pBs, 1); BsWriteOneBit (pBs, 1);
BsFlush (pBs); BsFlush (pBs);
} }
static inline bool BsCheckByteAlign (SBitStringAux* pBs) { static inline bool BsCheckByteAlign (SBitStringAux* pBs) {
return ! (pBs->iLeftBits & 0x7); return ! (pBs->iLeftBits & 0x7);
} }
static inline int32_t BsGetBitsPos (SBitStringAux* pBs) { static inline int32_t BsGetBitsPos (SBitStringAux* pBs) {
return (int32_t) (((pBs->pBufPtr - pBs->pBuf) << 3) + 32 - pBs->iLeftBits); return (int32_t) (((pBs->pBufPtr - pBs->pBuf) << 3) + 32 - pBs->iLeftBits);
} }
} }

36
codec/encoder/core/inc/svc_enc_macroblock.h
View File

@ -47,29 +47,29 @@ namespace WelsSVCEnc {
// keep the most essential level pData structure be 64 Bytes, which matches cache line size; if so, the order with structure maybe negligible. // keep the most essential level pData structure be 64 Bytes, which matches cache line size; if so, the order with structure maybe negligible.
// pls take care when modify MB structure size // pls take care when modify MB structure size
typedef struct TagMB { typedef struct TagMB {
/*************************mb_layer() syntax and generated********************************/ /*************************mb_layer() syntax and generated********************************/
/*mb_layer():*/ /*mb_layer():*/
Mb_Type uiMbType; // including MB detailed partition type, number and type of reference list Mb_Type uiMbType; // including MB detailed partition type, number and type of reference list
int16_t iMbXY; // offset position of MB top left point based int16_t iMbXY; // offset position of MB top left point based
int16_t iMbX; // position of MB in horizontal axis int16_t iMbX; // position of MB in horizontal axis
int16_t iMbY; // position of MB in vertical axis int16_t iMbY; // position of MB in vertical axis
uint8_t uiNeighborAvail; // avail && same_slice: LEFT_MB_POS:0x01, TOP_MB_POS:0x02, TOPRIGHT_MB_POS = 0x04 ,TOPLEFT_MB_POS = 0x08; uint8_t uiNeighborAvail; // avail && same_slice: LEFT_MB_POS:0x01, TOP_MB_POS:0x02, TOPRIGHT_MB_POS = 0x04 ,TOPLEFT_MB_POS = 0x08;
uint8_t uiCbp; uint8_t uiCbp;
SMVUnitXY* sMv; SMVUnitXY* sMv;
int8_t* pRefIndex; int8_t* pRefIndex;
int32_t* pSadCost; // mb sad. set to 0 for intra mb int32_t* pSadCost; // mb sad. set to 0 for intra mb
int8_t* pIntra4x4PredMode; // [MB_BLOCK4x4_NUM] int8_t* pIntra4x4PredMode; // [MB_BLOCK4x4_NUM]
int8_t* pNonZeroCount; // [MB_LUMA_CHROMA_BLOCK4x4_NUM] int8_t* pNonZeroCount; // [MB_LUMA_CHROMA_BLOCK4x4_NUM]
SMVUnitXY sP16x16Mv; SMVUnitXY sP16x16Mv;
uint8_t uiLumaQp; // uiLumaQp: pPps->iInitialQp + sSliceHeader->delta_qp + mb->dquant. uint8_t uiLumaQp; // uiLumaQp: pPps->iInitialQp + sSliceHeader->delta_qp + mb->dquant.
uint8_t uiChromaQp; uint8_t uiChromaQp;
uint8_t uiSliceIdc; // AVC: pFirstMbInSlice?; SVC: (pFirstMbInSlice << 7) | ((uiDependencyId << 4) | uiQualityId); uint8_t uiSliceIdc; // AVC: pFirstMbInSlice?; SVC: (pFirstMbInSlice << 7) | ((uiDependencyId << 4) | uiQualityId);
uint8_t reserved_filling_bytes[1]; // filling bytes reserved to make structure aligned with 4 bytes, higher cache hit on less structure size by 2 cache lines( 2 * 64 bytes) once hit uint8_t reserved_filling_bytes[1]; // filling bytes reserved to make structure aligned with 4 bytes, higher cache hit on less structure size by 2 cache lines( 2 * 64 bytes) once hit
} SMB, *PMb; } SMB, *PMb;
} }

34
codec/encoder/core/inc/svc_enc_slice_segment.h
View File

@ -73,29 +73,29 @@ namespace WelsSVCEnc {
*/ */
/* Single/multiple slices */ /* Single/multiple slices */
typedef struct SlicepEncCtx_s { typedef struct SlicepEncCtx_s {
SliceModeEnum uiSliceMode; /* 0: single slice in frame; 1: multiple slices in frame; */ SliceModeEnum uiSliceMode; /* 0: single slice in frame; 1: multiple slices in frame; */
int16_t iMbWidth; /* width of picture size in mb */ int16_t iMbWidth; /* width of picture size in mb */
int16_t iMbHeight; /* height of picture size in mb */ int16_t iMbHeight; /* height of picture size in mb */
int16_t iSliceNumInFrame; /* count number of slices in frame; */ int16_t iSliceNumInFrame; /* count number of slices in frame; */
int32_t iMbNumInFrame; /* count number of MBs in frame */ int32_t iMbNumInFrame; /* count number of MBs in frame */
uint8_t* pOverallMbMap; /* overall MB map in frame, store virtual slice idc; */ uint8_t* pOverallMbMap; /* overall MB map in frame, store virtual slice idc; */
int16_t* pFirstMbInSlice; /* first MB address top-left based in every slice respectively; */ int16_t* pFirstMbInSlice; /* first MB address top-left based in every slice respectively; */
int32_t* pCountMbNumInSlice; /* count number of MBs in every slice respectively; */ int32_t* pCountMbNumInSlice; /* count number of MBs in every slice respectively; */
uint32_t uiSliceSizeConstraint;/*in byte*/ uint32_t uiSliceSizeConstraint;/*in byte*/
int32_t iMaxSliceNumConstraint;/*maximal number of slices constraint*/ int32_t iMaxSliceNumConstraint;/*maximal number of slices constraint*/
} SSliceCtx; } SSliceCtx;
typedef struct TagDynamicSlicingStack { typedef struct TagDynamicSlicingStack {
int32_t iStartPos; int32_t iStartPos;
int32_t iCurrentPos; int32_t iCurrentPos;
uint8_t* pBsStackBufPtr; // current writing position uint8_t* pBsStackBufPtr; // current writing position
uint32_t uiBsStackCurBits; uint32_t uiBsStackCurBits;
int32_t iBsStackLeftBits; int32_t iBsStackLeftBits;
int32_t iMbSkipRunStack; int32_t iMbSkipRunStack;
uint8_t uiLastMbQp; uint8_t uiLastMbQp;
} SDynamicSlicingStack; } SDynamicSlicingStack;
/*! /*!

4
codec/encoder/core/inc/svc_mode_decision.h
View File

@ -54,8 +54,8 @@ namespace WelsSVCEnc {
#define DELTA_QP_SCD_THD 5 #define DELTA_QP_SCD_THD 5
typedef enum { typedef enum {
STATIC, STATIC,
SCROLLED, SCROLLED,
} ESkipModes; } ESkipModes;
// NOILP ILFMD ENTRANCE // NOILP ILFMD ENTRANCE

130
codec/encoder/core/inc/svc_motion_estimate.h
View File

@ -55,78 +55,78 @@ namespace WelsSVCEnc {
#define EXPANDED_MVD_RANGE ((504+1)<<1) #define EXPANDED_MVD_RANGE ((504+1)<<1)
enum { enum {
ME_DIA = 0x01, // LITTLE DIAMOND= 0x01 ME_DIA = 0x01, // LITTLE DIAMOND= 0x01
ME_CROSS = 0x02, // CROSS= 0x02 ME_CROSS = 0x02, // CROSS= 0x02
ME_FME = 0x04, // FME = 0x04 ME_FME = 0x04, // FME = 0x04
ME_FULL = 0x10, // FULL ME_FULL = 0x10, // FULL
// derived ME methods combination // derived ME methods combination
ME_DIA_CROSS = (ME_DIA | ME_CROSS), // DIA+CROSS ME_DIA_CROSS = (ME_DIA | ME_CROSS), // DIA+CROSS
ME_DIA_CROSS_FME = (ME_DIA_CROSS | ME_FME), // DIA+CROSS+FME ME_DIA_CROSS_FME = (ME_DIA_CROSS | ME_FME), // DIA+CROSS+FME
}; };
union SadPredISatdUnit { union SadPredISatdUnit {
uint32_t uiSadPred; uint32_t uiSadPred;
uint32_t uiSatd; //reuse the sad_pred as a temp satd pData uint32_t uiSatd; //reuse the sad_pred as a temp satd pData
}; };
typedef struct TagWelsME { typedef struct TagWelsME {
/* input */ /* input */
uint16_t* pMvdCost; uint16_t* pMvdCost;
union SadPredISatdUnit uSadPredISatd; //reuse the sad_pred as a temp pData union SadPredISatdUnit uSadPredISatd; //reuse the sad_pred as a temp pData
uint32_t uint32_t
uiSadCost; //used by ME and RC //max SAD should be max_delta*size+lambda*mvdsize = 255*256+91*33*2 = 65280 + 6006 = 71286 > (2^16)-1 = 65535 uiSadCost; //used by ME and RC //max SAD should be max_delta*size+lambda*mvdsize = 255*256+91*33*2 = 65280 + 6006 = 71286 > (2^16)-1 = 65535
uint32_t uiSatdCost; /* satd + lm * nbits */ uint32_t uiSatdCost; /* satd + lm * nbits */
uint32_t uiSadCostThreshold; uint32_t uiSadCostThreshold;
int32_t iCurMeBlockPixX; int32_t iCurMeBlockPixX;
int32_t iCurMeBlockPixY; int32_t iCurMeBlockPixY;
uint8_t uiBlockSize; /* BLOCK_WxH */ uint8_t uiBlockSize; /* BLOCK_WxH */
uint8_t uiReserved; uint8_t uiReserved;
uint8_t* pEncMb; uint8_t* pEncMb;
uint8_t* pRefMb; uint8_t* pRefMb;
uint8_t* pColoRefMb; uint8_t* pColoRefMb;
SMVUnitXY sMvp; SMVUnitXY sMvp;
SMVUnitXY sMvBase; SMVUnitXY sMvBase;
SMVUnitXY sDirectionalMv; SMVUnitXY sDirectionalMv;
SScreenBlockFeatureStorage* pRefFeatureStorage; SScreenBlockFeatureStorage* pRefFeatureStorage;
/* output */ /* output */
SMVUnitXY sMv; SMVUnitXY sMv;
} SWelsME; } SWelsME;
typedef struct TagFeatureSearchIn { typedef struct TagFeatureSearchIn {
PSampleSadSatdCostFunc pSad; PSampleSadSatdCostFunc pSad;
uint32_t* pTimesOfFeature; uint32_t* pTimesOfFeature;
uint16_t** pQpelLocationOfFeature; uint16_t** pQpelLocationOfFeature;
uint16_t* pMvdCostX; uint16_t* pMvdCostX;
uint16_t* pMvdCostY; uint16_t* pMvdCostY;
uint8_t* pEnc; uint8_t* pEnc;
uint8_t* pColoRef; uint8_t* pColoRef;
int32_t iEncStride; int32_t iEncStride;
int32_t iRefStride; int32_t iRefStride;
uint16_t uiSadCostThresh; uint16_t uiSadCostThresh;
int32_t iFeatureOfCurrent; int32_t iFeatureOfCurrent;
int32_t iCurPixX; int32_t iCurPixX;
int32_t iCurPixY; int32_t iCurPixY;
int32_t iCurPixXQpel; int32_t iCurPixXQpel;
int32_t iCurPixYQpel; int32_t iCurPixYQpel;
int32_t iMinQpelX; int32_t iMinQpelX;
int32_t iMinQpelY; int32_t iMinQpelY;
int32_t iMaxQpelX; int32_t iMaxQpelX;
int32_t iMaxQpelY; int32_t iMaxQpelY;
} SFeatureSearchIn; } SFeatureSearchIn;
typedef struct TagFeatureSearchOut { typedef struct TagFeatureSearchOut {
SMVUnitXY sBestMv; SMVUnitXY sBestMv;
uint32_t uiBestSadCost; uint32_t uiBestSadCost;
uint8_t* pBestRef; uint8_t* pBestRef;
} SFeatureSearchOut; } SFeatureSearchOut;
#define COST_MVD(table, mx, my) (table[mx] + table[my]) #define COST_MVD(table, mx, my) (table[mx] + table[my])
@ -207,8 +207,8 @@ void LineFullSearch_c (SWelsFuncPtrList* pFuncList, SWelsME* pMe,
#ifdef X86_ASM #ifdef X86_ASM
extern "C" extern "C"
{ {
uint32_t SampleSad8x8Hor8_sse41 (uint8_t*, int32_t, uint8_t*, int32_t, uint16_t*, int32_t*); uint32_t SampleSad8x8Hor8_sse41 (uint8_t*, int32_t, uint8_t*, int32_t, uint16_t*, int32_t*);
uint32_t SampleSad16x16Hor8_sse41 (uint8_t*, int32_t, uint8_t*, int32_t, uint16_t*, int32_t*); uint32_t SampleSad16x16Hor8_sse41 (uint8_t*, int32_t, uint8_t*, int32_t, uint16_t*, int32_t*);
} }
void VerticalFullSearchUsingSSE41 (SWelsFuncPtrList* pFuncList, SWelsME* pMe, void VerticalFullSearchUsingSSE41 (SWelsFuncPtrList* pFuncList, SWelsME* pMe,
@ -277,27 +277,27 @@ inline void SetMvWithinIntegerMvRange (const int32_t kiMbWidth, const int32_t ki
const int32_t kiMbY, const int32_t kiMbY,
const int32_t kiMaxMvRange, const int32_t kiMaxMvRange,
SMVUnitXY* pMvMin, SMVUnitXY* pMvMax) { SMVUnitXY* pMvMin, SMVUnitXY* pMvMax) {
pMvMin->iMvX = WELS_MAX (-1 * ((kiMbX + 1) << 4) + INTPEL_NEEDED_MARGIN, -1 * kiMaxMvRange); pMvMin->iMvX = WELS_MAX (-1 * ((kiMbX + 1) << 4) + INTPEL_NEEDED_MARGIN, -1 * kiMaxMvRange);
pMvMin->iMvY = WELS_MAX (-1 * ((kiMbY + 1) << 4) + INTPEL_NEEDED_MARGIN, -1 * kiMaxMvRange); pMvMin->iMvY = WELS_MAX (-1 * ((kiMbY + 1) << 4) + INTPEL_NEEDED_MARGIN, -1 * kiMaxMvRange);
pMvMax->iMvX = WELS_MIN (((kiMbWidth - kiMbX) << 4) - INTPEL_NEEDED_MARGIN, kiMaxMvRange); pMvMax->iMvX = WELS_MIN (((kiMbWidth - kiMbX) << 4) - INTPEL_NEEDED_MARGIN, kiMaxMvRange);
pMvMax->iMvY = WELS_MIN (((kiMbHeight - kiMbY) << 4) - INTPEL_NEEDED_MARGIN, kiMaxMvRange); pMvMax->iMvY = WELS_MIN (((kiMbHeight - kiMbY) << 4) - INTPEL_NEEDED_MARGIN, kiMaxMvRange);
} }
inline bool CheckMvInRange (const int16_t kiCurrentMv, const int16_t kiMinMv, const int16_t kiMaxMv) { inline bool CheckMvInRange (const int16_t kiCurrentMv, const int16_t kiMinMv, const int16_t kiMaxMv) {
return ((kiCurrentMv >= kiMinMv) && (kiCurrentMv < kiMaxMv)); return ((kiCurrentMv >= kiMinMv) && (kiCurrentMv < kiMaxMv));
} }
inline bool CheckMvInRange (const SMVUnitXY ksCurrentMv, const SMVUnitXY ksMinMv, const SMVUnitXY ksMaxMv) { inline bool CheckMvInRange (const SMVUnitXY ksCurrentMv, const SMVUnitXY ksMinMv, const SMVUnitXY ksMaxMv) {
return (CheckMvInRange (ksCurrentMv.iMvX, ksMinMv.iMvX, ksMaxMv.iMvX) return (CheckMvInRange (ksCurrentMv.iMvX, ksMinMv.iMvX, ksMaxMv.iMvX)
&& CheckMvInRange (ksCurrentMv.iMvY, ksMinMv.iMvY, ksMaxMv.iMvY)); && CheckMvInRange (ksCurrentMv.iMvY, ksMinMv.iMvY, ksMaxMv.iMvY));
} }
//FME switch related //FME switch related
inline bool CalcFMESwitchFlag (const uint8_t uiFMEGoodFrameCount, const int32_t iHighFreMbPrecentage, inline bool CalcFMESwitchFlag (const uint8_t uiFMEGoodFrameCount, const int32_t iHighFreMbPrecentage,
const int32_t iAvgMbSAD, const bool bScrollingDetected) { const int32_t iAvgMbSAD, const bool bScrollingDetected) {
return (bScrollingDetected || (uiFMEGoodFrameCount > 0 && iAvgMbSAD > FMESWITCH_MBSAD_THRESHOLD)); return (bScrollingDetected || (uiFMEGoodFrameCount > 0 && iAvgMbSAD > FMESWITCH_MBSAD_THRESHOLD));
//TODO: add the logic of iHighFreMbPrecentage //TODO: add the logic of iHighFreMbPrecentage
//return ( iHighFreMbPrecentage > 2 //return ( iHighFreMbPrecentage > 2
// && ( bScrollingDetected || iHighFreMbPrecentage >15 // && ( bScrollingDetected || iHighFreMbPrecentage >15
// ||( uiFMEGoodFrameCount>0 && iFrameSAD > FMESWITCH_FRAMESAD_THRESHOLD ) ) ); // ||( uiFMEGoodFrameCount>0 && iFrameSAD > FMESWITCH_FRAMESAD_THRESHOLD ) ) );
} }
} }
#endif #endif

26
codec/encoder/core/inc/vlc_encoder.h
View File

@ -58,36 +58,36 @@ extern const ALIGNED_DECLARE (uint8_t, g_kuiEncNcMapTable[18], 16);
static inline int32_t WriteTotalCoeffTrailingones (SBitStringAux* pBs, uint8_t uiNc, uint8_t uiTotalCoeff, static inline int32_t WriteTotalCoeffTrailingones (SBitStringAux* pBs, uint8_t uiNc, uint8_t uiTotalCoeff,
uint8_t uiTrailingOnes) { uint8_t uiTrailingOnes) {
const uint8_t kuiNcIdx = g_kuiEncNcMapTable[uiNc]; const uint8_t kuiNcIdx = g_kuiEncNcMapTable[uiNc];
const uint8_t* kpCoeffToken = &g_kuiVlcCoeffToken[kuiNcIdx][uiTotalCoeff][uiTrailingOnes][0]; const uint8_t* kpCoeffToken = &g_kuiVlcCoeffToken[kuiNcIdx][uiTotalCoeff][uiTrailingOnes][0];
return BsWriteBits (pBs, kpCoeffToken[1], kpCoeffToken[0]); return BsWriteBits (pBs, kpCoeffToken[1], kpCoeffToken[0]);
} }
static inline int32_t WriteTotalcoeffTrailingonesChroma (SBitStringAux* pBs, uint8_t uiTotalCoeff, static inline int32_t WriteTotalcoeffTrailingonesChroma (SBitStringAux* pBs, uint8_t uiTotalCoeff,
uint8_t uiTrailingOnes) { uint8_t uiTrailingOnes) {
const uint8_t* kpCoeffToken = &g_kuiVlcCoeffToken[4][uiTotalCoeff][uiTrailingOnes][0]; const uint8_t* kpCoeffToken = &g_kuiVlcCoeffToken[4][uiTotalCoeff][uiTrailingOnes][0];
return BsWriteBits (pBs, kpCoeffToken[1], kpCoeffToken[0]); return BsWriteBits (pBs, kpCoeffToken[1], kpCoeffToken[0]);
} }
//kuiZeroCount = level_prefix; //kuiZeroCount = level_prefix;
static inline int32_t WriteLevelPrefix (SBitStringAux* pBs, const uint32_t kuiZeroCount) { static inline int32_t WriteLevelPrefix (SBitStringAux* pBs, const uint32_t kuiZeroCount) {
BsWriteBits (pBs, kuiZeroCount + 1, 1); BsWriteBits (pBs, kuiZeroCount + 1, 1);
return 0; return 0;
} }
static inline int32_t WriteTotalZeros (SBitStringAux* pBs, uint32_t uiTotalCoeff, uint32_t uiTotalZeros) { static inline int32_t WriteTotalZeros (SBitStringAux* pBs, uint32_t uiTotalCoeff, uint32_t uiTotalZeros) {
const uint8_t* kpTotalZeros = &g_kuiVlcTotalZeros[uiTotalCoeff][uiTotalZeros][0]; const uint8_t* kpTotalZeros = &g_kuiVlcTotalZeros[uiTotalCoeff][uiTotalZeros][0];
return BsWriteBits (pBs, kpTotalZeros[1], kpTotalZeros[0]); return BsWriteBits (pBs, kpTotalZeros[1], kpTotalZeros[0]);
} }
static inline int32_t WriteTotalZerosChromaDc (SBitStringAux* pBs, uint32_t uiTotalCoeff, uint32_t uiTotalZeros) { static inline int32_t WriteTotalZerosChromaDc (SBitStringAux* pBs, uint32_t uiTotalCoeff, uint32_t uiTotalZeros) {
const uint8_t* kpTotalZerosChromaDc = &g_kuiVlcTotalZerosChromaDc[uiTotalCoeff][uiTotalZeros][0]; const uint8_t* kpTotalZerosChromaDc = &g_kuiVlcTotalZerosChromaDc[uiTotalCoeff][uiTotalZeros][0];
return BsWriteBits (pBs, kpTotalZerosChromaDc[1], kpTotalZerosChromaDc[0]); return BsWriteBits (pBs, kpTotalZerosChromaDc[1], kpTotalZerosChromaDc[0]);
} }
static inline int32_t WriteRunBefore (SBitStringAux* pBs, uint8_t uiZeroLeft, uint8_t uiRunBefore) { static inline int32_t WriteRunBefore (SBitStringAux* pBs, uint8_t uiZeroLeft, uint8_t uiRunBefore) {
const uint8_t* kpRunBefore = &g_kuiVlcRunBefore[uiZeroLeft][uiRunBefore][0]; const uint8_t* kpRunBefore = &g_kuiVlcRunBefore[uiZeroLeft][uiRunBefore][0];
return BsWriteBits (pBs, kpRunBefore[1], kpRunBefore[0]); return BsWriteBits (pBs, kpRunBefore[1], kpRunBefore[0]);
} }
} }
#endif #endif

214
codec/encoder/core/inc/wels_common_basis.h
View File

@ -50,38 +50,38 @@ extern const uint8_t g_kuiChromaQpTable[52];
* NAL Unit Type (5 Bits) * NAL Unit Type (5 Bits)
*/ */
enum EWelsNalUnitType { enum EWelsNalUnitType {
NAL_UNIT_UNSPEC_0 = 0, NAL_UNIT_UNSPEC_0 = 0,
NAL_UNIT_CODED_SLICE = 1, NAL_UNIT_CODED_SLICE = 1,
NAL_UNIT_CODED_SLICE_DPA = 2, NAL_UNIT_CODED_SLICE_DPA = 2,
NAL_UNIT_CODED_SLICE_DPB = 3, NAL_UNIT_CODED_SLICE_DPB = 3,
NAL_UNIT_CODED_SLICE_DPC = 4, NAL_UNIT_CODED_SLICE_DPC = 4,
NAL_UNIT_CODED_SLICE_IDR = 5, NAL_UNIT_CODED_SLICE_IDR = 5,
NAL_UNIT_SEI = 6, NAL_UNIT_SEI = 6,
NAL_UNIT_SPS = 7, NAL_UNIT_SPS = 7,
NAL_UNIT_PPS = 8, NAL_UNIT_PPS = 8,
NAL_UNIT_AU_DELIMITER = 9, NAL_UNIT_AU_DELIMITER = 9,
NAL_UNIT_END_OF_SEQ = 10, NAL_UNIT_END_OF_SEQ = 10,
NAL_UNIT_END_OF_STR = 11, NAL_UNIT_END_OF_STR = 11,
NAL_UNIT_FILLER_DATA = 12, NAL_UNIT_FILLER_DATA = 12,
NAL_UNIT_SPS_EXT = 13, NAL_UNIT_SPS_EXT = 13,
NAL_UNIT_PREFIX = 14, NAL_UNIT_PREFIX = 14,
NAL_UNIT_SUBSET_SPS = 15, NAL_UNIT_SUBSET_SPS = 15,
NAL_UNIT_RESV_16 = 16, NAL_UNIT_RESV_16 = 16,
NAL_UNIT_RESV_17 = 17, NAL_UNIT_RESV_17 = 17,
NAL_UNIT_RESV_18 = 18, NAL_UNIT_RESV_18 = 18,
NAL_UNIT_AUX_CODED_SLICE = 19, NAL_UNIT_AUX_CODED_SLICE = 19,
NAL_UNIT_CODED_SLICE_EXT = 20, NAL_UNIT_CODED_SLICE_EXT = 20,
NAL_UNIT_RESV_21 = 21, NAL_UNIT_RESV_21 = 21,
NAL_UNIT_RESV_22 = 22, NAL_UNIT_RESV_22 = 22,
NAL_UNIT_RESV_23 = 23, NAL_UNIT_RESV_23 = 23,
NAL_UNIT_UNSPEC_24 = 24, NAL_UNIT_UNSPEC_24 = 24,
NAL_UNIT_UNSPEC_25 = 25, NAL_UNIT_UNSPEC_25 = 25,
NAL_UNIT_UNSPEC_26 = 26, NAL_UNIT_UNSPEC_26 = 26,
NAL_UNIT_UNSPEC_27 = 27, NAL_UNIT_UNSPEC_27 = 27,
NAL_UNIT_UNSPEC_28 = 28, NAL_UNIT_UNSPEC_28 = 28,
NAL_UNIT_UNSPEC_29 = 29, NAL_UNIT_UNSPEC_29 = 29,
NAL_UNIT_UNSPEC_30 = 30, NAL_UNIT_UNSPEC_30 = 30,
NAL_UNIT_UNSPEC_31 = 31 NAL_UNIT_UNSPEC_31 = 31
}; };
/* /*
@ -89,10 +89,10 @@ enum EWelsNalUnitType {
*/ */
enum EWelsNalRefIdc { enum EWelsNalRefIdc {
NRI_PRI_LOWEST = 0, NRI_PRI_LOWEST = 0,
NRI_PRI_LOW = 1, NRI_PRI_LOW = 1,
NRI_PRI_HIGH = 2, NRI_PRI_HIGH = 2,
NRI_PRI_HIGHEST = 3 NRI_PRI_HIGHEST = 3
}; };
/* /*
@ -100,9 +100,9 @@ enum EWelsNalRefIdc {
*/ */
enum EVclType { enum EVclType {
NON_VCL = 0, NON_VCL = 0,
VCL = 1, VCL = 1,
NOT_APP = 2 NOT_APP = 2
}; };
/* /*
@ -129,64 +129,64 @@ extern const EVclType g_keTypeMap[32][2];
*/ */
enum EWelsSliceType { enum EWelsSliceType {
P_SLICE = 0, P_SLICE = 0,
B_SLICE = 1, B_SLICE = 1,
I_SLICE = 2, I_SLICE = 2,
SP_SLICE = 3, SP_SLICE = 3,
SI_SLICE = 4, SI_SLICE = 4,
UNKNOWN_SLICE = 5 UNKNOWN_SLICE = 5
}; };
/* SSlice Types in scalable extension */ ; /* SSlice Types in scalable extension */ ;
enum ESliceTypeExt { enum ESliceTypeExt {
EP_SLICE = 0, // EP_SLICE: 0, 5 EP_SLICE = 0, // EP_SLICE: 0, 5
EB_SLICE = 1, // EB_SLICE: 1, 6 EB_SLICE = 1, // EB_SLICE: 1, 6
EI_SLICE = 2 // EI_SLICE: 2, 7 EI_SLICE = 2 // EI_SLICE: 2, 7
}; };
/* List Index */ /* List Index */
enum EListIndex { enum EListIndex {
LIST_0 = 0, LIST_0 = 0,
LIST_1 = 1, LIST_1 = 1,
LIST_A = 2 LIST_A = 2
}; };
struct SMVUnitXY { // each 4 Bytes struct SMVUnitXY { // each 4 Bytes
int16_t iMvX; int16_t iMvX;
int16_t iMvY; int16_t iMvY;
public: public:
SMVUnitXY& sDeltaMv (const SMVUnitXY& _v0, const SMVUnitXY& _v1) { SMVUnitXY& sDeltaMv (const SMVUnitXY& _v0, const SMVUnitXY& _v1) {
iMvX = _v0.iMvX - _v1.iMvX; iMvX = _v0.iMvX - _v1.iMvX;
iMvY = _v0.iMvY - _v1.iMvY; iMvY = _v0.iMvY - _v1.iMvY;
return (*this); return (*this);
} }
}; };
typedef struct TagMVComponentUnit { // each LIST_0/LIST_1 typedef struct TagMVComponentUnit { // each LIST_0/LIST_1
SMVUnitXY sMotionVectorCache[5 * 6 - 1]; // Luma only: 5 x 6 - 1 = 29 D-Words SMVUnitXY sMotionVectorCache[5 * 6 - 1]; // Luma only: 5 x 6 - 1 = 29 D-Words
int8_t iRefIndexCache[5 * 6]; // Luma only: 5 x 6 = 30 bytes int8_t iRefIndexCache[5 * 6]; // Luma only: 5 x 6 = 30 bytes
} SMVComponentUnit, *PMVComponentUnit; } SMVComponentUnit, *PMVComponentUnit;
typedef struct TagParaSetOffsetVariable { typedef struct TagParaSetOffsetVariable {
int32_t iParaSetIdDelta[MAX_DQ_LAYER_NUM/*+1*/]; //mark delta between SPS_ID_in_bs and sps_id_in_encoder, can be minus, for each dq-layer int32_t iParaSetIdDelta[MAX_DQ_LAYER_NUM/*+1*/]; //mark delta between SPS_ID_in_bs and sps_id_in_encoder, can be minus, for each dq-layer
//need not extra +1 due no MGS and FMO case so far //need not extra +1 due no MGS and FMO case so far
bool bUsedParaSetIdInBs[MAX_PPS_COUNT]; //mark the used SPS_ID with 1 bool bUsedParaSetIdInBs[MAX_PPS_COUNT]; //mark the used SPS_ID with 1
uint32_t uiNextParaSetIdToUseInBs; //mark the next SPS_ID_in_bs, for all layers uint32_t uiNextParaSetIdToUseInBs; //mark the next SPS_ID_in_bs, for all layers
} SParaSetOffsetVariable; } SParaSetOffsetVariable;
typedef struct TagParaSetOffset { typedef struct TagParaSetOffset {
//in PS0 design, "sParaSetOffsetVariable" record the previous paras before current IDR, AND NEED to be stacked and recover across IDR //in PS0 design, "sParaSetOffsetVariable" record the previous paras before current IDR, AND NEED to be stacked and recover across IDR
SParaSetOffsetVariable SParaSetOffsetVariable
sParaSetOffsetVariable[PARA_SET_TYPE]; //PARA_SET_TYPE=3; paraset_type = 0: AVC_SPS; =1: Subset_SPS; =2: PPS sParaSetOffsetVariable[PARA_SET_TYPE]; //PARA_SET_TYPE=3; paraset_type = 0: AVC_SPS; =1: Subset_SPS; =2: PPS
//in PSO design, "bPpsIdMappingIntoSubsetsps" uses the current para of current IDR period //in PSO design, "bPpsIdMappingIntoSubsetsps" uses the current para of current IDR period
bool bool
bPpsIdMappingIntoSubsetsps[MAX_DQ_LAYER_NUM/*+1*/]; // need not extra +1 due no MGS and FMO case so far bPpsIdMappingIntoSubsetsps[MAX_DQ_LAYER_NUM/*+1*/]; // need not extra +1 due no MGS and FMO case so far
uint16_t uint16_t
uiIdrPicId; // IDR picture id: [0, 65535], this one is used for LTR!! Can we just NOT put this into the SParaSetOffset structure?!! uiIdrPicId; // IDR picture id: [0, 65535], this one is used for LTR!! Can we just NOT put this into the SParaSetOffset structure?!!
#if _DEBUG #if _DEBUG
bool bEnableSpsPpsIdAddition; bool bEnableSpsPpsIdAddition;
#endif #endif
} SParaSetOffset; } SParaSetOffset;
@ -194,47 +194,47 @@ typedef struct TagParaSetOffset {
/* Motion Vector components */ /* Motion Vector components */
enum EMvComp { enum EMvComp {
MV_X = 0, MV_X = 0,
MV_Y = 1, MV_Y = 1,
MV_A = 2 MV_A = 2
}; };
/* Chroma Components */ /* Chroma Components */
enum EChromaComp { enum EChromaComp {
CHROMA_CB = 0, CHROMA_CB = 0,
CHROMA_CR = 1, CHROMA_CR = 1,
CHROMA_A = 2 CHROMA_A = 2
}; };
/* Position Offset structure */ /* Position Offset structure */
typedef struct TagCropOffset { typedef struct TagCropOffset {
int16_t iCropLeft; int16_t iCropLeft;
int16_t iCropRight; int16_t iCropRight;
int16_t iCropTop; int16_t iCropTop;
int16_t iCropBottom; int16_t iCropBottom;
} SCropOffset; } SCropOffset;
/* Transform Type */ /* Transform Type */
enum ETransType { enum ETransType {
T_4x4 = 0, T_4x4 = 0,
T_8x8 = 1, T_8x8 = 1,
T_16x16 = 2, T_16x16 = 2,
T_PCM = 3 T_PCM = 3
}; };
enum EMbPosition { enum EMbPosition {
LEFT_MB_POS = 0x01, // A LEFT_MB_POS = 0x01, // A
TOP_MB_POS = 0x02, // B TOP_MB_POS = 0x02, // B
TOPRIGHT_MB_POS = 0x04, // C TOPRIGHT_MB_POS = 0x04, // C
TOPLEFT_MB_POS = 0x08, // D, TOPLEFT_MB_POS = 0x08, // D,
RIGHT_MB_POS = 0x10, // add followed four case to reuse when intra up-sample RIGHT_MB_POS = 0x10, // add followed four case to reuse when intra up-sample
BOTTOM_MB_POS = 0x20, // BOTTOM_MB_POS = 0x20, //
BOTTOMRIGHT_MB_POS = 0x40, // BOTTOMRIGHT_MB_POS = 0x40, //
BOTTOMLEFT_MB_POS = 0x80, // BOTTOMLEFT_MB_POS = 0x80, //
MB_POS_A = 0x100 MB_POS_A = 0x100
}; };
#define MB_ON_PIC_BOUNDRY (RIGHT_MB_POS|BOTTOM_MB_POS|LEFT_MB_POS|TOP_MB_POS) #define MB_ON_PIC_BOUNDRY (RIGHT_MB_POS|BOTTOM_MB_POS|LEFT_MB_POS|TOP_MB_POS)
@ -301,13 +301,13 @@ typedef uint32_t Mb_Type;
enum { enum {
Intra4x4 = 0, Intra4x4 = 0,
Intra16x16 = 1, Intra16x16 = 1,
Inter16x16 = 2, Inter16x16 = 2,
Inter16x8 = 3, Inter16x8 = 3,
Inter8x16 = 4, Inter8x16 = 4,
Inter8x8 = 5, Inter8x8 = 5,
PSkip = 6 PSkip = 6
}; };
@ -315,13 +315,13 @@ enum {
* Memory Management Control Operation (MMCO) code * Memory Management Control Operation (MMCO) code
*/ */
enum EMmcoCode { enum EMmcoCode {
MMCO_END = 0, MMCO_END = 0,
MMCO_SHORT2UNUSED = 1, MMCO_SHORT2UNUSED = 1,
MMCO_LONG2UNUSED = 2, MMCO_LONG2UNUSED = 2,
MMCO_SHORT2LONG = 3, MMCO_SHORT2LONG = 3,
MMCO_SET_MAX_LONG = 4, MMCO_SET_MAX_LONG = 4,
MMCO_RESET = 5, MMCO_RESET = 5,
MMCO_LONG = 6 MMCO_LONG = 6
}; };
/////////intra16x16 Luma /////////intra16x16 Luma

12
codec/encoder/core/inc/wels_const.h
View File

@ -179,14 +179,14 @@
#define SLICE_NUM_EXPAND_COEF 2 #define SLICE_NUM_EXPAND_COEF 2
enum { enum {
BLOCK_16x16 = 0, BLOCK_16x16 = 0,
BLOCK_16x8 = 1, BLOCK_16x8 = 1,
BLOCK_8x16 = 2, BLOCK_8x16 = 2,
BLOCK_8x8 = 3, BLOCK_8x8 = 3,
BLOCK_4x4 = 4, BLOCK_4x4 = 4,
// BLOCK_8x4 = 5, // BLOCK_8x4 = 5,
// BLOCK_4x8 = 6, // BLOCK_4x8 = 6,
BLOCK_SIZE_ALL = 5 BLOCK_SIZE_ALL = 5
}; };
enum { enum {

2
codec/encoder/core/inc/wels_preprocess.h
View File

@ -126,7 +126,7 @@ class CWelsPreProcess {
int32_t AnalyzeSpatialPic (sWelsEncCtx* pEncCtx, const int32_t kiDIdx); int32_t AnalyzeSpatialPic (sWelsEncCtx* pEncCtx, const int32_t kiDIdx);
int32_t UpdateSpatialPictures (sWelsEncCtx* pEncCtx, SWelsSvcCodingParam* pParam, const int8_t iCurTid, int32_t UpdateSpatialPictures (sWelsEncCtx* pEncCtx, SWelsSvcCodingParam* pParam, const int8_t iCurTid,
const int32_t d_idx); const int32_t d_idx);
int32_t GetRefFrameInfo (int32_t iRefIdx,SPicture *&pRefOri); int32_t GetRefFrameInfo (int32_t iRefIdx, SPicture*& pRefOri);
void AnalyzePictureComplexity (sWelsEncCtx* pCtx, SPicture* pCurPicture, SPicture* pRefPicture, void AnalyzePictureComplexity (sWelsEncCtx* pCtx, SPicture* pCurPicture, SPicture* pRefPicture,
const int32_t kiDependencyId, const bool kbCalculateBGD); const int32_t kiDependencyId, const bool kbCalculateBGD);

56
codec/encoder/core/src/deblocking.cpp
View File

@ -575,22 +575,22 @@ void DeblockingBSCalc_neon (SWelsFuncPtrList* pFunc, SMB* pCurMb, uint8_t uiBS[2
#if defined(HAVE_NEON_AARCH64) && defined(SINGLE_REF_FRAME) #if defined(HAVE_NEON_AARCH64) && defined(SINGLE_REF_FRAME)
void DeblockingBSCalc_AArch64_neon (SWelsFuncPtrList* pFunc, SMB* pCurMb, uint8_t uiBS[2][4][4], Mb_Type uiCurMbType, void DeblockingBSCalc_AArch64_neon (SWelsFuncPtrList* pFunc, SMB* pCurMb, uint8_t uiBS[2][4][4], Mb_Type uiCurMbType,
int32_t iMbStride, int32_t iLeftFlag, int32_t iTopFlag) { int32_t iMbStride, int32_t iLeftFlag, int32_t iTopFlag) {
DeblockingBSCalcEnc_AArch64_neon (pCurMb->pNonZeroCount, pCurMb->sMv, pCurMb->uiNeighborAvail, iMbStride, uiBS); DeblockingBSCalcEnc_AArch64_neon (pCurMb->pNonZeroCount, pCurMb->sMv, pCurMb->uiNeighborAvail, iMbStride, uiBS);
if (iLeftFlag) { if (iLeftFlag) {
if (IS_INTRA ((pCurMb - 1)->uiMbType)) { if (IS_INTRA ((pCurMb - 1)->uiMbType)) {
* (uint32_t*)uiBS[0][0] = 0x04040404; * (uint32_t*)uiBS[0][0] = 0x04040404;
}
} else {
* (uint32_t*)uiBS[0][0] = 0;
} }
if (iTopFlag) { } else {
if (IS_INTRA ((pCurMb - iMbStride)->uiMbType)) { * (uint32_t*)uiBS[0][0] = 0;
* (uint32_t*)uiBS[1][0] = 0x04040404; }
} if (iTopFlag) {
} else { if (IS_INTRA ((pCurMb - iMbStride)->uiMbType)) {
* (uint32_t*)uiBS[1][0] = 0; * (uint32_t*)uiBS[1][0] = 0x04040404;
} }
} else {
* (uint32_t*)uiBS[1][0] = 0;
}
} }
#endif #endif
@ -787,9 +787,9 @@ void WelsBlockFuncInit (PSetNoneZeroCountZeroFunc* pfSetNZCZero, int32_t iCpu)
} }
#endif #endif
#ifdef HAVE_NEON_AARCH64 #ifdef HAVE_NEON_AARCH64
if (iCpu & WELS_CPU_NEON) { if (iCpu & WELS_CPU_NEON) {
*pfSetNZCZero = WelsNonZeroCount_AArch64_neon; *pfSetNZCZero = WelsNonZeroCount_AArch64_neon;
} }
#endif #endif
} }
@ -839,21 +839,21 @@ void DeblockingInit (DeblockingFunc* pFunc, int32_t iCpu) {
#endif #endif
#if defined(HAVE_NEON_AARCH64) #if defined(HAVE_NEON_AARCH64)
if (iCpu & WELS_CPU_NEON) { if (iCpu & WELS_CPU_NEON) {
pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_AArch64_neon; pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_AArch64_neon;
pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_AArch64_neon; pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_AArch64_neon;
pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_AArch64_neon; pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_AArch64_neon;
pFunc->pfLumaDeblockingEQ4Hor = DeblockLumaEq4H_AArch64_neon; pFunc->pfLumaDeblockingEQ4Hor = DeblockLumaEq4H_AArch64_neon;
pFunc->pfChromaDeblockingLT4Ver = DeblockChromaLt4V_AArch64_neon; pFunc->pfChromaDeblockingLT4Ver = DeblockChromaLt4V_AArch64_neon;
pFunc->pfChromaDeblockingEQ4Ver = DeblockChromaEq4V_AArch64_neon; pFunc->pfChromaDeblockingEQ4Ver = DeblockChromaEq4V_AArch64_neon;
pFunc->pfChromaDeblockingLT4Hor = DeblockChromaLt4H_AArch64_neon; pFunc->pfChromaDeblockingLT4Hor = DeblockChromaLt4H_AArch64_neon;
pFunc->pfChromaDeblockingEQ4Hor = DeblockChromaEq4H_AArch64_neon; pFunc->pfChromaDeblockingEQ4Hor = DeblockChromaEq4H_AArch64_neon;
#if defined(SINGLE_REF_FRAME) #if defined(SINGLE_REF_FRAME)
pFunc->pfDeblockingBSCalc = DeblockingBSCalc_AArch64_neon; pFunc->pfDeblockingBSCalc = DeblockingBSCalc_AArch64_neon;
#endif #endif
} }
#endif #endif
} }

110
codec/encoder/core/src/ratectl.cpp
View File

@ -57,11 +57,12 @@ FILE* fp_vgop = NULL;
#endif #endif
#define _BITS_RANGE 0 #define _BITS_RANGE 0
const int32_t g_kiQpToQstepTable[52] = { 63, 71, 79, 89, 100, 112, 126, 141, 159, 178, const int32_t g_kiQpToQstepTable[52] = { 63, 71, 79, 89, 100, 112, 126, 141, 159, 178,
200, 224, 252, 283, 317, 356, 400, 449, 504, 566, 200, 224, 252, 283, 317, 356, 400, 449, 504, 566,
635, 713, 800, 898, 1008, 1131, 1270, 1425, 1600, 1796, 635, 713, 800, 898, 1008, 1131, 1270, 1425, 1600, 1796,
2016, 2263, 2540, 2851, 3200, 3592, 4032, 4525, 5080, 5702, 2016, 2263, 2540, 2851, 3200, 3592, 4032, 4525, 5080, 5702,
6400, 7184, 8063, 9051,10159,11404,12800,14368,16127,18102, 6400, 7184, 8063, 9051, 10159, 11404, 12800, 14368, 16127, 18102,
20319,22807}; //WELS_ROUND(INT_MULTIPLY*pow (2.0, (iQP - 4.0) / 6.0)) 20319, 22807
}; //WELS_ROUND(INT_MULTIPLY*pow (2.0, (iQP - 4.0) / 6.0))
void RcInitLayerMemory (SWelsSvcRc* pWelsSvcRc, CMemoryAlign* pMA, const int32_t kiMaxTl) { void RcInitLayerMemory (SWelsSvcRc* pWelsSvcRc, CMemoryAlign* pMA, const int32_t kiMaxTl) {
const int32_t kiSliceNum = pWelsSvcRc->iSliceNum; const int32_t kiSliceNum = pWelsSvcRc->iSliceNum;
@ -106,7 +107,7 @@ static inline int32_t RcConvertQp2QStep (int32_t iQP) {
return g_kiQpToQstepTable[iQP]; return g_kiQpToQstepTable[iQP];
} }
static inline int32_t RcConvertQStep2Qp (int32_t iQpStep) { static inline int32_t RcConvertQStep2Qp (int32_t iQpStep) {
return WELS_ROUND((6 * log (iQpStep*1.0f/INT_MULTIPLY) / log (2.0) + 4.0)); return WELS_ROUND ((6 * log (iQpStep * 1.0f / INT_MULTIPLY) / log (2.0) + 4.0));
} }
void RcInitSequenceParameter (sWelsEncCtx* pEncCtx) { void RcInitSequenceParameter (sWelsEncCtx* pEncCtx) {
@ -135,10 +136,12 @@ void RcInitSequenceParameter (sWelsEncCtx* pEncCtx) {
pWelsSvcRc->iSkipBufferRatio = SKIP_RATIO; pWelsSvcRc->iSkipBufferRatio = SKIP_RATIO;
pWelsSvcRc->iQpRangeUpperInFrame = (QP_RANGE_UPPER_MODE1 * MAX_BITS_VARY_PERCENTAGE - ((QP_RANGE_UPPER_MODE1 - QP_RANGE_MODE0) * pWelsSvcRc->iQpRangeUpperInFrame = (QP_RANGE_UPPER_MODE1 * MAX_BITS_VARY_PERCENTAGE - ((
pWelsSvcRc->iRcVaryRatio)) / MAX_BITS_VARY_PERCENTAGE; QP_RANGE_UPPER_MODE1 - QP_RANGE_MODE0) *
pWelsSvcRc->iQpRangeLowerInFrame = (QP_RANGE_LOWER_MODE1 * MAX_BITS_VARY_PERCENTAGE - ((QP_RANGE_LOWER_MODE1 - QP_RANGE_MODE0) * pWelsSvcRc->iRcVaryRatio)) / MAX_BITS_VARY_PERCENTAGE;
pWelsSvcRc->iRcVaryRatio)) / MAX_BITS_VARY_PERCENTAGE; pWelsSvcRc->iQpRangeLowerInFrame = (QP_RANGE_LOWER_MODE1 * MAX_BITS_VARY_PERCENTAGE - ((
QP_RANGE_LOWER_MODE1 - QP_RANGE_MODE0) *
pWelsSvcRc->iRcVaryRatio)) / MAX_BITS_VARY_PERCENTAGE;
if (iMbWidth <= MB_WIDTH_THRESHOLD_90P) { if (iMbWidth <= MB_WIDTH_THRESHOLD_90P) {
pWelsSvcRc->iSkipQpValue = SKIP_QP_90P; pWelsSvcRc->iSkipQpValue = SKIP_QP_90P;
@ -223,8 +226,9 @@ void RcUpdateBitrateFps (sWelsEncCtx* pEncCtx) {
SSpatialLayerInternal* pDLayerParamInternal = &pEncCtx->pSvcParam->sDependencyLayers[pEncCtx->uiDependencyId]; SSpatialLayerInternal* pDLayerParamInternal = &pEncCtx->pSvcParam->sDependencyLayers[pEncCtx->uiDependencyId];
const int32_t kiGopSize = (1 << pDLayerParamInternal->iDecompositionStages); const int32_t kiGopSize = (1 << pDLayerParamInternal->iDecompositionStages);
const int32_t kiHighestTid = pDLayerParamInternal->iHighestTemporalId; const int32_t kiHighestTid = pDLayerParamInternal->iHighestTemporalId;
int32_t input_iBitsPerFrame = WELS_ROUND(pDLayerParam->iSpatialBitrate * INT_MULTIPLY / pDLayerParamInternal->fInputFrameRate); int32_t input_iBitsPerFrame = WELS_ROUND (pDLayerParam->iSpatialBitrate * INT_MULTIPLY /
const int32_t kiGopBits = WELS_DIV_ROUND(input_iBitsPerFrame * kiGopSize, INT_MULTIPLY); pDLayerParamInternal->fInputFrameRate);
const int32_t kiGopBits = WELS_DIV_ROUND (input_iBitsPerFrame * kiGopSize, INT_MULTIPLY);
int32_t i; int32_t i;
pWelsSvcRc->iBitRate = pDLayerParam->iSpatialBitrate; pWelsSvcRc->iBitRate = pDLayerParam->iSpatialBitrate;
@ -236,12 +240,14 @@ void RcUpdateBitrateFps (sWelsEncCtx* pEncCtx) {
for (i = 0; i <= kiHighestTid; i++) { for (i = 0; i <= kiHighestTid; i++) {
const int64_t kdConstraitBits = kiGopBits * pTOverRc[i].iTlayerWeight; const int64_t kdConstraitBits = kiGopBits * pTOverRc[i].iTlayerWeight;
pTOverRc[i].iMinBitsTl = WELS_DIV_ROUND(kdConstraitBits * iMinBitsRatio, INT_MULTIPLY * MAX_BITS_VARY_PERCENTAGE * WEIGHT_MULTIPLY); pTOverRc[i].iMinBitsTl = WELS_DIV_ROUND (kdConstraitBits * iMinBitsRatio,
pTOverRc[i].iMaxBitsTl = WELS_DIV_ROUND(kdConstraitBits * iMaxBitsRatio, INT_MULTIPLY * MAX_BITS_VARY_PERCENTAGE * WEIGHT_MULTIPLY); INT_MULTIPLY * MAX_BITS_VARY_PERCENTAGE * WEIGHT_MULTIPLY);
pTOverRc[i].iMaxBitsTl = WELS_DIV_ROUND (kdConstraitBits * iMaxBitsRatio,
INT_MULTIPLY * MAX_BITS_VARY_PERCENTAGE * WEIGHT_MULTIPLY);
} }
//When bitrate is changed, pBuffer size should be updated //When bitrate is changed, pBuffer size should be updated
pWelsSvcRc->iBufferSizeSkip = WELS_DIV_ROUND(pWelsSvcRc->iBitRate * pWelsSvcRc->iSkipBufferRatio, INT_MULTIPLY); pWelsSvcRc->iBufferSizeSkip = WELS_DIV_ROUND (pWelsSvcRc->iBitRate * pWelsSvcRc->iSkipBufferRatio, INT_MULTIPLY);
pWelsSvcRc->iBufferSizePadding = WELS_DIV_ROUND(pWelsSvcRc->iBitRate * PADDING_BUFFER_RATIO, INT_MULTIPLY); pWelsSvcRc->iBufferSizePadding = WELS_DIV_ROUND (pWelsSvcRc->iBitRate * PADDING_BUFFER_RATIO, INT_MULTIPLY);
//change remaining bits //change remaining bits
if (pWelsSvcRc->iBitsPerFrame > REMAIN_BITS_TH) if (pWelsSvcRc->iBitsPerFrame > REMAIN_BITS_TH)
@ -256,7 +262,7 @@ void RcInitVGop (sWelsEncCtx* pEncCtx) {
SRCTemporal* pTOverRc = pWelsSvcRc->pTemporalOverRc; SRCTemporal* pTOverRc = pWelsSvcRc->pTemporalOverRc;
const int32_t kiHighestTid = pEncCtx->pSvcParam->sDependencyLayers[kiDid].iHighestTemporalId; const int32_t kiHighestTid = pEncCtx->pSvcParam->sDependencyLayers[kiDid].iHighestTemporalId;
pWelsSvcRc->iRemainingBits = WELS_DIV_ROUND(VGOP_SIZE * pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY); pWelsSvcRc->iRemainingBits = WELS_DIV_ROUND (VGOP_SIZE * pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY);
pWelsSvcRc->iRemainingWeights = pWelsSvcRc->iGopNumberInVGop * WEIGHT_MULTIPLY; pWelsSvcRc->iRemainingWeights = pWelsSvcRc->iGopNumberInVGop * WEIGHT_MULTIPLY;
pWelsSvcRc->iFrameCodedInVGop = 0; pWelsSvcRc->iFrameCodedInVGop = 0;
@ -427,7 +433,7 @@ void RcCalculateIdrQp (sWelsEncCtx* pEncCtx) {
pWelsSvcRc->iIntraMbCount; pWelsSvcRc->iIntraMbCount;
} }
pWelsSvcRc->iInitialQp = RcConvertQStep2Qp (pWelsSvcRc->iIntraComplexity / pWelsSvcRc->iInitialQp = RcConvertQStep2Qp (pWelsSvcRc->iIntraComplexity /
pWelsSvcRc->iTargetBits); pWelsSvcRc->iTargetBits);
pWelsSvcRc->iInitialQp = WELS_CLIP3 (pWelsSvcRc->iInitialQp, MIN_IDR_QP, MAX_IDR_QP); pWelsSvcRc->iInitialQp = WELS_CLIP3 (pWelsSvcRc->iInitialQp, MIN_IDR_QP, MAX_IDR_QP);
pEncCtx->iGlobalQp = pWelsSvcRc->iInitialQp; pEncCtx->iGlobalQp = pWelsSvcRc->iInitialQp;
pWelsSvcRc->iQStep = RcConvertQp2QStep (pEncCtx->iGlobalQp); pWelsSvcRc->iQStep = RcConvertQp2QStep (pEncCtx->iGlobalQp);
@ -465,17 +471,19 @@ void RcCalculatePictureQp (sWelsEncCtx* pEncCtx) {
pWelsSvcRc->iLastCalculatedQScale = iLumaQp; pWelsSvcRc->iLastCalculatedQScale = iLumaQp;
if (pEncCtx->pSvcParam->bEnableAdaptiveQuant) { if (pEncCtx->pSvcParam->bEnableAdaptiveQuant) {
iLumaQp = WELS_CLIP3 ((iLumaQp*INT_MULTIPLY - pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp)/INT_MULTIPLY, GOM_MIN_QP_MODE, MAX_LOW_BR_QP); iLumaQp = WELS_CLIP3 ((iLumaQp * INT_MULTIPLY - pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp) /
INT_MULTIPLY, GOM_MIN_QP_MODE, MAX_LOW_BR_QP);
} }
pEncCtx->iGlobalQp = iLumaQp; pEncCtx->iGlobalQp = iLumaQp;
return; return;
} else { } else {
int64_t iCmplxRatio = WELS_DIV_ROUND64(pEncCtx->pVaa->sComplexityAnalysisParam.iFrameComplexity *INT_MULTIPLY, pTOverRc->iFrameCmplxMean); int64_t iCmplxRatio = WELS_DIV_ROUND64 (pEncCtx->pVaa->sComplexityAnalysisParam.iFrameComplexity * INT_MULTIPLY,
pTOverRc->iFrameCmplxMean);
iCmplxRatio = WELS_CLIP3 (iCmplxRatio, INT_MULTIPLY - FRAME_CMPLX_RATIO_RANGE, INT_MULTIPLY + FRAME_CMPLX_RATIO_RANGE); iCmplxRatio = WELS_CLIP3 (iCmplxRatio, INT_MULTIPLY - FRAME_CMPLX_RATIO_RANGE, INT_MULTIPLY + FRAME_CMPLX_RATIO_RANGE);
pWelsSvcRc->iQStep = WELS_DIV_ROUND((pTOverRc->iLinearCmplx * iCmplxRatio), (pWelsSvcRc->iTargetBits * INT_MULTIPLY)); pWelsSvcRc->iQStep = WELS_DIV_ROUND ((pTOverRc->iLinearCmplx * iCmplxRatio), (pWelsSvcRc->iTargetBits * INT_MULTIPLY));
iLumaQp = RcConvertQStep2Qp (pWelsSvcRc->iQStep); iLumaQp = RcConvertQStep2Qp (pWelsSvcRc->iQStep);
//limit QP //limit QP
@ -501,7 +509,8 @@ void RcCalculatePictureQp (sWelsEncCtx* pEncCtx) {
#ifndef _NOT_USE_AQ_FOR_TEST_ #ifndef _NOT_USE_AQ_FOR_TEST_
if (pEncCtx->pSvcParam->bEnableAdaptiveQuant) { if (pEncCtx->pSvcParam->bEnableAdaptiveQuant) {
iLumaQp = WELS_DIV_ROUND(iLumaQp*INT_MULTIPLY - pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp,INT_MULTIPLY); iLumaQp = WELS_DIV_ROUND (iLumaQp * INT_MULTIPLY - pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp,
INT_MULTIPLY);
if (pEncCtx->pSvcParam->iRCMode != RC_LOW_BW_MODE) if (pEncCtx->pSvcParam->iRCMode != RC_LOW_BW_MODE)
iLumaQp = WELS_CLIP3 (iLumaQp, pWelsSvcRc->iMinQp, pWelsSvcRc->iMaxQp); iLumaQp = WELS_CLIP3 (iLumaQp, pWelsSvcRc->iMinQp, pWelsSvcRc->iMaxQp);
@ -516,7 +525,7 @@ void RcInitSliceInformation (sWelsEncCtx* pEncCtx) {
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
SRCSlicing* pSOverRc = &pWelsSvcRc->pSlicingOverRc[0]; SRCSlicing* pSOverRc = &pWelsSvcRc->pSlicingOverRc[0];
const int32_t kiSliceNum = pWelsSvcRc->iSliceNum; const int32_t kiSliceNum = pWelsSvcRc->iSliceNum;
const int32_t kiBitsPerMb = WELS_DIV_ROUND(pWelsSvcRc->iTargetBits * INT_MULTIPLY, pWelsSvcRc->iNumberMbFrame); const int32_t kiBitsPerMb = WELS_DIV_ROUND (pWelsSvcRc->iTargetBits * INT_MULTIPLY, pWelsSvcRc->iNumberMbFrame);
for (int32_t i = 0; i < kiSliceNum; i++) { for (int32_t i = 0; i < kiSliceNum; i++) {
pSOverRc->iStartMbSlice = pSOverRc->iStartMbSlice =
@ -524,7 +533,7 @@ void RcInitSliceInformation (sWelsEncCtx* pEncCtx) {
pSOverRc->iEndMbSlice += (pCurSliceCtx->pCountMbNumInSlice[i] - 1); pSOverRc->iEndMbSlice += (pCurSliceCtx->pCountMbNumInSlice[i] - 1);
pSOverRc->iTotalQpSlice = 0; pSOverRc->iTotalQpSlice = 0;
pSOverRc->iTotalMbSlice = 0; pSOverRc->iTotalMbSlice = 0;
pSOverRc->iTargetBitsSlice = WELS_DIV_ROUND(kiBitsPerMb * pCurSliceCtx->pCountMbNumInSlice[i], INT_MULTIPLY); pSOverRc->iTargetBitsSlice = WELS_DIV_ROUND (kiBitsPerMb * pCurSliceCtx->pCountMbNumInSlice[i], INT_MULTIPLY);
pSOverRc->iFrameBitsSlice = 0; pSOverRc->iFrameBitsSlice = 0;
pSOverRc->iGomBitsSlice = 0; pSOverRc->iGomBitsSlice = 0;
++ pSOverRc; ++ pSOverRc;
@ -538,10 +547,10 @@ void RcDecideTargetBits (sWelsEncCtx* pEncCtx) {
pWelsSvcRc->iCurrentBitsLevel = BITS_NORMAL; pWelsSvcRc->iCurrentBitsLevel = BITS_NORMAL;
//allocate bits //allocate bits
if (pEncCtx->eSliceType == I_SLICE) { if (pEncCtx->eSliceType == I_SLICE) {
pWelsSvcRc->iTargetBits = WELS_DIV_ROUND(pWelsSvcRc->iBitsPerFrame * IDR_BITRATE_RATIO, INT_MULTIPLY); pWelsSvcRc->iTargetBits = WELS_DIV_ROUND (pWelsSvcRc->iBitsPerFrame * IDR_BITRATE_RATIO, INT_MULTIPLY);
} else { } else {
pWelsSvcRc->iTargetBits = (int32_t)((int64_t)pWelsSvcRc->iRemainingBits * pTOverRc->iTlayerWeight / pWelsSvcRc->iTargetBits = (int32_t) ((int64_t)pWelsSvcRc->iRemainingBits * pTOverRc->iTlayerWeight /
pWelsSvcRc->iRemainingWeights); pWelsSvcRc->iRemainingWeights);
if ((pWelsSvcRc->iTargetBits <= 0) && (pEncCtx->pSvcParam->iRCMode == RC_LOW_BW_MODE)) { if ((pWelsSvcRc->iTargetBits <= 0) && (pEncCtx->pSvcParam->iRCMode == RC_LOW_BW_MODE)) {
pWelsSvcRc->iCurrentBitsLevel = BITS_EXCEEDED; pWelsSvcRc->iCurrentBitsLevel = BITS_EXCEEDED;
} else if ((pWelsSvcRc->iTargetBits <= pTOverRc->iMinBitsTl) && (pEncCtx->pSvcParam->iRCMode == RC_LOW_BW_MODE)) { } else if ((pWelsSvcRc->iTargetBits <= pTOverRc->iMinBitsTl) && (pEncCtx->pSvcParam->iRCMode == RC_LOW_BW_MODE)) {
@ -635,9 +644,10 @@ void RcGomTargetBits (sWelsEncCtx* pEncCtx, const int32_t kiSliceId) {
iSumSad += pWelsSvcRc_Base->pCurrentFrameGomSad[i]; iSumSad += pWelsSvcRc_Base->pCurrentFrameGomSad[i];
} }
if (0 == iSumSad) if (0 == iSumSad)
iAllocateBits = WELS_DIV_ROUND(iLeftBits, (iLastGomIndex - kiComplexityIndex)); iAllocateBits = WELS_DIV_ROUND (iLeftBits, (iLastGomIndex - kiComplexityIndex));
else else
iAllocateBits = WELS_DIV_ROUND((int64_t)iLeftBits * pWelsSvcRc_Base->pCurrentFrameGomSad[kiComplexityIndex + 1], iSumSad); iAllocateBits = WELS_DIV_ROUND ((int64_t)iLeftBits * pWelsSvcRc_Base->pCurrentFrameGomSad[kiComplexityIndex + 1],
iSumSad);
} }
pSOverRc->iGomTargetBits = iAllocateBits; pSOverRc->iGomTargetBits = iAllocateBits;
@ -657,7 +667,7 @@ void RcCalculateGomQp (sWelsEncCtx* pEncCtx, SMB* pCurMb, int32_t iSliceId) {
pSOverRc->iCalculatedQpSlice += 2; pSOverRc->iCalculatedQpSlice += 2;
} else { } else {
//globe decision //globe decision
iBitsRatio = 10000 * iLeftBits / (iTargetLeftBits+1); iBitsRatio = 10000 * iLeftBits / (iTargetLeftBits + 1);
if (iBitsRatio < 8409) //2^(-1.5/6)*10000 if (iBitsRatio < 8409) //2^(-1.5/6)*10000
pSOverRc->iCalculatedQpSlice += 2; pSOverRc->iCalculatedQpSlice += 2;
else if (iBitsRatio < 9439) //2^(-0.5/6)*10000 else if (iBitsRatio < 9439) //2^(-0.5/6)*10000
@ -680,11 +690,11 @@ void RcCalculateGomQp (sWelsEncCtx* pEncCtx, SMB* pCurMb, int32_t iSliceId) {
void RcVBufferCalculationSkip (sWelsEncCtx* pEncCtx) { void RcVBufferCalculationSkip (sWelsEncCtx* pEncCtx) {
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
SRCTemporal* pTOverRc = pWelsSvcRc->pTemporalOverRc; SRCTemporal* pTOverRc = pWelsSvcRc->pTemporalOverRc;
const int32_t kiOutputBits = WELS_DIV_ROUND(pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY); const int32_t kiOutputBits = WELS_DIV_ROUND (pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY);
//condition 1: whole pBuffer fullness //condition 1: whole pBuffer fullness
pWelsSvcRc->iBufferFullnessSkip += (pWelsSvcRc->iFrameDqBits - kiOutputBits); pWelsSvcRc->iBufferFullnessSkip += (pWelsSvcRc->iFrameDqBits - kiOutputBits);
//condition 2: VGOP bits constraint //condition 2: VGOP bits constraint
const int32_t kiVGopBits = WELS_DIV_ROUND(pWelsSvcRc->iBitsPerFrame * VGOP_SIZE, INT_MULTIPLY); const int32_t kiVGopBits = WELS_DIV_ROUND (pWelsSvcRc->iBitsPerFrame * VGOP_SIZE, INT_MULTIPLY);
int32_t iVGopBitsPred = 0; int32_t iVGopBitsPred = 0;
for (int32_t i = pWelsSvcRc->iFrameCodedInVGop + 1; i < VGOP_SIZE; i++) for (int32_t i = pWelsSvcRc->iFrameCodedInVGop + 1; i < VGOP_SIZE; i++)
iVGopBitsPred += pTOverRc[pWelsSvcRc->iTlOfFrames[i]].iMinBitsTl; iVGopBitsPred += pTOverRc[pWelsSvcRc->iTlOfFrames[i]].iMinBitsTl;
@ -705,32 +715,32 @@ void RcVBufferCalculationSkip (sWelsEncCtx* pEncCtx) {
pWelsSvcRc->iBufferFullnessSkip = 0; pWelsSvcRc->iBufferFullnessSkip = 0;
if (pEncCtx->iSkipFrameFlag == 1) { if (pEncCtx->iSkipFrameFlag == 1) {
pWelsSvcRc->iRemainingBits += WELS_DIV_ROUND(pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY); pWelsSvcRc->iRemainingBits += WELS_DIV_ROUND (pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY);
pWelsSvcRc->iSkipFrameNum++; pWelsSvcRc->iSkipFrameNum++;
pWelsSvcRc->iSkipFrameInVGop++; pWelsSvcRc->iSkipFrameInVGop++;
} }
} }
void WelsRcFrameDelayJudge(void* pCtx) { void WelsRcFrameDelayJudge (void* pCtx) {
sWelsEncCtx* pEncCtx = (sWelsEncCtx*)pCtx; sWelsEncCtx* pEncCtx = (sWelsEncCtx*)pCtx;
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
SSpatialLayerConfig* pDLayerParam = &pEncCtx->pSvcParam->sSpatialLayers[pEncCtx->uiDependencyId]; SSpatialLayerConfig* pDLayerParam = &pEncCtx->pSvcParam->sSpatialLayers[pEncCtx->uiDependencyId];
SSpatialLayerInternal* pDLayerParamInternal = &pEncCtx->pSvcParam->sDependencyLayers[pEncCtx->uiDependencyId]; SSpatialLayerInternal* pDLayerParamInternal = &pEncCtx->pSvcParam->sDependencyLayers[pEncCtx->uiDependencyId];
int32_t iSentBits = WELS_ROUND(pDLayerParam->iSpatialBitrate / pDLayerParamInternal->fOutputFrameRate); int32_t iSentBits = WELS_ROUND (pDLayerParam->iSpatialBitrate / pDLayerParamInternal->fOutputFrameRate);
pWelsSvcRc->bSkipFlag = false; pWelsSvcRc->bSkipFlag = false;
if (pWelsSvcRc->iBufferFullnessSkip > pWelsSvcRc->iBufferSizeSkip) { if (pWelsSvcRc->iBufferFullnessSkip > pWelsSvcRc->iBufferSizeSkip) {
pWelsSvcRc->bSkipFlag = true; pWelsSvcRc->bSkipFlag = true;
pWelsSvcRc->iBufferFullnessSkip -= iSentBits; pWelsSvcRc->iBufferFullnessSkip -= iSentBits;
pWelsSvcRc->iBufferFullnessSkip = WELS_MAX(pWelsSvcRc->iBufferFullnessSkip, 0); pWelsSvcRc->iBufferFullnessSkip = WELS_MAX (pWelsSvcRc->iBufferFullnessSkip, 0);
} }
} }
void RcVBufferCalculationPadding (sWelsEncCtx* pEncCtx) { void RcVBufferCalculationPadding (sWelsEncCtx* pEncCtx) {
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
const int32_t kiOutputBits = WELS_DIV_ROUND(pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY); const int32_t kiOutputBits = WELS_DIV_ROUND (pWelsSvcRc->iBitsPerFrame, INT_MULTIPLY);
const int32_t kiBufferThreshold = WELS_DIV_ROUND(PADDING_THRESHOLD * (-pWelsSvcRc->iBufferSizePadding), INT_MULTIPLY); const int32_t kiBufferThreshold = WELS_DIV_ROUND (PADDING_THRESHOLD * (-pWelsSvcRc->iBufferSizePadding), INT_MULTIPLY);
pWelsSvcRc->iBufferFullnessPadding += (pWelsSvcRc->iFrameDqBits - kiOutputBits); pWelsSvcRc->iBufferFullnessPadding += (pWelsSvcRc->iFrameDqBits - kiOutputBits);
@ -767,7 +777,7 @@ void RcUpdatePictureQpBits (sWelsEncCtx* pEncCtx, int32_t iCodedBits) {
++ pSOverRc; ++ pSOverRc;
} }
if (iTotalMb > 0) if (iTotalMb > 0)
pWelsSvcRc->iAverageFrameQp = WELS_DIV_ROUND(INT_MULTIPLY * iTotalQp, iTotalMb * INT_MULTIPLY); pWelsSvcRc->iAverageFrameQp = WELS_DIV_ROUND (INT_MULTIPLY * iTotalQp, iTotalMb * INT_MULTIPLY);
else else
pWelsSvcRc->iAverageFrameQp = pEncCtx->iGlobalQp; pWelsSvcRc->iAverageFrameQp = pEncCtx->iGlobalQp;
} else { } else {
@ -779,11 +789,12 @@ void RcUpdatePictureQpBits (sWelsEncCtx* pEncCtx, int32_t iCodedBits) {
void RcUpdateIntraComplexity (sWelsEncCtx* pEncCtx) { void RcUpdateIntraComplexity (sWelsEncCtx* pEncCtx) {
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
int32_t iAlpha = WELS_DIV_ROUND(INT_MULTIPLY, (1 + pWelsSvcRc->iIdrNum)); int32_t iAlpha = WELS_DIV_ROUND (INT_MULTIPLY, (1 + pWelsSvcRc->iIdrNum));
if (iAlpha < (INT_MULTIPLY/4)) iAlpha = INT_MULTIPLY/4; if (iAlpha < (INT_MULTIPLY / 4)) iAlpha = INT_MULTIPLY / 4;
int64_t iIntraCmplx = pWelsSvcRc->iQStep * pWelsSvcRc->iFrameDqBits; int64_t iIntraCmplx = pWelsSvcRc->iQStep * pWelsSvcRc->iFrameDqBits;
pWelsSvcRc->iIntraComplexity = WELS_DIV_ROUND(((INT_MULTIPLY - iAlpha) * pWelsSvcRc->iIntraComplexity + iAlpha * iIntraCmplx), INT_MULTIPLY); pWelsSvcRc->iIntraComplexity = WELS_DIV_ROUND (((INT_MULTIPLY - iAlpha) * pWelsSvcRc->iIntraComplexity + iAlpha *
iIntraCmplx), INT_MULTIPLY);
pWelsSvcRc->iIntraMbCount = pWelsSvcRc->iNumberMbFrame; pWelsSvcRc->iIntraMbCount = pWelsSvcRc->iNumberMbFrame;
pWelsSvcRc->iIdrNum++; pWelsSvcRc->iIdrNum++;
@ -799,14 +810,15 @@ void RcUpdateFrameComplexity (sWelsEncCtx* pEncCtx) {
if (0 == pTOverRc->iPFrameNum) { if (0 == pTOverRc->iPFrameNum) {
pTOverRc->iLinearCmplx = ((int64_t)pWelsSvcRc->iFrameDqBits) * pWelsSvcRc->iQStep; pTOverRc->iLinearCmplx = ((int64_t)pWelsSvcRc->iFrameDqBits) * pWelsSvcRc->iQStep;
} else { } else {
pTOverRc->iLinearCmplx = WELS_DIV_ROUND64((LINEAR_MODEL_DECAY_FACTOR * (int64_t)pTOverRc->iLinearCmplx pTOverRc->iLinearCmplx = WELS_DIV_ROUND64 ((LINEAR_MODEL_DECAY_FACTOR * (int64_t)pTOverRc->iLinearCmplx
+ (INT_MULTIPLY - LINEAR_MODEL_DECAY_FACTOR) * (int64_t)(pWelsSvcRc->iFrameDqBits * pWelsSvcRc->iQStep)), INT_MULTIPLY); + (INT_MULTIPLY - LINEAR_MODEL_DECAY_FACTOR) * (int64_t) (pWelsSvcRc->iFrameDqBits * pWelsSvcRc->iQStep)),
INT_MULTIPLY);
} }
int32_t iAlpha = WELS_DIV_ROUND(INT_MULTIPLY, (1 + pTOverRc->iPFrameNum)); int32_t iAlpha = WELS_DIV_ROUND (INT_MULTIPLY, (1 + pTOverRc->iPFrameNum));
if (iAlpha < SMOOTH_FACTOR_MIN_VALUE) if (iAlpha < SMOOTH_FACTOR_MIN_VALUE)
iAlpha = SMOOTH_FACTOR_MIN_VALUE; iAlpha = SMOOTH_FACTOR_MIN_VALUE;
pTOverRc->iFrameCmplxMean = WELS_DIV_ROUND(((INT_MULTIPLY - iAlpha) * pTOverRc->iFrameCmplxMean + iAlpha * pTOverRc->iFrameCmplxMean = WELS_DIV_ROUND (((INT_MULTIPLY - iAlpha) * pTOverRc->iFrameCmplxMean + iAlpha *
pEncCtx->pVaa->sComplexityAnalysisParam.iFrameComplexity), INT_MULTIPLY); pEncCtx->pVaa->sComplexityAnalysisParam.iFrameComplexity), INT_MULTIPLY);
pTOverRc->iPFrameNum++; pTOverRc->iPFrameNum++;
if (pTOverRc->iPFrameNum > 255) if (pTOverRc->iPFrameNum > 255)
@ -951,8 +963,8 @@ void WelsRcPictureInitDisable (void* pCtx) {
pEncCtx->iGlobalQp = RcCalculateCascadingQp (pEncCtx, kiQp); pEncCtx->iGlobalQp = RcCalculateCascadingQp (pEncCtx, kiQp);
if (pEncCtx->pSvcParam->bEnableAdaptiveQuant && (pEncCtx->eSliceType == P_SLICE)) { if (pEncCtx->pSvcParam->bEnableAdaptiveQuant && (pEncCtx->eSliceType == P_SLICE)) {
pEncCtx->iGlobalQp = WELS_CLIP3 ( (pEncCtx->iGlobalQp *INT_MULTIPLY - pEncCtx->iGlobalQp = WELS_CLIP3 ((pEncCtx->iGlobalQp * INT_MULTIPLY -
pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp)/INT_MULTIPLY, GOM_MIN_QP_MODE, GOM_MAX_QP_MODE); pEncCtx->pVaa->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp) / INT_MULTIPLY, GOM_MIN_QP_MODE, GOM_MAX_QP_MODE);
} else { } else {
pEncCtx->iGlobalQp = WELS_CLIP3 (pEncCtx->iGlobalQp, 0, 51); pEncCtx->iGlobalQp = WELS_CLIP3 (pEncCtx->iGlobalQp, 0, 51);
} }

2
codec/encoder/core/src/svc_enc_slice_segment.cpp
View File

@ -284,7 +284,7 @@ void GomValidCheckSliceMbNum (const int32_t kiMbWidth, const int32_t kiMbHeight,
while (uiSliceIdx + 1 < kuiSliceNum) { while (uiSliceIdx + 1 < kuiSliceNum) {
// GOM boundary aligned // GOM boundary aligned
int32_t iNumMbAssigning = WELS_DIV_ROUND(INT_MULTIPLY * kiMbNumPerSlice, iGomSize * INT_MULTIPLY) * iGomSize; int32_t iNumMbAssigning = WELS_DIV_ROUND (INT_MULTIPLY * kiMbNumPerSlice, iGomSize * INT_MULTIPLY) * iGomSize;
// make sure one GOM at least in each slice for safe // make sure one GOM at least in each slice for safe
if (iNumMbAssigning < iMinimalMbNum) if (iNumMbAssigning < iMinimalMbNum)

2
codec/encoder/core/src/svc_mode_decision.cpp
View File

@ -341,7 +341,7 @@ bool MdInterSCDPskipProcess (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSl
if (bSkipFlag) { if (bSkipFlag) {
bool bQpSimilarFlag = (kiRefMbQp - kiCurMbQp <= DELTA_QP_SCD_THD || kiRefMbQp <= 26); bool bQpSimilarFlag = (kiRefMbQp - kiCurMbQp <= DELTA_QP_SCD_THD || kiRefMbQp <= 26);
SMVUnitXY sVaaPredSkipMv = {0,0}, sCurMbMv[2] = {{0,0},{0,0}}; SMVUnitXY sVaaPredSkipMv = {0, 0}, sCurMbMv[2] = {{0, 0}, {0, 0}};
PredSkipMv (pMbCache, &sVaaPredSkipMv); PredSkipMv (pMbCache, &sVaaPredSkipMv);
if (eSkipMode == SCROLLED) { if (eSkipMode == SCROLLED) {

29
codec/processing/src/adaptivequantization/AdaptiveQuantization.cpp
View File

@ -142,8 +142,8 @@ EResult CAdaptiveQuantization::Process (int32_t iType, SPixMap* pSrcPixMap, SPix
pCurFrameY += (iCurStride) << 4; pCurFrameY += (iCurStride) << 4;
} }
} }
iAverageMotionIndex = WELS_DIV_ROUND64(iAverageMotionIndex * AQ_INT_MULTIPLY,iMbTotalNum); iAverageMotionIndex = WELS_DIV_ROUND64 (iAverageMotionIndex * AQ_INT_MULTIPLY, iMbTotalNum);
iAverageTextureIndex = WELS_DIV_ROUND64(iAverageTextureIndex * AQ_INT_MULTIPLY, iMbTotalNum); iAverageTextureIndex = WELS_DIV_ROUND64 (iAverageTextureIndex * AQ_INT_MULTIPLY, iMbTotalNum);
if ((iAverageMotionIndex <= AQ_PESN) && (iAverageMotionIndex >= -AQ_PESN)) { if ((iAverageMotionIndex <= AQ_PESN) && (iAverageMotionIndex >= -AQ_PESN)) {
iAverageMotionIndex = AQ_INT_MULTIPLY; iAverageMotionIndex = AQ_INT_MULTIPLY;
} }
@ -153,34 +153,37 @@ EResult CAdaptiveQuantization::Process (int32_t iType, SPixMap* pSrcPixMap, SPix
// motion mb residual map to QP // motion mb residual map to QP
// texture mb original map to QP // texture mb original map to QP
iAverMotionTextureIndexToDeltaQp = 0; iAverMotionTextureIndexToDeltaQp = 0;
iAverageMotionIndex = WELS_DIV_ROUND64(AVERAGE_TIME_MOTION * iAverageMotionIndex, AQ_TIME_INT_MULTIPLY); iAverageMotionIndex = WELS_DIV_ROUND64 (AVERAGE_TIME_MOTION * iAverageMotionIndex, AQ_TIME_INT_MULTIPLY);
if (m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_QUALITY_MODE) { if (m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_QUALITY_MODE) {
iAverageTextureIndex = WELS_DIV_ROUND64(AVERAGE_TIME_TEXTURE_QUALITYMODE * iAverageTextureIndex, AQ_TIME_INT_MULTIPLY); iAverageTextureIndex = WELS_DIV_ROUND64 (AVERAGE_TIME_TEXTURE_QUALITYMODE * iAverageTextureIndex, AQ_TIME_INT_MULTIPLY);
} else { } else {
iAverageTextureIndex = WELS_DIV_ROUND64(AVERAGE_TIME_TEXTURE_BITRATEMODE * iAverageTextureIndex, AQ_TIME_INT_MULTIPLY); iAverageTextureIndex = WELS_DIV_ROUND64 (AVERAGE_TIME_TEXTURE_BITRATEMODE * iAverageTextureIndex, AQ_TIME_INT_MULTIPLY);
} }
int64_t iAQ_EPSN = -((int64_t)AQ_PESN*AQ_TIME_INT_MULTIPLY*AQ_QSTEP_INT_MULTIPLY/AQ_INT_MULTIPLY); int64_t iAQ_EPSN = - ((int64_t)AQ_PESN * AQ_TIME_INT_MULTIPLY * AQ_QSTEP_INT_MULTIPLY / AQ_INT_MULTIPLY);
pMotionTexture = m_sAdaptiveQuantParam.pMotionTextureUnit; pMotionTexture = m_sAdaptiveQuantParam.pMotionTextureUnit;
for (j = 0; j < iMbHeight; j ++) { for (j = 0; j < iMbHeight; j ++) {
for (i = 0; i < iMbWidth; i++) { for (i = 0; i < iMbWidth; i++) {
int64_t a = WELS_DIV_ROUND64((int64_t)(pMotionTexture->uiTextureIndex) *AQ_INT_MULTIPLY * AQ_TIME_INT_MULTIPLY, iAverageTextureIndex); int64_t a = WELS_DIV_ROUND64 ((int64_t) (pMotionTexture->uiTextureIndex) * AQ_INT_MULTIPLY * AQ_TIME_INT_MULTIPLY,
iQStep = WELS_DIV_ROUND64((a - AQ_TIME_INT_MULTIPLY) * AQ_QSTEP_INT_MULTIPLY, (a + MODEL_ALPHA)); iAverageTextureIndex);
iQStep = WELS_DIV_ROUND64 ((a - AQ_TIME_INT_MULTIPLY) * AQ_QSTEP_INT_MULTIPLY, (a + MODEL_ALPHA));
iLumaTextureDeltaQp = MODEL_TIME * iQStep;// range +- 6 iLumaTextureDeltaQp = MODEL_TIME * iQStep;// range +- 6
iMotionTextureIndexToDeltaQp = ((int32_t)(iLumaTextureDeltaQp/(AQ_TIME_INT_MULTIPLY))); iMotionTextureIndexToDeltaQp = ((int32_t) (iLumaTextureDeltaQp / (AQ_TIME_INT_MULTIPLY)));
a = WELS_DIV_ROUND64(((int64_t)pMotionTexture->uiMotionIndex)*AQ_INT_MULTIPLY * AQ_TIME_INT_MULTIPLY, iAverageMotionIndex); a = WELS_DIV_ROUND64 (((int64_t)pMotionTexture->uiMotionIndex) * AQ_INT_MULTIPLY * AQ_TIME_INT_MULTIPLY,
iQStep = WELS_DIV_ROUND64((a - AQ_TIME_INT_MULTIPLY) * AQ_QSTEP_INT_MULTIPLY, (a + MODEL_ALPHA)); iAverageMotionIndex);
iQStep = WELS_DIV_ROUND64 ((a - AQ_TIME_INT_MULTIPLY) * AQ_QSTEP_INT_MULTIPLY, (a + MODEL_ALPHA));
iLumaMotionDeltaQp = MODEL_TIME * iQStep;// range +- 6 iLumaMotionDeltaQp = MODEL_TIME * iQStep;// range +- 6
if ((m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_QUALITY_MODE && iLumaMotionDeltaQp < iAQ_EPSN) if ((m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_QUALITY_MODE && iLumaMotionDeltaQp < iAQ_EPSN)
|| (m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_BITRATE_MODE)) { || (m_sAdaptiveQuantParam.iAdaptiveQuantMode == AQ_BITRATE_MODE)) {
iMotionTextureIndexToDeltaQp += ((int32_t)(iLumaMotionDeltaQp/(AQ_TIME_INT_MULTIPLY))); iMotionTextureIndexToDeltaQp += ((int32_t) (iLumaMotionDeltaQp / (AQ_TIME_INT_MULTIPLY)));
} }
m_sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp[j * iMbWidth + i] = (int8_t)(iMotionTextureIndexToDeltaQp/AQ_QSTEP_INT_MULTIPLY); m_sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp[j * iMbWidth + i] = (int8_t) (iMotionTextureIndexToDeltaQp /
AQ_QSTEP_INT_MULTIPLY);
iAverMotionTextureIndexToDeltaQp += iMotionTextureIndexToDeltaQp; iAverMotionTextureIndexToDeltaQp += iMotionTextureIndexToDeltaQp;
pMotionTexture++; pMotionTexture++;
} }

900
module/task_utils_generated.h
View File

File diff suppressed because it is too large Load Diff

10
test/BaseDecoderTest.h
View File

@ -24,19 +24,19 @@ class BaseDecoderTest {
}; };
struct Callback { struct Callback {
virtual void onDecodeFrame(const Frame& frame) = 0; virtual void onDecodeFrame (const Frame& frame) = 0;
}; };
BaseDecoderTest(); BaseDecoderTest();
void SetUp(); void SetUp();
void TearDown(); void TearDown();
void DecodeFile(const char* fileName, Callback* cbk); void DecodeFile (const char* fileName, Callback* cbk);
bool Open(const char* fileName); bool Open (const char* fileName);
bool DecodeNextFrame(Callback* cbk); bool DecodeNextFrame (Callback* cbk);
private: private:
void DecodeFrame(const uint8_t* src, int sliceSize, Callback* cbk); void DecodeFrame (const uint8_t* src, int sliceSize, Callback* cbk);
ISVCDecoder* decoder_; ISVCDecoder* decoder_;
std::ifstream file_; std::ifstream file_;

8
test/BaseEncoderTest.h
View File

@ -8,14 +8,16 @@
class BaseEncoderTest { class BaseEncoderTest {
public: public:
struct Callback { struct Callback {
virtual void onEncodeFrame(const SFrameBSInfo& frameInfo) = 0; virtual void onEncodeFrame (const SFrameBSInfo& frameInfo) = 0;
}; };
BaseEncoderTest(); BaseEncoderTest();
void SetUp(); void SetUp();
void TearDown(); void TearDown();
void EncodeFile(const char* fileName, EUsageType usageType, int width, int height, float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk); void EncodeFile (const char* fileName, EUsageType usageType, int width, int height, float frameRate,
void EncodeStream(InputStream* in, EUsageType usageType, int width, int height, float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk); SliceModeEnum slices, bool denoise, int layers, Callback* cbk);
void EncodeStream (InputStream* in, EUsageType usageType, int width, int height, float frameRate, SliceModeEnum slices,
bool denoise, int layers, Callback* cbk);
private: private:
ISVCEncoder* encoder_; ISVCEncoder* encoder_;

105
test/api/BaseDecoderTest.cpp
View File

@ -5,18 +5,18 @@
#include "utils/BufferedData.h" #include "utils/BufferedData.h"
#include "BaseDecoderTest.h" #include "BaseDecoderTest.h"
static void ReadFrame(std::ifstream* file, BufferedData* buf) { static void ReadFrame (std::ifstream* file, BufferedData* buf) {
// start code of a frame is {0, 0, 0, 1} // start code of a frame is {0, 0, 0, 1}
int zeroCount = 0; int zeroCount = 0;
char b; char b;
buf->Clear(); buf->Clear();
for (;;) { for (;;) {
file->read(&b, 1); file->read (&b, 1);
if (file->gcount() != 1) { // end of file if (file->gcount() != 1) { // end of file
return; return;
} }
if (!buf->PushBack(b)) { if (!buf->PushBack (b)) {
FAIL() << "unable to allocate memory"; FAIL() << "unable to allocate memory";
} }
@ -28,8 +28,8 @@ static void ReadFrame(std::ifstream* file, BufferedData* buf) {
zeroCount = b != 0 ? 0 : zeroCount + 1; zeroCount = b != 0 ? 0 : zeroCount + 1;
} else { } else {
if (b == 1) { if (b == 1) {
if (file->seekg(-4, file->cur).good()) { if (file->seekg (-4, file->cur).good()) {
buf->SetLength(buf->Length() - 4); buf->SetLength (buf->Length() - 4);
return; return;
} else { } else {
FAIL() << "unable to seek file"; FAIL() << "unable to seek file";
@ -44,94 +44,97 @@ static void ReadFrame(std::ifstream* file, BufferedData* buf) {
} }
BaseDecoderTest::BaseDecoderTest() BaseDecoderTest::BaseDecoderTest()
: decoder_(NULL), decodeStatus_(OpenFile) {} : decoder_ (NULL), decodeStatus_ (OpenFile) {}
void BaseDecoderTest::SetUp() { void BaseDecoderTest::SetUp() {
long rv = WelsCreateDecoder(&decoder_); long rv = WelsCreateDecoder (&decoder_);
ASSERT_EQ(0, rv); ASSERT_EQ (0, rv);
ASSERT_TRUE(decoder_ != NULL); ASSERT_TRUE (decoder_ != NULL);
SDecodingParam decParam; SDecodingParam decParam;
memset(&decParam, 0, sizeof(SDecodingParam)); memset (&decParam, 0, sizeof (SDecodingParam));
decParam.iOutputColorFormat = videoFormatI420; decParam.iOutputColorFormat = videoFormatI420;
decParam.uiTargetDqLayer = UCHAR_MAX; decParam.uiTargetDqLayer = UCHAR_MAX;
decParam.uiEcActiveFlag = 1; decParam.uiEcActiveFlag = 1;
decParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT; decParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT;
rv = decoder_->Initialize(&decParam); rv = decoder_->Initialize (&decParam);
ASSERT_EQ(0, rv); ASSERT_EQ (0, rv);
} }
void BaseDecoderTest::TearDown() { void BaseDecoderTest::TearDown() {
if (decoder_ != NULL) { if (decoder_ != NULL) {
decoder_->Uninitialize(); decoder_->Uninitialize();
WelsDestroyDecoder(decoder_); WelsDestroyDecoder (decoder_);
} }
} }
void BaseDecoderTest::DecodeFrame(const uint8_t* src, int sliceSize, Callback* cbk) { void BaseDecoderTest::DecodeFrame (const uint8_t* src, int sliceSize, Callback* cbk) {
uint8_t* data[3]; uint8_t* data[3];
SBufferInfo bufInfo; SBufferInfo bufInfo;
memset(data, 0, sizeof(data)); memset (data, 0, sizeof (data));
memset(&bufInfo, 0, sizeof(SBufferInfo)); memset (&bufInfo, 0, sizeof (SBufferInfo));
DECODING_STATE rv = decoder_->DecodeFrame2(src, sliceSize, data, &bufInfo); DECODING_STATE rv = decoder_->DecodeFrame2 (src, sliceSize, data, &bufInfo);
ASSERT_TRUE(rv == dsErrorFree); ASSERT_TRUE (rv == dsErrorFree);
if (bufInfo.iBufferStatus == 1 && cbk != NULL) { if (bufInfo.iBufferStatus == 1 && cbk != NULL) {
const Frame frame = { const Frame frame = {
{ // y plane {
data[0], // y plane
bufInfo.UsrData.sSystemBuffer.iWidth, data[0],
bufInfo.UsrData.sSystemBuffer.iHeight, bufInfo.UsrData.sSystemBuffer.iWidth,
bufInfo.UsrData.sSystemBuffer.iStride[0] bufInfo.UsrData.sSystemBuffer.iHeight,
}, bufInfo.UsrData.sSystemBuffer.iStride[0]
{ // u plane },
data[1], {
bufInfo.UsrData.sSystemBuffer.iWidth / 2, // u plane
bufInfo.UsrData.sSystemBuffer.iHeight / 2, data[1],
bufInfo.UsrData.sSystemBuffer.iStride[1] bufInfo.UsrData.sSystemBuffer.iWidth / 2,
}, bufInfo.UsrData.sSystemBuffer.iHeight / 2,
{ // v plane bufInfo.UsrData.sSystemBuffer.iStride[1]
data[2], },
bufInfo.UsrData.sSystemBuffer.iWidth / 2, {
bufInfo.UsrData.sSystemBuffer.iHeight / 2, // v plane
bufInfo.UsrData.sSystemBuffer.iStride[1] data[2],
}, bufInfo.UsrData.sSystemBuffer.iWidth / 2,
bufInfo.UsrData.sSystemBuffer.iHeight / 2,
bufInfo.UsrData.sSystemBuffer.iStride[1]
},
}; };
cbk->onDecodeFrame(frame); cbk->onDecodeFrame (frame);
} }
} }
void BaseDecoderTest::DecodeFile(const char* fileName, Callback* cbk) { void BaseDecoderTest::DecodeFile (const char* fileName, Callback* cbk) {
std::ifstream file(fileName, std::ios::in | std::ios::binary); std::ifstream file (fileName, std::ios::in | std::ios::binary);
ASSERT_TRUE(file.is_open()); ASSERT_TRUE (file.is_open());
BufferedData buf; BufferedData buf;
while (true) { while (true) {
ReadFrame(&file, &buf); ReadFrame (&file, &buf);
if (::testing::Test::HasFatalFailure()) { if (::testing::Test::HasFatalFailure()) {
return; return;
} }
if (buf.Length() == 0) { if (buf.Length() == 0) {
break; break;
} }
DecodeFrame(buf.data(), buf.Length(), cbk); DecodeFrame (buf.data(), buf.Length(), cbk);
if (::testing::Test::HasFatalFailure()) { if (::testing::Test::HasFatalFailure()) {
return; return;
} }
} }
int32_t iEndOfStreamFlag = 1; int32_t iEndOfStreamFlag = 1;
decoder_->SetOption(DECODER_OPTION_END_OF_STREAM, &iEndOfStreamFlag); decoder_->SetOption (DECODER_OPTION_END_OF_STREAM, &iEndOfStreamFlag);
// Get pending last frame // Get pending last frame
DecodeFrame(NULL, 0, cbk); DecodeFrame (NULL, 0, cbk);
} }
bool BaseDecoderTest::Open(const char* fileName) { bool BaseDecoderTest::Open (const char* fileName) {
if (decodeStatus_ == OpenFile) { if (decodeStatus_ == OpenFile) {
file_.open(fileName, std::ios_base::out | std::ios_base::binary); file_.open (fileName, std::ios_base::out | std::ios_base::binary);
if (file_.is_open()) { if (file_.is_open()) {
decodeStatus_ = Decoding; decodeStatus_ = Decoding;
return true; return true;
@ -140,10 +143,10 @@ bool BaseDecoderTest::Open(const char* fileName) {
return false; return false;
} }
bool BaseDecoderTest::DecodeNextFrame(Callback* cbk) { bool BaseDecoderTest::DecodeNextFrame (Callback* cbk) {
switch (decodeStatus_) { switch (decodeStatus_) {
case Decoding: case Decoding:
ReadFrame(&file_, &buf_); ReadFrame (&file_, &buf_);
if (::testing::Test::HasFatalFailure()) { if (::testing::Test::HasFatalFailure()) {
return false; return false;
} }
@ -151,15 +154,15 @@ bool BaseDecoderTest::DecodeNextFrame(Callback* cbk) {
decodeStatus_ = EndOfStream; decodeStatus_ = EndOfStream;
return true; return true;
} }
DecodeFrame(buf_.data(), buf_.Length(), cbk); DecodeFrame (buf_.data(), buf_.Length(), cbk);
if (::testing::Test::HasFatalFailure()) { if (::testing::Test::HasFatalFailure()) {
return false; return false;
} }
return true; return true;
case EndOfStream: { case EndOfStream: {
int32_t iEndOfStreamFlag = 1; int32_t iEndOfStreamFlag = 1;
decoder_->SetOption(DECODER_OPTION_END_OF_STREAM, &iEndOfStreamFlag); decoder_->SetOption (DECODER_OPTION_END_OF_STREAM, &iEndOfStreamFlag);
DecodeFrame(NULL, 0, cbk); DecodeFrame (NULL, 0, cbk);
decodeStatus_ = End; decodeStatus_ = End;
break; break;
} }

60
test/api/BaseEncoderTest.cpp
View File

@ -5,11 +5,11 @@
#include "utils/FileInputStream.h" #include "utils/FileInputStream.h"
#include "BaseEncoderTest.h" #include "BaseEncoderTest.h"
static int InitWithParam(ISVCEncoder* encoder, EUsageType usageType,int width, static int InitWithParam (ISVCEncoder* encoder, EUsageType usageType, int width,
int height, float frameRate, SliceModeEnum sliceMode, bool denoise, int layers) { int height, float frameRate, SliceModeEnum sliceMode, bool denoise, int layers) {
if (SM_SINGLE_SLICE == sliceMode && !denoise && layers == 1) { if (SM_SINGLE_SLICE == sliceMode && !denoise && layers == 1) {
SEncParamBase param; SEncParamBase param;
memset (&param, 0, sizeof(SEncParamBase)); memset (&param, 0, sizeof (SEncParamBase));
param.iUsageType = usageType; param.iUsageType = usageType;
param.fMaxFrameRate = frameRate; param.fMaxFrameRate = frameRate;
@ -18,10 +18,10 @@ static int InitWithParam(ISVCEncoder* encoder, EUsageType usageType,int width,
param.iTargetBitrate = 5000000; param.iTargetBitrate = 5000000;
param.iInputCsp = videoFormatI420; param.iInputCsp = videoFormatI420;
return encoder->Initialize(&param); return encoder->Initialize (&param);
} else { } else {
SEncParamExt param; SEncParamExt param;
encoder->GetDefaultParams(&param); encoder->GetDefaultParams (&param);
param.iUsageType = usageType; param.iUsageType = usageType;
param.fMaxFrameRate = frameRate; param.fMaxFrameRate = frameRate;
@ -49,62 +49,62 @@ static int InitWithParam(ISVCEncoder* encoder, EUsageType usageType,int width,
} }
param.iTargetBitrate *= param.iSpatialLayerNum; param.iTargetBitrate *= param.iSpatialLayerNum;
return encoder->InitializeExt(&param); return encoder->InitializeExt (&param);
} }
} }
BaseEncoderTest::BaseEncoderTest() : encoder_(NULL) {} BaseEncoderTest::BaseEncoderTest() : encoder_ (NULL) {}
void BaseEncoderTest::SetUp() { void BaseEncoderTest::SetUp() {
int rv = WelsCreateSVCEncoder(&encoder_); int rv = WelsCreateSVCEncoder (&encoder_);
ASSERT_EQ(0, rv); ASSERT_EQ (0, rv);
ASSERT_TRUE(encoder_ != NULL); ASSERT_TRUE (encoder_ != NULL);
} }
void BaseEncoderTest::TearDown() { void BaseEncoderTest::TearDown() {
if (encoder_) { if (encoder_) {
encoder_->Uninitialize(); encoder_->Uninitialize();
WelsDestroySVCEncoder(encoder_); WelsDestroySVCEncoder (encoder_);
} }
} }
void BaseEncoderTest::EncodeStream(InputStream* in, EUsageType usageType, int width, int height, void BaseEncoderTest::EncodeStream (InputStream* in, EUsageType usageType, int width, int height,
float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk) { float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk) {
int rv = InitWithParam(encoder_, usageType, width, height, frameRate, slices, denoise, layers); int rv = InitWithParam (encoder_, usageType, width, height, frameRate, slices, denoise, layers);
ASSERT_TRUE(rv == cmResultSuccess); ASSERT_TRUE (rv == cmResultSuccess);
// I420: 1(Y) + 1/4(U) + 1/4(V) // I420: 1(Y) + 1/4(U) + 1/4(V)
int frameSize = width * height * 3 / 2; int frameSize = width * height * 3 / 2;
BufferedData buf; BufferedData buf;
buf.SetLength(frameSize); buf.SetLength (frameSize);
ASSERT_TRUE(buf.Length() == (size_t)frameSize); ASSERT_TRUE (buf.Length() == (size_t)frameSize);
SFrameBSInfo info; SFrameBSInfo info;
memset(&info, 0, sizeof(SFrameBSInfo)); memset (&info, 0, sizeof (SFrameBSInfo));
SSourcePicture pic; SSourcePicture pic;
memset(&pic,0,sizeof(SSourcePicture)); memset (&pic, 0, sizeof (SSourcePicture));
pic.iPicWidth = width; pic.iPicWidth = width;
pic.iPicHeight = height; pic.iPicHeight = height;
pic.iColorFormat = videoFormatI420; pic.iColorFormat = videoFormatI420;
pic.iStride[0] = pic.iPicWidth; pic.iStride[0] = pic.iPicWidth;
pic.iStride[1] = pic.iStride[2] = pic.iPicWidth>>1; pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
pic.pData[0] = buf.data(); pic.pData[0] = buf.data();
pic.pData[1] = pic.pData[0] + width *height; pic.pData[1] = pic.pData[0] + width * height;
pic.pData[2] = pic.pData[1] + (width*height>>2); pic.pData[2] = pic.pData[1] + (width * height >> 2);
while (in->read(buf.data(), frameSize) == frameSize) { while (in->read (buf.data(), frameSize) == frameSize) {
rv = encoder_->EncodeFrame(&pic, &info); rv = encoder_->EncodeFrame (&pic, &info);
ASSERT_TRUE(rv == cmResultSuccess); ASSERT_TRUE (rv == cmResultSuccess);
if (info.eFrameType != videoFrameTypeSkip && cbk != NULL) { if (info.eFrameType != videoFrameTypeSkip && cbk != NULL) {
cbk->onEncodeFrame(info); cbk->onEncodeFrame (info);
} }
} }
} }
void BaseEncoderTest::EncodeFile(const char* fileName, EUsageType usageType, int width, int height, void BaseEncoderTest::EncodeFile (const char* fileName, EUsageType usageType, int width, int height,
float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk) { float frameRate, SliceModeEnum slices, bool denoise, int layers, Callback* cbk) {
FileInputStream fileStream; FileInputStream fileStream;
ASSERT_TRUE(fileStream.Open(fileName)); ASSERT_TRUE (fileStream.Open (fileName));
EncodeStream(&fileStream, usageType, width, height, frameRate, slices, denoise, layers, cbk); EncodeStream (&fileStream, usageType, width, height, frameRate, slices, denoise, layers, cbk);
} }

42
test/api/DataGenerator.cpp
View File

@ -7,35 +7,34 @@
using namespace std; using namespace std;
bool YUVPixelDataGenerator( uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ) bool YUVPixelDataGenerator (uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride) {
{
#define SRC_FRAME_WIDTH (160) #define SRC_FRAME_WIDTH (160)
#define SRC_FRAME_HEIGHT (96) #define SRC_FRAME_HEIGHT (96)
if ( SRC_FRAME_WIDTH-iWidth <= 0 || SRC_FRAME_HEIGHT-iHeight <= 0 ) { if (SRC_FRAME_WIDTH - iWidth <= 0 || SRC_FRAME_HEIGHT - iHeight <= 0) {
return false; return false;
} }
const int32_t kiFrameSize = SRC_FRAME_WIDTH*SRC_FRAME_HEIGHT; const int32_t kiFrameSize = SRC_FRAME_WIDTH * SRC_FRAME_HEIGHT;
BufferedData sBuf; BufferedData sBuf;
sBuf.SetLength(kiFrameSize); sBuf.SetLength (kiFrameSize);
if (sBuf.Length() != (size_t)kiFrameSize) { if (sBuf.Length() != (size_t)kiFrameSize) {
return false; return false;
} }
FileInputStream fileStream; FileInputStream fileStream;
if (!fileStream.Open("res/CiscoVT2people_160x96_6fps.yuv")) { if (!fileStream.Open ("res/CiscoVT2people_160x96_6fps.yuv")) {
return false; return false;
} }
if (fileStream.read(sBuf.data(), kiFrameSize) == kiFrameSize) { if (fileStream.read (sBuf.data(), kiFrameSize) == kiFrameSize) {
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
int32_t iStartPosX = rand()%(SRC_FRAME_WIDTH-iWidth); int32_t iStartPosX = rand() % (SRC_FRAME_WIDTH - iWidth);
int32_t iStartPosY = rand()%(SRC_FRAME_HEIGHT-iHeight); int32_t iStartPosY = rand() % (SRC_FRAME_HEIGHT - iHeight);
uint8_t* pSrcPointer = sBuf.data() + iStartPosX + iStartPosY*SRC_FRAME_WIDTH; uint8_t* pSrcPointer = sBuf.data() + iStartPosX + iStartPosY * SRC_FRAME_WIDTH;
uint8_t* pLocalPointer = pPointer; uint8_t* pLocalPointer = pPointer;
for (int j=0;j<iHeight;j++) { for (int j = 0; j < iHeight; j++) {
memcpy(pLocalPointer, pSrcPointer, iWidth*sizeof(uint8_t)); memcpy (pLocalPointer, pSrcPointer, iWidth * sizeof (uint8_t));
pLocalPointer += iStride; pLocalPointer += iStride;
pSrcPointer += SRC_FRAME_WIDTH; pSrcPointer += SRC_FRAME_WIDTH;
} }
@ -44,24 +43,21 @@ bool YUVPixelDataGenerator( uint8_t* pPointer, int32_t iWidth, int32_t iHeight,
return false; return false;
} }
void RandomPixelDataGenerator( uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride, int32_t iIdx ) void RandomPixelDataGenerator (uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride, int32_t iIdx) {
{
uint8_t* pLocalPointer = pPointer; uint8_t* pLocalPointer = pPointer;
srand((uint32_t)(time(NULL)+iIdx)); srand ((uint32_t) (time (NULL) + iIdx));
for (int32_t j=0;j<iHeight;j++) { for (int32_t j = 0; j < iHeight; j++) {
for (int32_t i=0;i<iWidth;i++) { for (int32_t i = 0; i < iWidth; i++) {
pLocalPointer[i] = rand()%256; pLocalPointer[i] = rand() % 256;
} }
pLocalPointer += iStride; pLocalPointer += iStride;
} }
} }
void RandomResidueDataGenerator( uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ) void RandomResidueDataGenerator (uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride) {
{
} }
void RandomCoeffDataGenerator( uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ) void RandomCoeffDataGenerator (uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride) {
{
} }

102
test/api/cpp_interface_test.cpp
View File

@ -2,16 +2,16 @@
#include "codec_api.h" #include "codec_api.h"
#include <stddef.h> #include <stddef.h>
static void CheckFunctionOrder(int expect, int actual, const char* name) { static void CheckFunctionOrder (int expect, int actual, const char* name) {
EXPECT_EQ(expect, actual) << "Wrong function order: " << name; EXPECT_EQ (expect, actual) << "Wrong function order: " << name;
} }
typedef void(*CheckFunc)(int, int, const char*); typedef void (*CheckFunc) (int, int, const char*);
extern "C" void CheckEncoderInterface(ISVCEncoder* p, CheckFunc); extern "C" void CheckEncoderInterface (ISVCEncoder* p, CheckFunc);
extern "C" void CheckDecoderInterface(ISVCDecoder* p, CheckFunc); extern "C" void CheckDecoderInterface (ISVCDecoder* p, CheckFunc);
extern "C" size_t GetBoolSize(void); extern "C" size_t GetBoolSize (void);
extern "C" size_t GetBoolOffset(void); extern "C" size_t GetBoolOffset (void);
extern "C" size_t GetBoolStructSize(void); extern "C" size_t GetBoolStructSize (void);
// Store the 'this' pointer to verify 'this' is received as expected from C code. // Store the 'this' pointer to verify 'this' is received as expected from C code.
static void* gThis; static void* gThis;
@ -22,98 +22,98 @@ static void* gThis;
*/ */
struct SVCEncoderImpl : public ISVCEncoder { struct SVCEncoderImpl : public ISVCEncoder {
virtual ~SVCEncoderImpl() {} virtual ~SVCEncoderImpl() {}
virtual int EXTAPI Initialize(const SEncParamBase* pParam) { virtual int EXTAPI Initialize (const SEncParamBase* pParam) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 1; return 1;
} }
virtual int EXTAPI InitializeExt(const SEncParamExt* pParam) { virtual int EXTAPI InitializeExt (const SEncParamExt* pParam) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 2; return 2;
} }
virtual int EXTAPI GetDefaultParams(SEncParamExt* pParam) { virtual int EXTAPI GetDefaultParams (SEncParamExt* pParam) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 3; return 3;
} }
virtual int EXTAPI Uninitialize() { virtual int EXTAPI Uninitialize() {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 4; return 4;
} }
virtual int EXTAPI EncodeFrame(const SSourcePicture* kpSrcPic, virtual int EXTAPI EncodeFrame (const SSourcePicture* kpSrcPic,
SFrameBSInfo* pBsInfo) { SFrameBSInfo* pBsInfo) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 5; return 5;
} }
virtual int EXTAPI EncodeParameterSets(SFrameBSInfo* pBsInfo) { virtual int EXTAPI EncodeParameterSets (SFrameBSInfo* pBsInfo) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 6; return 6;
} }
virtual int EXTAPI PauseFrame(const SSourcePicture* kpSrcPic, virtual int EXTAPI PauseFrame (const SSourcePicture* kpSrcPic,
SFrameBSInfo* pBsInfo) { SFrameBSInfo* pBsInfo) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 7; return 7;
} }
virtual int EXTAPI ForceIntraFrame(bool bIDR) { virtual int EXTAPI ForceIntraFrame (bool bIDR) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 8; return 8;
} }
virtual int EXTAPI SetOption(ENCODER_OPTION eOptionId, void* pOption) { virtual int EXTAPI SetOption (ENCODER_OPTION eOptionId, void* pOption) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 9; return 9;
} }
virtual int EXTAPI GetOption(ENCODER_OPTION eOptionId, void* pOption) { virtual int EXTAPI GetOption (ENCODER_OPTION eOptionId, void* pOption) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 10; return 10;
} }
}; };
struct SVCDecoderImpl : public ISVCDecoder { struct SVCDecoderImpl : public ISVCDecoder {
virtual ~SVCDecoderImpl() {} virtual ~SVCDecoderImpl() {}
virtual long EXTAPI Initialize(const SDecodingParam* pParam) { virtual long EXTAPI Initialize (const SDecodingParam* pParam) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 1; return 1;
} }
virtual long EXTAPI Uninitialize() { virtual long EXTAPI Uninitialize() {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 2; return 2;
} }
virtual DECODING_STATE EXTAPI DecodeFrame(const unsigned char* pSrc, virtual DECODING_STATE EXTAPI DecodeFrame (const unsigned char* pSrc,
const int iSrcLen, unsigned char** ppDst, int* pStride, const int iSrcLen, unsigned char** ppDst, int* pStride,
int& iWidth, int& iHeight) { int& iWidth, int& iHeight) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return static_cast<DECODING_STATE>(3); return static_cast<DECODING_STATE> (3);
} }
virtual DECODING_STATE EXTAPI DecodeFrame2(const unsigned char* pSrc, virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* pSrc,
const int iSrcLen, unsigned char** ppDst, SBufferInfo* pDstInfo) { const int iSrcLen, unsigned char** ppDst, SBufferInfo* pDstInfo) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return static_cast<DECODING_STATE>(4); return static_cast<DECODING_STATE> (4);
} }
virtual DECODING_STATE EXTAPI DecodeFrameEx(const unsigned char* pSrc, virtual DECODING_STATE EXTAPI DecodeFrameEx (const unsigned char* pSrc,
const int iSrcLen, unsigned char* pDst, int iDstStride, const int iSrcLen, unsigned char* pDst, int iDstStride,
int& iDstLen, int& iWidth, int& iHeight, int& iColorFormat) { int& iDstLen, int& iWidth, int& iHeight, int& iColorFormat) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return static_cast<DECODING_STATE>(5); return static_cast<DECODING_STATE> (5);
} }
virtual long EXTAPI SetOption (DECODER_OPTION eOptionId, void* pOption) { virtual long EXTAPI SetOption (DECODER_OPTION eOptionId, void* pOption) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 6; return 6;
} }
virtual long EXTAPI GetOption (DECODER_OPTION eOptionId, void* pOption) { virtual long EXTAPI GetOption (DECODER_OPTION eOptionId, void* pOption) {
EXPECT_TRUE(gThis == this); EXPECT_TRUE (gThis == this);
return 7; return 7;
} }
}; };
TEST(ISVCEncoderTest, CheckFunctionOrder) { TEST (ISVCEncoderTest, CheckFunctionOrder) {
SVCEncoderImpl* p = new SVCEncoderImpl; SVCEncoderImpl* p = new SVCEncoderImpl;
gThis = p; gThis = p;
CheckEncoderInterface(p, CheckFunctionOrder); CheckEncoderInterface (p, CheckFunctionOrder);
delete p; delete p;
} }
TEST(ISVCDecoderTest, CheckFunctionOrder) { TEST (ISVCDecoderTest, CheckFunctionOrder) {
SVCDecoderImpl* p = new SVCDecoderImpl; SVCDecoderImpl* p = new SVCDecoderImpl;
gThis = p; gThis = p;
CheckDecoderInterface(p, CheckFunctionOrder); CheckDecoderInterface (p, CheckFunctionOrder);
delete p; delete p;
} }
@ -122,8 +122,8 @@ struct bool_test_struct {
bool b; bool b;
}; };
TEST(ISVCDecoderEncoderTest, CheckCAbi) { TEST (ISVCDecoderEncoderTest, CheckCAbi) {
EXPECT_EQ(sizeof(bool), GetBoolSize()) << "Wrong size of bool type"; EXPECT_EQ (sizeof (bool), GetBoolSize()) << "Wrong size of bool type";
EXPECT_EQ(offsetof(bool_test_struct, b), GetBoolOffset()) << "Wrong alignment of bool in a struct"; EXPECT_EQ (offsetof (bool_test_struct, b), GetBoolOffset()) << "Wrong alignment of bool in a struct";
EXPECT_EQ(sizeof(bool_test_struct), GetBoolStructSize()) << "Wrong size of struct with a bool"; EXPECT_EQ (sizeof (bool_test_struct), GetBoolStructSize()) << "Wrong size of struct with a bool";
} }

50
test/api/decode_encode_test.cpp
View File

@ -6,21 +6,21 @@
#include "BaseDecoderTest.h" #include "BaseDecoderTest.h"
#include "BaseEncoderTest.h" #include "BaseEncoderTest.h"
static void UpdateHashFromFrame(const SFrameBSInfo& info, SHA1Context* ctx) { static void UpdateHashFromFrame (const SFrameBSInfo& info, SHA1Context* ctx) {
for (int i = 0; i < info.iLayerNum; ++i) { for (int i = 0; i < info.iLayerNum; ++i) {
const SLayerBSInfo& layerInfo = info.sLayerInfo[i]; const SLayerBSInfo& layerInfo = info.sLayerInfo[i];
int layerSize = 0; int layerSize = 0;
for (int j = 0; j < layerInfo.iNalCount; ++j) { for (int j = 0; j < layerInfo.iNalCount; ++j) {
layerSize += layerInfo.pNalLengthInByte[j]; layerSize += layerInfo.pNalLengthInByte[j];
} }
SHA1Input(ctx, layerInfo.pBsBuf, layerSize); SHA1Input (ctx, layerInfo.pBsBuf, layerSize);
} }
} }
static void WritePlaneBuffer(BufferedData* buf, const uint8_t* plane, static void WritePlaneBuffer (BufferedData* buf, const uint8_t* plane,
int width, int height, int stride) { int width, int height, int stride) {
for (int i = 0; i < height; i++) { for (int i = 0; i < height; i++) {
if (!buf->PushBack(plane, width)) { if (!buf->PushBack (plane, width)) {
FAIL() << "unable to allocate memory"; FAIL() << "unable to allocate memory";
} }
plane += stride; plane += stride;
@ -36,9 +36,9 @@ struct DecodeEncodeFileParam {
}; };
class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>, class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>,
public BaseDecoderTest, public BaseDecoderTest::Callback, public BaseDecoderTest, public BaseDecoderTest::Callback,
public BaseEncoderTest , public BaseEncoderTest::Callback, public BaseEncoderTest , public BaseEncoderTest::Callback,
public InputStream { public InputStream {
public: public:
virtual void SetUp() { virtual void SetUp() {
BaseDecoderTest::SetUp(); BaseDecoderTest::SetUp();
@ -49,7 +49,7 @@ class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>,
if (HasFatalFailure()) { if (HasFatalFailure()) {
return; return;
} }
SHA1Reset(&ctx_); SHA1Reset (&ctx_);
} }
virtual void TearDown() { virtual void TearDown() {
@ -57,22 +57,22 @@ class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>,
BaseEncoderTest::TearDown(); BaseEncoderTest::TearDown();
} }
virtual void onDecodeFrame(const Frame& frame) { virtual void onDecodeFrame (const Frame& frame) {
const Plane& y = frame.y; const Plane& y = frame.y;
const Plane& u = frame.u; const Plane& u = frame.u;
const Plane& v = frame.v; const Plane& v = frame.v;
WritePlaneBuffer(&buf_, y.data, y.width, y.height, y.stride); WritePlaneBuffer (&buf_, y.data, y.width, y.height, y.stride);
WritePlaneBuffer(&buf_, u.data, u.width, u.height, u.stride); WritePlaneBuffer (&buf_, u.data, u.width, u.height, u.stride);
WritePlaneBuffer(&buf_, v.data, v.width, v.height, v.stride); WritePlaneBuffer (&buf_, v.data, v.width, v.height, v.stride);
} }
virtual void onEncodeFrame(const SFrameBSInfo& frameInfo) { virtual void onEncodeFrame (const SFrameBSInfo& frameInfo) {
UpdateHashFromFrame(frameInfo, &ctx_); UpdateHashFromFrame (frameInfo, &ctx_);
} }
virtual int read(void* ptr, size_t len) { virtual int read (void* ptr, size_t len) {
while (buf_.Length() < len) { while (buf_.Length() < len) {
bool hasNext = DecodeNextFrame(this); bool hasNext = DecodeNextFrame (this);
if (HasFatalFailure()) { if (HasFatalFailure()) {
return -1; return -1;
} }
@ -83,7 +83,7 @@ class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>,
break; break;
} }
} }
return buf_.PopFront(static_cast<uint8_t*>(ptr), len); return buf_.PopFront (static_cast<uint8_t*> (ptr), len);
} }
protected: protected:
@ -91,15 +91,15 @@ class DecodeEncodeTest : public ::testing::TestWithParam<DecodeEncodeFileParam>,
BufferedData buf_; BufferedData buf_;
}; };
TEST_P(DecodeEncodeTest, CompareOutput) { TEST_P (DecodeEncodeTest, CompareOutput) {
DecodeEncodeFileParam p = GetParam(); DecodeEncodeFileParam p = GetParam();
ASSERT_TRUE(Open(p.fileName)); ASSERT_TRUE (Open (p.fileName));
EncodeStream(this, CAMERA_VIDEO_REAL_TIME,p.width, p.height, p.frameRate, SM_SINGLE_SLICE, false, 1, this); EncodeStream (this, CAMERA_VIDEO_REAL_TIME, p.width, p.height, p.frameRate, SM_SINGLE_SLICE, false, 1, this);
unsigned char digest[SHA_DIGEST_LENGTH]; unsigned char digest[SHA_DIGEST_LENGTH];
SHA1Result(&ctx_, digest); SHA1Result (&ctx_, digest);
if (!HasFatalFailure()) { if (!HasFatalFailure()) {
CompareHash(digest, p.hashStr); CompareHash (digest, p.hashStr);
} }
} }
@ -108,5 +108,5 @@ static const DecodeEncodeFileParam kFileParamArray[] = {
{"res/test_vd_rc.264", "106fd8cc978c1801b0d1f8297e9b7f17d5336e15", 320, 192, 12.0f}, {"res/test_vd_rc.264", "106fd8cc978c1801b0d1f8297e9b7f17d5336e15", 320, 192, 12.0f},
}; };
INSTANTIATE_TEST_CASE_P(DecodeEncodeFile, DecodeEncodeTest, INSTANTIATE_TEST_CASE_P (DecodeEncodeFile, DecodeEncodeTest,
::testing::ValuesIn(kFileParamArray)); ::testing::ValuesIn (kFileParamArray));

32
test/api/decoder_test.cpp
View File

@ -2,10 +2,10 @@
#include "utils/HashFunctions.h" #include "utils/HashFunctions.h"
#include "BaseDecoderTest.h" #include "BaseDecoderTest.h"
static void UpdateHashFromPlane(SHA1Context* ctx, const uint8_t* plane, static void UpdateHashFromPlane (SHA1Context* ctx, const uint8_t* plane,
int width, int height, int stride) { int width, int height, int stride) {
for (int i = 0; i < height; i++) { for (int i = 0; i < height; i++) {
SHA1Input(ctx, plane, width); SHA1Input (ctx, plane, width);
plane += stride; plane += stride;
} }
} }
@ -21,7 +21,7 @@ class DecoderInitTest : public ::testing::Test, public BaseDecoderTest {
} }
}; };
TEST_F(DecoderInitTest, JustInit) {} TEST_F (DecoderInitTest, JustInit) {}
struct FileParam { struct FileParam {
const char* fileName; const char* fileName;
@ -29,35 +29,35 @@ struct FileParam {
}; };
class DecoderOutputTest : public ::testing::WithParamInterface<FileParam>, class DecoderOutputTest : public ::testing::WithParamInterface<FileParam>,
public DecoderInitTest, public BaseDecoderTest::Callback { public DecoderInitTest, public BaseDecoderTest::Callback {
public: public:
virtual void SetUp() { virtual void SetUp() {
DecoderInitTest::SetUp(); DecoderInitTest::SetUp();
if (HasFatalFailure()) { if (HasFatalFailure()) {
return; return;
} }
SHA1Reset(&ctx_); SHA1Reset (&ctx_);
} }
virtual void onDecodeFrame(const Frame& frame) { virtual void onDecodeFrame (const Frame& frame) {
const Plane& y = frame.y; const Plane& y = frame.y;
const Plane& u = frame.u; const Plane& u = frame.u;
const Plane& v = frame.v; const Plane& v = frame.v;
UpdateHashFromPlane(&ctx_, y.data, y.width, y.height, y.stride); UpdateHashFromPlane (&ctx_, y.data, y.width, y.height, y.stride);
UpdateHashFromPlane(&ctx_, u.data, u.width, u.height, u.stride); UpdateHashFromPlane (&ctx_, u.data, u.width, u.height, u.stride);
UpdateHashFromPlane(&ctx_, v.data, v.width, v.height, v.stride); UpdateHashFromPlane (&ctx_, v.data, v.width, v.height, v.stride);
} }
protected: protected:
SHA1Context ctx_; SHA1Context ctx_;
}; };
TEST_P(DecoderOutputTest, CompareOutput) { TEST_P (DecoderOutputTest, CompareOutput) {
FileParam p = GetParam(); FileParam p = GetParam();
DecodeFile(p.fileName, this); DecodeFile (p.fileName, this);
unsigned char digest[SHA_DIGEST_LENGTH]; unsigned char digest[SHA_DIGEST_LENGTH];
SHA1Result(&ctx_, digest); SHA1Result (&ctx_, digest);
if (!HasFatalFailure()) { if (!HasFatalFailure()) {
CompareHash(digest, p.hashStr); CompareHash (digest, p.hashStr);
} }
} }
@ -96,5 +96,5 @@ static const FileParam kFileParamArray[] = {
{"res/SVA_NL2_E.264", "70453ef8097c94dd190d6d2d1d5cb83c67e66238"} {"res/SVA_NL2_E.264", "70453ef8097c94dd190d6d2d1d5cb83c67e66238"}
}; };
INSTANTIATE_TEST_CASE_P(DecodeFile, DecoderOutputTest, INSTANTIATE_TEST_CASE_P (DecodeFile, DecoderOutputTest,
::testing::ValuesIn(kFileParamArray)); ::testing::ValuesIn (kFileParamArray));

68
test/api/encoder_test.cpp
View File

@ -2,14 +2,14 @@
#include "utils/HashFunctions.h" #include "utils/HashFunctions.h"
#include "BaseEncoderTest.h" #include "BaseEncoderTest.h"
static void UpdateHashFromFrame(const SFrameBSInfo& info, SHA1Context* ctx) { static void UpdateHashFromFrame (const SFrameBSInfo& info, SHA1Context* ctx) {
for (int i = 0; i < info.iLayerNum; ++i) { for (int i = 0; i < info.iLayerNum; ++i) {
const SLayerBSInfo& layerInfo = info.sLayerInfo[i]; const SLayerBSInfo& layerInfo = info.sLayerInfo[i];
int layerSize = 0; int layerSize = 0;
for (int j = 0; j < layerInfo.iNalCount; ++j) { for (int j = 0; j < layerInfo.iNalCount; ++j) {
layerSize += layerInfo.pNalLengthInByte[j]; layerSize += layerInfo.pNalLengthInByte[j];
} }
SHA1Input(ctx, layerInfo.pBsBuf, layerSize); SHA1Input (ctx, layerInfo.pBsBuf, layerSize);
} }
} }
@ -23,7 +23,7 @@ class EncoderInitTest : public ::testing::Test, public BaseEncoderTest {
} }
}; };
TEST_F(EncoderInitTest, JustInit) {} TEST_F (EncoderInitTest, JustInit) {}
struct EncodeFileParam { struct EncodeFileParam {
const char* fileName; const char* fileName;
@ -38,80 +38,80 @@ struct EncodeFileParam {
}; };
class EncoderOutputTest : public ::testing::WithParamInterface<EncodeFileParam>, class EncoderOutputTest : public ::testing::WithParamInterface<EncodeFileParam>,
public EncoderInitTest , public BaseEncoderTest::Callback { public EncoderInitTest , public BaseEncoderTest::Callback {
public: public:
virtual void SetUp() { virtual void SetUp() {
EncoderInitTest::SetUp(); EncoderInitTest::SetUp();
if (HasFatalFailure()) { if (HasFatalFailure()) {
return; return;
} }
SHA1Reset(&ctx_); SHA1Reset (&ctx_);
} }
virtual void onEncodeFrame(const SFrameBSInfo& frameInfo) { virtual void onEncodeFrame (const SFrameBSInfo& frameInfo) {
UpdateHashFromFrame(frameInfo, &ctx_); UpdateHashFromFrame (frameInfo, &ctx_);
} }
protected: protected:
SHA1Context ctx_; SHA1Context ctx_;
}; };
TEST_P(EncoderOutputTest, CompareOutput) { TEST_P (EncoderOutputTest, CompareOutput) {
EncodeFileParam p = GetParam(); EncodeFileParam p = GetParam();
EncodeFile(p.fileName, p.usageType ,p.width, p.height, p.frameRate, p.slices, p.denoise, p.layers, this); EncodeFile (p.fileName, p.usageType , p.width, p.height, p.frameRate, p.slices, p.denoise, p.layers, this);
//will remove this after screen content algorithms are ready, //will remove this after screen content algorithms are ready,
//because the bitstream output will vary when the different algorithms are added. //because the bitstream output will vary when the different algorithms are added.
if(p.usageType == SCREEN_CONTENT_REAL_TIME) if (p.usageType == SCREEN_CONTENT_REAL_TIME)
return; return;
unsigned char digest[SHA_DIGEST_LENGTH]; unsigned char digest[SHA_DIGEST_LENGTH];
SHA1Result(&ctx_, digest); SHA1Result (&ctx_, digest);
if (!HasFatalFailure()) { if (!HasFatalFailure()) {
CompareHash(digest, p.hashStr); CompareHash (digest, p.hashStr);
} }
} }
static const EncodeFileParam kFileParamArray[] = { static const EncodeFileParam kFileParamArray[] = {
{ {
"res/CiscoVT2people_320x192_12fps.yuv", "res/CiscoVT2people_320x192_12fps.yuv",
"0a36b75e423fc6b49f6adf7eee12c039a096f538", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 1 "0a36b75e423fc6b49f6adf7eee12c039a096f538", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 1
}, },
{ {
"res/CiscoVT2people_160x96_6fps.yuv", "res/CiscoVT2people_160x96_6fps.yuv",
"73981e6ea5b62f7338212c538a7cc755e7c9c030", CAMERA_VIDEO_REAL_TIME, 160, 96, 6.0f, SM_SINGLE_SLICE, false, 1 "73981e6ea5b62f7338212c538a7cc755e7c9c030", CAMERA_VIDEO_REAL_TIME, 160, 96, 6.0f, SM_SINGLE_SLICE, false, 1
}, },
{ {
"res/Static_152_100.yuv", "res/Static_152_100.yuv",
"83db4c0e3006bbe039bd327b6e78c57fbb05316f", CAMERA_VIDEO_REAL_TIME, 152, 100, 6.0f, SM_SINGLE_SLICE, false, 1 "83db4c0e3006bbe039bd327b6e78c57fbb05316f", CAMERA_VIDEO_REAL_TIME, 152, 100, 6.0f, SM_SINGLE_SLICE, false, 1
}, },
{ {
"res/CiscoVT2people_320x192_12fps.yuv", "res/CiscoVT2people_320x192_12fps.yuv",
"c8b759bcec7ffa048f1d3ded594b8815bed0aead", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_ROWMB_SLICE, false, 1 // One slice per MB row "c8b759bcec7ffa048f1d3ded594b8815bed0aead", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_ROWMB_SLICE, false, 1 // One slice per MB row
}, },
{ {
"res/CiscoVT2people_320x192_12fps.yuv", "res/CiscoVT2people_320x192_12fps.yuv",
"e64ba75456c821ca35a949eda89f85bff8ee69fa", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, true, 1 "e64ba75456c821ca35a949eda89f85bff8ee69fa", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, true, 1
}, },
{ {
"res/CiscoVT2people_320x192_12fps.yuv", "res/CiscoVT2people_320x192_12fps.yuv",
"684e6d141ada776892bdb01ee93efe475983ed36", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 2 "684e6d141ada776892bdb01ee93efe475983ed36", CAMERA_VIDEO_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 2
}, },
{ {
"res/Cisco_Absolute_Power_1280x720_30fps.yuv", "res/Cisco_Absolute_Power_1280x720_30fps.yuv",
"6df1ece77c0de63cdf8ab52ccef3a7d139022717", CAMERA_VIDEO_REAL_TIME, 1280, 720, 30.0f, SM_DYN_SLICE, false, 1 "6df1ece77c0de63cdf8ab52ccef3a7d139022717", CAMERA_VIDEO_REAL_TIME, 1280, 720, 30.0f, SM_DYN_SLICE, false, 1
}, },
{ {
"res/CiscoVT2people_320x192_12fps.yuv", "res/CiscoVT2people_320x192_12fps.yuv",
"", SCREEN_CONTENT_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 1 "", SCREEN_CONTENT_REAL_TIME, 320, 192, 12.0f, SM_SINGLE_SLICE, false, 1
}, },
{ {
"res/CiscoVT2people_160x96_6fps.yuv", "res/CiscoVT2people_160x96_6fps.yuv",
"", SCREEN_CONTENT_REAL_TIME, 160, 96, 6.0f, SM_SINGLE_SLICE, false, 1 "", SCREEN_CONTENT_REAL_TIME, 160, 96, 6.0f, SM_SINGLE_SLICE, false, 1
}, },
{ {
"res/Static_152_100.yuv", "res/Static_152_100.yuv",
"", SCREEN_CONTENT_REAL_TIME, 152, 100, 6.0f, SM_SINGLE_SLICE, false, 1 "", SCREEN_CONTENT_REAL_TIME, 152, 100, 6.0f, SM_SINGLE_SLICE, false, 1
} }
}; };
INSTANTIATE_TEST_CASE_P(EncodeFile, EncoderOutputTest, INSTANTIATE_TEST_CASE_P (EncodeFile, EncoderOutputTest,
::testing::ValuesIn(kFileParamArray)); ::testing::ValuesIn (kFileParamArray));

8
test/api/simple_test.cpp
View File

@ -5,15 +5,15 @@
#if (defined(ANDROID_NDK)||defined(APPLE_IOS)) #if (defined(ANDROID_NDK)||defined(APPLE_IOS))
int CodecUtMain(int argc , char** argv ) { int CodecUtMain (int argc , char** argv) {
#else #else
int main (int argc, char** argv) { int main (int argc, char** argv) {
#endif #endif
#if defined(ANDROID_NDK) #if defined(ANDROID_NDK)
char xmlPath[1024] = ""; char xmlPath[1024] = "";
sprintf(xmlPath,"xml:%s",argv[1]); sprintf (xmlPath, "xml:%s", argv[1]);
::testing::GTEST_FLAG(output) = xmlPath; ::testing::GTEST_FLAG (output) = xmlPath;
#endif #endif
::testing::InitGoogleTest (&argc, argv); ::testing::InitGoogleTest (&argc, argv);

8
test/build/android/jni/codec_unittest.cpp
View File

@ -8,7 +8,7 @@
#define LOG_TAG "codec_unittest" #define LOG_TAG "codec_unittest"
#define LOGI(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__) #define LOGI(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
int CodecUtMain(int argc, char** argv); int CodecUtMain (int argc, char** argv);
extern "C" extern "C"
JNIEXPORT void JNICALL Java_com_cisco_codec_unittest_MainActivity_DoUnittest JNIEXPORT void JNICALL Java_com_cisco_codec_unittest_MainActivity_DoUnittest
(JNIEnv* env, jobject thiz, jstring directory, jstring jspath) { (JNIEnv* env, jobject thiz, jstring directory, jstring jspath) {
@ -16,11 +16,11 @@ JNIEXPORT void JNICALL Java_com_cisco_codec_unittest_MainActivity_DoUnittest
char* argv[2]; char* argv[2];
int argc = 2; int argc = 2;
argv[0] = (char*) ("codec_unittest.exe"); argv[0] = (char*) ("codec_unittest.exe");
argv[1] = (char*) ((*env).GetStringUTFChars (jspath,NULL)); argv[1] = (char*) ((*env).GetStringUTFChars (jspath, NULL));
chdir((*env).GetStringUTFChars (directory, NULL)); chdir ((*env).GetStringUTFChars (directory, NULL));
LOGI ("PATH: %s", argv[1]); LOGI ("PATH: %s", argv[1]);
LOGI ("Start to run JNI module!+++"); LOGI ("Start to run JNI module!+++");
CodecUtMain(argc,argv); CodecUtMain (argc, argv);
LOGI ("End to run JNI module!+++"); LOGI ("End to run JNI module!+++");
} }

2
test/build/ios/codec_unittest/codec_unittest/AppDelegate.h
View File

@ -10,6 +10,6 @@
@interface AppDelegate : UIResponder <UIApplicationDelegate> @interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window; @property (strong, nonatomic) UIWindow* window;
@end @end

6
test/decoder/DecUT_Deblock.cpp
View File

@ -141,6 +141,8 @@ GENERATE_LUMA_UT (LumaEq4H_AArch64_neon, DeblockLumaEq4H_AArch64_neon_wrap, Debl
GENERATE_CHROMA_UT (ChromaLt4V_AArch64_neon, DeblockChromaLt4V_AArch64_neon, DeblockChromaLt4V_c, WELS_CPU_NEON, 0) GENERATE_CHROMA_UT (ChromaLt4V_AArch64_neon, DeblockChromaLt4V_AArch64_neon, DeblockChromaLt4V_c, WELS_CPU_NEON, 0)
GENERATE_CHROMA_UT (ChromaLt4H_AArch64_neon, DeblockChromaLt4H_AArch64_neon, DeblockChromaLt4H_c, WELS_CPU_NEON, 1) GENERATE_CHROMA_UT (ChromaLt4H_AArch64_neon, DeblockChromaLt4H_AArch64_neon, DeblockChromaLt4H_c, WELS_CPU_NEON, 1)
GENERATE_CHROMA_UT (ChromaEq4V_AArch64_neon, DeblockChromaEq4V_AArch64_neon_wrap, DeblockChromaEq4V_c_wrap, WELS_CPU_NEON, 0) GENERATE_CHROMA_UT (ChromaEq4V_AArch64_neon, DeblockChromaEq4V_AArch64_neon_wrap, DeblockChromaEq4V_c_wrap,
GENERATE_CHROMA_UT (ChromaEq4H_AArch64_neon, DeblockChromaEq4H_AArch64_neon_wrap, DeblockChromaEq4H_c_wrap, WELS_CPU_NEON, 1) WELS_CPU_NEON, 0)
GENERATE_CHROMA_UT (ChromaEq4H_AArch64_neon, DeblockChromaEq4H_AArch64_neon_wrap, DeblockChromaEq4H_c_wrap,
WELS_CPU_NEON, 1)
#endif #endif

513
test/encoder/EncUT_DecodeMbAux.cpp
View File

@ -9,156 +9,156 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
TEST(DecodeMbAuxTest, TestIhdm_4x4_dc) { TEST (DecodeMbAuxTest, TestIhdm_4x4_dc) {
short W[16],T[16],Y[16]; short W[16], T[16], Y[16];
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
W[i]=rand()%256+1; W[i] = rand() % 256 + 1;
T[0]=W[0]+W[4]+W[8]+W[12]; T[0] = W[0] + W[4] + W[8] + W[12];
T[1]=W[1]+W[5]+W[9]+W[13]; T[1] = W[1] + W[5] + W[9] + W[13];
T[2]=W[2]+W[6]+W[10]+W[14]; T[2] = W[2] + W[6] + W[10] + W[14];
T[3]=W[3]+W[7]+W[11]+W[15]; T[3] = W[3] + W[7] + W[11] + W[15];
T[4]=W[0]+W[4]-W[8]-W[12]; T[4] = W[0] + W[4] - W[8] - W[12];
T[5]=W[1]+W[5]-W[9]-W[13]; T[5] = W[1] + W[5] - W[9] - W[13];
T[6]=W[2]+W[6]-W[10]-W[14]; T[6] = W[2] + W[6] - W[10] - W[14];
T[7]=W[3]+W[7]-W[11]-W[15]; T[7] = W[3] + W[7] - W[11] - W[15];
T[8]=W[0]-W[4]-W[8]+W[12]; T[8] = W[0] - W[4] - W[8] + W[12];
T[9]=W[1]-W[5]-W[9]+W[13]; T[9] = W[1] - W[5] - W[9] + W[13];
T[10]=W[2]-W[6]-W[10]+W[14]; T[10] = W[2] - W[6] - W[10] + W[14];
T[11]=W[3]-W[7]-W[11]+W[15]; T[11] = W[3] - W[7] - W[11] + W[15];
T[12]=W[0]-W[4]+W[8]-W[12]; T[12] = W[0] - W[4] + W[8] - W[12];
T[13]=W[1]-W[5]+W[9]-W[13]; T[13] = W[1] - W[5] + W[9] - W[13];
T[14]=W[2]-W[6]+W[10]-W[14]; T[14] = W[2] - W[6] + W[10] - W[14];
T[15]=W[3]-W[7]+W[11]-W[15]; T[15] = W[3] - W[7] + W[11] - W[15];
Y[0]=T[0]+T[1]+T[2]+T[3]; Y[0] = T[0] + T[1] + T[2] + T[3];
Y[1]=T[0]+T[1]-T[2]-T[3]; Y[1] = T[0] + T[1] - T[2] - T[3];
Y[2]=T[0]-T[1]-T[2]+T[3]; Y[2] = T[0] - T[1] - T[2] + T[3];
Y[3]=T[0]-T[1]+T[2]-T[3]; Y[3] = T[0] - T[1] + T[2] - T[3];
Y[4]=T[4]+T[5]+T[6]+T[7]; Y[4] = T[4] + T[5] + T[6] + T[7];
Y[5]=T[4]+T[5]-T[6]-T[7]; Y[5] = T[4] + T[5] - T[6] - T[7];
Y[6]=T[4]-T[5]-T[6]+T[7]; Y[6] = T[4] - T[5] - T[6] + T[7];
Y[7]=T[4]-T[5]+T[6]-T[7]; Y[7] = T[4] - T[5] + T[6] - T[7];
Y[8]=T[8]+T[9]+T[10]+T[11]; Y[8] = T[8] + T[9] + T[10] + T[11];
Y[9]=T[8]+T[9]-T[10]-T[11]; Y[9] = T[8] + T[9] - T[10] - T[11];
Y[10]=T[8]-T[9]-T[10]+T[11]; Y[10] = T[8] - T[9] - T[10] + T[11];
Y[11]=T[8]-T[9]+T[10]-T[11]; Y[11] = T[8] - T[9] + T[10] - T[11];
Y[12]=T[12]+T[13]+T[14]+T[15]; Y[12] = T[12] + T[13] + T[14] + T[15];
Y[13]=T[12]+T[13]-T[14]-T[15]; Y[13] = T[12] + T[13] - T[14] - T[15];
Y[14]=T[12]-T[13]-T[14]+T[15]; Y[14] = T[12] - T[13] - T[14] + T[15];
Y[15]=T[12]-T[13]+T[14]-T[15]; Y[15] = T[12] - T[13] + T[14] - T[15];
WelsIHadamard4x4Dc(W); WelsIHadamard4x4Dc (W);
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
EXPECT_EQ( Y[i],W[i] ); EXPECT_EQ (Y[i], W[i]);
} }
TEST(DecodeMbAuxTest, TestDequant_4x4_luma_dc) { TEST (DecodeMbAuxTest, TestDequant_4x4_luma_dc) {
short T[16],W[16]; short T[16], W[16];
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
for (int qp=0; qp<12; qp++) { for (int qp = 0; qp < 12; qp++) {
for(int i=0; i<16; i++) { for (int i = 0; i < 16; i++) {
T[i]=rand()%256+1; T[i] = rand() % 256 + 1;
W[i]=T[i]; W[i] = T[i];
} }
WelsDequantLumaDc4x4(W,qp); WelsDequantLumaDc4x4 (W, qp);
for(int i=0; i<16; i++) { for (int i = 0; i < 16; i++) {
T[i]= (((T[i]*g_kuiDequantCoeff[qp%6][0]+(1 << (1 - qp / 6))))>>(2- qp / 6)); T[i] = (((T[i] * g_kuiDequantCoeff[qp % 6][0] + (1 << (1 - qp / 6)))) >> (2 - qp / 6));
EXPECT_EQ(T[i],W[i]); EXPECT_EQ (T[i], W[i]);
} }
} }
} }
TEST(DecodeMbAuxTest, TestDequant_ihdm_4x4_c) { TEST (DecodeMbAuxTest, TestDequant_ihdm_4x4_c) {
short W[16],T[16],Y[16]; short W[16], T[16], Y[16];
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
const unsigned short mf=rand()%16+1; const unsigned short mf = rand() % 16 + 1;
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
W[i]=rand()%256+1; W[i] = rand() % 256 + 1;
T[0]=W[0]+W[4]+W[8]+W[12]; T[0] = W[0] + W[4] + W[8] + W[12];
T[1]=W[1]+W[5]+W[9]+W[13]; T[1] = W[1] + W[5] + W[9] + W[13];
T[2]=W[2]+W[6]+W[10]+W[14]; T[2] = W[2] + W[6] + W[10] + W[14];
T[3]=W[3]+W[7]+W[11]+W[15]; T[3] = W[3] + W[7] + W[11] + W[15];
T[4]=W[0]+W[4]-W[8]-W[12]; T[4] = W[0] + W[4] - W[8] - W[12];
T[5]=W[1]+W[5]-W[9]-W[13]; T[5] = W[1] + W[5] - W[9] - W[13];
T[6]=W[2]+W[6]-W[10]-W[14]; T[6] = W[2] + W[6] - W[10] - W[14];
T[7]=W[3]+W[7]-W[11]-W[15]; T[7] = W[3] + W[7] - W[11] - W[15];
T[8]=W[0]-W[4]-W[8]+W[12]; T[8] = W[0] - W[4] - W[8] + W[12];
T[9]=W[1]-W[5]-W[9]+W[13]; T[9] = W[1] - W[5] - W[9] + W[13];
T[10]=W[2]-W[6]-W[10]+W[14]; T[10] = W[2] - W[6] - W[10] + W[14];
T[11]=W[3]-W[7]-W[11]+W[15]; T[11] = W[3] - W[7] - W[11] + W[15];
T[12]=W[0]-W[4]+W[8]-W[12]; T[12] = W[0] - W[4] + W[8] - W[12];
T[13]=W[1]-W[5]+W[9]-W[13]; T[13] = W[1] - W[5] + W[9] - W[13];
T[14]=W[2]-W[6]+W[10]-W[14]; T[14] = W[2] - W[6] + W[10] - W[14];
T[15]=W[3]-W[7]+W[11]-W[15]; T[15] = W[3] - W[7] + W[11] - W[15];
Y[0]=(T[0]+T[1]+T[2]+T[3])*mf; Y[0] = (T[0] + T[1] + T[2] + T[3]) * mf;
Y[1]=(T[0]+T[1]-T[2]-T[3])*mf; Y[1] = (T[0] + T[1] - T[2] - T[3]) * mf;
Y[2]=(T[0]-T[1]-T[2]+T[3])*mf; Y[2] = (T[0] - T[1] - T[2] + T[3]) * mf;
Y[3]=(T[0]-T[1]+T[2]-T[3])*mf; Y[3] = (T[0] - T[1] + T[2] - T[3]) * mf;
Y[4]=(T[4]+T[5]+T[6]+T[7])*mf; Y[4] = (T[4] + T[5] + T[6] + T[7]) * mf;
Y[5]=(T[4]+T[5]-T[6]-T[7])*mf; Y[5] = (T[4] + T[5] - T[6] - T[7]) * mf;
Y[6]=(T[4]-T[5]-T[6]+T[7])*mf; Y[6] = (T[4] - T[5] - T[6] + T[7]) * mf;
Y[7]=(T[4]-T[5]+T[6]-T[7])*mf; Y[7] = (T[4] - T[5] + T[6] - T[7]) * mf;
Y[8]=(T[8]+T[9]+T[10]+T[11])*mf; Y[8] = (T[8] + T[9] + T[10] + T[11]) * mf;
Y[9]=(T[8]+T[9]-T[10]-T[11])*mf; Y[9] = (T[8] + T[9] - T[10] - T[11]) * mf;
Y[10]=(T[8]-T[9]-T[10]+T[11])*mf; Y[10] = (T[8] - T[9] - T[10] + T[11]) * mf;
Y[11]=(T[8]-T[9]+T[10]-T[11])*mf; Y[11] = (T[8] - T[9] + T[10] - T[11]) * mf;
Y[12]=(T[12]+T[13]+T[14]+T[15])*mf; Y[12] = (T[12] + T[13] + T[14] + T[15]) * mf;
Y[13]=(T[12]+T[13]-T[14]-T[15])*mf; Y[13] = (T[12] + T[13] - T[14] - T[15]) * mf;
Y[14]=(T[12]-T[13]-T[14]+T[15])*mf; Y[14] = (T[12] - T[13] - T[14] + T[15]) * mf;
Y[15]=(T[12]-T[13]+T[14]-T[15])*mf; Y[15] = (T[12] - T[13] + T[14] - T[15]) * mf;
WelsDequantIHadamard4x4_c(W,mf); WelsDequantIHadamard4x4_c (W, mf);
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
EXPECT_EQ( Y[i],W[i] ); EXPECT_EQ (Y[i], W[i]);
} }
TEST(DecodeMbAuxTest, TestDequant_4x4_c) { TEST (DecodeMbAuxTest, TestDequant_4x4_c) {
short W[16], T[16]; short W[16], T[16];
unsigned short mf[16]; unsigned short mf[16];
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
for(int i=0;i<16;i++) { for (int i = 0; i < 16; i++) {
W[i]=rand()%256+1; W[i] = rand() % 256 + 1;
T[i]=W[i]; T[i] = W[i];
} }
for(int i=0;i<8;i++) for (int i = 0; i < 8; i++)
mf[i]=rand()%16+1; mf[i] = rand() % 16 + 1;
WelsDequant4x4_c(W,mf); WelsDequant4x4_c (W, mf);
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
EXPECT_EQ( T[i]*mf[i%8],W[i] ); EXPECT_EQ (T[i]*mf[i % 8], W[i]);
} }
TEST(DecodeMbAuxTest, TestDequant_4_4x4_c) { TEST (DecodeMbAuxTest, TestDequant_4_4x4_c) {
short W[64], T[64]; short W[64], T[64];
unsigned short mf[16]; unsigned short mf[16];
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
for(int i=0;i<64;i++) { for (int i = 0; i < 64; i++) {
W[i]=rand()%256+1; W[i] = rand() % 256 + 1;
T[i]=W[i]; T[i] = W[i];
} }
for(int i=0;i<8;i++) for (int i = 0; i < 8; i++)
mf[i]=rand()%16+1; mf[i] = rand() % 16 + 1;
WelsDequantFour4x4_c(W,mf); WelsDequantFour4x4_c (W, mf);
for(int i=0;i<64;i++) for (int i = 0; i < 64; i++)
EXPECT_EQ( T[i]*mf[i%8],W[i] ); EXPECT_EQ (T[i]*mf[i % 8], W[i]);
} }
void WelsDequantHadamard2x2DcAnchor( int16_t* pDct, int16_t iMF) { void WelsDequantHadamard2x2DcAnchor (int16_t* pDct, int16_t iMF) {
const int16_t iSumU = pDct[0] + pDct[2]; const int16_t iSumU = pDct[0] + pDct[2];
const int16_t iDelU = pDct[0] - pDct[2]; const int16_t iDelU = pDct[0] - pDct[2];
const int16_t iSumD = pDct[1] + pDct[3]; const int16_t iSumD = pDct[1] + pDct[3];
@ -168,220 +168,223 @@ void WelsDequantHadamard2x2DcAnchor( int16_t* pDct, int16_t iMF) {
pDct[2] = (iDelU + iDelD) * iMF; pDct[2] = (iDelU + iDelD) * iMF;
pDct[3] = (iDelU - iDelD) * iMF; pDct[3] = (iDelU - iDelD) * iMF;
} }
TEST(DecodeMbAuxTest, WelsDequantIHadamard2x2Dc) { TEST (DecodeMbAuxTest, WelsDequantIHadamard2x2Dc) {
int16_t iDct[4], iRefDct[4]; int16_t iDct[4], iRefDct[4];
int16_t iMF; int16_t iMF;
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
iMF = rand() & 127; iMF = rand() & 127;
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
iDct[i] = iRefDct[i] = (rand() & 65535) - 32768; iDct[i] = iRefDct[i] = (rand() & 65535) - 32768;
WelsDequantHadamard2x2DcAnchor(iRefDct, iMF); WelsDequantHadamard2x2DcAnchor (iRefDct, iMF);
WelsDequantIHadamard2x2Dc(iDct, iMF); WelsDequantIHadamard2x2Dc (iDct, iMF);
bool ok = true; bool ok = true;
for(int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if(iDct[i] != iRefDct[i]) { if (iDct[i] != iRefDct[i]) {
ok = false; ok = false;
break; break;
} }
} }
EXPECT_TRUE(ok); EXPECT_TRUE (ok);
} }
#define FDEC_STRIDE 32 #define FDEC_STRIDE 32
void WelsIDctT4Anchor( uint8_t *p_dst, int16_t dct[16] ) { void WelsIDctT4Anchor (uint8_t* p_dst, int16_t dct[16]) {
int16_t tmp[16]; int16_t tmp[16];
int32_t iStridex2 = (FDEC_STRIDE<<1); int32_t iStridex2 = (FDEC_STRIDE << 1);
int32_t iStridex3 = iStridex2 + FDEC_STRIDE; int32_t iStridex3 = iStridex2 + FDEC_STRIDE;
uint8_t uiDst = 0; uint8_t uiDst = 0;
int i; int i;
for( i = 0; i < 4; i++ ) { for (i = 0; i < 4; i++) {
tmp[i<<2] = dct[i<<2] + dct[(i<<2)+1] + dct[(i<<2)+2] + (dct[(i<<2)+3]>>1); tmp[i << 2] = dct[i << 2] + dct[ (i << 2) + 1] + dct[ (i << 2) + 2] + (dct[ (i << 2) + 3] >> 1);
tmp[(i<<2)+1] = dct[i<<2] + (dct[(i<<2)+1]>>1) - dct[(i<<2)+2] - dct[(i<<2)+3]; tmp[ (i << 2) + 1] = dct[i << 2] + (dct[ (i << 2) + 1] >> 1) - dct[ (i << 2) + 2] - dct[ (i << 2) + 3];
tmp[(i<<2)+2] = dct[i<<2] - (dct[(i<<2)+1]>>1) - dct[(i<<2)+2] + dct[(i<<2)+3]; tmp[ (i << 2) + 2] = dct[i << 2] - (dct[ (i << 2) + 1] >> 1) - dct[ (i << 2) + 2] + dct[ (i << 2) + 3];
tmp[(i<<2)+3] = dct[i<<2] - dct[(i<<2)+1] + dct[(i<<2)+2] - (dct[(i<<2)+3]>>1); tmp[ (i << 2) + 3] = dct[i << 2] - dct[ (i << 2) + 1] + dct[ (i << 2) + 2] - (dct[ (i << 2) + 3] >> 1);
} }
for( i = 0; i < 4; i++ ) { for (i = 0; i < 4; i++) {
uiDst = p_dst[i]; uiDst = p_dst[i];
p_dst[i] = WelsClip1(uiDst + ((tmp[i]+tmp[4+i]+ tmp[8+i]+(tmp[12+i]>>1)+32)>>6)); p_dst[i] = WelsClip1 (uiDst + ((tmp[i] + tmp[4 + i] + tmp[8 + i] + (tmp[12 + i] >> 1) + 32) >> 6));
uiDst = p_dst[i+FDEC_STRIDE]; uiDst = p_dst[i + FDEC_STRIDE];
p_dst[i+FDEC_STRIDE] = WelsClip1(uiDst + ((tmp[i]+(tmp[4+i]>>1)-tmp[8+i]-tmp[12+i]+32) >>6)); p_dst[i + FDEC_STRIDE] = WelsClip1 (uiDst + ((tmp[i] + (tmp[4 + i] >> 1) - tmp[8 + i] - tmp[12 + i] + 32) >> 6));
uiDst = p_dst[i+iStridex2]; uiDst = p_dst[i + iStridex2];
p_dst[i+iStridex2] = WelsClip1(uiDst + ((tmp[i]-(tmp[4+i]>>1)-tmp[8+i]+tmp[12+i]+32) >>6)); p_dst[i + iStridex2] = WelsClip1 (uiDst + ((tmp[i] - (tmp[4 + i] >> 1) - tmp[8 + i] + tmp[12 + i] + 32) >> 6));
uiDst = p_dst[i+iStridex3]; uiDst = p_dst[i + iStridex3];
p_dst[i+iStridex3] = WelsClip1(uiDst + ((tmp[i]-tmp[4+i]+ tmp[8+i]-(tmp[12+i]>>1)+32)>>6)); p_dst[i + iStridex3] = WelsClip1 (uiDst + ((tmp[i] - tmp[4 + i] + tmp[8 + i] - (tmp[12 + i] >> 1) + 32) >> 6));
} }
} }
TEST(DecodeMbAuxTest, WelsIDctT4Rec_c) { TEST (DecodeMbAuxTest, WelsIDctT4Rec_c) {
int16_t iRefDct[16]; uint8_t iRefDst[16*FDEC_STRIDE]; int16_t iRefDct[16];
ENFORCE_STACK_ALIGN_1D(int16_t, iDct, 16, 16); uint8_t iRefDst[16 * FDEC_STRIDE];
ENFORCE_STACK_ALIGN_1D(uint8_t, iPred, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (int16_t, iDct, 16, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRec, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iPred, 16 * FDEC_STRIDE, 16);
srand((unsigned int)time(NULL)); ENFORCE_STACK_ALIGN_1D (uint8_t, iRec, 16 * FDEC_STRIDE, 16);
for(int i = 0; i < 4; i++) { srand ((unsigned int)time (NULL));
for(int j = 0; j < 4; j++) { for (int i = 0; i < 4; i++) {
iRefDct[i*4+j] = iDct[i*4+j] = (rand() & 65535) - 32768; for (int j = 0; j < 4; j++) {
iPred[i*FDEC_STRIDE+j] = iRefDst[i*FDEC_STRIDE+j] = rand() & 255; iRefDct[i * 4 + j] = iDct[i * 4 + j] = (rand() & 65535) - 32768;
iPred[i * FDEC_STRIDE + j] = iRefDst[i * FDEC_STRIDE + j] = rand() & 255;
} }
} }
WelsIDctT4Anchor(iRefDst, iRefDct); WelsIDctT4Anchor (iRefDst, iRefDct);
WelsIDctT4Rec_c(iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctT4Rec_c (iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
int ok = -1; int ok = -1;
for(int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
for(int j = 0; j < 4; j++) { for (int j = 0; j < 4; j++) {
if(iRec[i*FDEC_STRIDE+j] != iRefDst[i*FDEC_STRIDE+j]) { if (iRec[i * FDEC_STRIDE + j] != iRefDst[i * FDEC_STRIDE + j]) {
ok = i*4+j; ok = i * 4 + j;
break; break;
} }
} }
} }
EXPECT_EQ(ok, -1); EXPECT_EQ (ok, -1);
} }
#if defined(X86_ASM) #if defined(X86_ASM)
TEST(DecodeMbAuxTest, WelsIDctT4Rec_mmx) { TEST (DecodeMbAuxTest, WelsIDctT4Rec_mmx) {
int32_t iCpuCores = 0; int32_t iCpuCores = 0;
uint32_t uiCpuFeatureFlag = WelsCPUFeatureDetect(&iCpuCores); uint32_t uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
if(uiCpuFeatureFlag & WELS_CPU_MMXEXT) { if (uiCpuFeatureFlag & WELS_CPU_MMXEXT) {
ENFORCE_STACK_ALIGN_1D(int16_t, iDct, 16, 16); ENFORCE_STACK_ALIGN_1D (int16_t, iDct, 16, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iPred, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iPred, 16 * FDEC_STRIDE, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRecC, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iRecC, 16 * FDEC_STRIDE, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRecM, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iRecM, 16 * FDEC_STRIDE, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
for(int j = 0; j < 4; j++) { for (int j = 0; j < 4; j++) {
iDct[i*4+j] = (rand() & ((1 << 12)-1)) - (1 << 11); iDct[i * 4 + j] = (rand() & ((1 << 12) - 1)) - (1 << 11);
iPred[i*FDEC_STRIDE+j] = rand() & 255; iPred[i * FDEC_STRIDE + j] = rand() & 255;
} }
} }
WelsIDctT4Rec_c(iRecC, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctT4Rec_c (iRecC, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
WelsIDctT4Rec_mmx(iRecM, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctT4Rec_mmx (iRecM, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
int ok = -1; int ok = -1;
for(int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
for(int j = 0; j < 4; j++) { for (int j = 0; j < 4; j++) {
if(iRecC[i*FDEC_STRIDE+j] != iRecM[i*FDEC_STRIDE+j]) { if (iRecC[i * FDEC_STRIDE + j] != iRecM[i * FDEC_STRIDE + j]) {
ok = i*4+j; ok = i * 4 + j;
break; break;
} }
} }
} }
EXPECT_EQ(ok, -1); EXPECT_EQ (ok, -1);
} }
} }
#endif #endif
void WelsIDctT8Anchor( uint8_t *p_dst, int16_t dct[4][16] ) { void WelsIDctT8Anchor (uint8_t* p_dst, int16_t dct[4][16]) {
WelsIDctT4Anchor( &p_dst[0], dct[0] ); WelsIDctT4Anchor (&p_dst[0], dct[0]);
WelsIDctT4Anchor( &p_dst[4], dct[1] ); WelsIDctT4Anchor (&p_dst[4], dct[1]);
WelsIDctT4Anchor( &p_dst[4*FDEC_STRIDE+0], dct[2] ); WelsIDctT4Anchor (&p_dst[4 * FDEC_STRIDE + 0], dct[2]);
WelsIDctT4Anchor( &p_dst[4*FDEC_STRIDE+4], dct[3] ); WelsIDctT4Anchor (&p_dst[4 * FDEC_STRIDE + 4], dct[3]);
} }
TEST(DecodeMbAuxTest, WelsIDctFourT4Rec_c) { TEST (DecodeMbAuxTest, WelsIDctFourT4Rec_c) {
int16_t iRefDct[4][16]; uint8_t iRefDst[16*FDEC_STRIDE]; int16_t iRefDct[4][16];
ENFORCE_STACK_ALIGN_1D(int16_t, iDct, 64, 16); uint8_t iRefDst[16 * FDEC_STRIDE];
ENFORCE_STACK_ALIGN_1D(uint8_t, iPred, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (int16_t, iDct, 64, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRec, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iPred, 16 * FDEC_STRIDE, 16);
srand((unsigned int)time(NULL)); ENFORCE_STACK_ALIGN_1D (uint8_t, iRec, 16 * FDEC_STRIDE, 16);
for(int k = 0; k < 4; k++) srand ((unsigned int)time (NULL));
for(int i = 0; i < 16; i++) for (int k = 0; k < 4; k++)
iRefDct[k][i] = iDct[k*16+i] = (rand() & 65535) - 32768; for (int i = 0; i < 16; i++)
iRefDct[k][i] = iDct[k * 16 + i] = (rand() & 65535) - 32768;
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
for(int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
iPred[i*FDEC_STRIDE+j] = iRefDst[i*FDEC_STRIDE+j] = rand() & 255; iPred[i * FDEC_STRIDE + j] = iRefDst[i * FDEC_STRIDE + j] = rand() & 255;
WelsIDctT8Anchor(iRefDst, iRefDct); WelsIDctT8Anchor (iRefDst, iRefDct);
WelsIDctFourT4Rec_c(iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctFourT4Rec_c (iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
int ok = -1; int ok = -1;
for(int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
for(int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
if(iRec[i*FDEC_STRIDE+j] != iRefDst[i*FDEC_STRIDE+j]) { if (iRec[i * FDEC_STRIDE + j] != iRefDst[i * FDEC_STRIDE + j]) {
ok = i*8+j; ok = i * 8 + j;
break; break;
} }
} }
} }
EXPECT_EQ(ok, -1); EXPECT_EQ (ok, -1);
} }
void WelsIDctRecI16x4DcAnchor( uint8_t *p_dst, int16_t dct[4] ) { void WelsIDctRecI16x4DcAnchor (uint8_t* p_dst, int16_t dct[4]) {
for(int i = 0; i < 4; i++, p_dst += FDEC_STRIDE) { for (int i = 0; i < 4; i++, p_dst += FDEC_STRIDE) {
p_dst[0] = WelsClip1(p_dst[0] + ((dct[0]+32)>>6)); p_dst[0] = WelsClip1 (p_dst[0] + ((dct[0] + 32) >> 6));
p_dst[1] = WelsClip1(p_dst[1] + ((dct[0]+32)>>6)); p_dst[1] = WelsClip1 (p_dst[1] + ((dct[0] + 32) >> 6));
p_dst[2] = WelsClip1(p_dst[2] + ((dct[0]+32)>>6)); p_dst[2] = WelsClip1 (p_dst[2] + ((dct[0] + 32) >> 6));
p_dst[3] = WelsClip1(p_dst[3] + ((dct[0]+32)>>6)); p_dst[3] = WelsClip1 (p_dst[3] + ((dct[0] + 32) >> 6));
p_dst[4] = WelsClip1(p_dst[4] + ((dct[1]+32)>>6)); p_dst[4] = WelsClip1 (p_dst[4] + ((dct[1] + 32) >> 6));
p_dst[5] = WelsClip1(p_dst[5] + ((dct[1]+32)>>6)); p_dst[5] = WelsClip1 (p_dst[5] + ((dct[1] + 32) >> 6));
p_dst[6] = WelsClip1(p_dst[6] + ((dct[1]+32)>>6)); p_dst[6] = WelsClip1 (p_dst[6] + ((dct[1] + 32) >> 6));
p_dst[7] = WelsClip1(p_dst[7] + ((dct[1]+32)>>6)); p_dst[7] = WelsClip1 (p_dst[7] + ((dct[1] + 32) >> 6));
p_dst[8] = WelsClip1(p_dst[8] + ((dct[2]+32)>>6)); p_dst[8] = WelsClip1 (p_dst[8] + ((dct[2] + 32) >> 6));
p_dst[9] = WelsClip1(p_dst[9] + ((dct[2]+32)>>6)); p_dst[9] = WelsClip1 (p_dst[9] + ((dct[2] + 32) >> 6));
p_dst[10] = WelsClip1(p_dst[10] + ((dct[2]+32)>>6)); p_dst[10] = WelsClip1 (p_dst[10] + ((dct[2] + 32) >> 6));
p_dst[11] = WelsClip1(p_dst[11] + ((dct[2]+32)>>6)); p_dst[11] = WelsClip1 (p_dst[11] + ((dct[2] + 32) >> 6));
p_dst[12] = WelsClip1(p_dst[12] + ((dct[3]+32)>>6)); p_dst[12] = WelsClip1 (p_dst[12] + ((dct[3] + 32) >> 6));
p_dst[13] = WelsClip1(p_dst[13] + ((dct[3]+32)>>6)); p_dst[13] = WelsClip1 (p_dst[13] + ((dct[3] + 32) >> 6));
p_dst[14] = WelsClip1(p_dst[14] + ((dct[3]+32)>>6)); p_dst[14] = WelsClip1 (p_dst[14] + ((dct[3] + 32) >> 6));
p_dst[15] = WelsClip1(p_dst[15] + ((dct[3]+32)>>6)); p_dst[15] = WelsClip1 (p_dst[15] + ((dct[3] + 32) >> 6));
} }
} }
void WelsIDctRecI16x16DcAnchor( uint8_t *p_dst, int16_t dct[4][4] ) { void WelsIDctRecI16x16DcAnchor (uint8_t* p_dst, int16_t dct[4][4]) {
for( int i = 0; i < 4; i++, p_dst += 4*FDEC_STRIDE ) for (int i = 0; i < 4; i++, p_dst += 4 * FDEC_STRIDE)
WelsIDctRecI16x4DcAnchor(&p_dst[0], dct[i]); WelsIDctRecI16x4DcAnchor (&p_dst[0], dct[i]);
} }
TEST(DecodeMbAuxTest, WelsIDctRecI16x16Dc_c) { TEST (DecodeMbAuxTest, WelsIDctRecI16x16Dc_c) {
uint8_t iRefDst[16*FDEC_STRIDE]; uint8_t iRefDst[16 * FDEC_STRIDE];
int16_t iRefDct[4][4]; int16_t iRefDct[4][4];
ENFORCE_STACK_ALIGN_1D(int16_t, iDct, 16, 16); ENFORCE_STACK_ALIGN_1D (int16_t, iDct, 16, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iPred, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iPred, 16 * FDEC_STRIDE, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRec, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iRec, 16 * FDEC_STRIDE, 16);
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
for(int j = 0; j < 16; j++) for (int j = 0; j < 16; j++)
iRefDst[i*FDEC_STRIDE+j] = iPred[i*FDEC_STRIDE+j] = rand() & 255; iRefDst[i * FDEC_STRIDE + j] = iPred[i * FDEC_STRIDE + j] = rand() & 255;
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
iRefDct[i][j] = iDct[i*4+j] = (rand() & 65535) - 32768; iRefDct[i][j] = iDct[i * 4 + j] = (rand() & 65535) - 32768;
WelsIDctRecI16x16DcAnchor(iRefDst, iRefDct); WelsIDctRecI16x16DcAnchor (iRefDst, iRefDct);
WelsIDctRecI16x16Dc_c(iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctRecI16x16Dc_c (iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
int ok = -1; int ok = -1;
for(int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
for(int j = 0; j < 16; j++) { for (int j = 0; j < 16; j++) {
if(iRec[i*FDEC_STRIDE+j] != iRefDst[i*FDEC_STRIDE+j]) { if (iRec[i * FDEC_STRIDE + j] != iRefDst[i * FDEC_STRIDE + j]) {
ok = i*16+j; ok = i * 16 + j;
break; break;
} }
} }
} }
EXPECT_EQ(ok, -1); EXPECT_EQ (ok, -1);
} }
#if defined(X86_ASM) #if defined(X86_ASM)
TEST(DecodeMbAuxTest, WelsIDctRecI16x16Dc_sse2) { TEST (DecodeMbAuxTest, WelsIDctRecI16x16Dc_sse2) {
int32_t iCpuCores = 0; int32_t iCpuCores = 0;
uint32_t uiCpuFeatureFlag = WelsCPUFeatureDetect(&iCpuCores); uint32_t uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
if(uiCpuFeatureFlag & WELS_CPU_SSE2) { if (uiCpuFeatureFlag & WELS_CPU_SSE2) {
uint8_t iRefDst[16*FDEC_STRIDE]; uint8_t iRefDst[16 * FDEC_STRIDE];
int16_t iRefDct[4][4]; int16_t iRefDct[4][4];
ENFORCE_STACK_ALIGN_1D(int16_t, iDct, 16, 16); ENFORCE_STACK_ALIGN_1D (int16_t, iDct, 16, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iPred, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iPred, 16 * FDEC_STRIDE, 16);
ENFORCE_STACK_ALIGN_1D(uint8_t, iRec, 16*FDEC_STRIDE, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, iRec, 16 * FDEC_STRIDE, 16);
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
for(int j = 0; j < 16; j++) for (int j = 0; j < 16; j++)
iRefDst[i*FDEC_STRIDE+j] = iPred[i*FDEC_STRIDE+j] = rand() & 255; iRefDst[i * FDEC_STRIDE + j] = iPred[i * FDEC_STRIDE + j] = rand() & 255;
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
iRefDct[i][j] = iDct[i*4+j] = (rand() & ((1<<15)-1)) - (1<<14); //2^14 limit, (2^15+32) will cause overflow for SSE2. iRefDct[i][j] = iDct[i * 4 + j] = (rand() & ((1 << 15) - 1)) - (1 <<
WelsIDctRecI16x16DcAnchor(iRefDst, iRefDct); 14); //2^14 limit, (2^15+32) will cause overflow for SSE2.
WelsIDctRecI16x16Dc_sse2(iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct); WelsIDctRecI16x16DcAnchor (iRefDst, iRefDct);
WelsIDctRecI16x16Dc_sse2 (iRec, FDEC_STRIDE, iPred, FDEC_STRIDE, iDct);
int ok = -1; int ok = -1;
for(int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
for(int j = 0; j < 16; j++) { for (int j = 0; j < 16; j++) {
if(iRec[i*FDEC_STRIDE+j] != iRefDst[i*FDEC_STRIDE+j]) { if (iRec[i * FDEC_STRIDE + j] != iRefDst[i * FDEC_STRIDE + j]) {
ok = i*16+j; ok = i * 16 + j;
break; break;
} }
} }
} }
EXPECT_EQ(ok, -1); EXPECT_EQ (ok, -1);
} }
} }
#endif #endif

298
test/encoder/EncUT_EncoderMb.cpp
View File

@ -6,195 +6,195 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
#include "encode_mb_aux.h" #include "encode_mb_aux.h"
__align16( const int16_t, g_kiQuantInterFFCompare[104][8] ) = { __align16 (const int16_t, g_kiQuantInterFFCompare[104][8]) = {
/* 0*/ { 0, 1, 0, 1, 1, 1, 1, 1 }, /* 0*/ { 0, 1, 0, 1, 1, 1, 1, 1 },
/* 1*/ { 0, 1, 0, 1, 1, 1, 1, 1 }, /* 1*/ { 0, 1, 0, 1, 1, 1, 1, 1 },
/* 2*/ { 1, 1, 1, 1, 1, 1, 1, 1 }, /* 2*/ { 1, 1, 1, 1, 1, 1, 1, 1 },
/* 3*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 3*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 4*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 4*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 5*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 5*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 6*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 6*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 7*/ { 1, 2, 1, 2, 2, 2, 2, 2 }, /* 7*/ { 1, 2, 1, 2, 2, 2, 2, 2 },
/* 8*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /* 8*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/* 9*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /* 9*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/*10*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /*10*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/*11*/ { 2, 2, 2, 2, 2, 4, 2, 4 }, /*11*/ { 2, 2, 2, 2, 2, 4, 2, 4 },
/*12*/ { 2, 3, 2, 3, 3, 4, 3, 4 }, /*12*/ { 2, 3, 2, 3, 3, 4, 3, 4 },
/*13*/ { 2, 3, 2, 3, 3, 5, 3, 5 }, /*13*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
/*14*/ { 2, 3, 2, 3, 3, 5, 3, 5 }, /*14*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
/*15*/ { 2, 4, 2, 4, 4, 6, 4, 6 }, /*15*/ { 2, 4, 2, 4, 4, 6, 4, 6 },
/*16*/ { 3, 4, 3, 4, 4, 7, 4, 7 }, /*16*/ { 3, 4, 3, 4, 4, 7, 4, 7 },
/*17*/ { 3, 5, 3, 5, 5, 8, 5, 8 }, /*17*/ { 3, 5, 3, 5, 5, 8, 5, 8 },
/*18*/ { 3, 6, 3, 6, 6, 9, 6, 9 }, /*18*/ { 3, 6, 3, 6, 6, 9, 6, 9 },
/*19*/ { 4, 6, 4, 6, 6, 10, 6, 10 }, /*19*/ { 4, 6, 4, 6, 6, 10, 6, 10 },
/*20*/ { 4, 7, 4, 7, 7, 11, 7, 11 }, /*20*/ { 4, 7, 4, 7, 7, 11, 7, 11 },
/*21*/ { 5, 8, 5, 8, 8, 12, 8, 12 }, /*21*/ { 5, 8, 5, 8, 8, 12, 8, 12 },
/*22*/ { 6, 9, 6, 9, 9, 13, 9, 13 }, /*22*/ { 6, 9, 6, 9, 9, 13, 9, 13 },
/*23*/ { 6, 10, 6, 10, 10, 16, 10, 16 }, /*23*/ { 6, 10, 6, 10, 10, 16, 10, 16 },
/*24*/ { 7, 11, 7, 11, 11, 17, 11, 17 }, /*24*/ { 7, 11, 7, 11, 11, 17, 11, 17 },
/*25*/ { 8, 12, 8, 12, 12, 19, 12, 19 }, /*25*/ { 8, 12, 8, 12, 12, 19, 12, 19 },
/*26*/ { 9, 14, 9, 14, 14, 21, 14, 21 }, /*26*/ { 9, 14, 9, 14, 14, 21, 14, 21 },
/*27*/ { 10, 15, 10, 15, 15, 25, 15, 25 }, /*27*/ { 10, 15, 10, 15, 15, 25, 15, 25 },
/*28*/ { 11, 17, 11, 17, 17, 27, 17, 27 }, /*28*/ { 11, 17, 11, 17, 17, 27, 17, 27 },
/*29*/ { 12, 20, 12, 20, 20, 31, 20, 31 }, /*29*/ { 12, 20, 12, 20, 20, 31, 20, 31 },
/*30*/ { 14, 22, 14, 22, 22, 34, 22, 34 }, /*30*/ { 14, 22, 14, 22, 22, 34, 22, 34 },
/*31*/ { 15, 24, 15, 24, 24, 39, 24, 39 }, /*31*/ { 15, 24, 15, 24, 24, 39, 24, 39 },
/*32*/ { 18, 27, 18, 27, 27, 43, 27, 43 }, /*32*/ { 18, 27, 18, 27, 27, 43, 27, 43 },
/*33*/ { 19, 31, 19, 31, 31, 49, 31, 49 }, /*33*/ { 19, 31, 19, 31, 31, 49, 31, 49 },
/*34*/ { 22, 34, 22, 34, 34, 54, 34, 54 }, /*34*/ { 22, 34, 22, 34, 34, 54, 34, 54 },
/*35*/ { 25, 40, 25, 40, 40, 62, 40, 62 }, /*35*/ { 25, 40, 25, 40, 40, 62, 40, 62 },
/*36*/ { 27, 45, 27, 45, 45, 69, 45, 69 }, /*36*/ { 27, 45, 27, 45, 45, 69, 45, 69 },
/*37*/ { 30, 48, 30, 48, 48, 77, 48, 77 }, /*37*/ { 30, 48, 30, 48, 48, 77, 48, 77 },
/*38*/ { 36, 55, 36, 55, 55, 86, 55, 86 }, /*38*/ { 36, 55, 36, 55, 55, 86, 55, 86 },
/*39*/ { 38, 62, 38, 62, 62, 99, 62, 99 }, /*39*/ { 38, 62, 38, 62, 62, 99, 62, 99 },
/*40*/ { 44, 69, 44, 69, 69, 107, 69, 107 }, /*40*/ { 44, 69, 44, 69, 69, 107, 69, 107 },
/*41*/ { 49, 79, 49, 79, 79, 125, 79, 125 }, /*41*/ { 49, 79, 49, 79, 79, 125, 79, 125 },
/*42*/ { 55, 89, 55, 89, 89, 137, 89, 137 }, /*42*/ { 55, 89, 55, 89, 89, 137, 89, 137 },
/*43*/ { 61, 96, 61, 96, 96, 154, 96, 154 }, /*43*/ { 61, 96, 61, 96, 96, 154, 96, 154 },
/*44*/ { 71, 110, 71, 110, 110, 171, 110, 171 }, /*44*/ { 71, 110, 71, 110, 110, 171, 110, 171 },
/*45*/ { 77, 124, 77, 124, 124, 198, 124, 198 }, /*45*/ { 77, 124, 77, 124, 124, 198, 124, 198 },
/*46*/ { 88, 137, 88, 137, 137, 217, 137, 217 }, /*46*/ { 88, 137, 88, 137, 137, 217, 137, 217 },
/*47*/ { 99, 159, 99, 159, 159, 250, 159, 250 }, /*47*/ { 99, 159, 99, 159, 159, 250, 159, 250 },
/*48*/ { 110, 179, 110, 179, 179, 275, 179, 275 }, /*48*/ { 110, 179, 110, 179, 179, 275, 179, 275 },
/*49*/ { 121, 191, 121, 191, 191, 313, 191, 313 }, /*49*/ { 121, 191, 121, 191, 191, 313, 191, 313 },
/*50*/ { 143, 221, 143, 221, 221, 341, 221, 341 }, /*50*/ { 143, 221, 143, 221, 221, 341, 221, 341 },
/*51*/ { 154, 245, 154, 245, 245, 402, 245, 402 }, /*51*/ { 154, 245, 154, 245, 245, 402, 245, 402 },
//from here below is intra //from here below is intra
/* 0*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 0*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 1*/ { 1, 1, 1, 1, 1, 2, 1, 2 }, /* 1*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
/* 2*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /* 2*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/* 3*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /* 3*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/* 4*/ { 1, 2, 1, 2, 2, 3, 2, 3 }, /* 4*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
/* 5*/ { 1, 2, 1, 2, 2, 4, 2, 4 }, /* 5*/ { 1, 2, 1, 2, 2, 4, 2, 4 },
/* 6*/ { 2, 3, 2, 3, 3, 4, 3, 4 }, /* 6*/ { 2, 3, 2, 3, 3, 4, 3, 4 },
/* 7*/ { 2, 3, 2, 3, 3, 5, 3, 5 }, /* 7*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
/* 8*/ { 2, 3, 2, 3, 3, 5, 3, 5 }, /* 8*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
/* 9*/ { 2, 4, 2, 4, 4, 6, 4, 6 }, /* 9*/ { 2, 4, 2, 4, 4, 6, 4, 6 },
/*10*/ { 3, 4, 3, 4, 4, 6, 4, 6 }, /*10*/ { 3, 4, 3, 4, 4, 6, 4, 6 },
/*11*/ { 3, 5, 3, 5, 5, 7, 5, 7 }, /*11*/ { 3, 5, 3, 5, 5, 7, 5, 7 },
/*12*/ { 3, 5, 3, 5, 5, 8, 5, 8 }, /*12*/ { 3, 5, 3, 5, 5, 8, 5, 8 },
/*13*/ { 4, 6, 4, 6, 6, 9, 6, 9 }, /*13*/ { 4, 6, 4, 6, 6, 9, 6, 9 },
/*14*/ { 4, 7, 4, 7, 7, 10, 7, 10 }, /*14*/ { 4, 7, 4, 7, 7, 10, 7, 10 },
/*15*/ { 5, 7, 5, 7, 7, 12, 7, 12 }, /*15*/ { 5, 7, 5, 7, 7, 12, 7, 12 },
/*16*/ { 5, 8, 5, 8, 8, 13, 8, 13 }, /*16*/ { 5, 8, 5, 8, 8, 13, 8, 13 },
/*17*/ { 6, 9, 6, 9, 9, 15, 9, 15 }, /*17*/ { 6, 9, 6, 9, 9, 15, 9, 15 },
/*18*/ { 7, 11, 7, 11, 11, 16, 11, 16 }, /*18*/ { 7, 11, 7, 11, 11, 16, 11, 16 },
/*19*/ { 7, 11, 7, 11, 11, 18, 11, 18 }, /*19*/ { 7, 11, 7, 11, 11, 18, 11, 18 },
/*20*/ { 9, 13, 9, 13, 13, 20, 13, 20 }, /*20*/ { 9, 13, 9, 13, 13, 20, 13, 20 },
/*21*/ { 9, 15, 9, 15, 15, 24, 15, 24 }, /*21*/ { 9, 15, 9, 15, 15, 24, 15, 24 },
/*22*/ { 11, 16, 11, 16, 16, 26, 16, 26 }, /*22*/ { 11, 16, 11, 16, 16, 26, 16, 26 },
/*23*/ { 12, 19, 12, 19, 19, 30, 19, 30 }, /*23*/ { 12, 19, 12, 19, 19, 30, 19, 30 },
/*24*/ { 13, 21, 13, 21, 21, 33, 21, 33 }, /*24*/ { 13, 21, 13, 21, 21, 33, 21, 33 },
/*25*/ { 14, 23, 14, 23, 23, 37, 23, 37 }, /*25*/ { 14, 23, 14, 23, 23, 37, 23, 37 },
/*26*/ { 17, 26, 17, 26, 26, 41, 26, 41 }, /*26*/ { 17, 26, 17, 26, 26, 41, 26, 41 },
/*27*/ { 18, 30, 18, 30, 30, 47, 30, 47 }, /*27*/ { 18, 30, 18, 30, 30, 47, 30, 47 },
/*28*/ { 21, 33, 21, 33, 33, 51, 33, 51 }, /*28*/ { 21, 33, 21, 33, 33, 51, 33, 51 },
/*29*/ { 24, 38, 24, 38, 38, 59, 38, 59 }, /*29*/ { 24, 38, 24, 38, 38, 59, 38, 59 },
/*30*/ { 26, 43, 26, 43, 43, 66, 43, 66 }, /*30*/ { 26, 43, 26, 43, 43, 66, 43, 66 },
/*31*/ { 29, 46, 29, 46, 46, 74, 46, 74 }, /*31*/ { 29, 46, 29, 46, 46, 74, 46, 74 },
/*32*/ { 34, 52, 34, 52, 52, 82, 52, 82 }, /*32*/ { 34, 52, 34, 52, 52, 82, 52, 82 },
/*33*/ { 37, 59, 37, 59, 59, 94, 59, 94 }, /*33*/ { 37, 59, 37, 59, 59, 94, 59, 94 },
/*34*/ { 42, 66, 42, 66, 66, 102, 66, 102 }, /*34*/ { 42, 66, 42, 66, 66, 102, 66, 102 },
/*35*/ { 47, 75, 47, 75, 75, 119, 75, 119 }, /*35*/ { 47, 75, 47, 75, 75, 119, 75, 119 },
/*36*/ { 52, 85, 52, 85, 85, 131, 85, 131 }, /*36*/ { 52, 85, 52, 85, 85, 131, 85, 131 },
/*37*/ { 58, 92, 58, 92, 92, 147, 92, 147 }, /*37*/ { 58, 92, 58, 92, 92, 147, 92, 147 },
/*38*/ { 68, 105, 68, 105, 105, 164, 105, 164 }, /*38*/ { 68, 105, 68, 105, 105, 164, 105, 164 },
/*39*/ { 73, 118, 73, 118, 118, 189, 118, 189 }, /*39*/ { 73, 118, 73, 118, 118, 189, 118, 189 },
/*40*/ { 84, 131, 84, 131, 131, 205, 131, 205 }, /*40*/ { 84, 131, 84, 131, 131, 205, 131, 205 },
/*41*/ { 94, 151, 94, 151, 151, 239, 151, 239 }, /*41*/ { 94, 151, 94, 151, 151, 239, 151, 239 },
/*42*/ { 105, 171, 105, 171, 171, 262, 171, 262 }, /*42*/ { 105, 171, 105, 171, 171, 262, 171, 262 },
/*43*/ { 116, 184, 116, 184, 184, 295, 184, 295 }, /*43*/ { 116, 184, 116, 184, 184, 295, 184, 295 },
/*44*/ { 136, 211, 136, 211, 211, 326, 211, 326 }, /*44*/ { 136, 211, 136, 211, 211, 326, 211, 326 },
/*45*/ { 147, 236, 147, 236, 236, 377, 236, 377 }, /*45*/ { 147, 236, 147, 236, 236, 377, 236, 377 },
/*46*/ { 168, 262, 168, 262, 262, 414, 262, 414 }, /*46*/ { 168, 262, 168, 262, 262, 414, 262, 414 },
/*47*/ { 189, 303, 189, 303, 303, 478, 303, 478 }, /*47*/ { 189, 303, 189, 303, 303, 478, 303, 478 },
/*48*/ { 211, 341, 211, 341, 341, 524, 341, 524 }, /*48*/ { 211, 341, 211, 341, 341, 524, 341, 524 },
/*49*/ { 231, 364, 231, 364, 364, 597, 364, 597 }, /*49*/ { 231, 364, 231, 364, 364, 597, 364, 597 },
/*50*/ { 272, 422, 272, 422, 422, 652, 422, 652 }, /*50*/ { 272, 422, 272, 422, 422, 652, 422, 652 },
/*51*/ { 295, 467, 295, 467, 467, 768, 467, 768 } /*51*/ { 295, 467, 295, 467, 467, 768, 467, 768 }
}; };
#define ThValue 2 #define ThValue 2
void TestQuant(uint32_t qp,uint8_t *pSrc,uint8_t *pPred,int16_t *pDct, void TestQuant (uint32_t qp, uint8_t* pSrc, uint8_t* pPred, int16_t* pDct,
int16_t *pDctCompare,int16_t iWidth,int16_t iHeight) { int16_t* pDctCompare, int16_t iWidth, int16_t iHeight) {
const int16_t *pMf = g_kiQuantMF[qp]; const int16_t* pMf = g_kiQuantMF[qp];
const int16_t *pFfCompareI = g_kiQuantInterFFCompare[52 + qp]; const int16_t* pFfCompareI = g_kiQuantInterFFCompare[52 + qp];
const int16_t *pFfCompareP = g_kiQuantInterFFCompare[qp]; const int16_t* pFfCompareP = g_kiQuantInterFFCompare[qp];
const int16_t *pFfI = g_kiQuantInterFF[6 + qp]; const int16_t* pFfI = g_kiQuantInterFF[6 + qp];
const int16_t *pFfP = g_kiQuantInterFF[qp]; const int16_t* pFfP = g_kiQuantInterFF[qp];
//quant4x4 Intra MB //quant4x4 Intra MB
RandomPixelDataGenerator(pSrc,iWidth,iHeight,iWidth,0); RandomPixelDataGenerator (pSrc, iWidth, iHeight, iWidth, 0);
RandomPixelDataGenerator(pPred,iWidth,iHeight,iWidth,rand()); RandomPixelDataGenerator (pPred, iWidth, iHeight, iWidth, rand());
for (int16_t i = 0; i<16; i++) { for (int16_t i = 0; i < 16; i++) {
pDct[i] = pSrc[i] - pPred[i]; pDct[i] = pSrc[i] - pPred[i];
pDctCompare[i] = pSrc[i] - pPred[i]; pDctCompare[i] = pSrc[i] - pPred[i];
} }
WelsQuant4x4_c(pDct,pFfI,pMf); WelsQuant4x4_c (pDct, pFfI, pMf);
WelsQuant4x4_c(pDctCompare,pFfCompareI,pMf); WelsQuant4x4_c (pDctCompare, pFfCompareI, pMf);
for (int16_t i = 0;i<16;i++) { for (int16_t i = 0; i < 16; i++) {
int16_t iDeta =WELS_ABS(pDct[i] - pDctCompare[i]); int16_t iDeta = WELS_ABS (pDct[i] - pDctCompare[i]);
iDeta = (iDeta < ThValue) ? 0 : iDeta; iDeta = (iDeta < ThValue) ? 0 : iDeta;
EXPECT_EQ(iDeta,0); EXPECT_EQ (iDeta, 0);
} }
//quant4x4 DC //quant4x4 DC
RandomPixelDataGenerator(pSrc,iWidth,iHeight,iWidth,0); RandomPixelDataGenerator (pSrc, iWidth, iHeight, iWidth, 0);
RandomPixelDataGenerator(pPred,iWidth,iHeight,iWidth,rand()); RandomPixelDataGenerator (pPred, iWidth, iHeight, iWidth, rand());
for (int16_t i = 0;i<16;i++) { for (int16_t i = 0; i < 16; i++) {
pDct[i] = pSrc[i] - pPred[i]; pDct[i] = pSrc[i] - pPred[i];
pDctCompare[i] = pSrc[i] - pPred[i]; pDctCompare[i] = pSrc[i] - pPred[i];
} }
WelsQuant4x4Dc_c(pDct,pFfI[0]<<1,pMf[0]>>1); WelsQuant4x4Dc_c (pDct, pFfI[0] << 1, pMf[0]>>1);
WelsQuant4x4Dc_c(pDctCompare,pFfCompareI[0]<<1,pMf[0]>>1); WelsQuant4x4Dc_c (pDctCompare, pFfCompareI[0] << 1, pMf[0]>>1);
for (int16_t i = 0;i<16;i++) { for (int16_t i = 0; i < 16; i++) {
int16_t iDeta =WELS_ABS(pDct[i] - pDctCompare[i]); int16_t iDeta = WELS_ABS (pDct[i] - pDctCompare[i]);
iDeta = (iDeta < ThValue) ? 0 : iDeta; iDeta = (iDeta < ThValue) ? 0 : iDeta;
EXPECT_EQ(iDeta,0); EXPECT_EQ (iDeta, 0);
} }
//quant4x4 Inter MB //quant4x4 Inter MB
RandomPixelDataGenerator(pSrc,iWidth,iHeight,iWidth,0); RandomPixelDataGenerator (pSrc, iWidth, iHeight, iWidth, 0);
RandomPixelDataGenerator(pPred,iWidth,iHeight,iWidth,rand()); RandomPixelDataGenerator (pPred, iWidth, iHeight, iWidth, rand());
for (int16_t i = 0; i<64; i++) { for (int16_t i = 0; i < 64; i++) {
pDct[i] = pSrc[i] - pPred[i]; pDct[i] = pSrc[i] - pPred[i];
pDctCompare[i] = pSrc[i] - pPred[i]; pDctCompare[i] = pSrc[i] - pPred[i];
} }
WelsQuantFour4x4_c(pDct,pFfP,pMf); WelsQuantFour4x4_c (pDct, pFfP, pMf);
WelsQuantFour4x4_c(pDctCompare,pFfCompareP,pMf); WelsQuantFour4x4_c (pDctCompare, pFfCompareP, pMf);
for (int16_t i = 0; i<64; i++) { for (int16_t i = 0; i < 64; i++) {
int16_t iDeta =WELS_ABS(pDct[i] - pDctCompare[i]); int16_t iDeta = WELS_ABS (pDct[i] - pDctCompare[i]);
iDeta = (iDeta <ThValue)?0:iDeta; iDeta = (iDeta < ThValue) ? 0 : iDeta;
EXPECT_EQ(iDeta,0); EXPECT_EQ (iDeta, 0);
} }
} }
TEST(EncoderMbTest, TestQuantTable) { TEST (EncoderMbTest, TestQuantTable) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
int16_t iWidth = 16; int16_t iWidth = 16;
int16_t iHeight = 16; int16_t iHeight = 16;
uint8_t *pSrc = (uint8_t *)cMemoryAlign.WelsMalloc(iWidth*iHeight,"quant_src"); uint8_t* pSrc = (uint8_t*)cMemoryAlign.WelsMalloc (iWidth * iHeight, "quant_src");
uint8_t *pPred = (uint8_t *)cMemoryAlign.WelsMalloc(iWidth*iHeight,"quant_pred"); uint8_t* pPred = (uint8_t*)cMemoryAlign.WelsMalloc (iWidth * iHeight, "quant_pred");
int16_t *pDct = (int16_t *)cMemoryAlign.WelsMalloc(64*sizeof(int16_t),"Dct Buffer"); int16_t* pDct = (int16_t*)cMemoryAlign.WelsMalloc (64 * sizeof (int16_t), "Dct Buffer");
int16_t *pDctCompare = (int16_t *)cMemoryAlign.WelsMalloc(64*sizeof(int16_t),"DctCompare Buffer"); int16_t* pDctCompare = (int16_t*)cMemoryAlign.WelsMalloc (64 * sizeof (int16_t), "DctCompare Buffer");
for (int32_t iQP = 0; iQP<51; iQP++) { for (int32_t iQP = 0; iQP < 51; iQP++) {
TestQuant(iQP,pSrc,pPred,pDct,pDctCompare,iWidth,iHeight); TestQuant (iQP, pSrc, pPred, pDct, pDctCompare, iWidth, iHeight);
} }
cMemoryAlign.WelsFree(pSrc,"quant_src"); cMemoryAlign.WelsFree (pSrc, "quant_src");
cMemoryAlign.WelsFree(pPred,"quant_pred"); cMemoryAlign.WelsFree (pPred, "quant_pred");
cMemoryAlign.WelsFree(pDct,"Dct Buffer"); cMemoryAlign.WelsFree (pDct, "Dct Buffer");
cMemoryAlign.WelsFree(pDctCompare,"DctCompare Buffer"); cMemoryAlign.WelsFree (pDctCompare, "DctCompare Buffer");
} }

622
test/encoder/EncUT_EncoderMbAux.cpp
View File

@ -9,229 +9,230 @@ using namespace WelsSVCEnc;
#define ALLOC_MEMORY(type, name, num) type* name = (type*)cMemoryAlign.WelsMalloc(num*sizeof(type), #name); #define ALLOC_MEMORY(type, name, num) type* name = (type*)cMemoryAlign.WelsMalloc(num*sizeof(type), #name);
#define FREE_MEMORY(name) cMemoryAlign.WelsFree(name, #name); #define FREE_MEMORY(name) cMemoryAlign.WelsFree(name, #name);
TEST(EncodeMbAuxTest, TestScan_4x4_ac_c) { TEST (EncodeMbAuxTest, TestScan_4x4_ac_c) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iLevel, 16); ALLOC_MEMORY (int16_t, iLevel, 16);
ALLOC_MEMORY(int16_t, iDctA, 16); ALLOC_MEMORY (int16_t, iDctA, 16);
ALLOC_MEMORY(int16_t, iDctB, 16); ALLOC_MEMORY (int16_t, iDctB, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i=0;i<16;i++) { for (int i = 0; i < 16; i++) {
iDctA[i]=rand()%256+1; iDctA[i] = rand() % 256 + 1;
iDctB[i]=iDctA[i]; iDctB[i] = iDctA[i];
} }
WelsScan4x4Ac_c( iLevel, iDctA ); WelsScan4x4Ac_c (iLevel, iDctA);
EXPECT_EQ(iLevel[0],iDctB[1]); EXPECT_EQ (iLevel[0], iDctB[1]);
EXPECT_EQ(iLevel[1],iDctB[4]); EXPECT_EQ (iLevel[1], iDctB[4]);
EXPECT_EQ(iLevel[2],iDctB[8]); EXPECT_EQ (iLevel[2], iDctB[8]);
EXPECT_EQ(iLevel[3],iDctB[5]); EXPECT_EQ (iLevel[3], iDctB[5]);
EXPECT_EQ(iLevel[4],iDctB[2]); EXPECT_EQ (iLevel[4], iDctB[2]);
EXPECT_EQ(iLevel[5],iDctB[3]); EXPECT_EQ (iLevel[5], iDctB[3]);
EXPECT_EQ(iLevel[6],iDctB[6]); EXPECT_EQ (iLevel[6], iDctB[6]);
EXPECT_EQ(iLevel[7],iDctB[9]); EXPECT_EQ (iLevel[7], iDctB[9]);
EXPECT_EQ(iLevel[8],iDctB[12]); EXPECT_EQ (iLevel[8], iDctB[12]);
EXPECT_EQ(iLevel[9],iDctB[13]); EXPECT_EQ (iLevel[9], iDctB[13]);
EXPECT_EQ(iLevel[10],iDctB[10]); EXPECT_EQ (iLevel[10], iDctB[10]);
EXPECT_EQ(iLevel[11],iDctB[7]); EXPECT_EQ (iLevel[11], iDctB[7]);
EXPECT_EQ(iLevel[12],iDctB[11]); EXPECT_EQ (iLevel[12], iDctB[11]);
EXPECT_EQ(iLevel[13],iDctB[14]); EXPECT_EQ (iLevel[13], iDctB[14]);
EXPECT_EQ(iLevel[14],iDctB[15]); EXPECT_EQ (iLevel[14], iDctB[15]);
EXPECT_EQ(iLevel[15],0); EXPECT_EQ (iLevel[15], 0);
FREE_MEMORY(iLevel); FREE_MEMORY (iLevel);
FREE_MEMORY(iDctA); FREE_MEMORY (iDctA);
FREE_MEMORY(iDctB); FREE_MEMORY (iDctB);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST(EncodeMbAuxTest, TestScan_4x4_ac_sse2) { TEST (EncodeMbAuxTest, TestScan_4x4_ac_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iLevelA, 16); ALLOC_MEMORY (int16_t, iLevelA, 16);
ALLOC_MEMORY(int16_t, iLevelB, 16); ALLOC_MEMORY (int16_t, iLevelB, 16);
ALLOC_MEMORY(int16_t, iDct, 16); ALLOC_MEMORY (int16_t, iDct, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i=0;i<16;i++) { for (int i = 0; i < 16; i++) {
iDct[i]=rand()%256+1; iDct[i] = rand() % 256 + 1;
} }
WelsScan4x4Ac_c( iLevelA, iDct ); WelsScan4x4Ac_c (iLevelA, iDct);
WelsScan4x4Ac_sse2( iLevelB, iDct ); WelsScan4x4Ac_sse2 (iLevelB, iDct);
for(int j=0; j<16;j++) for (int j = 0; j < 16; j++)
EXPECT_EQ(iLevelA[j], iLevelB[j]); EXPECT_EQ (iLevelA[j], iLevelB[j]);
FREE_MEMORY(iLevelA); FREE_MEMORY (iLevelA);
FREE_MEMORY(iLevelB); FREE_MEMORY (iLevelB);
FREE_MEMORY(iDct); FREE_MEMORY (iDct);
} }
TEST(EncodeMbAuxTest, WelsScan4x4DcAc_sse2) { TEST (EncodeMbAuxTest, WelsScan4x4DcAc_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iLevelA, 32); ALLOC_MEMORY (int16_t, iLevelA, 32);
ALLOC_MEMORY(int16_t, iLevelB, 32); ALLOC_MEMORY (int16_t, iLevelB, 32);
ALLOC_MEMORY(int16_t, iDct, 32); ALLOC_MEMORY (int16_t, iDct, 32);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 32; i++) for (int i = 0; i < 32; i++)
iDct[i] = (rand() & 32767) - 16384; iDct[i] = (rand() & 32767) - 16384;
WelsScan4x4DcAc_sse2(iLevelA, iDct); WelsScan4x4DcAc_sse2 (iLevelA, iDct);
WelsScan4x4DcAc_c(iLevelB, iDct); WelsScan4x4DcAc_c (iLevelB, iDct);
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
EXPECT_EQ(iLevelA[i], iLevelB[i]); EXPECT_EQ (iLevelA[i], iLevelB[i]);
FREE_MEMORY(iLevelA); FREE_MEMORY (iLevelA);
FREE_MEMORY(iLevelB); FREE_MEMORY (iLevelB);
FREE_MEMORY(iDct); FREE_MEMORY (iDct);
} }
#endif #endif
TEST(EncodeMbAuxTest, TestScan_4x4_dcc) { TEST (EncodeMbAuxTest, TestScan_4x4_dcc) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iLevel, 16); ALLOC_MEMORY (int16_t, iLevel, 16);
ALLOC_MEMORY(int16_t, iDctA, 16); ALLOC_MEMORY (int16_t, iDctA, 16);
ALLOC_MEMORY(int16_t, iDctB, 16); ALLOC_MEMORY (int16_t, iDctB, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i=0;i<16;i++) for (int i = 0; i < 16; i++)
iDctA[i] = iDctB[i] = rand()%256+1; iDctA[i] = iDctB[i] = rand() % 256 + 1;
WelsScan4x4Dc( iLevel, iDctA ); WelsScan4x4Dc (iLevel, iDctA);
EXPECT_EQ(iLevel[0],iDctB[0]); EXPECT_EQ (iLevel[0], iDctB[0]);
EXPECT_EQ(iLevel[1],iDctB[1]); EXPECT_EQ (iLevel[1], iDctB[1]);
EXPECT_EQ(iLevel[2],iDctB[4]); EXPECT_EQ (iLevel[2], iDctB[4]);
EXPECT_EQ(iLevel[3],iDctB[8]); EXPECT_EQ (iLevel[3], iDctB[8]);
EXPECT_EQ(iLevel[4],iDctB[5]); EXPECT_EQ (iLevel[4], iDctB[5]);
EXPECT_EQ(iLevel[5],iDctB[2]); EXPECT_EQ (iLevel[5], iDctB[2]);
EXPECT_EQ(iLevel[6],iDctB[3]); EXPECT_EQ (iLevel[6], iDctB[3]);
EXPECT_EQ(iLevel[7],iDctB[6]); EXPECT_EQ (iLevel[7], iDctB[6]);
EXPECT_EQ(iLevel[8],iDctB[9]); EXPECT_EQ (iLevel[8], iDctB[9]);
EXPECT_EQ(iLevel[9],iDctB[12]); EXPECT_EQ (iLevel[9], iDctB[12]);
EXPECT_EQ(iLevel[10],iDctB[13]); EXPECT_EQ (iLevel[10], iDctB[13]);
EXPECT_EQ(iLevel[11],iDctB[10]); EXPECT_EQ (iLevel[11], iDctB[10]);
EXPECT_EQ(iLevel[12],iDctB[7]); EXPECT_EQ (iLevel[12], iDctB[7]);
EXPECT_EQ(iLevel[13],iDctB[11]); EXPECT_EQ (iLevel[13], iDctB[11]);
EXPECT_EQ(iLevel[14],iDctB[14]); EXPECT_EQ (iLevel[14], iDctB[14]);
EXPECT_EQ(iLevel[15],iDctB[15]); EXPECT_EQ (iLevel[15], iDctB[15]);
FREE_MEMORY(iLevel); FREE_MEMORY (iLevel);
FREE_MEMORY(iDctA); FREE_MEMORY (iDctA);
FREE_MEMORY(iDctB); FREE_MEMORY (iDctB);
} }
static inline void PixelSubWH( int16_t *iDiff, int iSize, uint8_t *pPix1, int iStride1, uint8_t *pPix2, int iStride2 ) { static inline void PixelSubWH (int16_t* iDiff, int iSize, uint8_t* pPix1, int iStride1, uint8_t* pPix2, int iStride2) {
int y, x; int y, x;
for( y = 0; y < iSize; y++ ) { for (y = 0; y < iSize; y++) {
for( x = 0; x < iSize; x++ ) for (x = 0; x < iSize; x++)
iDiff[x + y*iSize] = pPix1[x] - pPix2[x]; iDiff[x + y * iSize] = pPix1[x] - pPix2[x];
pPix1 += iStride1; pPix1 += iStride1;
pPix2 += iStride2; pPix2 += iStride2;
}
} }
}
#define FENC_STRIDE 16 #define FENC_STRIDE 16
#define FDEC_STRIDE 32 #define FDEC_STRIDE 32
static void Sub4x4DctAnchor( int16_t iDct[4][4], uint8_t *pPix1, uint8_t *pPix2 ) { static void Sub4x4DctAnchor (int16_t iDct[4][4], uint8_t* pPix1, uint8_t* pPix2) {
int16_t iDiff[4][4]; int16_t iDiff[4][4];
int16_t tmp[4][4]; int16_t tmp[4][4];
int i; int i;
PixelSubWH( (int16_t*)iDiff, 4, pPix1, FENC_STRIDE, pPix2, FDEC_STRIDE ); PixelSubWH ((int16_t*)iDiff, 4, pPix1, FENC_STRIDE, pPix2, FDEC_STRIDE);
for( i = 0; i < 4; i++ ) { for (i = 0; i < 4; i++) {
const int a03 = iDiff[i][0] + iDiff[i][3]; const int a03 = iDiff[i][0] + iDiff[i][3];
const int a12 = iDiff[i][1] + iDiff[i][2]; const int a12 = iDiff[i][1] + iDiff[i][2];
const int s03 = iDiff[i][0] - iDiff[i][3]; const int s03 = iDiff[i][0] - iDiff[i][3];
const int s12 = iDiff[i][1] - iDiff[i][2]; const int s12 = iDiff[i][1] - iDiff[i][2];
tmp[0][i] = a03 + a12; tmp[0][i] = a03 + a12;
tmp[1][i] = 2*s03 + s12; tmp[1][i] = 2 * s03 + s12;
tmp[2][i] = a03 - a12; tmp[2][i] = a03 - a12;
tmp[3][i] = s03 - 2*s12; tmp[3][i] = s03 - 2 * s12;
} }
for( i = 0; i < 4; i++ ) { for (i = 0; i < 4; i++) {
const int a03 = tmp[i][0] + tmp[i][3]; const int a03 = tmp[i][0] + tmp[i][3];
const int a12 = tmp[i][1] + tmp[i][2]; const int a12 = tmp[i][1] + tmp[i][2];
const int s03 = tmp[i][0] - tmp[i][3]; const int s03 = tmp[i][0] - tmp[i][3];
const int s12 = tmp[i][1] - tmp[i][2]; const int s12 = tmp[i][1] - tmp[i][2];
iDct[i][0] = a03 + a12; iDct[i][0] = a03 + a12;
iDct[i][1] = 2*s03 + s12; iDct[i][1] = 2 * s03 + s12;
iDct[i][2] = a03 - a12; iDct[i][2] = a03 - a12;
iDct[i][3] = s03 - 2*s12; iDct[i][3] = s03 - 2 * s12;
} }
} }
static void Sub8x8DctAnchor( int16_t iDct[4][4][4], uint8_t *pPix1, uint8_t *pPix2 ) { static void Sub8x8DctAnchor (int16_t iDct[4][4][4], uint8_t* pPix1, uint8_t* pPix2) {
Sub4x4DctAnchor( iDct[0], &pPix1[0], &pPix2[0] ); Sub4x4DctAnchor (iDct[0], &pPix1[0], &pPix2[0]);
Sub4x4DctAnchor( iDct[1], &pPix1[4], &pPix2[4] ); Sub4x4DctAnchor (iDct[1], &pPix1[4], &pPix2[4]);
Sub4x4DctAnchor( iDct[2], &pPix1[4*FENC_STRIDE+0], &pPix2[4*FDEC_STRIDE+0] ); Sub4x4DctAnchor (iDct[2], &pPix1[4 * FENC_STRIDE + 0], &pPix2[4 * FDEC_STRIDE + 0]);
Sub4x4DctAnchor( iDct[3], &pPix1[4*FENC_STRIDE+4], &pPix2[4*FDEC_STRIDE+4] ); Sub4x4DctAnchor (iDct[3], &pPix1[4 * FENC_STRIDE + 4], &pPix2[4 * FDEC_STRIDE + 4]);
} }
TEST(EncodeMbAuxTest, WelsDctT4_c) { TEST (EncodeMbAuxTest, WelsDctT4_c) {
int16_t iDctRef[4][4]; int16_t iDctRef[4][4];
uint8_t uiPix1[16*FENC_STRIDE], uiPix2[16*FDEC_STRIDE]; uint8_t uiPix1[16 * FENC_STRIDE], uiPix2[16 * FDEC_STRIDE];
int16_t iDct[16]; int16_t iDct[16];
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
uiPix1[i*FENC_STRIDE+j] = uiPix2[i*FDEC_STRIDE+j] = rand() & 255; uiPix1[i * FENC_STRIDE + j] = uiPix2[i * FDEC_STRIDE + j] = rand() & 255;
Sub4x4DctAnchor(iDctRef, uiPix1, uiPix2); Sub4x4DctAnchor (iDctRef, uiPix1, uiPix2);
WelsDctT4_c(iDct, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); WelsDctT4_c (iDct, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
EXPECT_EQ(iDctRef[j][i], iDct[i*4+j]); EXPECT_EQ (iDctRef[j][i], iDct[i * 4 + j]);
} }
TEST(EncodeMbAuxTest, WelsDctFourT4_c) { TEST (EncodeMbAuxTest, WelsDctFourT4_c) {
int16_t iDctRef[4][4][4]; uint8_t uiPix1[16*FENC_STRIDE], uiPix2[16*FDEC_STRIDE]; int16_t iDctRef[4][4][4];
int16_t iDct[16*4]; uint8_t uiPix1[16 * FENC_STRIDE], uiPix2[16 * FDEC_STRIDE];
srand((unsigned int)time(NULL)); int16_t iDct[16 * 4];
for(int i = 0; i < 8; i++) srand ((unsigned int)time (NULL));
for(int j = 0; j < 8; j++) for (int i = 0; i < 8; i++)
uiPix1[i*FENC_STRIDE+j] = uiPix2[i*FDEC_STRIDE+j] = rand() & 255; for (int j = 0; j < 8; j++)
Sub8x8DctAnchor(iDctRef, uiPix1, uiPix2); uiPix1[i * FENC_STRIDE + j] = uiPix2[i * FDEC_STRIDE + j] = rand() & 255;
WelsDctFourT4_c(iDct, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); Sub8x8DctAnchor (iDctRef, uiPix1, uiPix2);
for(int k = 0; k < 4; k++) WelsDctFourT4_c (iDct, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
for(int i = 0; i < 4; i++) for (int k = 0; k < 4; k++)
for(int j = 0; j < 4; j++) for (int i = 0; i < 4; i++)
EXPECT_EQ(iDctRef[k][j][i], iDct[k*16+i*4+j]); for (int j = 0; j < 4; j++)
EXPECT_EQ (iDctRef[k][j][i], iDct[k * 16 + i * 4 + j]);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST(EncodeMbAuxTest, WelsDctT4_mmx) { TEST (EncodeMbAuxTest, WelsDctT4_mmx) {
int16_t iDctC[16], iDctM[16]; int16_t iDctC[16], iDctM[16];
uint8_t uiPix1[16*FENC_STRIDE], uiPix2[16*FDEC_STRIDE]; uint8_t uiPix1[16 * FENC_STRIDE], uiPix2[16 * FDEC_STRIDE];
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
uiPix1[i*FENC_STRIDE+j] = uiPix2[i*FDEC_STRIDE+j] = rand() & 255; uiPix1[i * FENC_STRIDE + j] = uiPix2[i * FDEC_STRIDE + j] = rand() & 255;
WelsDctT4_c(iDctC, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); WelsDctT4_c (iDctC, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
WelsDctT4_mmx(iDctM, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); WelsDctT4_mmx (iDctM, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
EXPECT_EQ(iDctC[i], iDctM[i]); EXPECT_EQ (iDctC[i], iDctM[i]);
} }
TEST(EncodeMbAuxTest, WelsDctFourT4_sse2) { TEST (EncodeMbAuxTest, WelsDctFourT4_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(uint8_t, uiPix1, 16*FENC_STRIDE); ALLOC_MEMORY (uint8_t, uiPix1, 16 * FENC_STRIDE);
ALLOC_MEMORY(uint8_t, uiPix2, 16*FDEC_STRIDE); ALLOC_MEMORY (uint8_t, uiPix2, 16 * FDEC_STRIDE);
ALLOC_MEMORY(int16_t, iDctC, 16*4); ALLOC_MEMORY (int16_t, iDctC, 16 * 4);
ALLOC_MEMORY(int16_t, iDctS, 16*4); ALLOC_MEMORY (int16_t, iDctS, 16 * 4);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
for(int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
uiPix1[i*FENC_STRIDE+j] = uiPix2[i*FDEC_STRIDE+j] = rand() & 255; uiPix1[i * FENC_STRIDE + j] = uiPix2[i * FDEC_STRIDE + j] = rand() & 255;
WelsDctFourT4_c(iDctC, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); WelsDctFourT4_c (iDctC, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
WelsDctFourT4_sse2(iDctS, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE); WelsDctFourT4_sse2 (iDctS, uiPix1, FENC_STRIDE, uiPix2, FDEC_STRIDE);
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
EXPECT_EQ(iDctC[i], iDctS[i]); EXPECT_EQ (iDctC[i], iDctS[i]);
FREE_MEMORY(uiPix1); FREE_MEMORY (uiPix1);
FREE_MEMORY(uiPix2); FREE_MEMORY (uiPix2);
FREE_MEMORY(iDctC); FREE_MEMORY (iDctC);
FREE_MEMORY(iDctS); FREE_MEMORY (iDctS);
} }
TEST(EncodeMbAuxTest, WelsCalculateSingleCtr4x4_sse2) { TEST (EncodeMbAuxTest, WelsCalculateSingleCtr4x4_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iDctC, 16); ALLOC_MEMORY (int16_t, iDctC, 16);
ALLOC_MEMORY(int16_t, iDctS, 16); ALLOC_MEMORY (int16_t, iDctS, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
iDctC[i] = iDctS[i] = (rand() & 65535 ) - 32768; iDctC[i] = iDctS[i] = (rand() & 65535) - 32768;
WelsCalculateSingleCtr4x4_c(iDctC); WelsCalculateSingleCtr4x4_c (iDctC);
WelsCalculateSingleCtr4x4_sse2(iDctS); WelsCalculateSingleCtr4x4_sse2 (iDctS);
for(int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
EXPECT_EQ(iDctC[i], iDctS[i]); EXPECT_EQ (iDctC[i], iDctS[i]);
FREE_MEMORY(iDctC); FREE_MEMORY (iDctC);
FREE_MEMORY(iDctS); FREE_MEMORY (iDctS);
} }
#endif #endif
void copy(uint8_t *pDst, int32_t iDStride, uint8_t *pSrc, int32_t iSStride, int32_t iWidth, int32_t iHeight) { void copy (uint8_t* pDst, int32_t iDStride, uint8_t* pSrc, int32_t iSStride, int32_t iWidth, int32_t iHeight) {
for(int i = 0; i < iHeight; i++) for (int i = 0; i < iHeight; i++)
memcpy(pDst+i*iDStride, pSrc+i*iSStride, iWidth); memcpy (pDst + i * iDStride, pSrc + i * iSStride, iWidth);
} }
#define GENERATE_UT_FOR_COPY(width, height, function) \ #define GENERATE_UT_FOR_COPY(width, height, function) \
@ -253,112 +254,112 @@ TEST(EncodeMbAuxTest, function) { \
EXPECT_EQ(ref_dst[i*iDStride+j], dst[i*iDStride+j]); \ EXPECT_EQ(ref_dst[i*iDStride+j], dst[i*iDStride+j]); \
} }
GENERATE_UT_FOR_COPY(4,4, WelsCopy4x4); GENERATE_UT_FOR_COPY (4, 4, WelsCopy4x4);
GENERATE_UT_FOR_COPY(8,8, WelsCopy8x8_c); GENERATE_UT_FOR_COPY (8, 8, WelsCopy8x8_c);
GENERATE_UT_FOR_COPY(8, 16, WelsCopy8x16_c); GENERATE_UT_FOR_COPY (8, 16, WelsCopy8x16_c);
GENERATE_UT_FOR_COPY(16, 8, WelsCopy16x8_c); GENERATE_UT_FOR_COPY (16, 8, WelsCopy16x8_c);
GENERATE_UT_FOR_COPY(16, 16, WelsCopy16x16_c); GENERATE_UT_FOR_COPY (16, 16, WelsCopy16x16_c);
#ifdef X86_ASM #ifdef X86_ASM
GENERATE_UT_FOR_COPY(16, 8, WelsCopy16x8NotAligned_sse2); GENERATE_UT_FOR_COPY (16, 8, WelsCopy16x8NotAligned_sse2);
GENERATE_UT_FOR_COPY(16, 16, WelsCopy16x16NotAligned_sse2); GENERATE_UT_FOR_COPY (16, 16, WelsCopy16x16NotAligned_sse2);
GENERATE_UT_FOR_COPY(16, 16, WelsCopy16x16_sse2); GENERATE_UT_FOR_COPY (16, 16, WelsCopy16x16_sse2);
#endif #endif
TEST(EncodeMbAuxTest, WelsGetNoneZeroCount_c) { TEST (EncodeMbAuxTest, WelsGetNoneZeroCount_c) {
int16_t _iLevel[32]; int16_t _iLevel[32];
int16_t *pLevel = (int16_t*) (((((uintptr_t)_iLevel) + 15) >> 4) << 4); int16_t* pLevel = (int16_t*) (((((uintptr_t)_iLevel) + 15) >> 4) << 4);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
int32_t result = 0; int32_t result = 0;
for(int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
pLevel[i] = (rand() & 0x07) - 4; pLevel[i] = (rand() & 0x07) - 4;
if(pLevel[i]) result ++; if (pLevel[i]) result ++;
} }
int32_t nnz = WelsGetNoneZeroCount_c(pLevel); int32_t nnz = WelsGetNoneZeroCount_c (pLevel);
EXPECT_EQ(nnz, result); EXPECT_EQ (nnz, result);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST(EncodeMbAuxTest, WelsGetNoneZeroCount_sse2) { TEST (EncodeMbAuxTest, WelsGetNoneZeroCount_sse2) {
int16_t _iLevel[32]; int16_t _iLevel[32];
int16_t *pLevel = (int16_t*) (((((uintptr_t)_iLevel) + 15) >> 4) << 4); int16_t* pLevel = (int16_t*) (((((uintptr_t)_iLevel) + 15) >> 4) << 4);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
int32_t result = 0; int32_t result = 0;
for(int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
pLevel[i] = (rand() & 0x07) - 4; pLevel[i] = (rand() & 0x07) - 4;
if(pLevel[i]) result ++; if (pLevel[i]) result ++;
} }
int32_t nnz = WelsGetNoneZeroCount_sse2(pLevel); int32_t nnz = WelsGetNoneZeroCount_sse2 (pLevel);
EXPECT_EQ(nnz, result); EXPECT_EQ (nnz, result);
} }
#endif #endif
#define WELS_ABS_LC(a) ((sign ^ (int32_t)(a)) - sign) #define WELS_ABS_LC(a) ((sign ^ (int32_t)(a)) - sign)
#define NEW_QUANT(pDct, ff, mf) (((ff)+ WELS_ABS_LC(pDct))*(mf)) >>16 #define NEW_QUANT(pDct, ff, mf) (((ff)+ WELS_ABS_LC(pDct))*(mf)) >>16
#define WELS_NEW_QUANT(pDct,ff,mf) WELS_ABS_LC(NEW_QUANT(pDct, ff, mf)) #define WELS_NEW_QUANT(pDct,ff,mf) WELS_ABS_LC(NEW_QUANT(pDct, ff, mf))
void WelsQuantFour4x4MaxAnchor(int16_t *pDct, int16_t* ff, int16_t *mf, int16_t *max) { void WelsQuantFour4x4MaxAnchor (int16_t* pDct, int16_t* ff, int16_t* mf, int16_t* max) {
int32_t i, j, k, sign; int32_t i, j, k, sign;
int16_t max_abs; int16_t max_abs;
for( k = 0; k < 4; k++) { for (k = 0; k < 4; k++) {
max_abs = 0; max_abs = 0;
for( i = 0; i < 16; i++ ) { for (i = 0; i < 16; i++) {
j = i & 0x07; j = i & 0x07;
sign = WELS_SIGN(pDct[i]); sign = WELS_SIGN (pDct[i]);
pDct[i] = NEW_QUANT(pDct[i], ff[j], mf[j]); pDct[i] = NEW_QUANT (pDct[i], ff[j], mf[j]);
if( max_abs < pDct[i]) max_abs = pDct[i]; if (max_abs < pDct[i]) max_abs = pDct[i];
pDct[i] = WELS_ABS_LC(pDct[i]); pDct[i] = WELS_ABS_LC (pDct[i]);
} }
pDct += 16; pDct += 16;
max[k] = max_abs; max[k] = max_abs;
} }
} }
TEST(EncodeMbAuxTest, WelsQuantFour4x4Max_c) { TEST (EncodeMbAuxTest, WelsQuantFour4x4Max_c) {
int16_t ff[8], mf[8]; int16_t ff[8], mf[8];
int16_t iDctA[64], iMaxA[16]; int16_t iDctA[64], iMaxA[16];
int16_t iDctC[64], iMaxC[16]; int16_t iDctC[64], iMaxC[16];
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
ff[i] = rand() & 32767; ff[i] = rand() & 32767;
mf[i] = rand() & 32767; mf[i] = rand() & 32767;
} }
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
iDctA[i] = iDctC[i] = (rand() & 65535) - 32767; iDctA[i] = iDctC[i] = (rand() & 65535) - 32767;
WelsQuantFour4x4MaxAnchor(iDctA, ff, mf, iMaxA); WelsQuantFour4x4MaxAnchor (iDctA, ff, mf, iMaxA);
WelsQuantFour4x4Max_c(iDctC, ff, mf, iMaxC); WelsQuantFour4x4Max_c (iDctC, ff, mf, iMaxC);
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
EXPECT_EQ(iDctA[i],iDctC[i]); EXPECT_EQ (iDctA[i], iDctC[i]);
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(iMaxA[i], iMaxC[i]); EXPECT_EQ (iMaxA[i], iMaxC[i]);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST(EncodeMbAuxTest, WelsQuantFour4x4Max_sse2) { TEST (EncodeMbAuxTest, WelsQuantFour4x4Max_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, ff, 8); ALLOC_MEMORY (int16_t, ff, 8);
ALLOC_MEMORY(int16_t, mf, 8); ALLOC_MEMORY (int16_t, mf, 8);
ALLOC_MEMORY(int16_t, iDctC, 64); ALLOC_MEMORY (int16_t, iDctC, 64);
ALLOC_MEMORY(int16_t, iDctS, 64); ALLOC_MEMORY (int16_t, iDctS, 64);
ALLOC_MEMORY(int16_t, iMaxC, 16); ALLOC_MEMORY (int16_t, iMaxC, 16);
ALLOC_MEMORY(int16_t, iMaxS, 16); ALLOC_MEMORY (int16_t, iMaxS, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
ff[i] = rand() & 32767; ff[i] = rand() & 32767;
mf[i] = rand() & 32767; mf[i] = rand() & 32767;
} }
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
iDctC[i] = iDctS[i] = (rand() & 65535) - 32767; iDctC[i] = iDctS[i] = (rand() & 65535) - 32767;
WelsQuantFour4x4Max_c(iDctC, ff, mf, iMaxC); WelsQuantFour4x4Max_c (iDctC, ff, mf, iMaxC);
WelsQuantFour4x4Max_sse2(iDctS, ff, mf, iMaxS); WelsQuantFour4x4Max_sse2 (iDctS, ff, mf, iMaxS);
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
EXPECT_EQ(iDctC[i], iDctS[i]); EXPECT_EQ (iDctC[i], iDctS[i]);
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(iMaxC[i], iMaxS[i]); EXPECT_EQ (iMaxC[i], iMaxS[i]);
FREE_MEMORY(ff); FREE_MEMORY (ff);
FREE_MEMORY(mf); FREE_MEMORY (mf);
FREE_MEMORY(iDctC); FREE_MEMORY (iDctC);
FREE_MEMORY(iDctS); FREE_MEMORY (iDctS);
FREE_MEMORY(iMaxC); FREE_MEMORY (iMaxC);
FREE_MEMORY(iMaxS); FREE_MEMORY (iMaxS);
} }
#endif #endif
int32_t WelsHadamardQuant2x2SkipAnchor(int16_t *rs, int16_t ff, int16_t mf) { int32_t WelsHadamardQuant2x2SkipAnchor (int16_t* rs, int16_t ff, int16_t mf) {
int16_t pDct[4], s[4]; int16_t pDct[4], s[4];
int16_t threshold = ((1<<16)-1)/mf - ff; int16_t threshold = ((1 << 16) - 1) / mf - ff;
s[0] = rs[0] + rs[32]; s[0] = rs[0] + rs[32];
s[1] = rs[0] - rs[32]; s[1] = rs[0] - rs[32];
s[2] = rs[16] + rs[48]; s[2] = rs[16] + rs[48];
@ -367,21 +368,22 @@ int32_t WelsHadamardQuant2x2SkipAnchor(int16_t *rs, int16_t ff, int16_t mf) {
pDct[1] = s[0] - s[2]; pDct[1] = s[0] - s[2];
pDct[2] = s[1] + s[3]; pDct[2] = s[1] + s[3];
pDct[3] = s[1] - s[3]; pDct[3] = s[1] - s[3];
return ((WELS_ABS(pDct[0]) > threshold) || (WELS_ABS(pDct[1]) > threshold) || (WELS_ABS(pDct[2]) > threshold) || (WELS_ABS(pDct[3]) > threshold)); return ((WELS_ABS (pDct[0]) > threshold) || (WELS_ABS (pDct[1]) > threshold) || (WELS_ABS (pDct[2]) > threshold)
|| (WELS_ABS (pDct[3]) > threshold));
} }
TEST(EncodeMbAuxTest, WelsHadamardQuant2x2Skip_c) { TEST (EncodeMbAuxTest, WelsHadamardQuant2x2Skip_c) {
int16_t iRS[64]; int16_t iRS[64];
int16_t ff, mf; int16_t ff, mf;
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
iRS[i] = (rand() & 32767) - 16384; iRS[i] = (rand() & 32767) - 16384;
ff = rand() & 32767; ff = rand() & 32767;
mf = rand() & 32767; mf = rand() & 32767;
EXPECT_EQ(WelsHadamardQuant2x2Skip_c(iRS, ff, mf), WelsHadamardQuant2x2SkipAnchor(iRS, ff, mf)); EXPECT_EQ (WelsHadamardQuant2x2Skip_c (iRS, ff, mf), WelsHadamardQuant2x2SkipAnchor (iRS, ff, mf));
} }
int32_t WelsHadamardQuant2x2Anchor(int16_t *rs, const int16_t ff, int16_t mf, int16_t * pDct, int16_t * block) { int32_t WelsHadamardQuant2x2Anchor (int16_t* rs, const int16_t ff, int16_t mf, int16_t* pDct, int16_t* block) {
int16_t s[4]; int16_t s[4];
int32_t sign, i, dc_nzc = 0; int32_t sign, i, dc_nzc = 0;
@ -400,95 +402,95 @@ int32_t WelsHadamardQuant2x2Anchor(int16_t *rs, const int16_t ff, int16_t mf, in
pDct[2] = s[1] + s[3]; pDct[2] = s[1] + s[3];
pDct[3] = s[1] - s[3]; pDct[3] = s[1] - s[3];
sign = WELS_SIGN(pDct[0]); sign = WELS_SIGN (pDct[0]);
pDct[0] = WELS_NEW_QUANT(pDct[0], ff, mf); pDct[0] = WELS_NEW_QUANT (pDct[0], ff, mf);
sign = WELS_SIGN(pDct[1]); sign = WELS_SIGN (pDct[1]);
pDct[1] = WELS_NEW_QUANT(pDct[1], ff, mf); pDct[1] = WELS_NEW_QUANT (pDct[1], ff, mf);
sign = WELS_SIGN(pDct[2]); sign = WELS_SIGN (pDct[2]);
pDct[2] = WELS_NEW_QUANT(pDct[2], ff, mf); pDct[2] = WELS_NEW_QUANT (pDct[2], ff, mf);
sign = WELS_SIGN(pDct[3]); sign = WELS_SIGN (pDct[3]);
pDct[3] = WELS_NEW_QUANT(pDct[3], ff, mf); pDct[3] = WELS_NEW_QUANT (pDct[3], ff, mf);
ST64( block, LD64(pDct) ); ST64 (block, LD64 (pDct));
for(i=0; i<4; i++) for (i = 0; i < 4; i++)
dc_nzc += (block[i] != 0); dc_nzc += (block[i] != 0);
return dc_nzc; return dc_nzc;
} }
TEST(EncodeMbAuxTest, WelsHadamardQuant2x2_c) { TEST (EncodeMbAuxTest, WelsHadamardQuant2x2_c) {
int16_t iRsC[64], iRsA[64]; int16_t iRsC[64], iRsA[64];
int16_t ff, mf; int16_t ff, mf;
int16_t iBlockA[16], iBlockC[16], iDctA[4], iDctC[4]; int16_t iBlockA[16], iBlockC[16], iDctA[4], iDctC[4];
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
iRsA[i] = iRsC[i] = (rand() & 32767) - 16384; iRsA[i] = iRsC[i] = (rand() & 32767) - 16384;
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
iDctA[i] = iDctC[i] = (rand() & 32767) - 16384; iDctA[i] = iDctC[i] = (rand() & 32767) - 16384;
ff = rand() & 32767; ff = rand() & 32767;
mf = rand() & 32767; mf = rand() & 32767;
int32_t iRetA = WelsHadamardQuant2x2Anchor(iRsA, ff, mf, iDctA, iBlockA); int32_t iRetA = WelsHadamardQuant2x2Anchor (iRsA, ff, mf, iDctA, iBlockA);
int32_t iRetC = WelsHadamardQuant2x2_c(iRsC, ff, mf, iDctC, iBlockC); int32_t iRetC = WelsHadamardQuant2x2_c (iRsC, ff, mf, iDctC, iBlockC);
EXPECT_EQ(iRetA, iRetC); EXPECT_EQ (iRetA, iRetC);
for(int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(iDctA[i], iDctC[i]); EXPECT_EQ (iDctA[i], iDctC[i]);
} }
void WelsHadamardT4DcAnchor( int16_t *pLumaDc, int16_t *pDct) { void WelsHadamardT4DcAnchor (int16_t* pLumaDc, int16_t* pDct) {
int32_t p[16], s[4]; int32_t p[16], s[4];
int32_t i, iIdx; int32_t i, iIdx;
for(i = 0 ; i < 16 ; i +=4) { for (i = 0 ; i < 16 ; i += 4) {
iIdx = ((i&0x08) << 4) +((i&0x04) << 3); iIdx = ((i & 0x08) << 4) + ((i & 0x04) << 3);
s[0] = pDct[iIdx ] + pDct[iIdx+80]; s[0] = pDct[iIdx ] + pDct[iIdx + 80];
s[3] = pDct[iIdx ] - pDct[iIdx+80]; s[3] = pDct[iIdx ] - pDct[iIdx + 80];
s[1] = pDct[iIdx+16] + pDct[iIdx+64]; s[1] = pDct[iIdx + 16] + pDct[iIdx + 64];
s[2] = pDct[iIdx+16] - pDct[iIdx+64]; s[2] = pDct[iIdx + 16] - pDct[iIdx + 64];
p[i ] = s[0] + s[1]; p[i ] = s[0] + s[1];
p[i+2] = s[0] - s[1]; p[i + 2] = s[0] - s[1];
p[i+1] = s[3] + s[2]; p[i + 1] = s[3] + s[2];
p[i+3] = s[3] - s[2]; p[i + 3] = s[3] - s[2];
} }
for(i = 0 ; i < 4 ; i ++) { for (i = 0 ; i < 4 ; i ++) {
s[0] = p[i ] + p[i+12]; s[0] = p[i ] + p[i + 12];
s[3] = p[i ] - p[i+12]; s[3] = p[i ] - p[i + 12];
s[1] = p[i+4] + p[i+ 8]; s[1] = p[i + 4] + p[i + 8];
s[2] = p[i+4] - p[i+ 8]; s[2] = p[i + 4] - p[i + 8];
pLumaDc[i ] = WELS_CLIP3((s[0] + s[1] + 1) >> 1, -32768, 32767); pLumaDc[i ] = WELS_CLIP3 ((s[0] + s[1] + 1) >> 1, -32768, 32767);
pLumaDc[i+8 ] = WELS_CLIP3((s[0] - s[1] + 1) >> 1, -32768, 32767); pLumaDc[i + 8 ] = WELS_CLIP3 ((s[0] - s[1] + 1) >> 1, -32768, 32767);
pLumaDc[i+4 ] = WELS_CLIP3((s[3] + s[2] + 1) >> 1, -32768, 32767); pLumaDc[i + 4 ] = WELS_CLIP3 ((s[3] + s[2] + 1) >> 1, -32768, 32767);
pLumaDc[i+12] = WELS_CLIP3((s[3] - s[2] + 1) >> 1, -32768, 32767); pLumaDc[i + 12] = WELS_CLIP3 ((s[3] - s[2] + 1) >> 1, -32768, 32767);
} }
} }
TEST(EncodeMbAuxTest, WelsHadamardT4Dc_c) { TEST (EncodeMbAuxTest, WelsHadamardT4Dc_c) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iDct, 128*16); ALLOC_MEMORY (int16_t, iDct, 128 * 16);
ALLOC_MEMORY(int16_t, iLumaDcR, 16); ALLOC_MEMORY (int16_t, iLumaDcR, 16);
ALLOC_MEMORY(int16_t, iLumaDcC, 16); ALLOC_MEMORY (int16_t, iLumaDcC, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 128*16; i++) for (int i = 0; i < 128 * 16; i++)
iDct[i] = (rand() & 32767) - 16384; iDct[i] = (rand() & 32767) - 16384;
WelsHadamardT4DcAnchor(iLumaDcR, iDct); WelsHadamardT4DcAnchor (iLumaDcR, iDct);
WelsHadamardT4Dc_c(iLumaDcC, iDct); WelsHadamardT4Dc_c (iLumaDcC, iDct);
for(int i = 0;i < 16; i++) for (int i = 0; i < 16; i++)
EXPECT_EQ(iLumaDcR[i], iLumaDcC[i]); EXPECT_EQ (iLumaDcR[i], iLumaDcC[i]);
FREE_MEMORY(iDct); FREE_MEMORY (iDct);
FREE_MEMORY(iLumaDcR); FREE_MEMORY (iLumaDcR);
FREE_MEMORY(iLumaDcC); FREE_MEMORY (iLumaDcC);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST(EncodeMbAuxTest, WelsHadamardT4Dc_sse2) { TEST (EncodeMbAuxTest, WelsHadamardT4Dc_sse2) {
CMemoryAlign cMemoryAlign(0); CMemoryAlign cMemoryAlign (0);
ALLOC_MEMORY(int16_t, iDct, 128*16); ALLOC_MEMORY (int16_t, iDct, 128 * 16);
ALLOC_MEMORY(int16_t, iLumaDcC, 16); ALLOC_MEMORY (int16_t, iLumaDcC, 16);
ALLOC_MEMORY(int16_t, iLumaDcS, 16); ALLOC_MEMORY (int16_t, iLumaDcS, 16);
srand((unsigned int)time(NULL)); srand ((unsigned int)time (NULL));
for(int i = 0; i < 128*16; i++) for (int i = 0; i < 128 * 16; i++)
iDct[i] = (rand() & 32767) - 16384; iDct[i] = (rand() & 32767) - 16384;
WelsHadamardT4Dc_c(iLumaDcC, iDct); WelsHadamardT4Dc_c (iLumaDcC, iDct);
WelsHadamardT4Dc_sse2(iLumaDcS, iDct); WelsHadamardT4Dc_sse2 (iLumaDcS, iDct);
for(int i = 0;i < 16; i++) for (int i = 0; i < 16; i++)
EXPECT_EQ(iLumaDcC[i], iLumaDcS[i]); EXPECT_EQ (iLumaDcC[i], iLumaDcS[i]);
FREE_MEMORY(iDct); FREE_MEMORY (iDct);
FREE_MEMORY(iLumaDcC); FREE_MEMORY (iLumaDcC);
FREE_MEMORY(iLumaDcS); FREE_MEMORY (iLumaDcS);
} }
#endif #endif

32
test/encoder/EncUT_ExpGolomb.cpp
View File

@ -5,37 +5,37 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
const double g_kdLog2Factor = 1.0 / log(2.0); const double g_kdLog2Factor = 1.0 / log (2.0);
TEST(UeExpGolombTest, TestBsSizeUeLt256) { TEST (UeExpGolombTest, TestBsSizeUeLt256) {
uint32_t uiInVal = 0; uint32_t uiInVal = 0;
for (; uiInVal < 256; ++ uiInVal) { for (; uiInVal < 256; ++ uiInVal) {
const uint32_t uiActVal = BsSizeUE( uiInVal ); const uint32_t uiActVal = BsSizeUE (uiInVal);
const int32_t m = static_cast<int32_t>(log( (uiInVal+1) * 1.0 ) * g_kdLog2Factor + 1e-6); const int32_t m = static_cast<int32_t> (log ((uiInVal + 1) * 1.0) * g_kdLog2Factor + 1e-6);
const uint32_t uiExpVal = (m<<1)+1; const uint32_t uiExpVal = (m << 1) + 1;
EXPECT_EQ(uiActVal, uiExpVal); EXPECT_EQ (uiActVal, uiExpVal);
} }
} }
TEST(UeExpGolombTest, TestBsSizeUeRangeFrom256To65534) { TEST (UeExpGolombTest, TestBsSizeUeRangeFrom256To65534) {
uint32_t uiInVal = 0x100; uint32_t uiInVal = 0x100;
for (; uiInVal < 0xFFFF; ++ uiInVal) { for (; uiInVal < 0xFFFF; ++ uiInVal) {
const uint32_t uiActVal = BsSizeUE( uiInVal ); const uint32_t uiActVal = BsSizeUE (uiInVal);
const int32_t m = static_cast<int32_t>(log( (uiInVal+1) * 1.0 ) * g_kdLog2Factor + 1e-6); const int32_t m = static_cast<int32_t> (log ((uiInVal + 1) * 1.0) * g_kdLog2Factor + 1e-6);
const uint32_t uiExpVal = (m<<1)+1; const uint32_t uiExpVal = (m << 1) + 1;
EXPECT_EQ(uiActVal, uiExpVal); EXPECT_EQ (uiActVal, uiExpVal);
} }
} }
TEST(UeExpGolombTest, TestBsSizeUeRangeFrom65535ToPlus256) { TEST (UeExpGolombTest, TestBsSizeUeRangeFrom65535ToPlus256) {
uint32_t uiInVal = 0xFFFF; uint32_t uiInVal = 0xFFFF;
const uint32_t uiCountBase = 256; const uint32_t uiCountBase = 256;
const uint32_t uiInValEnd = uiInVal + uiCountBase; const uint32_t uiInValEnd = uiInVal + uiCountBase;
for (; uiInVal < uiInValEnd; ++ uiInVal) { for (; uiInVal < uiInValEnd; ++ uiInVal) {
const uint32_t uiActVal = BsSizeUE( uiInVal ); const uint32_t uiActVal = BsSizeUE (uiInVal);
// float precision issue in case use math::log // float precision issue in case use math::log
const int32_t m = WELS_LOG2(1+uiInVal); const int32_t m = WELS_LOG2 (1 + uiInVal);
const uint32_t uiExpVal = (m<<1)+1; const uint32_t uiExpVal = (m << 1) + 1;
EXPECT_EQ(uiActVal, uiExpVal); EXPECT_EQ (uiActVal, uiExpVal);
} }
} }

483
test/encoder/EncUT_GetIntraPredictor.cpp
View File

@ -7,40 +7,39 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredV) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredV) {
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
const int32_t kkiStride = 0; const int32_t kkiStride = 0;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredV_c(pPred, pRef, kkiStride); WelsI4x4LumaPredV_c (pPred, pRef, kkiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&pRef[-kkiStride])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&pRef[-kkiStride]));
delete []pRef; delete []pRef;
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH) TEST (GetIntraPredictorTest, TestGetI4x4LumaPredH) {
{ const int32_t kiStride = rand() % 256 + 16;
const int32_t kiStride = rand()%256+16; const uint32_t kiStride2 = (kiStride << 1) - 1;
const uint32_t kiStride2 = (kiStride<<1)-1;
const uint32_t kiStride3 = kiStride + kiStride2; const uint32_t kiStride3 = kiStride + kiStride2;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[kiStride3+2]; uint8_t* pRef = new uint8_t[kiStride3 + 2];
for (int i=0; i<(static_cast<int32_t>(kiStride3+2)); i++) for (int i = 0; i < (static_cast<int32_t> (kiStride3 + 2)); i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef++; pRef++;
const uint8_t kuiH1 = pRef[-1]; const uint8_t kuiH1 = pRef[-1];
const uint8_t kuiH2 = pRef[kiStride-1]; const uint8_t kuiH2 = pRef[kiStride - 1];
const uint8_t kuiH3 = pRef[kiStride2]; const uint8_t kuiH3 = pRef[kiStride2];
const uint8_t kuiH4 = pRef[kiStride3]; const uint8_t kuiH4 = pRef[kiStride3];
const uint8_t kuiV1[4] = {kuiH1, kuiH1, kuiH1, kuiH1}; const uint8_t kuiV1[4] = {kuiH1, kuiH1, kuiH1, kuiH1};
@ -50,17 +49,17 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH)
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16)// TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
ST32(&uiV[0], LD32(kuiV1)); ST32 (&uiV[0], LD32 (kuiV1));
ST32(&uiV[4], LD32(kuiV2)); ST32 (&uiV[4], LD32 (kuiV2));
ST32(&uiV[8], LD32(kuiV3)); ST32 (&uiV[8], LD32 (kuiV3));
ST32(&uiV[12], LD32(kuiV4)); ST32 (&uiV[12], LD32 (kuiV4));
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredH_c(pPred, pRef, kiStride); WelsI4x4LumaPredH_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]), LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef--; pRef--;
@ -68,105 +67,105 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH)
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDL) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDL) {
const int32_t kiStride = 0; const int32_t kiStride = 0;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiT3 = pRef[3-kiStride]; const uint8_t kuiT3 = pRef[3 - kiStride];
const uint8_t kuiT4 = pRef[4-kiStride]; const uint8_t kuiT4 = pRef[4 - kiStride];
const uint8_t kuiT5 = pRef[5-kiStride]; const uint8_t kuiT5 = pRef[5 - kiStride];
const uint8_t kuiT6 = pRef[6-kiStride]; const uint8_t kuiT6 = pRef[6 - kiStride];
const uint8_t kuiT7 = pRef[7-kiStride]; const uint8_t kuiT7 = pRef[7 - kiStride];
const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2; const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2; const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3<<1))>>2; const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3 << 1)) >> 2;
const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4<<1))>>2; const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4 << 1)) >> 2;
const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5<<1))>>2; const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5 << 1)) >> 2;
const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6<<1))>>2; const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6 << 1)) >> 2;
const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7<<1))>>2; const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7 << 1)) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = kuiDDL0; uiV[0] = kuiDDL0;
uiV[1] = uiV[4] = kuiDDL1; uiV[1] = uiV[4] = kuiDDL1;
uiV[2] = uiV[5] = uiV[8] = kuiDDL2; uiV[2] = uiV[5] = uiV[8] = kuiDDL2;
uiV[3] = uiV[6] = uiV[9] = uiV[12] = kuiDDL3; uiV[3] = uiV[6] = uiV[9] = uiV[12] = kuiDDL3;
uiV[7] = uiV[10]= uiV[13]= kuiDDL4; uiV[7] = uiV[10] = uiV[13] = kuiDDL4;
uiV[11]= uiV[14]= kuiDDL5; uiV[11] = uiV[14] = kuiDDL5;
uiV[15] = kuiDDL6; uiV[15] = kuiDDL6;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredDDL_c(pPred, pRef, kiStride); WelsI4x4LumaPredDDL_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
delete []pRef; delete []pRef;
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) {
const int32_t kiStride = 0; const int32_t kiStride = 0;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiT3 = pRef[3-kiStride]; const uint8_t kuiT3 = pRef[3 - kiStride];
const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2; const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2; const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3<<1))>>2; const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3 << 1)) >> 2;
const uint8_t kuiDLT3 = (2 + (kuiT3<<2))>>2; const uint8_t kuiDLT3 = (2 + (kuiT3 << 2)) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
memset(&uiV[6], kuiDLT3, 10*sizeof(uint8_t)); memset (&uiV[6], kuiDLT3, 10 * sizeof (uint8_t));
uiV[0] = kuiDLT0; uiV[0] = kuiDLT0;
uiV[1] = uiV[4] = kuiDLT1; uiV[1] = uiV[4] = kuiDLT1;
uiV[2] = uiV[5] = uiV[8] = kuiDLT2; uiV[2] = uiV[5] = uiV[8] = kuiDLT2;
uiV[3] = kuiDLT3; uiV[3] = kuiDLT3;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredDDLTop_c(pPred, pRef, kiStride); WelsI4x4LumaPredDDLTop_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
delete []pRef; delete []pRef;
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
const int32_t kiStride = rand()%256+16; const int32_t kiStride = rand() % 256 + 16;
const int32_t kiStride2 = kiStride<<1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[kiStride3+kiStride+1]; uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
for (int i=0; i<kiStride3+kiStride+1; i++) for (int i = 0; i < kiStride3 + kiStride + 1; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef += kiStride + 1; pRef += kiStride + 1;
const uint8_t kuiLT = pRef[-kiStride-1]; const uint8_t kuiLT = pRef[-kiStride - 1];
const uint8_t kuiL0 = pRef[-1]; const uint8_t kuiL0 = pRef[-1];
const uint8_t kuiL1 = pRef[kiStride-1]; const uint8_t kuiL1 = pRef[kiStride - 1];
const uint8_t kuiL2 = pRef[kiStride2-1]; const uint8_t kuiL2 = pRef[kiStride2 - 1];
const uint8_t kuiL3 = pRef[kiStride3-1]; const uint8_t kuiL3 = pRef[kiStride3 - 1];
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiT3 = pRef[3-kiStride]; const uint8_t kuiT3 = pRef[3 - kiStride];
const uint16_t kuiTL0 = 1 + kuiLT + kuiL0; const uint16_t kuiTL0 = 1 + kuiLT + kuiL0;
const uint16_t kuiLT0 = 1 + kuiLT + kuiT0; const uint16_t kuiLT0 = 1 + kuiLT + kuiT0;
const uint16_t kuiT01 = 1 + kuiT0 + kuiT1; const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;
@ -182,21 +181,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2; const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2;
const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2; const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2;
const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2; const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = uiV[5] = uiV[10] = uiV[15] = kuiDDR0; uiV[0] = uiV[5] = uiV[10] = uiV[15] = kuiDDR0;
uiV[1] = uiV[6] = uiV[11] = kuiDDR1; uiV[1] = uiV[6] = uiV[11] = kuiDDR1;
uiV[2] = uiV[7] = kuiDDR2; uiV[2] = uiV[7] = kuiDDR2;
uiV[3] = kuiDDR3; uiV[3] = kuiDDR3;
uiV[4] = uiV[9] = uiV[14] = kuiDDR4; uiV[4] = uiV[9] = uiV[14] = kuiDDR4;
uiV[8] = uiV[13] = kuiDDR5; uiV[8] = uiV[13] = kuiDDR5;
uiV[12]= kuiDDR6; uiV[12] = kuiDDR6;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredDDR_c(pPred, pRef, kiStride); WelsI4x4LumaPredDDR_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef -= kiStride + 1; pRef -= kiStride + 1;
@ -204,94 +203,94 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVL) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVL) {
const int32_t kiStride = 0; const int32_t kiStride = 0;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiT3 = pRef[3-kiStride]; const uint8_t kuiT3 = pRef[3 - kiStride];
const uint8_t kuiT4 = pRef[4-kiStride]; const uint8_t kuiT4 = pRef[4 - kiStride];
const uint8_t kuiT5 = pRef[5-kiStride]; const uint8_t kuiT5 = pRef[5 - kiStride];
const uint8_t kuiT6 = pRef[6-kiStride]; const uint8_t kuiT6 = pRef[6 - kiStride];
const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1)>>1; const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1) >> 1;
const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2)>>1; const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2) >> 1;
const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3)>>1; const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3) >> 1;
const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4)>>1; const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4) >> 1;
const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5)>>1; const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5) >> 1;
const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2; const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2; const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3<<1) + kuiT4)>>2; const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3 << 1) + kuiT4) >> 2;
const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4<<1) + kuiT5)>>2; const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4 << 1) + kuiT5) >> 2;
const uint8_t kuiVL9 = (2 + kuiT4 + (kuiT5<<1) + kuiT6)>>2; const uint8_t kuiVL9 = (2 + kuiT4 + (kuiT5 << 1) + kuiT6) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = kuiVL0; uiV[0] = kuiVL0;
uiV[1] = uiV[8] = kuiVL1; uiV[1] = uiV[8] = kuiVL1;
uiV[2] = uiV[9] = kuiVL2; uiV[2] = uiV[9] = kuiVL2;
uiV[3] = uiV[10]= kuiVL3; uiV[3] = uiV[10] = kuiVL3;
uiV[4] = kuiVL5; uiV[4] = kuiVL5;
uiV[5] = uiV[12] = kuiVL6; uiV[5] = uiV[12] = kuiVL6;
uiV[6] = uiV[13] = kuiVL7; uiV[6] = uiV[13] = kuiVL7;
uiV[7] = uiV[14] = kuiVL8; uiV[7] = uiV[14] = kuiVL8;
uiV[11]= kuiVL4; uiV[11] = kuiVL4;
uiV[15]= kuiVL9; uiV[15] = kuiVL9;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredVL_c(pPred, pRef, kiStride); WelsI4x4LumaPredVL_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
delete []pRef; delete []pRef;
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {
const int32_t kiStride = 0; const int32_t kiStride = 0;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef++; pRef++;
uint8_t *pTopLeft = &pRef[-kiStride-1]; // top-left uint8_t* pTopLeft = &pRef[-kiStride - 1]; // top-left
const uint8_t kuiT0 = *(pTopLeft+1); const uint8_t kuiT0 = * (pTopLeft + 1);
const uint8_t kuiT1 = *(pTopLeft+2); const uint8_t kuiT1 = * (pTopLeft + 2);
const uint8_t kuiT2 = *(pTopLeft+3); const uint8_t kuiT2 = * (pTopLeft + 3);
const uint8_t kuiT3 = *(pTopLeft+4); const uint8_t kuiT3 = * (pTopLeft + 4);
const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1)>>1; const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1) >> 1;
const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2)>>1; const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2) >> 1;
const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3)>>1; const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3) >> 1;
const uint8_t kuiVLT3 = (1 + (kuiT3<<1))>>1; const uint8_t kuiVLT3 = (1 + (kuiT3 << 1)) >> 1;
const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2; const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2; const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3<<1) + kuiT3)>>2; const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3 << 1) + kuiT3) >> 2;
const uint8_t kuiVLT7 = (2 + (kuiT3<<2))>>2; const uint8_t kuiVLT7 = (2 + (kuiT3 << 2)) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = kuiVLT0; uiV[0] = kuiVLT0;
uiV[1] = uiV[8] = kuiVLT1; uiV[1] = uiV[8] = kuiVLT1;
uiV[2] = uiV[9] = kuiVLT2; uiV[2] = uiV[9] = kuiVLT2;
uiV[3] = uiV[10]= uiV[11] = kuiVLT3; uiV[3] = uiV[10] = uiV[11] = kuiVLT3;
uiV[4] = kuiVLT4; uiV[4] = kuiVLT4;
uiV[5] = uiV[12] = kuiVLT5; uiV[5] = uiV[12] = kuiVLT5;
uiV[6] = uiV[13] = kuiVLT6; uiV[6] = uiV[13] = kuiVLT6;
uiV[7] = uiV[14] = uiV[15] = kuiVLT7; uiV[7] = uiV[14] = uiV[15] = kuiVLT7;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredVLTop_c(pPred, pRef, kiStride); WelsI4x4LumaPredVLTop_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef--; pRef--;
@ -299,26 +298,26 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
const int32_t kiStride = rand()%256+16; const int32_t kiStride = rand() % 256 + 16;
const int32_t kiStride2 = kiStride<<1; const int32_t kiStride2 = kiStride << 1;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[kiStride2+kiStride+1]; uint8_t* pRef = new uint8_t[kiStride2 + kiStride + 1];
for (int i=0; i<kiStride2+kiStride+1; i++) for (int i = 0; i < kiStride2 + kiStride + 1; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef += kiStride + 1; pRef += kiStride + 1;
const uint8_t kuiLT = pRef[-kiStride-1]; // top-left const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
const uint8_t kuiL0 = pRef[-1]; const uint8_t kuiL0 = pRef[-1];
const uint8_t kuiL1 = pRef[kiStride-1]; const uint8_t kuiL1 = pRef[kiStride - 1];
const uint8_t kuiL2 = pRef[kiStride2-1]; const uint8_t kuiL2 = pRef[kiStride2 - 1];
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiT3 = pRef[3-kiStride]; const uint8_t kuiT3 = pRef[3 - kiStride];
const uint8_t kuiVR0 = (1 + kuiLT + kuiT0) >> 1; const uint8_t kuiVR0 = (1 + kuiLT + kuiT0) >> 1;
const uint8_t kuiVR1 = (1 + kuiT0 + kuiT1) >> 1; const uint8_t kuiVR1 = (1 + kuiT0 + kuiT1) >> 1;
const uint8_t kuiVR2 = (1 + kuiT1 + kuiT2) >> 1; const uint8_t kuiVR2 = (1 + kuiT1 + kuiT2) >> 1;
@ -329,7 +328,7 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
const uint8_t kuiVR7 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2; const uint8_t kuiVR7 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
const uint8_t kuiVR8 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2; const uint8_t kuiVR8 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
const uint8_t kuiVR9 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2; const uint8_t kuiVR9 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = uiV[9] = kuiVR0; uiV[0] = uiV[9] = kuiVR0;
uiV[1] = uiV[10] = kuiVR1; uiV[1] = uiV[10] = kuiVR1;
uiV[2] = uiV[11] = kuiVR2; uiV[2] = uiV[11] = kuiVR2;
@ -339,14 +338,14 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
uiV[6] = uiV[15] = kuiVR6; uiV[6] = uiV[15] = kuiVR6;
uiV[7] = kuiVR7; uiV[7] = kuiVR7;
uiV[8] = kuiVR8; uiV[8] = kuiVR8;
uiV[12]= kuiVR9; uiV[12] = kuiVR9;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredVR_c(pPred, pRef, kiStride); WelsI4x4LumaPredVR_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef -= kiStride + 1; pRef -= kiStride + 1;
@ -354,23 +353,23 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
const int32_t kiStride = rand()%256+16; const int32_t kiStride = rand() % 256 + 16;
const int32_t kiStride2 = kiStride<<1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[kiStride3+1]; uint8_t* pRef = new uint8_t[kiStride3 + 1];
for (int i=0; i<kiStride3+1; i++) for (int i = 0; i < kiStride3 + 1; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef++; pRef++;
const uint8_t kuiL0 = pRef[-1]; const uint8_t kuiL0 = pRef[-1];
const uint8_t kuiL1 = pRef[kiStride-1]; const uint8_t kuiL1 = pRef[kiStride - 1];
const uint8_t kuiL2 = pRef[kiStride2-1]; const uint8_t kuiL2 = pRef[kiStride2 - 1];
const uint8_t kuiL3 = pRef[kiStride3-1]; const uint8_t kuiL3 = pRef[kiStride3 - 1];
const uint16_t kuiL01 = (1 + kuiL0 + kuiL1); const uint16_t kuiL01 = (1 + kuiL0 + kuiL1);
const uint16_t kuiL12 = (1 + kuiL1 + kuiL2); const uint16_t kuiL12 = (1 + kuiL1 + kuiL2);
const uint16_t kuiL23 = (1 + kuiL2 + kuiL3); const uint16_t kuiL23 = (1 + kuiL2 + kuiL3);
@ -380,21 +379,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
const uint8_t kuiHU3 = (kuiL12 + kuiL23) >> 2; const uint8_t kuiHU3 = (kuiL12 + kuiL23) >> 2;
const uint8_t kuiHU4 = kuiL23 >> 1; const uint8_t kuiHU4 = kuiL23 >> 1;
const uint8_t kuiHU5 = (1 + kuiL23 + (kuiL3 << 1)) >> 2; const uint8_t kuiHU5 = (1 + kuiL23 + (kuiL3 << 1)) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = kuiHU0; uiV[0] = kuiHU0;
uiV[1] = kuiHU1; uiV[1] = kuiHU1;
uiV[2] = uiV[4] = kuiHU2; uiV[2] = uiV[4] = kuiHU2;
uiV[3] = uiV[5] = kuiHU3; uiV[3] = uiV[5] = kuiHU3;
uiV[6] = uiV[8] = kuiHU4; uiV[6] = uiV[8] = kuiHU4;
uiV[7] = uiV[9] = kuiHU5; uiV[7] = uiV[9] = kuiHU5;
memset(&uiV[10], kuiL3, 6*sizeof(uint8_t)); memset (&uiV[10], kuiL3, 6 * sizeof (uint8_t));
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredHU_c(pPred, pRef, kiStride); WelsI4x4LumaPredHU_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef--; pRef--;
@ -402,38 +401,38 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) { TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
const int32_t kiStride = rand()%256+16; const int32_t kiStride = rand() % 256 + 16;
const int32_t kiStride2 = kiStride<<1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[kiStride3+kiStride+1]; uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
for (int i=0; i<kiStride3+kiStride+1; i++) for (int i = 0; i < kiStride3 + kiStride + 1; i++)
pRef[i] = rand() % 256; pRef[i] = rand() % 256;
pRef += kiStride + 1; pRef += kiStride + 1;
const uint8_t kuiLT = pRef[-kiStride-1]; // top-left const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
const uint8_t kuiL0 = pRef[-1]; const uint8_t kuiL0 = pRef[-1];
const uint8_t kuiL1 = pRef[kiStride-1]; const uint8_t kuiL1 = pRef[kiStride - 1];
const uint8_t kuiL2 = pRef[kiStride2-1]; const uint8_t kuiL2 = pRef[kiStride2 - 1];
const uint8_t kuiL3 = pRef[kiStride3-1]; const uint8_t kuiL3 = pRef[kiStride3 - 1];
const uint8_t kuiT0 = pRef[-kiStride]; const uint8_t kuiT0 = pRef[-kiStride];
const uint8_t kuiT1 = pRef[1-kiStride]; const uint8_t kuiT1 = pRef[1 - kiStride];
const uint8_t kuiT2 = pRef[2-kiStride]; const uint8_t kuiT2 = pRef[2 - kiStride];
const uint8_t kuiHD0 = (1 + kuiLT + kuiL0)>>1; const uint8_t kuiHD0 = (1 + kuiLT + kuiL0) >> 1;
const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT<<1) + kuiT0)>>2; const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT << 1) + kuiT0) >> 2;
const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0<<1) + kuiT1)>>2; const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0 << 1) + kuiT1) >> 2;
const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2; const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1)>>1; const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1) >> 1;
const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0<<1) + kuiL1)>>2; const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2)>>1; const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2) >> 1;
const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1<<1) + kuiL2)>>2; const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;
const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3)>>1; const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3) >> 1;
const uint8_t kuiHD9 = (2 + kuiL1 + (kuiL2<<1) + kuiL3)>>2; const uint8_t kuiHD9 = (2 + kuiL1 + (kuiL2 << 1) + kuiL3) >> 2;
ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
uiV[0] = uiV[6] = kuiHD0; uiV[0] = uiV[6] = kuiHD0;
uiV[1] = uiV[7] = kuiHD1; uiV[1] = uiV[7] = kuiHD1;
uiV[2] = kuiHD2; uiV[2] = kuiHD2;
@ -446,11 +445,11 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
uiV[13] = kuiHD9; uiV[13] = kuiHD9;
const uint32_t kuiCpuFlag = 0; const uint32_t kuiCpuFlag = 0;
WelsInitFillingPredFuncs(kuiCpuFlag); WelsInitFillingPredFuncs (kuiCpuFlag);
WelsI4x4LumaPredHD_c(pPred, pRef, kiStride); WelsI4x4LumaPredHD_c (pPred, pRef, kiStride);
for (int i=0; i<4; i++) for (int i = 0; i < 4; i++)
EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i])); EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
pRef -= kiStride + 1; pRef -= kiStride + 1;
@ -458,52 +457,52 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetIChormaPredV) { TEST (GetIntraPredictorTest, TestGetIChormaPredV) {
uint8_t *pPred = new uint8_t[64]; uint8_t* pPred = new uint8_t[64];
uint8_t *pRef = new uint8_t[64]; uint8_t* pRef = new uint8_t[64];
for (int i=0; i<64; i++) for (int i = 0; i < 64; i++)
pRef[i] = rand() % 256 + 1; pRef[i] = rand() % 256 + 1;
const int32_t kiStride = 0; const int32_t kiStride = 0;
WelsIChormaPredV_c(pPred, pRef, kiStride); WelsIChormaPredV_c (pPred, pRef, kiStride);
for (int i=0; i<8; i++) for (int i = 0; i < 8; i++)
EXPECT_EQ(LD32(&pPred[8*i]),LD32(&pRef[-kiStride])); EXPECT_EQ (LD32 (&pPred[8 * i]), LD32 (&pRef[-kiStride]));
delete []pRef; delete []pRef;
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) { TEST (GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {
const int32_t kiStride = rand()%16+16; const int32_t kiStride = rand() % 16 + 16;
int32_t i, j; int32_t i, j;
uint8_t *pPred = new uint8_t[16*kiStride]; uint8_t* pPred = new uint8_t[16 * kiStride];
uint8_t *pRef = new uint8_t[16*kiStride+1]; uint8_t* pRef = new uint8_t[16 * kiStride + 1];
for (i=0; i<16*kiStride+1; i++) for (i = 0; i < 16 * kiStride + 1; i++)
pRef[i]=rand()%256+1; pRef[i] = rand() % 256 + 1;
pRef += kiStride + 1; pRef += kiStride + 1;
int32_t iA=0, iB=0, iC=0, iH=0, iV=0; int32_t iA = 0, iB = 0, iC = 0, iH = 0, iV = 0;
uint8_t *pTop = &pRef[-kiStride]; uint8_t* pTop = &pRef[-kiStride];
uint8_t *pLeft = &pRef[-1]; uint8_t* pLeft = &pRef[-1];
int32_t iPredStride = 16; int32_t iPredStride = 16;
for (i=0; i<8; i++) { for (i = 0; i < 8; i++) {
iH += (i + 1) * (pTop[8 + i] - pTop[6 - i]); iH += (i + 1) * (pTop[8 + i] - pTop[6 - i]);
iV += (i + 1) * (pLeft[(8 + i)*kiStride] - pLeft[(6 - i)*kiStride]); iV += (i + 1) * (pLeft[ (8 + i) * kiStride] - pLeft[ (6 - i) * kiStride]);
} }
iA = (pLeft[15*kiStride] + pTop[15]) << 4; iA = (pLeft[15 * kiStride] + pTop[15]) << 4;
iB = (5 * iH + 32) >> 6; iB = (5 * iH + 32) >> 6;
iC = (5 * iV + 32) >> 6; iC = (5 * iV + 32) >> 6;
WelsI16x16LumaPredPlane_c(pPred, pRef, kiStride); WelsI16x16LumaPredPlane_c (pPred, pRef, kiStride);
for (i=0; i<16; i++) { for (i = 0; i < 16; i++) {
for (j=0; j<16; j++) { for (j = 0; j < 16; j++) {
EXPECT_EQ(pPred[j],(uint8_t)WelsClip1((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5)); EXPECT_EQ (pPred[j], (uint8_t)WelsClip1 ((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5));
} }
pPred += iPredStride; pPred += iPredStride;
} }
@ -514,14 +513,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) { TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
const int32_t kiStride = rand()%16+16; const int32_t kiStride = rand() % 16 + 16;
int i; int i;
uint8_t *pPred = new uint8_t[256]; uint8_t* pPred = new uint8_t[256];
uint8_t *pRef = new uint8_t[16*kiStride]; uint8_t* pRef = new uint8_t[16 * kiStride];
for (i=0; i<16*kiStride; i++) for (i = 0; i < 16 * kiStride; i++)
pRef[i] = rand() % 256 + 1; pRef[i] = rand() % 256 + 1;
pRef += kiStride; pRef += kiStride;
@ -532,14 +531,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
uint8_t uiMean = 0; uint8_t uiMean = 0;
do { do {
iSum += pRef[-1+iTmp] + pRef[-kiStride+i]; iSum += pRef[-1 + iTmp] + pRef[-kiStride + i];
iTmp -= kiStride; iTmp -= kiStride;
} while(i-- > 0); } while (i-- > 0);
uiMean = ( 16 + iSum ) >> 5; uiMean = (16 + iSum) >> 5;
WelsI16x16LumaPredDc_c(pPred, pRef, kiStride); WelsI16x16LumaPredDc_c (pPred, pRef, kiStride);
for (i=0; i<256; i++) for (i = 0; i < 256; i++)
EXPECT_EQ(pPred[i],uiMean); EXPECT_EQ (pPred[i], uiMean);
pRef -= kiStride; pRef -= kiStride;
@ -547,14 +546,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
delete []pPred; delete []pPred;
} }
TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) { TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {
const int32_t kiStride = rand()%16+16; const int32_t kiStride = rand() % 16 + 16;
int i; int i;
uint8_t *pPred = new uint8_t[256]; uint8_t* pPred = new uint8_t[256];
uint8_t *pRef = new uint8_t[16*kiStride]; uint8_t* pRef = new uint8_t[16 * kiStride];
for (i=0; i<16*kiStride; i++) for (i = 0; i < 16 * kiStride; i++)
pRef[i] = rand() % 256 + 1; pRef[i] = rand() % 256 + 1;
pRef += kiStride; pRef += kiStride;
@ -563,13 +562,13 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {
i = 15; i = 15;
uint8_t uiMean = 0; uint8_t uiMean = 0;
do { do {
iSum += pRef[-kiStride+i]; iSum += pRef[-kiStride + i];
} while(i-- > 0); } while (i-- > 0);
uiMean = ( 8 + iSum ) >> 4; uiMean = (8 + iSum) >> 4;
WelsI16x16LumaPredDcTop_c(pPred, pRef, kiStride); WelsI16x16LumaPredDcTop_c (pPred, pRef, kiStride);
for (i=0; i<256; i++) for (i = 0; i < 256; i++)
EXPECT_EQ(pPred[i],uiMean); EXPECT_EQ (pPred[i], uiMean);
pRef -= kiStride; pRef -= kiStride;

68
test/encoder/EncUT_MemoryAlloc.cpp
View File

@ -6,54 +6,54 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
//Tests of WelsGetCacheLineSize Begin //Tests of WelsGetCacheLineSize Begin
TEST(MemoryAlignTest, GetCacheLineSize_LoopWithin16K) { TEST (MemoryAlignTest, GetCacheLineSize_LoopWithin16K) {
const unsigned int kuiTestBoundary16K = 16 * 1024; const unsigned int kuiTestBoundary16K = 16 * 1024;
unsigned int uiTargetAlign = 1; unsigned int uiTargetAlign = 1;
while (uiTargetAlign < kuiTestBoundary16K) { while (uiTargetAlign < kuiTestBoundary16K) {
CMemoryAlign cTestMa(uiTargetAlign); CMemoryAlign cTestMa (uiTargetAlign);
ASSERT_EQ( (uiTargetAlign & 0x0F)?16:uiTargetAlign, cTestMa.WelsGetCacheLineSize() ); ASSERT_EQ ((uiTargetAlign & 0x0F) ? 16 : uiTargetAlign, cTestMa.WelsGetCacheLineSize());
++ uiTargetAlign; ++ uiTargetAlign;
} }
} }
TEST(MemoryAlignTest, GetCacheLineSize_Zero) { TEST (MemoryAlignTest, GetCacheLineSize_Zero) {
CMemoryAlign cTestMa(0); CMemoryAlign cTestMa (0);
const uint32_t kuiSixteen = 16; const uint32_t kuiSixteen = 16;
ASSERT_EQ( kuiSixteen, cTestMa.WelsGetCacheLineSize() ); ASSERT_EQ (kuiSixteen, cTestMa.WelsGetCacheLineSize());
} }
TEST(MemoryAlignTest, GetCacheLineSize_MaxUINT) { TEST (MemoryAlignTest, GetCacheLineSize_MaxUINT) {
CMemoryAlign cTestMa(0xFFFFFFFF); CMemoryAlign cTestMa (0xFFFFFFFF);
const uint32_t kuiSixteen = 16; const uint32_t kuiSixteen = 16;
ASSERT_EQ( kuiSixteen, cTestMa.WelsGetCacheLineSize() ); ASSERT_EQ (kuiSixteen, cTestMa.WelsGetCacheLineSize());
} }
//Tests of WelsGetCacheLineSize End //Tests of WelsGetCacheLineSize End
//Tests of WelsMallocAndFree Begin //Tests of WelsMallocAndFree Begin
TEST(MemoryAlignTest, WelsMallocAndFreeOnceFunctionVerify) { TEST (MemoryAlignTest, WelsMallocAndFreeOnceFunctionVerify) {
const uint32_t kuiTargetAlignSize[4] = {32, 16, 64, 8}; const uint32_t kuiTargetAlignSize[4] = {32, 16, 64, 8};
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
const uint32_t kuiZero = 0; const uint32_t kuiZero = 0;
for (int i=0; i<4; i++) { for (int i = 0; i < 4; i++) {
const uint32_t kuiTestAlignSize = kuiTargetAlignSize[i]; const uint32_t kuiTestAlignSize = kuiTargetAlignSize[i];
const uint32_t kuiTestDataSize = abs(rand()); const uint32_t kuiTestDataSize = abs (rand());
CMemoryAlign cTestMa(kuiTestAlignSize); CMemoryAlign cTestMa (kuiTestAlignSize);
const uint32_t uiSize = kuiTestDataSize; const uint32_t uiSize = kuiTestDataSize;
const char strUnitTestTag[100] = "pUnitTestData"; const char strUnitTestTag[100] = "pUnitTestData";
const uint32_t kuiUsedCacheLineSize = ((kuiTestAlignSize == 0) || (kuiTestAlignSize & 0x0F)) ? (16) : (kuiTestAlignSize); const uint32_t kuiUsedCacheLineSize = ((kuiTestAlignSize == 0)
const uint32_t kuiExtraAlignSize = kuiUsedCacheLineSize-1; || (kuiTestAlignSize & 0x0F)) ? (16) : (kuiTestAlignSize);
const uint32_t kuiExpectedSize = sizeof( void ** ) + sizeof( int32_t ) + kuiExtraAlignSize + uiSize; const uint32_t kuiExtraAlignSize = kuiUsedCacheLineSize - 1;
uint8_t *pUnitTestData = static_cast<uint8_t *>(cTestMa.WelsMalloc(uiSize, strUnitTestTag)); const uint32_t kuiExpectedSize = sizeof (void**) + sizeof (int32_t) + kuiExtraAlignSize + uiSize;
if ( pUnitTestData != NULL ) { uint8_t* pUnitTestData = static_cast<uint8_t*> (cTestMa.WelsMalloc (uiSize, strUnitTestTag));
ASSERT_TRUE( (((uintptr_t)(pUnitTestData)) & kuiExtraAlignSize) == 0 ); if (pUnitTestData != NULL) {
EXPECT_EQ( kuiExpectedSize, cTestMa.WelsGetMemoryUsage() ); ASSERT_TRUE ((((uintptr_t) (pUnitTestData)) & kuiExtraAlignSize) == 0);
cTestMa.WelsFree( pUnitTestData, strUnitTestTag ); EXPECT_EQ (kuiExpectedSize, cTestMa.WelsGetMemoryUsage());
EXPECT_EQ( kuiZero, cTestMa.WelsGetMemoryUsage() ); cTestMa.WelsFree (pUnitTestData, strUnitTestTag);
} EXPECT_EQ (kuiZero, cTestMa.WelsGetMemoryUsage());
else { } else {
EXPECT_EQ( NULL, pUnitTestData ); EXPECT_EQ (NULL, pUnitTestData);
EXPECT_EQ( kuiZero, cTestMa.WelsGetMemoryUsage() ); EXPECT_EQ (kuiZero, cTestMa.WelsGetMemoryUsage());
cTestMa.WelsFree( pUnitTestData, strUnitTestTag ); cTestMa.WelsFree (pUnitTestData, strUnitTestTag);
EXPECT_EQ( kuiZero, cTestMa.WelsGetMemoryUsage() ); EXPECT_EQ (kuiZero, cTestMa.WelsGetMemoryUsage());
} }
} }
} }

296
test/encoder/EncUT_MotionEstimate.cpp
View File

@ -9,30 +9,30 @@
using namespace WelsSVCEnc; using namespace WelsSVCEnc;
void CopyTargetBlock( uint8_t* pSrcBlock, const int32_t kiBlockSize, SMVUnitXY sTargetMv, const int32_t kiRefPicStride, void CopyTargetBlock (uint8_t* pSrcBlock, const int32_t kiBlockSize, SMVUnitXY sTargetMv, const int32_t kiRefPicStride,
uint8_t* pRefPic) { uint8_t* pRefPic) {
uint8_t* pTargetPos = pRefPic+sTargetMv.iMvY*kiRefPicStride+sTargetMv.iMvX; uint8_t* pTargetPos = pRefPic + sTargetMv.iMvY * kiRefPicStride + sTargetMv.iMvX;
uint8_t* pSourcePos = pSrcBlock; uint8_t* pSourcePos = pSrcBlock;
for (int i = 0; i<kiBlockSize; i++) { for (int i = 0; i < kiBlockSize; i++) {
memcpy( pSourcePos, pTargetPos, kiBlockSize*sizeof(uint8_t) ); memcpy (pSourcePos, pTargetPos, kiBlockSize * sizeof (uint8_t));
pTargetPos += kiRefPicStride; pTargetPos += kiRefPicStride;
pSourcePos += kiBlockSize; pSourcePos += kiBlockSize;
} }
} }
void InitMe( const uint8_t kuiQp, const uint32_t kuiMvdTableMiddle, const uint32_t kuiMvdTableStride, void InitMe (const uint8_t kuiQp, const uint32_t kuiMvdTableMiddle, const uint32_t kuiMvdTableStride,
uint16_t* pMvdCostTable, SWelsME* pMe) { uint16_t* pMvdCostTable, SWelsME* pMe) {
MvdCostInit( pMvdCostTable, kuiMvdTableStride ); MvdCostInit (pMvdCostTable, kuiMvdTableStride);
pMe->pMvdCost = &pMvdCostTable[kuiQp*kuiMvdTableStride + kuiMvdTableMiddle]; pMe->pMvdCost = &pMvdCostTable[kuiQp * kuiMvdTableStride + kuiMvdTableMiddle];
pMe->sMvp.iMvX = pMe->sMvp.iMvY = 0; pMe->sMvp.iMvX = pMe->sMvp.iMvY = 0;
pMe->sMvBase.iMvX = pMe->sMvBase.iMvY = 0; pMe->sMvBase.iMvX = pMe->sMvBase.iMvY = 0;
pMe->sMv.iMvX = pMe->sMv.iMvY = 0; pMe->sMv.iMvX = pMe->sMv.iMvY = 0;
} }
class MotionEstimateTest : public ::testing::Test { class MotionEstimateTest : public ::testing::Test {
public: public:
virtual void SetUp() { virtual void SetUp() {
m_pRefData = NULL; m_pRefData = NULL;
m_pSrcBlock = NULL; m_pSrcBlock = NULL;
@ -41,72 +41,72 @@ public:
m_iWidth = 64;//size of search window m_iWidth = 64;//size of search window
m_iHeight = 64;//size of search window m_iHeight = 64;//size of search window
m_iMaxSearchBlock = 16; m_iMaxSearchBlock = 16;
m_uiMvdTableSize = (1 + (648 << 1)); m_uiMvdTableSize = (1 + (648 << 1));
pMa = new CMemoryAlign(0); pMa = new CMemoryAlign (0);
m_pRefData = static_cast<uint8_t *> m_pRefData = static_cast<uint8_t*>
(pMa->WelsMalloc(m_iWidth*m_iHeight, "RefPic")); (pMa->WelsMalloc (m_iWidth * m_iHeight, "RefPic"));
ASSERT_TRUE( NULL != m_pRefData ); ASSERT_TRUE (NULL != m_pRefData);
m_pSrcBlock = static_cast<uint8_t *> m_pSrcBlock = static_cast<uint8_t*>
(pMa->WelsMalloc(m_iMaxSearchBlock*m_iMaxSearchBlock, "SrcBlock")); (pMa->WelsMalloc (m_iMaxSearchBlock * m_iMaxSearchBlock, "SrcBlock"));
ASSERT_TRUE( NULL != m_pSrcBlock ); ASSERT_TRUE (NULL != m_pSrcBlock);
m_pMvdCostTable=new uint16_t[52*m_uiMvdTableSize]; m_pMvdCostTable = new uint16_t[52 * m_uiMvdTableSize];
ASSERT_TRUE( NULL != m_pMvdCostTable ); ASSERT_TRUE (NULL != m_pMvdCostTable);
} }
void DoLineTest(PLineFullSearchFunc func, bool horizontal); void DoLineTest (PLineFullSearchFunc func, bool horizontal);
virtual void TearDown() { virtual void TearDown() {
delete [] m_pMvdCostTable; delete [] m_pMvdCostTable;
pMa->WelsFree( m_pRefData, "RefPic"); pMa->WelsFree (m_pRefData, "RefPic");
pMa->WelsFree( m_pSrcBlock, "SrcBlock"); pMa->WelsFree (m_pSrcBlock, "SrcBlock");
delete pMa; delete pMa;
} }
public: public:
uint8_t *m_pRefData; uint8_t* m_pRefData;
uint8_t *m_pSrcBlock; uint8_t* m_pSrcBlock;
uint32_t m_uiMvdTableSize; uint32_t m_uiMvdTableSize;
uint16_t *m_pMvdCostTable; uint16_t* m_pMvdCostTable;
int32_t m_iWidth; int32_t m_iWidth;
int32_t m_iHeight; int32_t m_iHeight;
int32_t m_iMaxSearchBlock; int32_t m_iMaxSearchBlock;
CMemoryAlign *pMa; CMemoryAlign* pMa;
}; };
TEST_F(MotionEstimateTest, TestDiamondSearch) { TEST_F (MotionEstimateTest, TestDiamondSearch) {
#define TEST_POS (5) #define TEST_POS (5)
const int32_t kiPositionToCheck[TEST_POS][2] = {{0,0}, {0,1}, {1,0}, {0,-1}, {-1,0}}; const int32_t kiPositionToCheck[TEST_POS][2] = {{0, 0}, {0, 1}, {1, 0}, {0, -1}, { -1, 0}};
const int32_t kiMaxBlock16Sad = 72000;//a rough number const int32_t kiMaxBlock16Sad = 72000;//a rough number
SWelsFuncPtrList sFuncList; SWelsFuncPtrList sFuncList;
SWelsME sMe; SWelsME sMe;
SSlice sSlice; SSlice sSlice;
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
const uint8_t kuiQp = rand()%52; const uint8_t kuiQp = rand() % 52;
InitMe(kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe); InitMe (kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe);
SMVUnitXY sTargetMv; SMVUnitXY sTargetMv;
WelsInitSampleSadFunc( &sFuncList, 0 );//test c functions WelsInitSampleSadFunc (&sFuncList, 0); //test c functions
uint8_t *pRefPicCenter = m_pRefData+(m_iHeight/2)*m_iWidth+(m_iWidth/2); uint8_t* pRefPicCenter = m_pRefData + (m_iHeight / 2) * m_iWidth + (m_iWidth / 2);
bool bDataGeneratorSucceed = false; bool bDataGeneratorSucceed = false;
bool bFoundMatch = false; bool bFoundMatch = false;
int32_t i, iTryTimes; int32_t i, iTryTimes;
for (i=0;i<TEST_POS;i++) { for (i = 0; i < TEST_POS; i++) {
sTargetMv.iMvX = kiPositionToCheck[i][0]; sTargetMv.iMvX = kiPositionToCheck[i][0];
sTargetMv.iMvY = kiPositionToCheck[i][1]; sTargetMv.iMvY = kiPositionToCheck[i][1];
iTryTimes = 100; iTryTimes = 100;
bDataGeneratorSucceed = false; bDataGeneratorSucceed = false;
bFoundMatch = false; bFoundMatch = false;
while (!bFoundMatch && (iTryTimes--)>0) { while (!bFoundMatch && (iTryTimes--) > 0) {
if (!YUVPixelDataGenerator( m_pRefData, m_iWidth, m_iHeight, m_iWidth )) if (!YUVPixelDataGenerator (m_pRefData, m_iWidth, m_iHeight, m_iWidth))
continue; continue;
bDataGeneratorSucceed = true; bDataGeneratorSucceed = true;
CopyTargetBlock( m_pSrcBlock, 16, sTargetMv, m_iWidth, pRefPicCenter); CopyTargetBlock (m_pSrcBlock, 16, sTargetMv, m_iWidth, pRefPicCenter);
//clean the sMe status //clean the sMe status
sMe.uiBlockSize = rand()%5; sMe.uiBlockSize = rand() % 5;
sMe.pEncMb = m_pSrcBlock; sMe.pEncMb = m_pSrcBlock;
sMe.pRefMb = pRefPicCenter; sMe.pRefMb = pRefPicCenter;
sMe.sMv.iMvX = sMe.sMv.iMvY = 0; sMe.sMv.iMvX = sMe.sMv.iMvY = 0;
@ -115,122 +115,121 @@ TEST_F(MotionEstimateTest, TestDiamondSearch) {
//the last selection may be affected by MVDcost, that is when (0,0) will be better //the last selection may be affected by MVDcost, that is when (0,0) will be better
//when comparing (1,1) and (1,0), due to the difference between MVD cost, it is possible that (1,0) is selected while the best match is (1,1) //when comparing (1,1) and (1,0), due to the difference between MVD cost, it is possible that (1,0) is selected while the best match is (1,1)
bFoundMatch = ((sMe.sMv.iMvX==(sTargetMv.iMvX))||(sMe.sMv.iMvX==0)) && ((sMe.sMv.iMvY==(sTargetMv.iMvY))||(sMe.sMv.iMvY==0)); bFoundMatch = ((sMe.sMv.iMvX == (sTargetMv.iMvX)) || (sMe.sMv.iMvX == 0)) && ((sMe.sMv.iMvY == (sTargetMv.iMvY))
|| (sMe.sMv.iMvY == 0));
} }
if (bDataGeneratorSucceed) { if (bDataGeneratorSucceed) {
//if DataGenerator never succeed, there is no meaning to check iTryTimes //if DataGenerator never succeed, there is no meaning to check iTryTimes
ASSERT_TRUE(iTryTimes > 0); ASSERT_TRUE (iTryTimes > 0);
//it is possible that ref at differnt position is identical, but that should be under a low probability //it is possible that ref at differnt position is identical, but that should be under a low probability
} }
} }
} }
void MotionEstimateTest::DoLineTest(PLineFullSearchFunc func, bool vertical) { void MotionEstimateTest::DoLineTest (PLineFullSearchFunc func, bool vertical) {
const int32_t kiMaxBlock16Sad = 72000;//a rough number const int32_t kiMaxBlock16Sad = 72000;//a rough number
SWelsFuncPtrList sFuncList; SWelsFuncPtrList sFuncList;
SWelsME sMe; SWelsME sMe;
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
const uint8_t kuiQp = rand()%52; const uint8_t kuiQp = rand() % 52;
InitMe(kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe); InitMe (kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe);
SMVUnitXY sTargetMv; SMVUnitXY sTargetMv;
WelsInitSampleSadFunc( &sFuncList, 0 );//test c functions WelsInitSampleSadFunc (&sFuncList, 0); //test c functions
WelsInitMeFunc(&sFuncList, WelsCPUFeatureDetect(NULL), 1); WelsInitMeFunc (&sFuncList, WelsCPUFeatureDetect (NULL), 1);
uint8_t *pRefPicCenter = m_pRefData+(m_iHeight/2)*m_iWidth+(m_iWidth/2); uint8_t* pRefPicCenter = m_pRefData + (m_iHeight / 2) * m_iWidth + (m_iWidth / 2);
sMe.iCurMeBlockPixX = (m_iWidth/2); sMe.iCurMeBlockPixX = (m_iWidth / 2);
sMe.iCurMeBlockPixY = (m_iHeight/2); sMe.iCurMeBlockPixY = (m_iHeight / 2);
bool bDataGeneratorSucceed = false; bool bDataGeneratorSucceed = false;
bool bFoundMatch = false; bool bFoundMatch = false;
int32_t iTryTimes=100; int32_t iTryTimes = 100;
if (vertical) { if (vertical) {
sTargetMv.iMvX = 0; sTargetMv.iMvX = 0;
sTargetMv.iMvY = -sMe.iCurMeBlockPixY + INTPEL_NEEDED_MARGIN + rand()%(m_iHeight - 16 - 2*INTPEL_NEEDED_MARGIN); sTargetMv.iMvY = -sMe.iCurMeBlockPixY + INTPEL_NEEDED_MARGIN + rand() % (m_iHeight - 16 - 2 * INTPEL_NEEDED_MARGIN);
} else { } else {
sTargetMv.iMvX = -sMe.iCurMeBlockPixX + INTPEL_NEEDED_MARGIN + rand()%(m_iWidth - 16 - 2*INTPEL_NEEDED_MARGIN); sTargetMv.iMvX = -sMe.iCurMeBlockPixX + INTPEL_NEEDED_MARGIN + rand() % (m_iWidth - 16 - 2 * INTPEL_NEEDED_MARGIN);
sTargetMv.iMvY = 0; sTargetMv.iMvY = 0;
} }
bDataGeneratorSucceed = false; bDataGeneratorSucceed = false;
bFoundMatch = false; bFoundMatch = false;
while (!bFoundMatch && (iTryTimes--)>0) { while (!bFoundMatch && (iTryTimes--) > 0) {
if (!YUVPixelDataGenerator( m_pRefData, m_iWidth, m_iHeight, m_iWidth )) if (!YUVPixelDataGenerator (m_pRefData, m_iWidth, m_iHeight, m_iWidth))
continue; continue;
bDataGeneratorSucceed = true; bDataGeneratorSucceed = true;
CopyTargetBlock( m_pSrcBlock, 16, sTargetMv, m_iWidth, pRefPicCenter); CopyTargetBlock (m_pSrcBlock, 16, sTargetMv, m_iWidth, pRefPicCenter);
//clean the sMe status //clean the sMe status
sMe.uiBlockSize = rand()%5; sMe.uiBlockSize = rand() % 5;
sMe.pEncMb = m_pSrcBlock; sMe.pEncMb = m_pSrcBlock;
sMe.pRefMb = pRefPicCenter; sMe.pRefMb = pRefPicCenter;
sMe.pColoRefMb = pRefPicCenter; sMe.pColoRefMb = pRefPicCenter;
sMe.sMv.iMvX = sMe.sMv.iMvY = 0; sMe.sMv.iMvX = sMe.sMv.iMvY = 0;
sMe.uiSadCost = sMe.uiSatdCost = kiMaxBlock16Sad; sMe.uiSadCost = sMe.uiSatdCost = kiMaxBlock16Sad;
const int32_t iCurMeBlockPixX = sMe.iCurMeBlockPixX; const int32_t iCurMeBlockPixX = sMe.iCurMeBlockPixX;
const int32_t iCurMeBlockQpelPixX = ((iCurMeBlockPixX)<<2); const int32_t iCurMeBlockQpelPixX = ((iCurMeBlockPixX) << 2);
const int32_t iCurMeBlockPixY = sMe.iCurMeBlockPixY; const int32_t iCurMeBlockPixY = sMe.iCurMeBlockPixY;
const int32_t iCurMeBlockQpelPixY = ((iCurMeBlockPixY)<<2); const int32_t iCurMeBlockQpelPixY = ((iCurMeBlockPixY) << 2);
uint16_t* pMvdCostX = sMe.pMvdCost - iCurMeBlockQpelPixX - sMe.sMvp.iMvX; //do the offset here uint16_t* pMvdCostX = sMe.pMvdCost - iCurMeBlockQpelPixX - sMe.sMvp.iMvX; //do the offset here
uint16_t* pMvdCostY = sMe.pMvdCost - iCurMeBlockQpelPixY - sMe.sMvp.iMvY; uint16_t* pMvdCostY = sMe.pMvdCost - iCurMeBlockQpelPixY - sMe.sMvp.iMvY;
uint16_t* pMvdCost = vertical ? pMvdCostY : pMvdCostX; uint16_t* pMvdCost = vertical ? pMvdCostY : pMvdCostX;
int iSize = vertical ? m_iHeight : m_iWidth; int iSize = vertical ? m_iHeight : m_iWidth;
int iFixedMvd = vertical ? pMvdCostX[ iCurMeBlockQpelPixX ] : pMvdCostY[ iCurMeBlockQpelPixY ]; int iFixedMvd = vertical ? pMvdCostX[ iCurMeBlockQpelPixX ] : pMvdCostY[ iCurMeBlockQpelPixY ];
func ( &sFuncList, &sMe, func (&sFuncList, &sMe,
pMvdCost, iFixedMvd, pMvdCost, iFixedMvd,
m_iMaxSearchBlock, m_iWidth, m_iMaxSearchBlock, m_iWidth,
INTPEL_NEEDED_MARGIN, INTPEL_NEEDED_MARGIN,
iSize-INTPEL_NEEDED_MARGIN-16, vertical ); iSize - INTPEL_NEEDED_MARGIN - 16, vertical);
//the last selection may be affected by MVDcost, that is when smaller MvY will be better //the last selection may be affected by MVDcost, that is when smaller MvY will be better
if (vertical) { if (vertical) {
bFoundMatch = (sMe.sMv.iMvX==0 bFoundMatch = (sMe.sMv.iMvX == 0
&&(sMe.sMv.iMvY==sTargetMv.iMvY||abs(sMe.sMv.iMvY)<abs(sTargetMv.iMvY))); && (sMe.sMv.iMvY == sTargetMv.iMvY || abs (sMe.sMv.iMvY) < abs (sTargetMv.iMvY)));
} else { } else {
bFoundMatch = (sMe.sMv.iMvY==0 bFoundMatch = (sMe.sMv.iMvY == 0
&&(sMe.sMv.iMvX==sTargetMv.iMvX||abs(sMe.sMv.iMvX)<abs(sTargetMv.iMvX))); && (sMe.sMv.iMvX == sTargetMv.iMvX || abs (sMe.sMv.iMvX) < abs (sTargetMv.iMvX)));
} }
//printf("DoLineTest Target: %d,%d\n", sTargetMv.iMvX, sTargetMv.iMvY); //printf("DoLineTest Target: %d,%d\n", sTargetMv.iMvX, sTargetMv.iMvY);
} }
if (bDataGeneratorSucceed) { if (bDataGeneratorSucceed) {
//if DataGenerator never succeed, there is no meaning to check iTryTimes //if DataGenerator never succeed, there is no meaning to check iTryTimes
ASSERT_TRUE(iTryTimes > 0); ASSERT_TRUE (iTryTimes > 0);
//it is possible that ref at differnt position is identical, but that should be under a low probability //it is possible that ref at differnt position is identical, but that should be under a low probability
} }
} }
TEST_F(MotionEstimateTest, TestVerticalSearch) { TEST_F (MotionEstimateTest, TestVerticalSearch) {
DoLineTest(LineFullSearch_c, true); DoLineTest (LineFullSearch_c, true);
} }
TEST_F(MotionEstimateTest, TestHorizontalSearch) { TEST_F (MotionEstimateTest, TestHorizontalSearch) {
DoLineTest(LineFullSearch_c, false); DoLineTest (LineFullSearch_c, false);
} }
#ifdef X86_ASM #ifdef X86_ASM
TEST_F(MotionEstimateTest, TestVerticalSearch_SSE41) TEST_F (MotionEstimateTest, TestVerticalSearch_SSE41) {
{
int32_t iTmp = 1; int32_t iTmp = 1;
uint32_t uiCPUFlags = WelsCPUFeatureDetect( &iTmp); uint32_t uiCPUFlags = WelsCPUFeatureDetect (&iTmp);
if ((uiCPUFlags & WELS_CPU_SSE41) == 0) return ; if ((uiCPUFlags & WELS_CPU_SSE41) == 0) return ;
DoLineTest(VerticalFullSearchUsingSSE41, true); DoLineTest (VerticalFullSearchUsingSSE41, true);
} }
TEST_F(MotionEstimateTest, TestHorizontalSearch_SSE41) TEST_F (MotionEstimateTest, TestHorizontalSearch_SSE41) {
{
int32_t iTmp = 1; int32_t iTmp = 1;
uint32_t uiCPUFlags = WelsCPUFeatureDetect( &iTmp); uint32_t uiCPUFlags = WelsCPUFeatureDetect (&iTmp);
if ((uiCPUFlags & WELS_CPU_SSE41) == 0) return ; if ((uiCPUFlags & WELS_CPU_SSE41) == 0) return ;
DoLineTest(HorizontalFullSearchUsingSSE41, false); DoLineTest (HorizontalFullSearchUsingSSE41, false);
} }
#endif #endif
class FeatureMotionEstimateTest : public ::testing::Test { class FeatureMotionEstimateTest : public ::testing::Test {
public: public:
virtual void SetUp() { virtual void SetUp() {
m_pRefData = NULL; m_pRefData = NULL;
m_pSrcBlock = NULL; m_pSrcBlock = NULL;
@ -239,66 +238,68 @@ public:
m_iWidth = 64;//size of search window m_iWidth = 64;//size of search window
m_iHeight = 64;//size of search window m_iHeight = 64;//size of search window
m_iMaxSearchBlock = 8; m_iMaxSearchBlock = 8;
m_uiMvdTableSize = (1 + (648 << 1)); m_uiMvdTableSize = (1 + (648 << 1));
m_pMa = new CMemoryAlign(16); m_pMa = new CMemoryAlign (16);
ASSERT_TRUE( NULL != m_pMa ); ASSERT_TRUE (NULL != m_pMa);
m_pRefData = (uint8_t*)m_pMa->WelsMalloc (m_iWidth*m_iHeight*sizeof (uint8_t), "m_pRefData"); m_pRefData = (uint8_t*)m_pMa->WelsMalloc (m_iWidth * m_iHeight * sizeof (uint8_t), "m_pRefData");
ASSERT_TRUE( NULL != m_pRefData ); ASSERT_TRUE (NULL != m_pRefData);
m_pSrcBlock = (uint8_t*)m_pMa->WelsMalloc (m_iMaxSearchBlock*m_iMaxSearchBlock*sizeof (uint8_t), "m_pSrcBlock"); m_pSrcBlock = (uint8_t*)m_pMa->WelsMalloc (m_iMaxSearchBlock * m_iMaxSearchBlock * sizeof (uint8_t), "m_pSrcBlock");
ASSERT_TRUE( NULL != m_pSrcBlock ); ASSERT_TRUE (NULL != m_pSrcBlock);
m_pMvdCostTable = (uint16_t*)m_pMa->WelsMalloc (52*m_uiMvdTableSize*sizeof (uint16_t), "m_pMvdCostTable"); m_pMvdCostTable = (uint16_t*)m_pMa->WelsMalloc (52 * m_uiMvdTableSize * sizeof (uint16_t), "m_pMvdCostTable");
ASSERT_TRUE( NULL != m_pMvdCostTable ); ASSERT_TRUE (NULL != m_pMvdCostTable);
m_pFeatureSearchPreparation = (SFeatureSearchPreparation*)m_pMa->WelsMalloc (sizeof (SFeatureSearchPreparation), "m_pFeatureSearchPreparation"); m_pFeatureSearchPreparation = (SFeatureSearchPreparation*)m_pMa->WelsMalloc (sizeof (SFeatureSearchPreparation),
ASSERT_TRUE( NULL != m_pFeatureSearchPreparation ); "m_pFeatureSearchPreparation");
m_pScreenBlockFeatureStorage = (SScreenBlockFeatureStorage*)m_pMa->WelsMalloc (sizeof (SScreenBlockFeatureStorage), "m_pScreenBlockFeatureStorage"); ASSERT_TRUE (NULL != m_pFeatureSearchPreparation);
ASSERT_TRUE( NULL != m_pScreenBlockFeatureStorage ); m_pScreenBlockFeatureStorage = (SScreenBlockFeatureStorage*)m_pMa->WelsMalloc (sizeof (SScreenBlockFeatureStorage),
"m_pScreenBlockFeatureStorage");
ASSERT_TRUE (NULL != m_pScreenBlockFeatureStorage);
} }
virtual void TearDown() { virtual void TearDown() {
if (m_pMa) { if (m_pMa) {
if (m_pRefData) { if (m_pRefData) {
m_pMa->WelsFree(m_pRefData, "m_pRefData"); m_pMa->WelsFree (m_pRefData, "m_pRefData");
m_pRefData = NULL; m_pRefData = NULL;
} }
if (m_pSrcBlock) { if (m_pSrcBlock) {
m_pMa->WelsFree(m_pSrcBlock, "m_pSrcBlock"); m_pMa->WelsFree (m_pSrcBlock, "m_pSrcBlock");
m_pSrcBlock = NULL; m_pSrcBlock = NULL;
} }
if (m_pMvdCostTable) { if (m_pMvdCostTable) {
m_pMa->WelsFree(m_pMvdCostTable, "m_pMvdCostTable"); m_pMa->WelsFree (m_pMvdCostTable, "m_pMvdCostTable");
m_pMvdCostTable = NULL; m_pMvdCostTable = NULL;
} }
if (m_pFeatureSearchPreparation) { if (m_pFeatureSearchPreparation) {
ReleaseFeatureSearchPreparation( m_pMa, m_pFeatureSearchPreparation->pFeatureOfBlock); ReleaseFeatureSearchPreparation (m_pMa, m_pFeatureSearchPreparation->pFeatureOfBlock);
m_pMa->WelsFree(m_pFeatureSearchPreparation, "m_pFeatureSearchPreparation"); m_pMa->WelsFree (m_pFeatureSearchPreparation, "m_pFeatureSearchPreparation");
m_pFeatureSearchPreparation = NULL; m_pFeatureSearchPreparation = NULL;
} }
if (m_pScreenBlockFeatureStorage) { if (m_pScreenBlockFeatureStorage) {
ReleaseScreenBlockFeatureStorage( m_pMa, m_pScreenBlockFeatureStorage ); ReleaseScreenBlockFeatureStorage (m_pMa, m_pScreenBlockFeatureStorage);
m_pMa->WelsFree(m_pScreenBlockFeatureStorage, "m_pScreenBlockFeatureStorage"); m_pMa->WelsFree (m_pScreenBlockFeatureStorage, "m_pScreenBlockFeatureStorage");
m_pScreenBlockFeatureStorage = NULL; m_pScreenBlockFeatureStorage = NULL;
} }
delete m_pMa; delete m_pMa;
m_pMa = NULL; m_pMa = NULL;
} }
} }
void InitRefPicForMeTest(SPicture* pRefPic) { void InitRefPicForMeTest (SPicture* pRefPic) {
pRefPic->pData[0] = m_pRefData; pRefPic->pData[0] = m_pRefData;
pRefPic->iLineSize[0] = m_iWidth; pRefPic->iLineSize[0] = m_iWidth;
pRefPic->iFrameAverageQp = rand()%52; pRefPic->iFrameAverageQp = rand() % 52;
pRefPic->iWidthInPixel = m_iWidth; pRefPic->iWidthInPixel = m_iWidth;
pRefPic->iHeightInPixel = m_iHeight; pRefPic->iHeightInPixel = m_iHeight;
} }
public: public:
CMemoryAlign* m_pMa; CMemoryAlign* m_pMa;
SFeatureSearchPreparation* m_pFeatureSearchPreparation; SFeatureSearchPreparation* m_pFeatureSearchPreparation;
SScreenBlockFeatureStorage* m_pScreenBlockFeatureStorage; SScreenBlockFeatureStorage* m_pScreenBlockFeatureStorage;
uint8_t *m_pRefData; uint8_t* m_pRefData;
uint8_t *m_pSrcBlock; uint8_t* m_pSrcBlock;
uint16_t *m_pMvdCostTable; uint16_t* m_pMvdCostTable;
uint32_t m_uiMvdTableSize; uint32_t m_uiMvdTableSize;
int32_t m_iWidth; int32_t m_iWidth;
@ -306,52 +307,52 @@ public:
int32_t m_iMaxSearchBlock; int32_t m_iMaxSearchBlock;
}; };
TEST_F(FeatureMotionEstimateTest, TestFeatureSearch) { TEST_F (FeatureMotionEstimateTest, TestFeatureSearch) {
const int32_t kiMaxBlock16Sad = 72000;//a rough number const int32_t kiMaxBlock16Sad = 72000;//a rough number
SWelsFuncPtrList sFuncList; SWelsFuncPtrList sFuncList;
WelsInitSampleSadFunc( &sFuncList, 0 );//test c functions WelsInitSampleSadFunc (&sFuncList, 0); //test c functions
WelsInitMeFunc( &sFuncList, 0, true ); WelsInitMeFunc (&sFuncList, 0, true);
SWelsME sMe; SWelsME sMe;
srand((uint32_t)time(NULL)); srand ((uint32_t)time (NULL));
const uint8_t kuiQp = rand()%52; const uint8_t kuiQp = rand() % 52;
InitMe(kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe); InitMe (kuiQp, 648, m_uiMvdTableSize, m_pMvdCostTable, &sMe);
sMe.iCurMeBlockPixX = (m_iWidth/2); sMe.iCurMeBlockPixX = (m_iWidth / 2);
sMe.iCurMeBlockPixY = (m_iHeight/2); sMe.iCurMeBlockPixY = (m_iHeight / 2);
uint8_t *pRefPicCenter = m_pRefData+(m_iHeight/2)*m_iWidth+(m_iWidth/2); uint8_t* pRefPicCenter = m_pRefData + (m_iHeight / 2) * m_iWidth + (m_iWidth / 2);
SPicture sRef; SPicture sRef;
InitRefPicForMeTest(&sRef); InitRefPicForMeTest (&sRef);
SSlice sSlice; SSlice sSlice;
const int32_t kiSupposedPaddingLength=16; const int32_t kiSupposedPaddingLength = 16;
SetMvWithinIntegerMvRange( m_iWidth/16-kiSupposedPaddingLength, m_iHeight/16-kiSupposedPaddingLength, SetMvWithinIntegerMvRange (m_iWidth / 16 - kiSupposedPaddingLength, m_iHeight / 16 - kiSupposedPaddingLength,
m_iWidth/2/16, m_iHeight/2/16, 508, m_iWidth / 2 / 16, m_iHeight / 2 / 16, 508,
&(sSlice.sMvStartMin), &(sSlice.sMvStartMax)); & (sSlice.sMvStartMin), & (sSlice.sMvStartMax));
int32_t iReturn; int32_t iReturn;
const int32_t kiNeedFeatureStorage = ME_DIA_CROSS_FME; const int32_t kiNeedFeatureStorage = ME_DIA_CROSS_FME;
iReturn = RequestFeatureSearchPreparation( m_pMa, m_iWidth, m_iHeight, kiNeedFeatureStorage, iReturn = RequestFeatureSearchPreparation (m_pMa, m_iWidth, m_iHeight, kiNeedFeatureStorage,
m_pFeatureSearchPreparation); m_pFeatureSearchPreparation);
ASSERT_TRUE( ENC_RETURN_SUCCESS==iReturn ); ASSERT_TRUE (ENC_RETURN_SUCCESS == iReturn);
iReturn = RequestScreenBlockFeatureStorage( m_pMa, m_iWidth, m_iHeight, kiNeedFeatureStorage, iReturn = RequestScreenBlockFeatureStorage (m_pMa, m_iWidth, m_iHeight, kiNeedFeatureStorage,
m_pScreenBlockFeatureStorage); m_pScreenBlockFeatureStorage);
ASSERT_TRUE( ENC_RETURN_SUCCESS==iReturn ); ASSERT_TRUE (ENC_RETURN_SUCCESS == iReturn);
SMVUnitXY sTargetMv; SMVUnitXY sTargetMv;
for (int i=sSlice.sMvStartMin.iMvX; i<=sSlice.sMvStartMax.iMvX;i++) { for (int i = sSlice.sMvStartMin.iMvX; i <= sSlice.sMvStartMax.iMvX; i++) {
for (int j=sSlice.sMvStartMin.iMvY; j<=sSlice.sMvStartMax.iMvY;j++) { for (int j = sSlice.sMvStartMin.iMvY; j <= sSlice.sMvStartMax.iMvY; j++) {
if ( i==0 || j==0) continue;//exclude x=0 or y=0 since that will be skipped by FME if (i == 0 || j == 0) continue; //exclude x=0 or y=0 since that will be skipped by FME
bool bDataGeneratorSucceed = false; bool bDataGeneratorSucceed = false;
bool bFoundMatch = false; bool bFoundMatch = false;
if (!YUVPixelDataGenerator( m_pRefData, m_iWidth, m_iHeight, m_iWidth )) if (!YUVPixelDataGenerator (m_pRefData, m_iWidth, m_iHeight, m_iWidth))
continue; continue;
bDataGeneratorSucceed = true; bDataGeneratorSucceed = true;
sTargetMv.iMvX = i; sTargetMv.iMvX = i;
sTargetMv.iMvY = j; sTargetMv.iMvY = j;
CopyTargetBlock( m_pSrcBlock, m_iMaxSearchBlock, sTargetMv, m_iWidth, pRefPicCenter ); CopyTargetBlock (m_pSrcBlock, m_iMaxSearchBlock, sTargetMv, m_iWidth, pRefPicCenter);
//clean sMe status //clean sMe status
sMe.uiBlockSize = BLOCK_8x8; sMe.uiBlockSize = BLOCK_8x8;
@ -362,22 +363,25 @@ TEST_F(FeatureMotionEstimateTest, TestFeatureSearch) {
sMe.uiSadCost = sMe.uiSatdCost = kiMaxBlock16Sad; sMe.uiSadCost = sMe.uiSatdCost = kiMaxBlock16Sad;
//begin FME process //begin FME process
PerformFMEPreprocess(&sFuncList, &sRef, m_pFeatureSearchPreparation->pFeatureOfBlock, PerformFMEPreprocess (&sFuncList, &sRef, m_pFeatureSearchPreparation->pFeatureOfBlock,
m_pScreenBlockFeatureStorage); m_pScreenBlockFeatureStorage);
m_pScreenBlockFeatureStorage->uiSadCostThreshold[BLOCK_8x8] = UINT_MAX;//to avoid early skip m_pScreenBlockFeatureStorage->uiSadCostThreshold[BLOCK_8x8] = UINT_MAX;//to avoid early skip
uint32_t uiMaxSearchPoint = INT_MAX; uint32_t uiMaxSearchPoint = INT_MAX;
SFeatureSearchIn sFeatureSearchIn = {0}; SFeatureSearchIn sFeatureSearchIn = {0};
if (SetFeatureSearchIn(&sFuncList, sMe, &sSlice, m_pScreenBlockFeatureStorage, if (SetFeatureSearchIn (&sFuncList, sMe, &sSlice, m_pScreenBlockFeatureStorage,
m_iMaxSearchBlock, m_iWidth, m_iMaxSearchBlock, m_iWidth,
&sFeatureSearchIn)) { &sFeatureSearchIn)) {
MotionEstimateFeatureFullSearch( sFeatureSearchIn, uiMaxSearchPoint, &sMe); MotionEstimateFeatureFullSearch (sFeatureSearchIn, uiMaxSearchPoint, &sMe);
} }
bool bMvMatch = sMe.sMv.iMvX==sTargetMv.iMvX && sMe.sMv.iMvY==sTargetMv.iMvY; bool bMvMatch = sMe.sMv.iMvX == sTargetMv.iMvX && sMe.sMv.iMvY == sTargetMv.iMvY;
bool bFeatureMatch = bool bFeatureMatch =
( *(m_pScreenBlockFeatureStorage->pFeatureOfBlockPointer +(m_iHeight/2+sTargetMv.iMvY)*(m_iWidth-8)+(m_iWidth/2+sTargetMv.iMvX)) (* (m_pScreenBlockFeatureStorage->pFeatureOfBlockPointer + (m_iHeight / 2 + sTargetMv.iMvY) * (m_iWidth - 8) +
== *(m_pScreenBlockFeatureStorage->pFeatureOfBlockPointer +(m_iHeight/2+sMe.sMv.iMvY)*(m_iWidth-8)+(m_iWidth/2+sMe.sMv.iMvX)) ) (m_iWidth / 2 + sTargetMv.iMvX))
&& ((sMe.pMvdCost[sMe.sMv.iMvY<<2]+sMe.pMvdCost[sMe.sMv.iMvX<<2]) <= (sMe.pMvdCost[sTargetMv.iMvY<<2]+sMe.pMvdCost[sTargetMv.iMvX<<2])); == * (m_pScreenBlockFeatureStorage->pFeatureOfBlockPointer + (m_iHeight / 2 + sMe.sMv.iMvY) * (m_iWidth - 8) +
(m_iWidth / 2 + sMe.sMv.iMvX)))
&& ((sMe.pMvdCost[sMe.sMv.iMvY << 2] + sMe.pMvdCost[sMe.sMv.iMvX << 2]) <= (sMe.pMvdCost[sTargetMv.iMvY << 2] +
sMe.pMvdCost[sTargetMv.iMvX << 2]));
//the last selection may be affected by MVDcost, that is when smaller Mv will be better //the last selection may be affected by MVDcost, that is when smaller Mv will be better
bFoundMatch = bMvMatch || bFeatureMatch; bFoundMatch = bMvMatch || bFeatureMatch;
@ -385,9 +389,9 @@ TEST_F(FeatureMotionEstimateTest, TestFeatureSearch) {
if (bDataGeneratorSucceed) { if (bDataGeneratorSucceed) {
//if DataGenerator never succeed, there is no meaning to check iTryTimes //if DataGenerator never succeed, there is no meaning to check iTryTimes
if (!bFoundMatch) { if (!bFoundMatch) {
printf("TestFeatureSearch Target: %d,%d, Result: %d,%d\n", sTargetMv.iMvX, sTargetMv.iMvY, sMe.sMv.iMvX, sMe.sMv.iMvY); printf ("TestFeatureSearch Target: %d,%d, Result: %d,%d\n", sTargetMv.iMvX, sTargetMv.iMvY, sMe.sMv.iMvX, sMe.sMv.iMvY);
} }
EXPECT_TRUE(bFoundMatch); EXPECT_TRUE (bFoundMatch);
} }
} }
} }

995
test/encoder/EncUT_Sample.cpp
View File

File diff suppressed because it is too large Load Diff

52
test/processing/ProcessUT_ScrollDetection.cpp
View File

@ -16,36 +16,36 @@ using namespace nsWelsVP;
ASSERT_TRUE(0); \ ASSERT_TRUE(0); \
} }
TEST(ScrollDetectionTest,TestScroll) TEST (ScrollDetectionTest, TestScroll) {
{
unsigned char* pSrc, *pRef; unsigned char* pSrc, *pRef;
int iWidthSets[4] = {640,1024,1280,1980}; int iWidthSets[4] = {640, 1024, 1280, 1980};
int iHeightSets[4] = {360,768,720,1080}; int iHeightSets[4] = {360, 768, 720, 1080};
int iStride = 0; int iStride = 0;
int iIdx = 0; int iIdx = 0;
for(int i=0; i<4; i++){ for (int i = 0; i < 4; i++) {
int iWidth = iWidthSets[i]; int iWidth = iWidthSets[i];
int iHeight = iHeightSets[i]; int iHeight = iHeightSets[i];
iStride = iWidth + 16; iStride = iWidth + 16;
pSrc = new unsigned char[iHeight*iStride]; pSrc = new unsigned char[iHeight * iStride];
ASSERT_TRUE(NULL != pSrc); ASSERT_TRUE (NULL != pSrc);
pRef = new unsigned char[iHeight*iStride]; pRef = new unsigned char[iHeight * iStride];
ASSERT_MEMORY_FAIL2X(pSrc, pRef) ASSERT_MEMORY_FAIL2X (pSrc, pRef)
RandomPixelDataGenerator(pRef, iWidth, iHeight, iStride, iIdx ); RandomPixelDataGenerator (pRef, iWidth, iHeight, iStride, iIdx);
int iMvRange = iHeight/3; int iMvRange = iHeight / 3;
int iScrollMv = rand()%(iMvRange<<1) - iMvRange; int iScrollMv = rand() % (iMvRange << 1) - iMvRange;
unsigned char* pSrcTmp = pSrc; unsigned char* pSrcTmp = pSrc;
unsigned char* pRefTmp = pRef; unsigned char* pRefTmp = pRef;
for (int j=0;j<iHeight;j++) { for (int j = 0; j < iHeight; j++) {
if ((j+iScrollMv)>=0 && (j+iScrollMv)<iHeight) if ((j + iScrollMv) >= 0 && (j + iScrollMv) < iHeight)
for (int i=0;i<iWidth;i++) { for (int i = 0; i < iWidth; i++) {
memcpy(pSrcTmp , &pRefTmp[(j+iScrollMv)*iStride], iWidth*sizeof(unsigned char)); memcpy (pSrcTmp , &pRefTmp[ (j + iScrollMv)*iStride], iWidth * sizeof (unsigned char));
} else { }
for (int i=0;i<iWidth;i++) else {
pSrcTmp[i] = rand()%256; for (int i = 0; i < iWidth; i++)
pSrcTmp[i] = rand() % 256;
} }
pSrcTmp += iStride; pSrcTmp += iStride;
} }
@ -65,16 +65,16 @@ TEST(ScrollDetectionTest,TestScroll)
int iCoreNum = 1; int iCoreNum = 1;
unsigned int uiCPUFlag = WelsCPUFeatureDetect (&iCoreNum); unsigned int uiCPUFlag = WelsCPUFeatureDetect (&iCoreNum);
CScrollDetection *pTest =new CScrollDetection(uiCPUFlag); CScrollDetection* pTest = new CScrollDetection (uiCPUFlag);
int iMethodIdx = METHOD_SCROLL_DETECTION; int iMethodIdx = METHOD_SCROLL_DETECTION;
pTest->Set(iMethodIdx, (&sScrollDetectionResult)); pTest->Set (iMethodIdx, (&sScrollDetectionResult));
int ret = pTest->Process(iMethodIdx,&sSrcMap, &sRefMap); int ret = pTest->Process (iMethodIdx, &sSrcMap, &sRefMap);
EXPECT_EQ(ret,0); EXPECT_EQ (ret, 0);
pTest->Get(iMethodIdx, (&sScrollDetectionResult)); pTest->Get (iMethodIdx, (&sScrollDetectionResult));
EXPECT_EQ(sScrollDetectionResult.bScrollDetectFlag,true); EXPECT_EQ (sScrollDetectionResult.bScrollDetectFlag, true);
EXPECT_EQ(sScrollDetectionResult.iScrollMvY,iScrollMv); EXPECT_EQ (sScrollDetectionResult.iScrollMvY, iScrollMv);
delete pTest; delete pTest;
delete []pSrc; delete []pSrc;

25
test/sha1.h
View File

@ -54,27 +54,26 @@ extern "C" {
* This structure will hold context information for the hashing * This structure will hold context information for the hashing
* operation * operation
*/ */
typedef struct SHA1Context typedef struct SHA1Context {
{ unsigned Message_Digest[5]; /* Message Digest (output) */
unsigned Message_Digest[5]; /* Message Digest (output) */
unsigned Length_Low; /* Message length in bits */ unsigned Length_Low; /* Message length in bits */
unsigned Length_High; /* Message length in bits */ unsigned Length_High; /* Message length in bits */
unsigned char Message_Block[64]; /* 512-bit message blocks */ unsigned char Message_Block[64]; /* 512-bit message blocks */
int Message_Block_Index; /* Index into message block array */ int Message_Block_Index; /* Index into message block array */
int Computed; /* Is the digest computed? */ int Computed; /* Is the digest computed? */
int Corrupted; /* Is the message digest corruped? */ int Corrupted; /* Is the message digest corruped? */
} SHA1Context; } SHA1Context;
/* /*
* Function Prototypes * Function Prototypes
*/ */
void SHA1Reset(SHA1Context *); void SHA1Reset (SHA1Context*);
int SHA1Result(SHA1Context *, unsigned char *); int SHA1Result (SHA1Context*, unsigned char*);
void SHA1Input( SHA1Context *, void SHA1Input (SHA1Context*,
const unsigned char *, const unsigned char*,
unsigned); unsigned);
#define SHA_DIGEST_LENGTH 20 #define SHA_DIGEST_LENGTH 20

32
test/utils/BufferedData.h
View File

@ -8,34 +8,34 @@
class BufferedData { class BufferedData {
public: public:
BufferedData() : data_(NULL), capacity_(0), length_(0) {} BufferedData() : data_ (NULL), capacity_ (0), length_ (0) {}
~BufferedData() { ~BufferedData() {
free(data_); free (data_);
} }
bool PushBack(uint8_t c) { bool PushBack (uint8_t c) {
if (!EnsureCapacity(length_ + 1)) { if (!EnsureCapacity (length_ + 1)) {
return false; return false;
} }
data_[length_++] = c; data_[length_++] = c;
return true; return true;
} }
bool PushBack(const uint8_t* data, size_t len) { bool PushBack (const uint8_t* data, size_t len) {
if (!EnsureCapacity(length_ + len)) { if (!EnsureCapacity (length_ + len)) {
return false; return false;
} }
memcpy(data_ + length_, data, len); memcpy (data_ + length_, data, len);
length_ += len; length_ += len;
return true; return true;
} }
size_t PopFront(uint8_t* ptr, size_t len) { size_t PopFront (uint8_t* ptr, size_t len) {
len = std::min(length_, len); len = std::min (length_, len);
memcpy(ptr, data_, len); memcpy (ptr, data_, len);
memmove(data_, data_ + len, length_ - len); memmove (data_, data_ + len, length_ - len);
SetLength(length_ - len); SetLength (length_ - len);
return len; return len;
} }
@ -43,8 +43,8 @@ class BufferedData {
length_ = 0; length_ = 0;
} }
void SetLength(size_t newLen) { void SetLength (size_t newLen) {
if (EnsureCapacity(newLen)) { if (EnsureCapacity (newLen)) {
length_ = newLen; length_ = newLen;
} }
} }
@ -58,11 +58,11 @@ class BufferedData {
} }
private: private:
bool EnsureCapacity(size_t capacity) { bool EnsureCapacity (size_t capacity) {
if (capacity > capacity_) { if (capacity > capacity_) {
size_t newsize = capacity * 2; size_t newsize = capacity * 2;
uint8_t* data = static_cast<uint8_t*>(realloc(data_, newsize)); uint8_t* data = static_cast<uint8_t*> (realloc (data_, newsize));
if (!data) if (!data)
return false; return false;

8
test/utils/DataGenerator.h
View File

@ -3,13 +3,13 @@
#include "typedefs.h" #include "typedefs.h"
bool YUVPixelDataGenerator( uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ); bool YUVPixelDataGenerator (uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride);
void RandomPixelDataGenerator( uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride, int32_t iIdx ); void RandomPixelDataGenerator (uint8_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride, int32_t iIdx);
void RandomResidueDataGenerator( uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ); void RandomResidueDataGenerator (uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride);
void RandomCoeffDataGenerator( uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride ); void RandomCoeffDataGenerator (uint16_t* pPointer, int32_t iWidth, int32_t iHeight, int32_t iStride);
#endif//DATA_GENERATOR_H__ #endif//DATA_GENERATOR_H__

8
test/utils/FileInputStream.h
View File

@ -6,15 +6,15 @@
class FileInputStream : public InputStream { class FileInputStream : public InputStream {
public: public:
bool Open(const char* fileName) { bool Open (const char* fileName) {
file_.open(fileName, std::ios_base::in | std::ios_base::binary); file_.open (fileName, std::ios_base::in | std::ios_base::binary);
return file_.is_open(); return file_.is_open();
} }
int read(void* ptr, size_t len) { int read (void* ptr, size_t len) {
if (!file_.good()) { if (!file_.good()) {
return -1; return -1;
} }
file_.read(static_cast<char*>(ptr), len); file_.read (static_cast<char*> (ptr), len);
return file_.gcount(); return file_.gcount();
} }
private: private:

6
test/utils/HashFunctions.h
View File

@ -6,13 +6,13 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "../sha1.h" #include "../sha1.h"
static void CompareHash(const unsigned char* digest, const char* hashStr) { static void CompareHash (const unsigned char* digest, const char* hashStr) {
char hashStrCmp[SHA_DIGEST_LENGTH * 2 + 1]; char hashStrCmp[SHA_DIGEST_LENGTH * 2 + 1];
for (int i = 0; i < SHA_DIGEST_LENGTH; ++i) { for (int i = 0; i < SHA_DIGEST_LENGTH; ++i) {
sprintf(&hashStrCmp[i*2], "%.2x", digest[i]); sprintf (&hashStrCmp[i * 2], "%.2x", digest[i]);
} }
hashStrCmp[SHA_DIGEST_LENGTH * 2] = '\0'; hashStrCmp[SHA_DIGEST_LENGTH * 2] = '\0';
EXPECT_STREQ(hashStr, hashStrCmp); EXPECT_STREQ (hashStr, hashStrCmp);
} }
#endif //__HASHFUNCTIONS_H__ #endif //__HASHFUNCTIONS_H__

2
test/utils/InputStream.h
View File

@ -4,7 +4,7 @@
#include <cstddef> #include <cstddef>
struct InputStream { struct InputStream {
virtual int read(void* ptr, size_t len) = 0; virtual int read (void* ptr, size_t len) = 0;
}; };
#endif //__INPUTSTREAM_H__ #endif //__INPUTSTREAM_H__