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

Use void instead of void_t

Browse Source 
There's really no reason for adding a typedef for void.
This commit is contained in:
Martin Storsjö 2014-02-08 23:26:33 +02:00
parent 2b77fe7f49
commit 7b96c6756e
55 changed files with 394 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
codec/common/cpu.h
View File

@ -55,12 +55,12 @@ extern "C" {
*/ */
int32_t WelsCPUIdVerify(); int32_t WelsCPUIdVerify();
void_t WelsCPUId (uint32_t uiIndex, uint32_t* pFeatureA, uint32_t* pFeatureB, uint32_t* pFeatureC, uint32_t* pFeatureD); void WelsCPUId (uint32_t uiIndex, uint32_t* pFeatureA, uint32_t* pFeatureB, uint32_t* pFeatureC, uint32_t* pFeatureD);
int32_t WelsCPUSupportAVX (uint32_t eax, uint32_t ecx); int32_t WelsCPUSupportAVX (uint32_t eax, uint32_t ecx);
int32_t WelsCPUSupportFMA (uint32_t eax, uint32_t ecx); int32_t WelsCPUSupportFMA (uint32_t eax, uint32_t ecx);
void_t WelsEmms(); void WelsEmms();
uint32_t WelsCPUFeatureDetect (int32_t* pNumberOfLogicProcessors); uint32_t WelsCPUFeatureDetect (int32_t* pNumberOfLogicProcessors);

2
codec/common/crt_util_safe_x.cpp
View File

@ -239,7 +239,7 @@ str_t* WelsStrcat (str_t* pDest, int32_t iSizeInBytes, const str_t* kpSrc) {
return WelsStrncpy(pDest + iCurLen, iSizeInBytes - iCurLen, kpSrc); return WelsStrncpy(pDest + iCurLen, iSizeInBytes - iCurLen, kpSrc);
} }
int32_t WelsFwrite (const void_t* kpBuffer, int32_t iSize, int32_t iCount, WelsFileHandle* pFp) { int32_t WelsFwrite (const void* kpBuffer, int32_t iSize, int32_t iCount, WelsFileHandle* pFp) {
return fwrite (kpBuffer, iSize, iCount, pFp); return fwrite (kpBuffer, iSize, iCount, pFp);
} }

24
codec/common/deblocking_common.cpp
View File

@ -1,7 +1,7 @@
#include "deblocking_common.h" #include "deblocking_common.h"
#include "macros.h" #include "macros.h"
// C code only // C code only
void_t DeblockLumaLt4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta, void DeblockLumaLt4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta,
int8_t* pTc) { int8_t* pTc) {
for (int32_t i = 0; i < 16; i++) { for (int32_t i = 0; i < 16; i++) {
int32_t iTc0 = pTc[i >> 2]; int32_t iTc0 = pTc[i >> 2];
@ -35,7 +35,7 @@ void_t DeblockLumaLt4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int3
pPix += iStrideY; pPix += iStrideY;
} }
} }
void_t DeblockLumaEq4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta) { void DeblockLumaEq4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, int32_t iBeta) {
int32_t p0, p1, p2, q0, q1, q2; int32_t p0, p1, p2, q0, q1, q2;
int32_t iDetaP0Q0; int32_t iDetaP0Q0;
bool bDetaP1P0, bDetaQ1Q0; bool bDetaP1P0, bDetaQ1Q0;
@ -77,19 +77,19 @@ void_t DeblockLumaEq4_c (uint8_t* pPix, int32_t iStrideX, int32_t iStrideY, int3
pPix += iStrideY; pPix += iStrideY;
} }
} }
void_t DeblockLumaLt4V_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* tc) { void DeblockLumaLt4V_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* tc) {
DeblockLumaLt4_c (pPix, iStride, 1, iAlpha, iBeta, tc); DeblockLumaLt4_c (pPix, iStride, 1, iAlpha, iBeta, tc);
} }
void_t DeblockLumaLt4H_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* tc) { void DeblockLumaLt4H_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* tc) {
DeblockLumaLt4_c (pPix, 1, iStride, iAlpha, iBeta, tc); DeblockLumaLt4_c (pPix, 1, iStride, iAlpha, iBeta, tc);
} }
void_t DeblockLumaEq4V_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta) { void DeblockLumaEq4V_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta) {
DeblockLumaEq4_c (pPix, iStride, 1, iAlpha, iBeta); DeblockLumaEq4_c (pPix, iStride, 1, iAlpha, iBeta);
} }
void_t DeblockLumaEq4H_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta) { void DeblockLumaEq4H_c (uint8_t* pPix, int32_t iStride, int32_t iAlpha, int32_t iBeta) {
DeblockLumaEq4_c (pPix, 1, iStride, iAlpha, iBeta); DeblockLumaEq4_c (pPix, 1, iStride, iAlpha, iBeta);
} }
void_t DeblockChromaLt4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, void DeblockChromaLt4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha,
int32_t iBeta, int8_t* pTc) { int32_t iBeta, int8_t* pTc) {
int32_t p0, p1, q0, q1, iDeta; int32_t p0, p1, q0, q1, iDeta;
bool bDetaP0Q0, bDetaP1P0, bDetaQ1Q0; bool bDetaP0Q0, bDetaP1P0, bDetaQ1Q0;
@ -131,7 +131,7 @@ void_t DeblockChromaLt4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, i
pPixCr += iStrideY; pPixCr += iStrideY;
} }
} }
void_t DeblockChromaEq4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha, void DeblockChromaEq4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, int32_t iStrideY, int32_t iAlpha,
int32_t iBeta) { int32_t iBeta) {
int32_t p0, p1, q0, q1; int32_t p0, p1, q0, q1;
bool bDetaP0Q0, bDetaP1P0, bDetaQ1Q0; bool bDetaP0Q0, bDetaP1P0, bDetaQ1Q0;
@ -165,18 +165,18 @@ void_t DeblockChromaEq4_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStrideX, i
pPixCb += iStrideY; pPixCb += iStrideY;
} }
} }
void_t DeblockChromaLt4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* tc) { int8_t* tc) {
DeblockChromaLt4_c (pPixCb, pPixCr, iStride, 1, iAlpha, iBeta, tc); DeblockChromaLt4_c (pPixCb, pPixCr, iStride, 1, iAlpha, iBeta, tc);
} }
void_t DeblockChromaLt4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* tc) { int8_t* tc) {
DeblockChromaLt4_c (pPixCb, pPixCr, 1, iStride, iAlpha, iBeta, tc); DeblockChromaLt4_c (pPixCb, pPixCr, 1, iStride, iAlpha, iBeta, tc);
} }
void_t DeblockChromaEq4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta) { void DeblockChromaEq4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta) {
DeblockChromaEq4_c (pPixCb, pPixCr, iStride, 1, iAlpha, iBeta); DeblockChromaEq4_c (pPixCb, pPixCr, iStride, 1, iAlpha, iBeta);
} }
void_t DeblockChromaEq4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta) { void DeblockChromaEq4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta) {
DeblockChromaEq4_c (pPixCb, pPixCr, 1, iStride, iAlpha, iBeta); DeblockChromaEq4_c (pPixCb, pPixCr, 1, iStride, iAlpha, iBeta);
} }

16
codec/common/deblocking_common.h
View File

@ -1,19 +1,19 @@
#ifndef WELS_DEBLOCKING_COMMON_H__ #ifndef WELS_DEBLOCKING_COMMON_H__
#define WELS_DEBLOCKING_COMMON_H__ #define WELS_DEBLOCKING_COMMON_H__
#include "typedefs.h" #include "typedefs.h"
void_t DeblockLumaLt4V_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc); void DeblockLumaLt4V_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc);
void_t DeblockLumaEq4V_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockLumaEq4V_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta);
void_t DeblockLumaLt4H_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc); void DeblockLumaLt4H_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta, int8_t* pTc);
void_t DeblockLumaEq4H_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockLumaEq4H_c (uint8_t* pPixY, int32_t iStride, int32_t iAlpha, int32_t iBeta);
void_t DeblockChromaLt4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* pTc); int8_t* pTc);
void_t DeblockChromaEq4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockChromaEq4V_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
void_t DeblockChromaLt4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta, void DeblockChromaLt4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* pTc); int8_t* pTc);
void_t DeblockChromaEq4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta); void DeblockChromaEq4H_c (uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, int32_t iAlpha, int32_t iBeta);
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
#define DEBLOCK_BS_SHIFTED(x) ((x) | ((x) << 8)) #define DEBLOCK_BS_SHIFTED(x) ((x) | ((x) << 8))

6
codec/common/ls_defines.h
View File

@ -57,9 +57,9 @@ struct tagUnaligned_16 {
#define ST32(a, b) (((struct tagUnaligned_32 *) (a))->l) = (b) #define ST32(a, b) (((struct tagUnaligned_32 *) (a))->l) = (b)
#define ST64(a, b) (((struct tagUnaligned_64 *) (a))->l) = (b) #define ST64(a, b) (((struct tagUnaligned_64 *) (a))->l) = (b)
// #else // #else
// inline void_t __ST16(void_t *dst, uint16_t v) { memcpy(dst, &v, 2); } // inline void __ST16(void *dst, uint16_t v) { memcpy(dst, &v, 2); }
// inline void_t __ST32(void_t *dst, uint32_t v) { memcpy(dst, &v, 4); } // inline void __ST32(void *dst, uint32_t v) { memcpy(dst, &v, 4); }
//inline void_t __ST64(void_t *dst, uint64_t v) { memcpy(dst, &v, 8); } //inline void __ST64(void *dst, uint64_t v) { memcpy(dst, &v, 8); }
// #endif // #endif
#else #else

12
codec/common/mb_copy.asm
View File

@ -432,7 +432,7 @@ WELS_EXTERN McCopyWidthEq16_sse2
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t PixelAvgWidthEq4_mmx( uint8_t *pDst, int iDstStride, ; void PixelAvgWidthEq4_mmx( uint8_t *pDst, int iDstStride,
; uint8_t *pSrcA, int iSrcAStride, ; uint8_t *pSrcA, int iSrcAStride,
; uint8_t *pSrcB, int iSrcBStride, ; uint8_t *pSrcB, int iSrcBStride,
; int iHeight ); ; int iHeight );
@ -468,7 +468,7 @@ ALIGN 4
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t PixelAvgWidthEq8_mmx( uint8_t *pDst, int iDstStride, ; void PixelAvgWidthEq8_mmx( uint8_t *pDst, int iDstStride,
; uint8_t *pSrcA, int iSrcAStride, ; uint8_t *pSrcA, int iSrcAStride,
; uint8_t *pSrcB, int iSrcBStride, ; uint8_t *pSrcB, int iSrcBStride,
; int iHeight ); ; int iHeight );
@ -522,7 +522,7 @@ ALIGN 4
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t PixelAvgWidthEq16_sse2( uint8_t *pDst, int iDstStride, ; void PixelAvgWidthEq16_sse2( uint8_t *pDst, int iDstStride,
; uint8_t *pSrcA, int iSrcAStride, ; uint8_t *pSrcA, int iSrcAStride,
; uint8_t *pSrcB, int iSrcBStride, ; uint8_t *pSrcB, int iSrcBStride,
; int iHeight ); ; int iHeight );
@ -577,7 +577,7 @@ ALIGN 4
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McCopyWidthEq4_mmx( uint8_t *pSrc, int iSrcStride, ; void McCopyWidthEq4_mmx( uint8_t *pSrc, int iSrcStride,
; uint8_t *pDst, int iDstStride, int iHeight ) ; uint8_t *pDst, int iDstStride, int iHeight )
;******************************************************************************* ;*******************************************************************************
McCopyWidthEq4_mmx: McCopyWidthEq4_mmx:
@ -618,7 +618,7 @@ ALIGN 4
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McCopyWidthEq8_mmx( uint8_t *pSrc, int iSrcStride, ; void McCopyWidthEq8_mmx( uint8_t *pSrc, int iSrcStride,
; uint8_t *pDst, int iDstStride, int iHeight ) ; uint8_t *pDst, int iDstStride, int iHeight )
;******************************************************************************* ;*******************************************************************************
McCopyWidthEq8_mmx: McCopyWidthEq8_mmx:
@ -655,7 +655,7 @@ ALIGN 4
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McCopyWidthEq16_sse2( uint8_t *pSrc, int iSrcStride, uint8_t *pDst, int iDstStride, int iHeight ) ; void McCopyWidthEq16_sse2( uint8_t *pSrc, int iSrcStride, uint8_t *pDst, int iDstStride, int iHeight )
;******************************************************************************* ;*******************************************************************************
;read unaligned memory ;read unaligned memory
%macro SSE_READ_UNA 2 %macro SSE_READ_UNA 2

12
codec/common/mc_luma.asm
View File

@ -76,7 +76,7 @@ WELS_EXTERN McHorVer20WidthEq4_mmx
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McHorVer20WidthEq4_mmx( uint8_t *pSrc, ; void McHorVer20WidthEq4_mmx( uint8_t *pSrc,
; int iSrcStride, ; int iSrcStride,
; uint8_t *pDst, ; uint8_t *pDst,
; int iDstStride, ; int iDstStride,
@ -179,7 +179,7 @@ WELS_EXTERN McHorVer20WidthEq16_sse2
ALIGN 16 ALIGN 16
;*********************************************************************** ;***********************************************************************
; void_t McHorVer22Width8HorFirst_sse2(int16_t *pSrc, ; void McHorVer22Width8HorFirst_sse2(int16_t *pSrc,
; int16_t iSrcStride, ; int16_t iSrcStride,
; uint8_t *pDst, ; uint8_t *pDst,
; int32_t iDstStride ; int32_t iDstStride
@ -241,7 +241,7 @@ McHorVer22Width8HorFirst_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McHorVer20WidthEq8_sse2( uint8_t *pSrc, ; void McHorVer20WidthEq8_sse2( uint8_t *pSrc,
; int iSrcStride, ; int iSrcStride,
; uint8_t *pDst, ; uint8_t *pDst,
; int iDstStride, ; int iDstStride,
@ -307,7 +307,7 @@ McHorVer20WidthEq8_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t McHorVer20WidthEq16_sse2( uint8_t *pSrc, ; void McHorVer20WidthEq16_sse2( uint8_t *pSrc,
; int iSrcStride, ; int iSrcStride,
; uint8_t *pDst, ; uint8_t *pDst,
; int iDstStride, ; int iDstStride,
@ -398,7 +398,7 @@ McHorVer20WidthEq16_sse2:
;******************************************************************************* ;*******************************************************************************
; void_t McHorVer02WidthEq8_sse2( uint8_t *pSrc, ; void McHorVer02WidthEq8_sse2( uint8_t *pSrc,
; int iSrcStride, ; int iSrcStride,
; uint8_t *pDst, ; uint8_t *pDst,
; int iDstStride, ; int iDstStride,
@ -1290,4 +1290,4 @@ McHorVer22HorFirst_sse2:
pop r12 pop r12
%endif %endif
LOAD_6_PARA_POP LOAD_6_PARA_POP
ret ret

4
codec/common/measure_time.h
View File

@ -57,11 +57,11 @@ extern "C" {
/*! /*!
* \brief time cost measure utilization * \brief time cost measure utilization
* \param void_t * \param void
* \return time elapsed since run (unit: microsecond) * \return time elapsed since run (unit: microsecond)
*/ */
static inline int64_t WelsTime (void_t) { static inline int64_t WelsTime (void) {
#ifndef _WIN32 #ifndef _WIN32
struct timeval tv_date; struct timeval tv_date;

4
codec/common/typedefs.h
View File

@ -77,9 +77,5 @@ typedef char str_t;
#define TRUE ((int32_t)1) #define TRUE ((int32_t)1)
#endif//TRUE #endif//TRUE
#ifndef void_t
#define void_t void
#endif
#endif //WELS_TYPE_DEFINES_H__ #endif //WELS_TYPE_DEFINES_H__

14
codec/console/dec/src/h264dec.cpp
View File

@ -57,8 +57,8 @@ using namespace std;
//#define STICK_STREAM_SIZE // For Demo interfaces test with track file of integrated frames //#define STICK_STREAM_SIZE // For Demo interfaces test with track file of integrated frames
void_t H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, const char* kpOuputFileName, void H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, const char* kpOuputFileName,
int32_t& iWidth, int32_t& iHeight, void_t* pOptionFileName) { int32_t& iWidth, int32_t& iHeight, void* pOptionFileName) {
FILE* pH264File = NULL; FILE* pH264File = NULL;
FILE* pYuvFile = NULL; FILE* pYuvFile = NULL;
FILE* pOptionFile = NULL; FILE* pOptionFile = NULL;
@ -68,7 +68,7 @@ void_t H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, co
uint8_t* pBuf = NULL; uint8_t* pBuf = NULL;
uint8_t uiStartCode[4] = {0, 0, 0, 1}; uint8_t uiStartCode[4] = {0, 0, 0, 1};
void_t* pData[3] = {NULL}; void* pData[3] = {NULL};
uint8_t* pDst[3] = {NULL}; uint8_t* pDst[3] = {NULL};
SBufferInfo sDstBufInfo; SBufferInfo sDstBufInfo;
@ -171,7 +171,7 @@ void_t H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, co
if (iBufPos >= iFileSize) { if (iBufPos >= iFileSize) {
iEndOfStreamFlag = true; iEndOfStreamFlag = true;
if (iEndOfStreamFlag) if (iEndOfStreamFlag)
pDecoder->SetOption (DECODER_OPTION_END_OF_STREAM, (void_t*)&iEndOfStreamFlag); pDecoder->SetOption (DECODER_OPTION_END_OF_STREAM, (void*)&iEndOfStreamFlag);
break; break;
} }
@ -228,7 +228,7 @@ void_t H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, co
iTotal += iEnd - iStart; iTotal += iEnd - iStart;
if (sDstBufInfo.iBufferStatus == 1) { if (sDstBufInfo.iBufferStatus == 1) {
iFrameNum++; iFrameNum++;
cOutputModule.Process ((void_t**)pDst, &sDstBufInfo, pYuvFile); cOutputModule.Process ((void**)pDst, &sDstBufInfo, pYuvFile);
if (sDstBufInfo.eBufferProperty == BUFFER_HOST) { if (sDstBufInfo.eBufferProperty == BUFFER_HOST) {
iWidth = sDstBufInfo.UsrData.sSystemBuffer.iWidth; iWidth = sDstBufInfo.UsrData.sSystemBuffer.iWidth;
iHeight = sDstBufInfo.UsrData.sSystemBuffer.iHeight; iHeight = sDstBufInfo.UsrData.sSystemBuffer.iHeight;
@ -267,7 +267,7 @@ void_t H264DecodeInstance (ISVCDecoder* pDecoder, const char* kpH264FileName, co
} }
if (sDstBufInfo.iBufferStatus == 1) { if (sDstBufInfo.iBufferStatus == 1) {
cOutputModule.Process ((void_t**)pDst, &sDstBufInfo, pYuvFile); cOutputModule.Process ((void**)pDst, &sDstBufInfo, pYuvFile);
if (sDstBufInfo.eBufferProperty == BUFFER_HOST) { if (sDstBufInfo.eBufferProperty == BUFFER_HOST) {
iWidth = sDstBufInfo.UsrData.sSystemBuffer.iWidth; iWidth = sDstBufInfo.UsrData.sSystemBuffer.iWidth;
iHeight = sDstBufInfo.UsrData.sSystemBuffer.iHeight; iHeight = sDstBufInfo.UsrData.sSystemBuffer.iHeight;
@ -446,7 +446,7 @@ int32_t main (int32_t iArgC, char* pArgV[]) {
H264DecodeInstance (pDecoder, strInputFile.c_str(), strOutputFile.c_str(), iWidth, iHeight, H264DecodeInstance (pDecoder, strInputFile.c_str(), strOutputFile.c_str(), iWidth, iHeight,
(!strOptionFile.empty() ? (void_t*) (const_cast<char*> (strOptionFile.c_str())) : NULL)); (!strOptionFile.empty() ? (void*) (const_cast<char*> (strOptionFile.c_str())) : NULL));
if (sDecParam.pFileNameRestructed != NULL) { if (sDecParam.pFileNameRestructed != NULL) {
delete []sDecParam.pFileNameRestructed; delete []sDecParam.pFileNameRestructed;

4
codec/decoder/core/asm/block_add.asm
View File

@ -53,7 +53,7 @@ WELS_EXTERN WelsResBlockZero16x16_sse2
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsResBlockZero16x16_sse2(int16_t* pBlock,int32_t iStride) ; void WelsResBlockZero16x16_sse2(int16_t* pBlock,int32_t iStride)
;******************************************************************************* ;*******************************************************************************
WelsResBlockZero16x16_sse2: WelsResBlockZero16x16_sse2:
;push r0 ;push r0
@ -134,7 +134,7 @@ WELS_EXTERN WelsResBlockZero8x8_sse2
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsResBlockZero8x8_sse2(int16_t * pBlock, int32_t iStride) ; void WelsResBlockZero8x8_sse2(int16_t * pBlock, int32_t iStride)
;******************************************************************************* ;*******************************************************************************
WelsResBlockZero8x8_sse2: WelsResBlockZero8x8_sse2:
;push r0 ;push r0

2
codec/decoder/core/asm/dct.asm
View File

@ -87,7 +87,7 @@ WELS_EXTERN IdctResAddPred_mmx
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t __cdecl IdctResAddPred_mmx( uint8_t *pPred, const int32_t kiStride, int16_t *pRs ) ; void __cdecl IdctResAddPred_mmx( uint8_t *pPred, const int32_t kiStride, int16_t *pRs )
;******************************************************************************* ;*******************************************************************************
IdctResAddPred_mmx: IdctResAddPred_mmx:

40
codec/decoder/core/asm/intra_pred.asm
View File

@ -184,7 +184,7 @@ WELS_EXTERN WelsDecoderI16x16LumaPredPlane_sse2
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t __cdecl WelsDecoderI4x4LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride) ; void __cdecl WelsDecoderI4x4LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride)
; ;
; pPred must align to 16 ; pPred must align to 16
;******************************************************************************* ;*******************************************************************************
@ -224,7 +224,7 @@ WelsDecoderI4x4LumaPredH_sse2:
ret ret
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderI16x16LumaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride); ; void WelsDecoderI16x16LumaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride);
;******************************************************************************* ;*******************************************************************************
WelsDecoderI16x16LumaPredPlane_sse2: WelsDecoderI16x16LumaPredPlane_sse2:
;%define pushsize 4 ;%define pushsize 4
@ -325,7 +325,7 @@ get_i16x16_luma_pred_plane_sse2_1:
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderI16x16LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride); ; void WelsDecoderI16x16LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride);
;******************************************************************************* ;*******************************************************************************
%macro SSE2_PRED_H_16X16_TWO_LINE_DEC 2 %macro SSE2_PRED_H_16X16_TWO_LINE_DEC 2
@ -363,7 +363,7 @@ WelsDecoderI16x16LumaPredH_sse2:
ret ret
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderI16x16LumaPredV_sse2(uint8_t *pPred, const int32_t kiStride); ; void WelsDecoderI16x16LumaPredV_sse2(uint8_t *pPred, const int32_t kiStride);
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI16x16LumaPredV_sse2 WELS_EXTERN WelsDecoderI16x16LumaPredV_sse2
WelsDecoderI16x16LumaPredV_sse2: WelsDecoderI16x16LumaPredV_sse2:
@ -406,7 +406,7 @@ WelsDecoderI16x16LumaPredV_sse2:
ret ret
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderIChromaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride); ; void WelsDecoderIChromaPredPlane_sse2(uint8_t *pPred, const int32_t kiStride);
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredPlane_sse2 WELS_EXTERN WelsDecoderIChromaPredPlane_sse2
WelsDecoderIChromaPredPlane_sse2: WelsDecoderIChromaPredPlane_sse2:
@ -515,7 +515,7 @@ ALIGN 16
; 7 is the start pixel of current 4x4 block ; 7 is the start pixel of current 4x4 block
; pPred[7] = ([6]+[0]*2+[1]+2)/4 ; pPred[7] = ([6]+[0]*2+[1]+2)/4
; ;
; void_t __cdecl WelsDecoderI4x4LumaPredDDR_mmx(uint8_t *pPred, const int32_t kiStride) ; void __cdecl WelsDecoderI4x4LumaPredDDR_mmx(uint8_t *pPred, const int32_t kiStride)
; ;
;******************************************************************************* ;*******************************************************************************
WelsDecoderI4x4LumaPredDDR_mmx: WelsDecoderI4x4LumaPredDDR_mmx:
@ -571,7 +571,7 @@ WelsDecoderI4x4LumaPredDDR_mmx:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t __cdecl WelsDecoderIChromaPredH_mmx(uint8_t *pPred, const int32_t kiStride) ; void __cdecl WelsDecoderIChromaPredH_mmx(uint8_t *pPred, const int32_t kiStride)
; copy 8 pixel of 8 line from left ; copy 8 pixel of 8 line from left
;******************************************************************************* ;*******************************************************************************
%macro MMX_PRED_H_8X8_ONE_LINE 4 %macro MMX_PRED_H_8X8_ONE_LINE 4
@ -637,7 +637,7 @@ WelsDecoderIChromaPredH_mmx:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t __cdecl WelsDecoderIChromaPredV_mmx(uint8_t *pPred, const int32_t kiStride) ; void __cdecl WelsDecoderIChromaPredV_mmx(uint8_t *pPred, const int32_t kiStride)
; copy 8 pixels from top 8 pixels ; copy 8 pixels from top 8 pixels
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredV_mmx WELS_EXTERN WelsDecoderIChromaPredV_mmx
@ -697,7 +697,7 @@ WelsDecoderIChromaPredV_mmx:
; j = (2 + l3 + (l2<<1) + l1)>>2 ; j = (2 + l3 + (l2<<1) + l1)>>2
; [b a f e h g j i] + [d c b a] --> mov to memory ; [b a f e h g j i] + [d c b a] --> mov to memory
; ;
; void_t WelsDecoderI4x4LumaPredHD_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI4x4LumaPredHD_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI4x4LumaPredHD_mmx WELS_EXTERN WelsDecoderI4x4LumaPredHD_mmx
WelsDecoderI4x4LumaPredHD_mmx: WelsDecoderI4x4LumaPredHD_mmx:
@ -786,7 +786,7 @@ ALIGN 16
; [g g f e d c b a] + [g g g g] --> mov to memory ; [g g f e d c b a] + [g g g g] --> mov to memory
; ;
; void_t WelsDecoderI4x4LumaPredHU_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI4x4LumaPredHU_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI4x4LumaPredHU_mmx WELS_EXTERN WelsDecoderI4x4LumaPredHU_mmx
WelsDecoderI4x4LumaPredHU_mmx: WelsDecoderI4x4LumaPredHU_mmx:
@ -878,7 +878,7 @@ ALIGN 16
; i = (2 + lt + (l0<<1) + l1)>>2 ; i = (2 + lt + (l0<<1) + l1)>>2
; j = (2 + l0 + (l1<<1) + l2)>>2 ; j = (2 + l0 + (l1<<1) + l2)>>2
; ;
; void_t WelsDecoderI4x4LumaPredVR_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI4x4LumaPredVR_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI4x4LumaPredVR_mmx WELS_EXTERN WelsDecoderI4x4LumaPredVR_mmx
WelsDecoderI4x4LumaPredVR_mmx: WelsDecoderI4x4LumaPredVR_mmx:
@ -971,7 +971,7 @@ ALIGN 16
; [g f e d c b a] --> mov to memory ; [g f e d c b a] --> mov to memory
; ;
; void_t WelsDecoderI4x4LumaPredDDL_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI4x4LumaPredDDL_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI4x4LumaPredDDL_mmx WELS_EXTERN WelsDecoderI4x4LumaPredDDL_mmx
WelsDecoderI4x4LumaPredDDL_mmx: WelsDecoderI4x4LumaPredDDL_mmx:
@ -1046,7 +1046,7 @@ ALIGN 16
; [i d c b a] + [j h g f e] --> mov to memory ; [i d c b a] + [j h g f e] --> mov to memory
; ;
; void_t WelsDecoderI4x4LumaPredVL_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI4x4LumaPredVL_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI4x4LumaPredVL_mmx WELS_EXTERN WelsDecoderI4x4LumaPredVL_mmx
WelsDecoderI4x4LumaPredVL_mmx: WelsDecoderI4x4LumaPredVL_mmx:
@ -1093,7 +1093,7 @@ WelsDecoderI4x4LumaPredVL_mmx:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; ;
; void_t WelsDecoderIChromaPredDc_sse2(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderIChromaPredDc_sse2(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredDc_sse2 WELS_EXTERN WelsDecoderIChromaPredDc_sse2
WelsDecoderIChromaPredDc_sse2: WelsDecoderIChromaPredDc_sse2:
@ -1198,7 +1198,7 @@ WelsDecoderIChromaPredDc_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; ;
; void_t WelsDecoderI16x16LumaPredDc_sse2(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI16x16LumaPredDc_sse2(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI16x16LumaPredDc_sse2 WELS_EXTERN WelsDecoderI16x16LumaPredDc_sse2
WelsDecoderI16x16LumaPredDc_sse2: WelsDecoderI16x16LumaPredDc_sse2:
@ -1286,7 +1286,7 @@ WelsDecoderI16x16LumaPredDc_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderI16x16LumaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI16x16LumaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI16x16LumaPredDcTop_sse2 WELS_EXTERN WelsDecoderI16x16LumaPredDcTop_sse2
WelsDecoderI16x16LumaPredDcTop_sse2: WelsDecoderI16x16LumaPredDcTop_sse2:
@ -1366,7 +1366,7 @@ WelsDecoderI16x16LumaPredDcTop_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderI16x16LumaPredDcNA_sse2(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderI16x16LumaPredDcNA_sse2(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderI16x16LumaPredDcNA_sse2 WELS_EXTERN WelsDecoderI16x16LumaPredDcNA_sse2
WelsDecoderI16x16LumaPredDcNA_sse2: WelsDecoderI16x16LumaPredDcNA_sse2:
@ -1412,7 +1412,7 @@ WelsDecoderI16x16LumaPredDcNA_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderIChromaPredDcLeft_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderIChromaPredDcLeft_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredDcLeft_mmx WELS_EXTERN WelsDecoderIChromaPredDcLeft_mmx
WelsDecoderIChromaPredDcLeft_mmx: WelsDecoderIChromaPredDcLeft_mmx:
@ -1495,7 +1495,7 @@ WelsDecoderIChromaPredDcLeft_mmx:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderIChromaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderIChromaPredDcTop_sse2(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredDcTop_sse2 WELS_EXTERN WelsDecoderIChromaPredDcTop_sse2
WelsDecoderIChromaPredDcTop_sse2: WelsDecoderIChromaPredDcTop_sse2:
@ -1544,7 +1544,7 @@ WelsDecoderIChromaPredDcTop_sse2:
ALIGN 16 ALIGN 16
;******************************************************************************* ;*******************************************************************************
; void_t WelsDecoderIChromaPredDcNA_mmx(uint8_t *pPred, const int32_t kiStride) ; void WelsDecoderIChromaPredDcNA_mmx(uint8_t *pPred, const int32_t kiStride)
;******************************************************************************* ;*******************************************************************************
WELS_EXTERN WelsDecoderIChromaPredDcNA_mmx WELS_EXTERN WelsDecoderIChromaPredDcNA_mmx
WelsDecoderIChromaPredDcNA_mmx: WelsDecoderIChromaPredDcNA_mmx:

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

@ -88,9 +88,9 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
int32_t ParseNonVclNal (PWelsDecoderContext pCtx, uint8_t* pRbsp, const int32_t kiSrcLen); int32_t ParseNonVclNal (PWelsDecoderContext pCtx, uint8_t* pRbsp, const int32_t kiSrcLen);
void_t ParseRefBasePicMarking (PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking); void ParseRefBasePicMarking (PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking);
void_t ParsePrefixNalUnit (PWelsDecoderContext pCtx, PBitStringAux pBs); void ParsePrefixNalUnit (PWelsDecoderContext pCtx, PBitStringAux pBs);
bool CheckAccessUnitBoundary (const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps); bool CheckAccessUnitBoundary (const PNalUnit kpCurNal, const PNalUnit kpLastNal, const PSps kpSps);
bool CheckAccessUnitBoundaryExt (PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt, bool CheckAccessUnitBoundaryExt (PNalUnitHeaderExt pLastNalHdrExt, PNalUnitHeaderExt pCurNalHeaderExt,
@ -141,7 +141,7 @@ int32_t ParsePps (PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux)
* \note Call it in case eNalUnitType is NAL_UNIT_SEI. * \note Call it in case eNalUnitType is NAL_UNIT_SEI.
************************************************************************************* *************************************************************************************
*/ */
int32_t ParseSei (void_t* pSei, PBitStringAux pBsAux); // reserved Sei_Msg type int32_t ParseSei (void* pSei, PBitStringAux pBsAux); // reserved Sei_Msg type
/*! /*!
************************************************************************************* *************************************************************************************

2
codec/decoder/core/inc/bit_stream.h
View File

@ -64,7 +64,7 @@ int32_t iLeftBits; // count number of available bits left ([1, 8]),
*/ */
int32_t InitBits (PBitStringAux pBitString, const uint8_t* kpBuf, const int32_t kiSize); int32_t InitBits (PBitStringAux pBitString, const uint8_t* kpBuf, const int32_t kiSize);
void_t InitReadBits (PBitStringAux pBitString); void InitReadBits (PBitStringAux pBitString);

10
codec/decoder/core/inc/deblocking.h
View File

@ -54,7 +54,7 @@ namespace WelsDec {
* \return NONE * \return NONE
*/ */
void_t DeblockingInit (PDeblockingFunc pDeblockingFunc, int32_t iCpu); void DeblockingInit (PDeblockingFunc pDeblockingFunc, int32_t iCpu);
/*! /*!
@ -64,7 +64,7 @@ void_t DeblockingInit (PDeblockingFunc pDeblockingFunc, int32_t iCpu);
* *
* \return NONE * \return NONE
*/ */
void_t WelsDeblockingFilterSlice (PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb); void WelsDeblockingFilterSlice (PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb);
/*! /*!
* \brief pixel deblocking filtering * \brief pixel deblocking filtering
@ -81,10 +81,10 @@ uint32_t DeblockingBsMarginalMBAvcbase (PDqLayer pCurDqLayer, int32_t iEdge, int
int32_t DeblockingAvailableNoInterlayer (PDqLayer pCurDqLayer, int32_t iFilterIdc); int32_t DeblockingAvailableNoInterlayer (PDqLayer pCurDqLayer, int32_t iFilterIdc);
void_t DeblockingIntraMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag); void DeblockingIntraMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag);
void_t DeblockingInterMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4], int32_t iBoundryFlag); void DeblockingInterMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4], int32_t iBoundryFlag);
void_t WelsDeblockingMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag); void WelsDeblockingMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag);
} // namespace WelsDec } // namespace WelsDec

2
codec/decoder/core/inc/dec_golomb.h
View File

@ -68,7 +68,7 @@ namespace WelsDec {
static inline int32_t ShowBits (PBitStringAux pBs, int32_t iNumBits) { static inline int32_t ShowBits (PBitStringAux pBs, int32_t iNumBits) {
return UBITS (pBs->uiCurBits, iNumBits); return UBITS (pBs->uiCurBits, iNumBits);
} }
static inline void_t FlushBits (PBitStringAux pBs, int32_t iNumBits) { static inline void FlushBits (PBitStringAux pBs, int32_t iNumBits) {
DUMP_BITS (pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iNumBits); DUMP_BITS (pBs->uiCurBits, pBs->pCurBuf, pBs->iLeftBits, iNumBits);
} }
static inline int32_t BsGetBits (PBitStringAux pBs, int32_t iNumBits) { static inline int32_t BsGetBits (PBitStringAux pBs, int32_t iNumBits) {

8
codec/decoder/core/inc/decode_mb_aux.h
View File

@ -38,23 +38,23 @@
namespace WelsDec { namespace WelsDec {
void_t InitDctClipTable (void_t); void InitDctClipTable (void);
void_t IdctResAddPred_c (uint8_t* pPred, const int32_t kiStride, int16_t* pRs); void IdctResAddPred_c (uint8_t* pPred, const int32_t kiStride, int16_t* pRs);
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif//__cplusplus #endif//__cplusplus
#if defined(X86_ASM) #if defined(X86_ASM)
void_t IdctResAddPred_mmx (uint8_t* pPred, const int32_t kiStride, int16_t* pRs); void IdctResAddPred_mmx (uint8_t* pPred, const int32_t kiStride, int16_t* pRs);
#endif//X86_ASM #endif//X86_ASM
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif//__cplusplus #endif//__cplusplus
void_t GetI4LumaIChromaAddrTable (int32_t* pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride); void GetI4LumaIChromaAddrTable (int32_t* pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride);
} // namespace WelsDec } // namespace WelsDec

20
codec/decoder/core/inc/decode_slice.h
View File

@ -37,7 +37,7 @@
namespace WelsDec { namespace WelsDec {
void_t WelsBlockInit (int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal); void WelsBlockInit (int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal);
int32_t WelsActualDecodeMbCavlcISlice (PWelsDecoderContext pCtx); int32_t WelsActualDecodeMbCavlcISlice (PWelsDecoderContext pCtx);
int32_t WelsDecodeMbCavlcISlice (PWelsDecoderContext pCtx, PNalUnit pNalCur); int32_t WelsDecodeMbCavlcISlice (PWelsDecoderContext pCtx, PNalUnit pNalCur);
@ -57,31 +57,31 @@ int32_t WelsMbIntraPredictionConstruction (PWelsDecoderContext pCtx, PDqLayer pC
int32_t WelsMbInterSampleConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer, int32_t WelsMbInterSampleConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer,
uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV, int32_t iStrideL, int32_t iStrideC); uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV, int32_t iStrideL, int32_t iStrideC);
int32_t WelsMbInterConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer); int32_t WelsMbInterConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer);
void_t WelsLumaDcDequantIdct (int16_t* pBlock, int32_t iQp); void WelsLumaDcDequantIdct (int16_t* pBlock, int32_t iQp);
int32_t WelsMbInterPrediction (PWelsDecoderContext pCtx, PDqLayer pCurLayer); int32_t WelsMbInterPrediction (PWelsDecoderContext pCtx, PDqLayer pCurLayer);
void_t WelsMbCopy (uint8_t* pDst, int32_t iStrideDst, uint8_t* pSrc, int32_t iStrideSrc, void WelsMbCopy (uint8_t* pDst, int32_t iStrideDst, uint8_t* pSrc, int32_t iStrideSrc,
int32_t iHeight, int32_t iWidth); int32_t iHeight, int32_t iWidth);
void_t WelsChromaDcIdct (int16_t* pBlock); void WelsChromaDcIdct (int16_t* pBlock);
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif//__cplusplus #endif//__cplusplus
#ifdef X86_ASM #ifdef X86_ASM
void_t WelsResBlockZero16x16_sse2 (int16_t* pBlock, int32_t iStride); void WelsResBlockZero16x16_sse2 (int16_t* pBlock, int32_t iStride);
void_t WelsResBlockZero8x8_sse2 (int16_t* pBlock, int32_t iStride); void WelsResBlockZero8x8_sse2 (int16_t* pBlock, int32_t iStride);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif//__cplusplus #endif//__cplusplus
void_t WelsBlockZero16x16_c (int16_t* pBlock, int32_t iStride); void WelsBlockZero16x16_c (int16_t* pBlock, int32_t iStride);
void_t WelsBlockZero8x8_c (int16_t* pBlock, int32_t iStride); void WelsBlockZero8x8_c (int16_t* pBlock, int32_t iStride);
void_t SetNonZeroCount_c (int16_t* pBlock, int8_t* pNonZeroCount); void SetNonZeroCount_c (int16_t* pBlock, int8_t* pNonZeroCount);
void_t WelsBlockFuncInit (SBlockFunc* pFunc, int32_t iCpu); void WelsBlockFuncInit (SBlockFunc* pFunc, int32_t iCpu);
} // namespace WelsDec } // namespace WelsDec

14
codec/decoder/core/inc/decoder.h
View File

@ -52,7 +52,7 @@ extern "C" {
/*! /*!
* \brief configure decoder parameters * \brief configure decoder parameters
*/ */
int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void_t* kpParam); int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void* kpParam);
/*! /*!
************************************************************************************* *************************************************************************************
@ -68,7 +68,7 @@ int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void_t* kpParam);
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void_t* pTraceHandle, PWelsLogCallbackFunc pLog); int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void* pTraceHandle, PWelsLogCallbackFunc pLog);
/*! /*!
************************************************************************************* *************************************************************************************
@ -81,7 +81,7 @@ int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void_t* pTraceHandle, PWelsL
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
void_t WelsEndDecoder (PWelsDecoderContext pCtx); void WelsEndDecoder (PWelsDecoderContext pCtx);
/*! /*!
************************************************************************************* *************************************************************************************
@ -112,7 +112,7 @@ int32_t WelsRequestMem (PWelsDecoderContext pCtx, const int32_t kiMbWidth, const
/* /*
* free memory blocks in avc * free memory blocks in avc
*/ */
void_t WelsFreeMem (PWelsDecoderContext pCtx); void WelsFreeMem (PWelsDecoderContext pCtx);
/* /*
* set colorspace format in decoder * set colorspace format in decoder
@ -130,11 +130,11 @@ int32_t DecoderSetCsp (PWelsDecoderContext pCtx, const int32_t kiColorFormat);
*/ */
int32_t SyncPictureResolutionExt (PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight); int32_t SyncPictureResolutionExt (PWelsDecoderContext pCtx, const int32_t kiMbWidth, const int32_t kiMbHeight);
void_t AssignFuncPointerForRec (PWelsDecoderContext pCtx); void AssignFuncPointerForRec (PWelsDecoderContext pCtx);
void_t ResetParameterSetsState (PWelsDecoderContext pCtx); void ResetParameterSetsState (PWelsDecoderContext pCtx);
void_t GetVclNalTemporalId (PWelsDecoderContext pCtx); //get the info that whether or not have VCL NAL in current AU, void GetVclNalTemporalId (PWelsDecoderContext pCtx); //get the info that whether or not have VCL NAL in current AU,
//and if YES, get the temporal ID //and if YES, get the temporal ID
#ifdef __cplusplus #ifdef __cplusplus

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

@ -79,9 +79,9 @@ typedef struct TagDataBuffer {
//typedef int32_t (*rec_mb) (Mb *cur_mb, PWelsDecoderContext pCtx); //typedef int32_t (*rec_mb) (Mb *cur_mb, PWelsDecoderContext pCtx);
/*typedef for get intra predictor func pointer*/ /*typedef for get intra predictor func pointer*/
typedef void_t (*PGetIntraPredFunc) (uint8_t* pPred, const int32_t kiLumaStride); typedef void (*PGetIntraPredFunc) (uint8_t* pPred, const int32_t kiLumaStride);
typedef void_t (*PIdctResAddPredFunc) (uint8_t* pPred, const int32_t kiStride, int16_t* pRs); typedef void (*PIdctResAddPredFunc) (uint8_t* pPred, const int32_t kiStride, int16_t* pRs);
typedef void_t (*PExpandPictureFunc) (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth, typedef void (*PExpandPictureFunc) (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth,
const int32_t kiPicHeight); const int32_t kiPicHeight);
/**/ /**/
@ -95,7 +95,7 @@ typedef struct TagRefPic {
int32_t iMaxLongTermFrameIdx; int32_t iMaxLongTermFrameIdx;
} SRefPic, *PRefPic; } SRefPic, *PRefPic;
typedef void_t (*PWelsMcFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, typedef void (*PWelsMcFunc) (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;
@ -116,13 +116,13 @@ typedef struct tagDeblockingFilter {
struct TagDeblockingFunc* pLoopf; struct TagDeblockingFunc* pLoopf;
} SDeblockingFilter, *PDeblockingFilter; } SDeblockingFilter, *PDeblockingFilter;
typedef void_t (*PDeblockingFilterMbFunc) (PDqLayer pCurDqLayer, PDeblockingFilter filter, int32_t boundry_flag); typedef void (*PDeblockingFilterMbFunc) (PDqLayer pCurDqLayer, PDeblockingFilter filter, int32_t boundry_flag);
typedef void_t (*PLumaDeblockingLT4Func) (uint8_t* iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta, typedef void (*PLumaDeblockingLT4Func) (uint8_t* iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta,
int8_t* iTc); int8_t* iTc);
typedef void_t (*PLumaDeblockingEQ4Func) (uint8_t* iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta); typedef void (*PLumaDeblockingEQ4Func) (uint8_t* iSampleY, int32_t iStride, int32_t iAlpha, int32_t iBeta);
typedef void_t (*PChromaDeblockingLT4Func) (uint8_t* iSampleCb, uint8_t* iSampleCr, int32_t iStride, int32_t iAlpha, typedef void (*PChromaDeblockingLT4Func) (uint8_t* iSampleCb, uint8_t* iSampleCr, int32_t iStride, int32_t iAlpha,
int32_t iBeta, int8_t* iTc); int32_t iBeta, int8_t* iTc);
typedef void_t (*PChromaDeblockingEQ4Func) (uint8_t* iSampleCb, uint8_t* iSampleCr, int32_t iStride, int32_t iAlpha, typedef void (*PChromaDeblockingEQ4Func) (uint8_t* iSampleCb, uint8_t* iSampleCr, int32_t iStride, int32_t iAlpha,
int32_t iBeta); int32_t iBeta);
typedef struct TagDeblockingFunc { typedef struct TagDeblockingFunc {
@ -137,11 +137,11 @@ typedef struct TagDeblockingFunc {
PChromaDeblockingEQ4Func pfChromaDeblockinEQ4Hor; PChromaDeblockingEQ4Func pfChromaDeblockinEQ4Hor;
} SDeblockingFunc, *PDeblockingFunc; } SDeblockingFunc, *PDeblockingFunc;
typedef void_t (*PWelsBlockAddStrideFunc) (uint8_t* pDest, uint8_t* pPred, int16_t* pRes, int32_t iPredStride, typedef void (*PWelsBlockAddStrideFunc) (uint8_t* pDest, uint8_t* pPred, int16_t* pRes, int32_t iPredStride,
int32_t iResStride); int32_t iResStride);
typedef void_t (*PWelsBlockZeroFunc) (int16_t* pBlock, int32_t iStride); typedef void (*PWelsBlockZeroFunc) (int16_t* pBlock, int32_t iStride);
typedef void_t (*PWelsNonZeroCountFunc) (int16_t* pBlock, int8_t* pNonZeroCount); typedef void (*PWelsNonZeroCountFunc) (int16_t* pBlock, int8_t* pNonZeroCount);
typedef void_t (*PWelsSimpleIdct4x4AddFunc) (int16_t* pDest, int16_t* pSrc, int32_t iStride); typedef void (*PWelsSimpleIdct4x4AddFunc) (int16_t* pDest, int16_t* pSrc, int32_t iStride);
typedef struct TagBlockFunc { typedef struct TagBlockFunc {
PWelsBlockZeroFunc pWelsBlockZero16x16Func; PWelsBlockZeroFunc pWelsBlockZero16x16Func;
@ -149,7 +149,7 @@ typedef struct TagBlockFunc {
PWelsNonZeroCountFunc pWelsSetNonZeroCountFunc; PWelsNonZeroCountFunc pWelsSetNonZeroCountFunc;
} SBlockFunc; } SBlockFunc;
typedef void_t (*PWelsFillNeighborMbInfoIntra4x4Func) (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, typedef void (*PWelsFillNeighborMbInfoIntra4x4Func) (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
int8_t* pIntraPredMode, PDqLayer pCurLayer); int8_t* pIntraPredMode, PDqLayer pCurLayer);
typedef int32_t (*PWelsParseIntra4x4ModeFunc) (PNeighAvail pNeighAvail, int8_t* pIntraPredMode, PBitStringAux pBs, typedef int32_t (*PWelsParseIntra4x4ModeFunc) (PNeighAvail pNeighAvail, int8_t* pIntraPredMode, PBitStringAux pBs,
PDqLayer pCurDqLayer); PDqLayer pCurDqLayer);
@ -166,7 +166,7 @@ typedef struct TagExpandPicFunc {
typedef struct TagWelsDecoderContext { typedef struct TagWelsDecoderContext {
// Input // Input
void_t* 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;
@ -322,7 +322,7 @@ typedef struct TagWelsDecoderContext {
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_t* pTraceHandle; void* pTraceHandle;
#ifdef NO_WAITING_AU #ifdef NO_WAITING_AU
//Save the last nal header info //Save the last nal header info

14
codec/decoder/core/inc/decoder_core.h
View File

@ -64,7 +64,7 @@ int32_t WelsInitMemory (PWelsDecoderContext pCtx);
* Free memory introduced in WelsInitMemory at destruction of decoder. * Free memory introduced in WelsInitMemory at destruction of decoder.
* *
*/ */
void_t WelsFreeMemory (PWelsDecoderContext pCtx); void WelsFreeMemory (PWelsDecoderContext pCtx);
/*! /*!
* \brief request memory when maximal picture width and height are available * \brief request memory when maximal picture width and height are available
@ -74,7 +74,7 @@ int32_t InitialDqLayersContext (PWelsDecoderContext pCtx, const int32_t kiMaxWid
/*! /*!
* \brief free dq layer context memory related * \brief free dq layer context memory related
*/ */
void_t UninitialDqLayersContext (PWelsDecoderContext pCtx); void UninitialDqLayersContext (PWelsDecoderContext pCtx);
/* /*
* DecodeNalHeaderExt * DecodeNalHeaderExt
@ -83,7 +83,7 @@ void_t UninitialDqLayersContext (PWelsDecoderContext pCtx);
* pNal: target NALUnit ptr * pNal: target NALUnit ptr
* pSrc: NAL Unit bitstream * pSrc: NAL Unit bitstream
*/ */
void_t DecodeNalHeaderExt (PNalUnit pNal, uint8_t* pSrc); void DecodeNalHeaderExt (PNalUnit pNal, uint8_t* pSrc);
/* /*
* ParseSliceHeaderSyntaxs * ParseSliceHeaderSyntaxs
@ -123,14 +123,14 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, int3
/* /*
* Prepare current dq layer context initialization. * Prepare current dq layer context initialization.
*/ */
void_t WelsDqLayerDecodeStart (PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps); void WelsDqLayerDecodeStart (PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps);
int32_t WelsDecodeAccessUnitStart (PWelsDecoderContext pCtx); int32_t WelsDecodeAccessUnitStart (PWelsDecoderContext pCtx);
void_t WelsDecodeAccessUnitEnd (PWelsDecoderContext pCtx); void WelsDecodeAccessUnitEnd (PWelsDecoderContext pCtx);
void_t ForceResetCurrentAccessUnit (PAccessUnit pAu); void ForceResetCurrentAccessUnit (PAccessUnit pAu);
void_t ForceClearCurrentNal (PAccessUnit pAu); void ForceClearCurrentNal (PAccessUnit pAu);
} // namespace WelsDec } // namespace WelsDec

4
codec/decoder/core/inc/expand_pic.h
View File

@ -47,10 +47,10 @@
namespace WelsDec { namespace WelsDec {
void_t ExpandReferencingPicture (PPicture pPic, PExpandPictureFunc pExpandPictureLuma, void ExpandReferencingPicture (PPicture pPic, PExpandPictureFunc pExpandPictureLuma,
PExpandPictureFunc pExpandPictureChroma[2]); PExpandPictureFunc pExpandPictureChroma[2]);
void_t InitExpandPictureFunc (SExpandPicFunc* pExpandPicFunc, const uint32_t kuiCpuFlags); void InitExpandPictureFunc (SExpandPicFunc* pExpandPicFunc, const uint32_t kuiCpuFlags);
} // namespace WelsDec } // namespace WelsDec

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

@ -84,7 +84,7 @@ int32_t InitFmo (PFmo pFmo, PPps pPps, const int32_t kiMbWidth, const int32_t ki
* *
* \return NONE * \return NONE
*/ */
void_t UninitFmoList (PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail); void UninitFmoList (PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail);
/*! /*!
* \brief update/insert FMO parameter unit * \brief update/insert FMO parameter unit

96
codec/decoder/core/inc/get_intra_predictor.h
View File

@ -45,66 +45,66 @@
namespace WelsDec { namespace WelsDec {
void_t WelsI4x4LumaPredV_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredV_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredH_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredH_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDc_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDc_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredVL_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredVL_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredVR_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredVR_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredHU_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredHU_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride); void WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredH_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredH_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredPlane_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredPlane_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredDc_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredDc_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredDcTop_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredDcTop_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsIChromaPredDcNA_c (uint8_t* pPred, const int32_t kiStride); void WelsIChromaPredDcNA_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredV_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredV_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredH_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredH_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredPlane_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredPlane_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredDc_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredDc_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride);
void_t WelsI16x16LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride); void WelsI16x16LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride);
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif//__cplusplus #endif//__cplusplus
#if defined(X86_ASM) #if defined(X86_ASM)
void_t WelsDecoderI16x16LumaPredPlane_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredPlane_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI16x16LumaPredH_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredH_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI16x16LumaPredV_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredV_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI16x16LumaPredDc_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredDc_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI16x16LumaPredDcTop_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredDcTop_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI16x16LumaPredDcNA_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI16x16LumaPredDcNA_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredDcTop_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredDcTop_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredPlane_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredPlane_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredDc_sse2 (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredDc_sse2 (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredH_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredH_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredV_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredV_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredDcLeft_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredDcLeft_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderIChromaPredDcNA_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderIChromaPredDcNA_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredH_sse2(uint8_t *pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredDDR_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredDDR_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredHD_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredHD_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredHU_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredHU_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredVR_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredVR_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredDDL_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredDDL_mmx (uint8_t* pPred, const int32_t kiStride);
void_t WelsDecoderI4x4LumaPredVL_mmx (uint8_t* pPred, const int32_t kiStride); void WelsDecoderI4x4LumaPredVL_mmx (uint8_t* pPred, const int32_t kiStride);
#endif//X86_ASM #endif//X86_ASM
#if defined(__cplusplus) #if defined(__cplusplus)

2
codec/decoder/core/inc/manage_dec_ref.h
View File

@ -53,7 +53,7 @@ REMOVE_BASE = 1,
REMOVE_BASE_FIRST = 2 REMOVE_BASE_FIRST = 2
} ERemoveFlag; } ERemoveFlag;
void_t WelsResetRefPic (PWelsDecoderContext pCtx); void WelsResetRefPic (PWelsDecoderContext pCtx);
int32_t WelsInitRefList (PWelsDecoderContext pCtx, int32_t iPoc); int32_t WelsInitRefList (PWelsDecoderContext pCtx, int32_t iPoc);
int32_t WelsReorderRefList (PWelsDecoderContext pCtx); int32_t WelsReorderRefList (PWelsDecoderContext pCtx);
int32_t WelsMarkAsRef (PWelsDecoderContext pCtx, const bool kbRefBaseMarkingFlag); int32_t WelsMarkAsRef (PWelsDecoderContext pCtx, const bool kbRefBaseMarkingFlag);

4
codec/decoder/core/inc/mc.h
View File

@ -40,10 +40,10 @@
namespace WelsDec { namespace WelsDec {
typedef void_t (*PMcChromaWidthExtFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, typedef void (*PMcChromaWidthExtFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
const uint8_t* kpABCD, int32_t iHeight); const uint8_t* kpABCD, int32_t iHeight);
void_t InitMcFunc (SMcFunc* pMcFunc, int32_t iCpu); void InitMcFunc (SMcFunc* pMcFunc, int32_t iCpu);
} // namespace WelsDec } // namespace WelsDec

4
codec/decoder/core/inc/mem_align.h
View File

@ -59,7 +59,7 @@ extern "C" {
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag); void* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag);
/*! /*!
************************************************************************************* *************************************************************************************
@ -73,7 +73,7 @@ void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag);
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
void_t WelsFree (void_t* pPtr, const str_t* kpTag); void WelsFree (void* pPtr, const str_t* kpTag);
#define WELS_SAFE_FREE(pPtr, pTag) if (pPtr) { WelsFree(pPtr, pTag); pPtr = NULL; } #define WELS_SAFE_FREE(pPtr, pTag) if (pPtr) { WelsFree(pPtr, pTag); pPtr = NULL; }

14
codec/decoder/core/inc/mv_pred.h
View File

@ -50,14 +50,14 @@ namespace WelsDec {
* \param * \param
* \param * \param
*/ */
void_t UpdateP16x16MotionInfo (PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2]); void UpdateP16x16MotionInfo (PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2]);
/*! /*!
* \brief update mv and ref_index cache for current MB, only for P_16x8 * \brief update mv and ref_index cache for current MB, only for P_16x8
* \param * \param
* \param * \param
*/ */
void_t UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], void UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A],
int8_t iRefIndex[LIST_A][30], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]); int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]);
@ -67,7 +67,7 @@ void_t UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A
* \param * \param
* \param * \param
*/ */
void_t UpdateP8x16MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], void UpdateP8x16MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A],
int8_t iRefIndex[LIST_A][30], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]); int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]);
@ -76,14 +76,14 @@ void_t UpdateP8x16MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A
* \param * \param
* \param output iMvp[] * \param output iMvp[]
*/ */
void_t PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]); void PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]);
/*! /*!
* \brief get the motion predictor for 4*4 or 8*8 or 16*16 block * \brief get the motion predictor for 4*4 or 8*8 or 16*16 block
* \param * \param
* \param output iMvp[] * \param output iMvp[]
*/ */
void_t PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int32_t iPartWidth, int8_t iRef, int16_t iMVP[2]); int32_t iPartIdx, int32_t iPartWidth, int8_t iRef, int16_t iMVP[2]);
/*! /*!
@ -91,7 +91,7 @@ void_t PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A]
* \param * \param
* \param output mvp_x and mvp_y * \param output mvp_x and mvp_y
*/ */
void_t PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]); int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]);
/*! /*!
@ -99,7 +99,7 @@ void_t PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefInde
* \param * \param
* \param output mvp_x and mvp_y * \param output mvp_x and mvp_y
*/ */
void_t PredInter8x16Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredInter8x16Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]); int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]);
} // namespace WelsDec } // namespace WelsDec

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

@ -134,13 +134,13 @@ static const SPartMbInfo g_ksInterSubMbTypeInfo[4] = {
{SUB_MB_TYPE_4x4, 4, 1}, {SUB_MB_TYPE_4x4, 4, 1},
}; };
void_t GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer); void GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer);
void_t WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, PDqLayer pCurLayer); void WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, PDqLayer pCurLayer);
void_t WelsFillCacheConstrain0Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, void WelsFillCacheConstrain0Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode,
PDqLayer pCurLayer); PDqLayer pCurLayer);
void_t WelsFillCacheConstrain1Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, void WelsFillCacheConstrain1Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode,
PDqLayer pCurLayer); PDqLayer pCurLayer);
void_t WelsFillCacheInter (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, void WelsFillCacheInter (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PDqLayer pCurLayer); int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PDqLayer pCurLayer);
@ -173,8 +173,8 @@ int32_t CheckIntraChromaPredMode (uint8_t uiSampleAvail, int8_t* pMode);
int32_t PredIntra4x4Mode (int8_t* pIntraPredMode, int32_t iIdx4); int32_t PredIntra4x4Mode (int8_t* pIntraPredMode, int32_t iIdx4);
void_t BsStartCavlc (PBitStringAux pBs); void BsStartCavlc (PBitStringAux pBs);
void_t BsEndCavlc (PBitStringAux pBs); void BsEndCavlc (PBitStringAux pBs);
int32_t WelsResidualBlockCavlc (SVlcTable* pVlcTable, int32_t WelsResidualBlockCavlc (SVlcTable* pVlcTable,
uint8_t* pNonZeroCountCache, uint8_t* pNonZeroCountCache,

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

@ -49,7 +49,7 @@
namespace WelsDec { namespace WelsDec {
void_t WelsFillRecNeededMbInfo (PWelsDecoderContext pCtx, bool bOutput, PDqLayer pCurLayer); void WelsFillRecNeededMbInfo (PWelsDecoderContext pCtx, bool bOutput, PDqLayer pCurLayer);
int32_t RecI4x4Mb (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLevel, PDqLayer pDqLayer); int32_t RecI4x4Mb (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLevel, PDqLayer pDqLayer);
@ -61,9 +61,9 @@ int32_t RecI16x16Mb (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLe
int32_t RecChroma (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLevel, PDqLayer pDqLayer); int32_t RecChroma (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLevel, PDqLayer pDqLayer);
void_t GetInterPred (uint8_t* pPredY, uint8_t* pPredCb, uint8_t* pPredCr, PWelsDecoderContext pCtx); void GetInterPred (uint8_t* pPredY, uint8_t* pPredCb, uint8_t* pPredCr, PWelsDecoderContext pCtx);
void_t FillBufForMc (uint8_t* pBuf, int32_t iBufStride, uint8_t* pSrc, int32_t iSrcStride, int32_t iSrcOffset, void FillBufForMc (uint8_t* pBuf, int32_t iBufStride, uint8_t* pSrc, int32_t iSrcStride, int32_t iSrcOffset,
int32_t iBlockWidth, int32_t iBlockHeight, int32_t iSrcX, int32_t iSrcY, int32_t iPicWidth, int32_t iPicHeight); int32_t iBlockWidth, int32_t iBlockHeight, int32_t iSrcX, int32_t iSrcY, int32_t iPicWidth, int32_t iPicHeight);
} // namespace WelsDec } // namespace WelsDec

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

@ -53,15 +53,15 @@ namespace WelsDec {
* Function pointer declaration for various tool sets * Function pointer declaration for various tool sets
*/ */
// wels log output // wels log output
typedef void_t (*PWelsLogCallbackFunc) (void_t* pPtr, const int32_t kiLevel, const char* kpFmt, va_list pArgv); typedef void (*PWelsLogCallbackFunc) (void* pPtr, const int32_t kiLevel, const char* kpFmt, va_list pArgv);
extern PWelsLogCallbackFunc g_pLog; extern PWelsLogCallbackFunc g_pLog;
#ifdef __GNUC__ #ifdef __GNUC__
extern void_t WelsLog (void_t* pPtr, int32_t iLevel, const char* kpFmt, ...) __attribute__ ((__format__ (__printf__, 3, extern void WelsLog (void* pPtr, int32_t iLevel, const char* kpFmt, ...) __attribute__ ((__format__ (__printf__, 3,
4))); 4)));
#else #else
extern void_t WelsLog (void_t* pPtr, int32_t iLevel, const char* kpFmt, ...); extern void WelsLog (void* pPtr, int32_t iLevel, const char* kpFmt, ...);
#endif #endif
#define DECODER_MODE_NAME(a) ((a == SW_MODE)?"SW_MODE":((a == GPU_MODE)?"GPU_MODE":((a == AUTO_MODE)?"AUTO_MODE":"SWITCH_MODE"))) #define DECODER_MODE_NAME(a) ((a == SW_MODE)?"SW_MODE":((a == GPU_MODE)?"GPU_MODE":((a == AUTO_MODE)?"AUTO_MODE":"SWITCH_MODE")))

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

@ -116,7 +116,7 @@ extern const uint8_t g_kuiZeroLeftBitNumMap[16];
#define WELS_GET_PREFIX_BITS(inval, outval) outval = GetPrefixBits(inval) #define WELS_GET_PREFIX_BITS(inval, outval) outval = GetPrefixBits(inval)
#endif #endif
static inline void_t 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;

6
codec/decoder/core/src/au_parser.cpp
View File

@ -559,7 +559,7 @@ int32_t ParseNonVclNal (PWelsDecoderContext pCtx, uint8_t* pRbsp, const int32_t
return iErr; return iErr;
} }
void_t ParseRefBasePicMarking (PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking) { void ParseRefBasePicMarking (PBitStringAux pBs, PRefBasePicMarking pRefBasePicMarking) {
const bool kbAdaptiveMarkingModeFlag = !!BsGetOneBit (pBs); const bool kbAdaptiveMarkingModeFlag = !!BsGetOneBit (pBs);
pRefBasePicMarking->bAdaptiveRefBasePicMarkingModeFlag = kbAdaptiveMarkingModeFlag; pRefBasePicMarking->bAdaptiveRefBasePicMarkingModeFlag = kbAdaptiveMarkingModeFlag;
if (kbAdaptiveMarkingModeFlag) { if (kbAdaptiveMarkingModeFlag) {
@ -583,7 +583,7 @@ void_t ParseRefBasePicMarking (PBitStringAux pBs, PRefBasePicMarking pRefBasePic
} }
} }
void_t ParsePrefixNalUnit (PWelsDecoderContext pCtx, PBitStringAux pBs) { void ParsePrefixNalUnit (PWelsDecoderContext pCtx, PBitStringAux pBs) {
PNalUnit pCurNal = &pCtx->sPrefixNal; PNalUnit pCurNal = &pCtx->sPrefixNal;
if (pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc != 0) { if (pCurNal->sNalHeaderExt.sNalUnitHeader.uiNalRefIdc != 0) {
@ -1030,7 +1030,7 @@ int32_t ParsePps (PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux)
* \note Call it in case eNalUnitType is NAL_UNIT_SEI. * \note Call it in case eNalUnitType is NAL_UNIT_SEI.
************************************************************************************* *************************************************************************************
*/ */
int32_t ParseSei (void_t* pSei, PBitStringAux pBsAux) { // reserved Sei_Msg type int32_t ParseSei (void* pSei, PBitStringAux pBsAux) { // reserved Sei_Msg type
return ERR_NONE; return ERR_NONE;

2
codec/decoder/core/src/bit_stream.cpp
View File

@ -47,7 +47,7 @@ inline uint32_t GetValue4Bytes (uint8_t* pDstNal) {
return uiValue; return uiValue;
} }
void_t InitReadBits (PBitStringAux pBitString) { void InitReadBits (PBitStringAux pBitString) {
pBitString->uiCurBits = GetValue4Bytes (pBitString->pCurBuf); pBitString->uiCurBits = GetValue4Bytes (pBitString->pCurBuf);
pBitString->pCurBuf += 4; pBitString->pCurBuf += 4;
pBitString->iLeftBits = -16; pBitString->iLeftBits = -16;

34
codec/decoder/core/src/deblocking.cpp
View File

@ -143,7 +143,7 @@ static const uint8_t g_kuiTableBIdx[2][8] = {
tc[3] = g_kiTc0Table(iIndexA)[pBS[3]] + bChroma;\ tc[3] = g_kiTc0Table(iIndexA)[pBS[3]] + bChroma;\
} }
void_t inline DeblockingBSInsideMBAvsbase (int8_t* pNnzTab, uint8_t nBS[2][4][4], int32_t iLShiftFactor) { void inline DeblockingBSInsideMBAvsbase (int8_t* pNnzTab, uint8_t nBS[2][4][4], int32_t iLShiftFactor) {
uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3; uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3;
ENFORCE_STACK_ALIGN_1D (uint8_t, uiBsx3, 4, 4); ENFORCE_STACK_ALIGN_1D (uint8_t, uiBsx3, 4, 4);
@ -177,7 +177,7 @@ void_t inline DeblockingBSInsideMBAvsbase (int8_t* pNnzTab, uint8_t nBS[2][4][4]
} }
void_t static inline DeblockingBSInsideMBNormal (PDqLayer pCurDqLayer, uint8_t nBS[2][4][4], int8_t* pNnzTab, void static inline DeblockingBSInsideMBNormal (PDqLayer pCurDqLayer, uint8_t nBS[2][4][4], int8_t* pNnzTab,
int32_t iMbXy) { int32_t iMbXy) {
uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3; uint32_t uiNnz32b0, uiNnz32b1, uiNnz32b2, uiNnz32b3;
int8_t* iRefIndex = pCurDqLayer->pRefIndex[LIST_0][iMbXy]; int8_t* iRefIndex = pCurDqLayer->pRefIndex[LIST_0][iMbXy];
@ -265,7 +265,7 @@ int32_t DeblockingAvailableNoInterlayer (PDqLayer pCurDqLayer, int32_t iFilterId
return (bLeftFlag << LEFT_FLAG_BIT) | (bTopFlag << TOP_FLAG_BIT); return (bLeftFlag << LEFT_FLAG_BIT) | (bTopFlag << TOP_FLAG_BIT);
} }
void_t FilteringEdgeLumaH (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) { void FilteringEdgeLumaH (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
int32_t iBeta; int32_t iBeta;
@ -282,7 +282,7 @@ void_t FilteringEdgeLumaH (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iS
} }
void_t FilteringEdgeLumaV (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) { void FilteringEdgeLumaV (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
int32_t iBeta; int32_t iBeta;
@ -299,7 +299,7 @@ void_t FilteringEdgeLumaV (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iS
} }
void_t FilteringEdgeLumaIntraH (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) { void FilteringEdgeLumaIntraH (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
int32_t iBeta; int32_t iBeta;
@ -313,7 +313,7 @@ void_t FilteringEdgeLumaIntraH (SDeblockingFilter* pFilter, uint8_t* pPix, int32
return; return;
} }
void_t FilteringEdgeLumaIntraV (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) { void FilteringEdgeLumaIntraV (SDeblockingFilter* pFilter, uint8_t* pPix, int32_t iStride, uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
int32_t iBeta; int32_t iBeta;
@ -326,7 +326,7 @@ void_t FilteringEdgeLumaIntraV (SDeblockingFilter* pFilter, uint8_t* pPix, int32
} }
return; return;
} }
void_t FilteringEdgeChromaH (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, void FilteringEdgeChromaH (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride,
uint8_t* pBS) { uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
@ -342,7 +342,7 @@ void_t FilteringEdgeChromaH (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_
} }
return; return;
} }
void_t FilteringEdgeChromaV (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, void FilteringEdgeChromaV (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride,
uint8_t* pBS) { uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
@ -359,7 +359,7 @@ void_t FilteringEdgeChromaV (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_
return; return;
} }
void_t FilteringEdgeChromaIntraH (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, void FilteringEdgeChromaIntraH (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride,
uint8_t* pBS) { uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
@ -374,7 +374,7 @@ void_t FilteringEdgeChromaIntraH (SDeblockingFilter* pFilter, uint8_t* pPixCb, u
return; return;
} }
void_t FilteringEdgeChromaIntraV (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride, void FilteringEdgeChromaIntraV (SDeblockingFilter* pFilter, uint8_t* pPixCb, uint8_t* pPixCr, int32_t iStride,
uint8_t* pBS) { uint8_t* pBS) {
int32_t iIndexA; int32_t iIndexA;
int32_t iAlpha; int32_t iAlpha;
@ -390,7 +390,7 @@ void_t FilteringEdgeChromaIntraV (SDeblockingFilter* pFilter, uint8_t* pPixCb, u
} }
void_t DeblockingInterMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4], void DeblockingInterMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint8_t nBS[2][4][4],
int32_t iBoundryFlag) { int32_t iBoundryFlag) {
int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex; int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
int32_t iMbX = pCurDqLayer->iMbX; int32_t iMbX = pCurDqLayer->iMbX;
@ -472,7 +472,7 @@ void_t DeblockingInterMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, uint
} }
} }
void_t FilteringEdgeLumaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) { void FilteringEdgeLumaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) {
int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex; int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
int32_t iMbX = pCurDqLayer->iMbX; int32_t iMbX = pCurDqLayer->iMbX;
int32_t iMbY = pCurDqLayer->iMbY; int32_t iMbY = pCurDqLayer->iMbY;
@ -520,7 +520,7 @@ void_t FilteringEdgeLumaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, in
pFilter->pLoopf->pfLumaDeblockingLT4Ver (&pDestY[ (3 << 2)*iLineSize], iLineSize, iAlpha, iBeta, iTc); pFilter->pLoopf->pfLumaDeblockingLT4Ver (&pDestY[ (3 << 2)*iLineSize], iLineSize, iAlpha, iBeta, iTc);
} }
} }
void_t FilteringEdgeChromaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) { void FilteringEdgeChromaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) {
int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex; int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
int32_t iMbX = pCurDqLayer->iMbX; int32_t iMbX = pCurDqLayer->iMbX;
int32_t iMbY = pCurDqLayer->iMbY; int32_t iMbY = pCurDqLayer->iMbY;
@ -567,12 +567,12 @@ void_t FilteringEdgeChromaHV (PDqLayer pCurDqLayer, PDeblockingFilter pFilter,
} }
// merge h&v lookup table operation to save performance // merge h&v lookup table operation to save performance
void_t DeblockingIntraMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) { void DeblockingIntraMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) {
FilteringEdgeLumaHV (pCurDqLayer, pFilter, iBoundryFlag); FilteringEdgeLumaHV (pCurDqLayer, pFilter, iBoundryFlag);
FilteringEdgeChromaHV (pCurDqLayer, pFilter, iBoundryFlag); FilteringEdgeChromaHV (pCurDqLayer, pFilter, iBoundryFlag);
} }
void_t WelsDeblockingMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) { void WelsDeblockingMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32_t iBoundryFlag) {
uint8_t nBS[2][4][4] = { 0 }; uint8_t nBS[2][4][4] = { 0 };
int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex; int32_t iMbXyIndex = pCurDqLayer->iMbXyIndex;
@ -624,7 +624,7 @@ void_t WelsDeblockingMb (PDqLayer pCurDqLayer, PDeblockingFilter pFilter, int32
* *
* \return NONE * \return NONE
*/ */
void_t WelsDeblockingFilterSlice (PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb) { void WelsDeblockingFilterSlice (PWelsDecoderContext pCtx, PDeblockingFilterMbFunc pDeblockMb) {
PDqLayer pCurDqLayer = pCtx->pCurDqLayer; PDqLayer pCurDqLayer = pCtx->pCurDqLayer;
PSliceHeaderExt pSliceHeaderExt = &pCurDqLayer->sLayerInfo.sSliceInLayer.sSliceHeaderExt; PSliceHeaderExt pSliceHeaderExt = &pCurDqLayer->sLayerInfo.sSliceInLayer.sSliceHeaderExt;
int32_t iMbWidth = pCurDqLayer->iMbWidth; int32_t iMbWidth = pCurDqLayer->iMbWidth;
@ -695,7 +695,7 @@ void_t WelsDeblockingFilterSlice (PWelsDecoderContext pCtx, PDeblockingFilterMbF
* \return NONE * \return NONE
*/ */
void_t DeblockingInit (SDeblockingFunc* pFunc, int32_t iCpu) { void DeblockingInit (SDeblockingFunc* pFunc, int32_t iCpu) {
pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_c; pFunc->pfLumaDeblockingLT4Ver = DeblockLumaLt4V_c;
pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_c; pFunc->pfLumaDeblockingEQ4Ver = DeblockLumaEq4V_c;
pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_c; pFunc->pfLumaDeblockingLT4Hor = DeblockLumaLt4H_c;

6
codec/decoder/core/src/decode_mb_aux.cpp
View File

@ -43,7 +43,7 @@ uint8_t g_ClipTable[256 + 2 *
/* init pClip table to pClip the final dct data */ /* init pClip table to pClip the final dct data */
void_t InitDctClipTable (void_t) { void InitDctClipTable (void) {
uint8_t* p = &g_ClipTable[0]; uint8_t* p = &g_ClipTable[0];
const int32_t kiLength = MAX_NEG_CROP * sizeof (uint8_t); const int32_t kiLength = MAX_NEG_CROP * sizeof (uint8_t);
int32_t i = 0; int32_t i = 0;
@ -65,7 +65,7 @@ void_t InitDctClipTable (void_t) {
//NOTE::: p_RS should NOT be modified and it will lead to mismatch with JSVM. //NOTE::: p_RS should NOT be modified and it will lead to mismatch with JSVM.
// so should allocate kA array to store the temporary value (idct). // so should allocate kA array to store the temporary value (idct).
void_t IdctResAddPred_c (uint8_t* pPred, const int32_t kiStride, int16_t* pRs) { void IdctResAddPred_c (uint8_t* pPred, const int32_t kiStride, int16_t* pRs) {
int16_t iSrc[16]; int16_t iSrc[16];
uint8_t* pDst = pPred; uint8_t* pDst = pPred;
@ -103,7 +103,7 @@ void_t IdctResAddPred_c (uint8_t* pPred, const int32_t kiStride, int16_t* pRs) {
} }
} }
void_t GetI4LumaIChromaAddrTable (int32_t* pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride) { void GetI4LumaIChromaAddrTable (int32_t* pBlockOffset, const int32_t kiYStride, const int32_t kiUVStride) {
int32_t* pOffset = pBlockOffset; int32_t* pOffset = pBlockOffset;
int32_t i; int32_t i;
const uint8_t kuiScan0 = g_kuiScan8[0]; const uint8_t kuiScan0 = g_kuiScan8[0];

16
codec/decoder/core/src/decode_slice.cpp
View File

@ -192,7 +192,7 @@ int32_t WelsMbInterConstruction (PWelsDecoderContext pCtx, PDqLayer pCurLayer) {
return 0; return 0;
} }
void_t WelsLumaDcDequantIdct (int16_t* pBlock, int32_t iQp) { void WelsLumaDcDequantIdct (int16_t* pBlock, int32_t iQp) {
const int32_t kiQMul = g_kuiDequantCoeff[iQp][0]; const int32_t kiQMul = g_kuiDequantCoeff[iQp][0];
#define STRIDE 16 #define STRIDE 16
int32_t i; int32_t i;
@ -270,7 +270,7 @@ int32_t WelsMbInterPrediction (PWelsDecoderContext pCtx, PDqLayer pCurLayer) {
return 0; return 0;
} }
void_t WelsMbCopy (uint8_t* pDst, int32_t iStrideDst, uint8_t* pSrc, int32_t iStrideSrc, void WelsMbCopy (uint8_t* pDst, int32_t iStrideDst, uint8_t* pSrc, int32_t iStrideSrc,
int32_t iHeight, int32_t iWidth) { int32_t iHeight, int32_t iWidth) {
int32_t i; int32_t i;
int32_t iOffsetDst = 0, iOffsetSrc = 0; int32_t iOffsetDst = 0, iOffsetSrc = 0;
@ -328,7 +328,7 @@ int32_t WelsTargetMbConstruction (PWelsDecoderContext pCtx) {
return 0; return 0;
} }
void_t WelsChromaDcIdct (int16_t* pBlock) { void WelsChromaDcIdct (int16_t* pBlock) {
int32_t iStride = 32; int32_t iStride = 32;
int32_t iXStride = 16; int32_t iXStride = 16;
int32_t iStride1 = iXStride + iStride; int32_t iStride1 = iXStride + iStride;
@ -1111,7 +1111,7 @@ int32_t WelsDecodeMbCavlcPSlice (PWelsDecoderContext pCtx, PNalUnit pNalCur) {
return 0; return 0;
} }
void_t WelsBlockInit (int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal) { void WelsBlockInit (int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t iStride, uint8_t uiVal) {
int32_t i; int32_t i;
int16_t* pDst = pBlock; int16_t* pDst = pBlock;
@ -1121,7 +1121,7 @@ void_t WelsBlockInit (int16_t* pBlock, int32_t iWidth, int32_t iHeight, int32_t
} }
} }
void_t WelsBlockFuncInit (SBlockFunc* pFunc, int32_t iCpu) { void WelsBlockFuncInit (SBlockFunc* pFunc, int32_t iCpu) {
pFunc->pWelsBlockZero16x16Func = WelsBlockZero16x16_c; pFunc->pWelsBlockZero16x16Func = WelsBlockZero16x16_c;
pFunc->pWelsBlockZero8x8Func = WelsBlockZero8x8_c; pFunc->pWelsBlockZero8x8Func = WelsBlockZero8x8_c;
pFunc->pWelsSetNonZeroCountFunc = SetNonZeroCount_c; pFunc->pWelsSetNonZeroCountFunc = SetNonZeroCount_c;
@ -1133,15 +1133,15 @@ void_t WelsBlockFuncInit (SBlockFunc* pFunc, int32_t iCpu) {
} }
#endif #endif
} }
void_t WelsBlockZero16x16_c (int16_t* pBlock, int32_t iStride) { void WelsBlockZero16x16_c (int16_t* pBlock, int32_t iStride) {
WelsBlockInit (pBlock, 16, 16, iStride, 0); WelsBlockInit (pBlock, 16, 16, iStride, 0);
} }
void_t WelsBlockZero8x8_c (int16_t* pBlock, int32_t iStride) { void WelsBlockZero8x8_c (int16_t* pBlock, int32_t iStride) {
WelsBlockInit (pBlock, 8, 8, iStride, 0); WelsBlockInit (pBlock, 8, 8, iStride, 0);
} }
void_t SetNonZeroCount_c (int16_t* pBlock, int8_t* pNonZeroCount) { void SetNonZeroCount_c (int16_t* pBlock, int8_t* pNonZeroCount) {
int32_t i; int32_t i;
int32_t iIndex; int32_t iIndex;

24
codec/decoder/core/src/decoder.cpp
View File

@ -57,9 +57,9 @@ namespace WelsDec {
extern PPicture AllocPicture (PWelsDecoderContext pCtx, const int32_t kiPicWidth, const int32_t kiPicHeight); extern PPicture AllocPicture (PWelsDecoderContext pCtx, const int32_t kiPicWidth, const int32_t kiPicHeight);
extern void_t FreePicture (PPicture pPic); extern void FreePicture (PPicture pPic);
inline void_t GetValueOf4Bytes (uint8_t* pDstNal, int32_t iDdstIdx) { inline void GetValueOf4Bytes (uint8_t* pDstNal, int32_t iDdstIdx) {
ST32(pDstNal, iDdstIdx); ST32(pDstNal, iDdstIdx);
} }
@ -98,7 +98,7 @@ static int32_t CreatePicBuff (PWelsDecoderContext pCtx, PPicBuff* ppPicBuf, cons
return 0; return 0;
} }
static void_t DestroyPicBuff (PPicBuff* ppPicBuf) { static void DestroyPicBuff (PPicBuff* ppPicBuf) {
PPicBuff pPicBuf = NULL; PPicBuff pPicBuf = NULL;
if (NULL == ppPicBuf || NULL == *ppPicBuf) if (NULL == ppPicBuf || NULL == *ppPicBuf)
@ -131,7 +131,7 @@ static void_t DestroyPicBuff (PPicBuff* ppPicBuf) {
/* /*
* fill data fields in default for decoder context * fill data fields in default for decoder context
*/ */
void_t WelsDecoderDefaults (PWelsDecoderContext pCtx) { void WelsDecoderDefaults (PWelsDecoderContext pCtx) {
int32_t iCpuCores = 1; int32_t iCpuCores = 1;
memset (pCtx, 0, sizeof (SWelsDecoderContext)); // fill zero first memset (pCtx, 0, sizeof (SWelsDecoderContext)); // fill zero first
@ -282,7 +282,7 @@ int32_t WelsRequestMem (PWelsDecoderContext pCtx, const int32_t kiMbWidth, const
/* /*
* free memory blocks in avc * free memory blocks in avc
*/ */
void_t WelsFreeMem (PWelsDecoderContext pCtx) { void WelsFreeMem (PWelsDecoderContext pCtx) {
int32_t iListIdx = 0; int32_t iListIdx = 0;
/* TODO: free memory blocks introduced in avc */ /* TODO: free memory blocks introduced in avc */
@ -308,7 +308,7 @@ void_t WelsFreeMem (PWelsDecoderContext pCtx) {
/*! /*!
* \brief Open decoder * \brief Open decoder
*/ */
void_t WelsOpenDecoder (PWelsDecoderContext pCtx) { void WelsOpenDecoder (PWelsDecoderContext pCtx) {
// function pointers // function pointers
//initial MC function pointer-- //initial MC function pointer--
InitMcFunc (& (pCtx->sMcFunc), pCtx->uiCpuFlag); InitMcFunc (& (pCtx->sMcFunc), pCtx->uiCpuFlag);
@ -333,7 +333,7 @@ void_t WelsOpenDecoder (PWelsDecoderContext pCtx) {
/*! /*!
* \brief Close decoder * \brief Close decoder
*/ */
void_t WelsCloseDecoder (PWelsDecoderContext pCtx) { void WelsCloseDecoder (PWelsDecoderContext pCtx) {
WelsFreeMem (pCtx); WelsFreeMem (pCtx);
WelsFreeMemory (pCtx); WelsFreeMemory (pCtx);
@ -350,7 +350,7 @@ void_t WelsCloseDecoder (PWelsDecoderContext pCtx) {
/*! /*!
* \brief configure decoder parameters * \brief configure decoder parameters
*/ */
int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void_t* kpParam) { int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void* kpParam) {
if (NULL == pCtx || NULL == kpParam) if (NULL == pCtx || NULL == kpParam)
return 1; return 1;
@ -387,7 +387,7 @@ int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const void_t* kpParam) {
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void_t* pTraceHandle, PWelsLogCallbackFunc pLog) { int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void* pTraceHandle, PWelsLogCallbackFunc pLog) {
if (pCtx == NULL) { if (pCtx == NULL) {
return ERR_INFO_INVALID_PTR; return ERR_INFO_INVALID_PTR;
} }
@ -423,12 +423,12 @@ int32_t WelsInitDecoder (PWelsDecoderContext pCtx, void_t* pTraceHandle, PWelsLo
* \note N/A * \note N/A
************************************************************************************* *************************************************************************************
*/ */
void_t WelsEndDecoder (PWelsDecoderContext pCtx) { void WelsEndDecoder (PWelsDecoderContext pCtx) {
// close decoder // close decoder
WelsCloseDecoder (pCtx); WelsCloseDecoder (pCtx);
} }
void_t GetVclNalTemporalId (PWelsDecoderContext pCtx) { void GetVclNalTemporalId (PWelsDecoderContext pCtx) {
PAccessUnit pAccessUnit = pCtx->pAccessUnitList; PAccessUnit pAccessUnit = pCtx->pAccessUnitList;
int32_t idx = pAccessUnit->uiStartPos; int32_t idx = pAccessUnit->uiStartPos;
@ -661,7 +661,7 @@ int32_t SyncPictureResolutionExt (PWelsDecoderContext pCtx, const int32_t kiMbWi
return iErr; return iErr;
} }
void_t AssignFuncPointerForRec (PWelsDecoderContext pCtx) { void AssignFuncPointerForRec (PWelsDecoderContext pCtx) {
pCtx->pGetI16x16LumaPredFunc[I16_PRED_V ] = WelsI16x16LumaPredV_c; pCtx->pGetI16x16LumaPredFunc[I16_PRED_V ] = WelsI16x16LumaPredV_c;
pCtx->pGetI16x16LumaPredFunc[I16_PRED_H ] = WelsI16x16LumaPredH_c; pCtx->pGetI16x16LumaPredFunc[I16_PRED_H ] = WelsI16x16LumaPredH_c;
pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC ] = WelsI16x16LumaPredDc_c; pCtx->pGetI16x16LumaPredFunc[I16_PRED_DC ] = WelsI16x16LumaPredDc_c;

32
codec/decoder/core/src/decoder_core.cpp
View File

@ -118,7 +118,7 @@ inline uint8_t GetTargetDqId (uint8_t uiTargetDqId, SDecodingParam* psParam) {
} }
inline void_t HandleReferenceLostL0 (PWelsDecoderContext pCtx, PNalUnit pCurNal) { inline void HandleReferenceLostL0 (PWelsDecoderContext pCtx, PNalUnit pCurNal) {
if (0 == pCurNal->sNalHeaderExt.uiTemporalId) { if (0 == pCurNal->sNalHeaderExt.uiTemporalId) {
pCtx->bReferenceLostAtT0Flag = true; pCtx->bReferenceLostAtT0Flag = true;
} }
@ -130,7 +130,7 @@ inline void_t HandleReferenceLostL0 (PWelsDecoderContext pCtx, PNalUnit pCurN
pCtx->iErrorCode |= dsBitstreamError; pCtx->iErrorCode |= dsBitstreamError;
} }
inline void_t HandleReferenceLost (PWelsDecoderContext pCtx, PNalUnit pCurNal) { inline void HandleReferenceLost (PWelsDecoderContext pCtx, PNalUnit pCurNal) {
if ((0 == pCurNal->sNalHeaderExt.uiTemporalId) || (1 == pCurNal->sNalHeaderExt.uiTemporalId)) { if ((0 == pCurNal->sNalHeaderExt.uiTemporalId) || (1 == pCurNal->sNalHeaderExt.uiTemporalId)) {
pCtx->bReferenceLostAtT0Flag = true; pCtx->bReferenceLostAtT0Flag = true;
} }
@ -309,7 +309,7 @@ int32_t WelsInitMemory (PWelsDecoderContext pCtx) {
* Free memory introduced in WelsInitMemory at destruction of decoder. * Free memory introduced in WelsInitMemory at destruction of decoder.
* *
*/ */
void_t WelsFreeMemory (PWelsDecoderContext pCtx) { void WelsFreeMemory (PWelsDecoderContext pCtx) {
if (pCtx == NULL) if (pCtx == NULL)
return; return;
@ -337,7 +337,7 @@ void_t WelsFreeMemory (PWelsDecoderContext pCtx) {
* pNal: target NALUnit ptr * pNal: target NALUnit ptr
* pSrc: NAL Unit bitstream * pSrc: NAL Unit bitstream
*/ */
void_t DecodeNalHeaderExt (PNalUnit pNal, uint8_t* pSrc) { void DecodeNalHeaderExt (PNalUnit pNal, uint8_t* pSrc) {
PNalUnitHeaderExt pHeaderExt = &pNal->sNalHeaderExt; PNalUnitHeaderExt pHeaderExt = &pNal->sNalHeaderExt;
uint8_t uiCurByte = *pSrc; uint8_t uiCurByte = *pSrc;
@ -1029,7 +1029,7 @@ int32_t InitialDqLayersContext (PWelsDecoderContext pCtx, const int32_t kiMaxWid
return ERR_NONE; return ERR_NONE;
} }
void_t UninitialDqLayersContext (PWelsDecoderContext pCtx) { void UninitialDqLayersContext (PWelsDecoderContext pCtx) {
int32_t i = 0; int32_t i = 0;
int32_t j = 0; int32_t j = 0;
@ -1183,7 +1183,7 @@ void_t UninitialDqLayersContext (PWelsDecoderContext pCtx) {
pCtx->bInitialDqLayersMem = false; pCtx->bInitialDqLayersMem = false;
} }
void_t ResetCurrentAccessUnit (PWelsDecoderContext pCtx) { void ResetCurrentAccessUnit (PWelsDecoderContext pCtx) {
PAccessUnit pCurAu = pCtx->pAccessUnitList; PAccessUnit pCurAu = pCtx->pAccessUnitList;
pCurAu->uiEndPos = 0; pCurAu->uiEndPos = 0;
@ -1211,7 +1211,7 @@ void_t ResetCurrentAccessUnit (PWelsDecoderContext pCtx) {
* \author * \author
* \history 11/16/2009 * \history 11/16/2009
*/ */
void_t ForceResetCurrentAccessUnit (PAccessUnit pAu) { void ForceResetCurrentAccessUnit (PAccessUnit pAu) {
uint32_t uiSucAuIdx = pAu->uiEndPos + 1; uint32_t uiSucAuIdx = pAu->uiEndPos + 1;
uint32_t uiCurAuIdx = 0; uint32_t uiCurAuIdx = 0;
@ -1235,13 +1235,13 @@ void_t ForceResetCurrentAccessUnit (PAccessUnit pAu) {
} }
//clear current corrupted NAL from pNalUnitsList //clear current corrupted NAL from pNalUnitsList
void_t ForceClearCurrentNal (PAccessUnit pAu) { void ForceClearCurrentNal (PAccessUnit pAu) {
if (pAu->uiAvailUnitsNum > 0) if (pAu->uiAvailUnitsNum > 0)
-- pAu->uiAvailUnitsNum; -- pAu->uiAvailUnitsNum;
} }
void_t CheckAvailNalUnitsListContinuity (PWelsDecoderContext pCtx, int32_t iStartIdx, int32_t iEndIdx) { void CheckAvailNalUnitsListContinuity (PWelsDecoderContext pCtx, int32_t iStartIdx, int32_t iEndIdx) {
PAccessUnit pCurAu = pCtx->pAccessUnitList; PAccessUnit pCurAu = pCtx->pAccessUnitList;
uint8_t uiLastNuDependencyId, uiLastNuLayerDqId; uint8_t uiLastNuDependencyId, uiLastNuLayerDqId;
@ -1284,7 +1284,7 @@ void_t CheckAvailNalUnitsListContinuity (PWelsDecoderContext pCtx, int32_t iStar
//main purpose: to support multi-slice and to include all slice which have the same uiDependencyId, uiQualityId and frame_num //main purpose: to support multi-slice and to include all slice which have the same uiDependencyId, uiQualityId and frame_num
//for single slice, pIdxNoInterLayerPred SHOULD NOT be modified //for single slice, pIdxNoInterLayerPred SHOULD NOT be modified
void_t RefineIdxNoInterLayerPred (PAccessUnit pCurAu, int32_t* pIdxNoInterLayerPred) { void RefineIdxNoInterLayerPred (PAccessUnit pCurAu, int32_t* pIdxNoInterLayerPred) {
int32_t iLastNalDependId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiDependencyId; int32_t iLastNalDependId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiDependencyId;
int32_t iLastNalQualityId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiQualityId; int32_t iLastNalQualityId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiQualityId;
uint8_t uiLastNalTId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiTemporalId; uint8_t uiLastNalTId = pCurAu->pNalUnitsList[*pIdxNoInterLayerPred]->sNalHeaderExt.uiTemporalId;
@ -1471,7 +1471,7 @@ bool CheckIntegrityNalUnitsList (PWelsDecoderContext pCtx) {
return true; return true;
} }
void_t CheckOnlyOneLayerInAu (PWelsDecoderContext pCtx) { void CheckOnlyOneLayerInAu (PWelsDecoderContext pCtx) {
PAccessUnit pCurAu = pCtx->pAccessUnitList; PAccessUnit pCurAu = pCtx->pAccessUnitList;
int32_t iEndIdx = pCurAu->uiEndPos; int32_t iEndIdx = pCurAu->uiEndPos;
@ -1524,7 +1524,7 @@ int32_t WelsDecodeAccessUnitStart (PWelsDecoderContext pCtx) {
return ERR_NONE; return ERR_NONE;
} }
void_t WelsDecodeAccessUnitEnd (PWelsDecoderContext pCtx) { void WelsDecodeAccessUnitEnd (PWelsDecoderContext pCtx) {
// uninitialize context of current access unit and rbsp buffer clean // uninitialize context of current access unit and rbsp buffer clean
ResetCurrentAccessUnit (pCtx); ResetCurrentAccessUnit (pCtx);
} }
@ -1596,7 +1596,7 @@ int32_t ConstructAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBufferI
return 0; return 0;
} }
static inline void_t InitDqLayerInfo (PDqLayer pDqLayer, PLayerInfo pLayerInfo, PNalUnit pNalUnit, PPicture pPicDec) { static inline void InitDqLayerInfo (PDqLayer pDqLayer, PLayerInfo pLayerInfo, PNalUnit pNalUnit, PPicture pPicDec) {
PNalUnitHeaderExt pNalHdrExt = &pNalUnit->sNalHeaderExt; PNalUnitHeaderExt pNalHdrExt = &pNalUnit->sNalHeaderExt;
PSliceHeaderExt pShExt = &pNalUnit->sNalData.sVclNal.sSliceHeaderExt; PSliceHeaderExt pShExt = &pNalUnit->sNalData.sVclNal.sSliceHeaderExt;
PSliceHeader pSh = &pShExt->sSliceHeader; PSliceHeader pSh = &pShExt->sSliceHeader;
@ -1634,7 +1634,7 @@ static inline void_t InitDqLayerInfo (PDqLayer pDqLayer, PLayerInfo pLayerInfo,
pDqLayer->bUseRefBasePicFlag = pNalHdrExt->bUseRefBasePicFlag; pDqLayer->bUseRefBasePicFlag = pNalHdrExt->bUseRefBasePicFlag;
} }
void_t WelsDqLayerDecodeStart (PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps) { void WelsDqLayerDecodeStart (PWelsDecoderContext pCtx, PNalUnit pCurNal, PSps pSps, PPps pPps) {
SNalUnitHeader* pNalHdr = &pCurNal->sNalHeaderExt.sNalUnitHeader; SNalUnitHeader* pNalHdr = &pCurNal->sNalHeaderExt.sNalUnitHeader;
PSliceHeader pSh = &pCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader; PSliceHeader pSh = &pCurNal->sNalData.sVclNal.sSliceHeaderExt.sSliceHeader;
@ -1661,7 +1661,7 @@ int32_t InitRefPicList (PWelsDecoderContext pCtx, const uint8_t kuiNRi, const bo
return iRet; return iRet;
} }
void_t InitCurDqLayerData (PWelsDecoderContext pCtx, PDqLayer pCurDq) { void InitCurDqLayerData (PWelsDecoderContext pCtx, PDqLayer pCurDq) {
if (NULL != pCtx && NULL != pCurDq) { if (NULL != pCtx && NULL != pCurDq) {
pCurDq->pCsData[0] = pCtx->pCsListXchg[0][0]; pCurDq->pCsData[0] = pCtx->pCsListXchg[0][0];
pCurDq->pCsData[1] = pCtx->pCsListXchg[0][1]; pCurDq->pCsData[1] = pCtx->pCsListXchg[0][1];
@ -1691,7 +1691,7 @@ void_t InitCurDqLayerData (PWelsDecoderContext pCtx, PDqLayer pCurDq) {
// added to reset state of parameter sets to waiting successive incoming IDR, 6/4/2010 // added to reset state of parameter sets to waiting successive incoming IDR, 6/4/2010
// It will be called in case packets lost/ broken and decoded failed at temporal level 0 // It will be called in case packets lost/ broken and decoded failed at temporal level 0
void_t ResetParameterSetsState (PWelsDecoderContext pCtx) { void ResetParameterSetsState (PWelsDecoderContext pCtx) {
pCtx->bSpsExistAheadFlag = false; pCtx->bSpsExistAheadFlag = false;
pCtx->bSubspsExistAheadFlag = false; pCtx->bSubspsExistAheadFlag = false;
pCtx->bPpsExistAheadFlag = false; pCtx->bPpsExistAheadFlag = false;

8
codec/decoder/core/src/expand_pic.cpp
View File

@ -37,7 +37,7 @@
namespace WelsDec { namespace WelsDec {
// rewrite it (split into luma & chroma) that is helpful for mmx/sse2 optimization perform, 9/27/2009 // rewrite it (split into luma & chroma) that is helpful for mmx/sse2 optimization perform, 9/27/2009
static inline void_t ExpandPictureLuma_c (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth, static inline void ExpandPictureLuma_c (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth,
const int32_t kiPicHeight) { const int32_t kiPicHeight) {
uint8_t* pTmp = pDst; uint8_t* pTmp = pDst;
uint8_t* pDstLastLine = pTmp + (kiPicHeight - 1) * kiStride; uint8_t* pDstLastLine = pTmp + (kiPicHeight - 1) * kiStride;
@ -77,7 +77,7 @@ static inline void_t ExpandPictureLuma_c (uint8_t* pDst, const int32_t kiStride,
} while (i < kiPicHeight); } while (i < kiPicHeight);
} }
static inline void_t ExpandPictureChroma_c (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth, static inline void ExpandPictureChroma_c (uint8_t* pDst, const int32_t kiStride, const int32_t kiPicWidth,
const int32_t kiPicHeight) { const int32_t kiPicHeight) {
uint8_t* pTmp = pDst; uint8_t* pTmp = pDst;
uint8_t* pDstLastLine = pTmp + (kiPicHeight - 1) * kiStride; uint8_t* pDstLastLine = pTmp + (kiPicHeight - 1) * kiStride;
@ -117,7 +117,7 @@ static inline void_t ExpandPictureChroma_c (uint8_t* pDst, const int32_t kiStrid
} while (i < kiPicHeight); } while (i < kiPicHeight);
} }
void_t InitExpandPictureFunc (SExpandPicFunc* pExpandPicFunc, const uint32_t kuiCpuFlags) { void InitExpandPictureFunc (SExpandPicFunc* pExpandPicFunc, const uint32_t kuiCpuFlags) {
pExpandPicFunc->pExpandLumaPicture = ExpandPictureLuma_c; pExpandPicFunc->pExpandLumaPicture = ExpandPictureLuma_c;
pExpandPicFunc->pExpandChromaPicture[0] = ExpandPictureChroma_c; pExpandPicFunc->pExpandChromaPicture[0] = ExpandPictureChroma_c;
pExpandPicFunc->pExpandChromaPicture[1] = ExpandPictureChroma_c; pExpandPicFunc->pExpandChromaPicture[1] = ExpandPictureChroma_c;
@ -131,7 +131,7 @@ void_t InitExpandPictureFunc (SExpandPicFunc* pExpandPicFunc, const uint32_t kui
#endif//X86_ASM #endif//X86_ASM
} }
void_t ExpandReferencingPicture (PPicture pPic, PExpandPictureFunc pExpLuma, PExpandPictureFunc pExpChroma[2]) { void ExpandReferencingPicture (PPicture pPic, PExpandPictureFunc pExpLuma, PExpandPictureFunc pExpChroma[2]) {
/*local variable*/ /*local variable*/
uint8_t* pPicY = pPic->pData[0]; uint8_t* pPicY = pPic->pData[0];
uint8_t* pPicCb = pPic->pData[1]; uint8_t* pPicCb = pPic->pData[1];

2
codec/decoder/core/src/fmo.cpp
View File

@ -200,7 +200,7 @@ int32_t InitFmo (PFmo pFmo, PPps pPps, const int32_t kiMbWidth, const int32_t ki
* *
* \return NONE * \return NONE
*/ */
void_t UninitFmoList (PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail) { void UninitFmoList (PFmo pFmo, const int32_t kiCnt, const int32_t kiAvail) {
PFmo pIter = pFmo; PFmo pIter = pFmo;
int32_t i = 0; int32_t i = 0;
int32_t iFreeNodes = 0; int32_t iFreeNodes = 0;

56
codec/decoder/core/src/get_intra_predictor.cpp
View File

@ -51,7 +51,7 @@ namespace WelsDec {
#define I8x8_COUNT 8 #define I8x8_COUNT 8
#define I16x16_COUNT 16 #define I16x16_COUNT 16
void_t WelsI4x4LumaPredV_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredV_c (uint8_t* pPred, const int32_t kiStride) {
const uint32_t kuiVal = LD32 (pPred - kiStride); const uint32_t kuiVal = LD32 (pPred - kiStride);
ST32 (pPred , kuiVal); ST32 (pPred , kuiVal);
@ -60,7 +60,7 @@ void_t WelsI4x4LumaPredV_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + (kiStride << 1) + kiStride , kuiVal); ST32 (pPred + (kiStride << 1) + kiStride , kuiVal);
} }
void_t WelsI4x4LumaPredH_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredH_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride2 + kiStride; const int32_t kiStride3 = kiStride2 + kiStride;
const uint32_t kuiL0 = 0x01010101U * pPred[-1 ]; const uint32_t kuiL0 = 0x01010101U * pPred[-1 ];
@ -74,7 +74,7 @@ void_t WelsI4x4LumaPredH_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + kiStride3, kuiL3); ST32 (pPred + kiStride3, kuiL3);
} }
void_t WelsI4x4LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride2 + kiStride; const int32_t kiStride3 = kiStride2 + kiStride;
const uint8_t kuiMean = (pPred[-1] + pPred[-1 + kiStride] + pPred[-1 + kiStride2] + pPred[-1 + kiStride3] + const uint8_t kuiMean = (pPred[-1] + pPred[-1 + kiStride] + pPred[-1 + kiStride2] + pPred[-1 + kiStride3] +
@ -87,7 +87,7 @@ void_t WelsI4x4LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + kiStride3, kuiMean32); ST32 (pPred + kiStride3, kuiMean32);
} }
void_t WelsI4x4LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride2 + kiStride; const int32_t kiStride3 = kiStride2 + kiStride;
const uint8_t kuiMean = (pPred[-1] + pPred[-1 + kiStride] + pPred[-1 + kiStride2] + pPred[-1 + kiStride3] + 2) >> 2; const uint8_t kuiMean = (pPred[-1] + pPred[-1 + kiStride] + pPred[-1 + kiStride2] + pPred[-1 + kiStride3] + 2) >> 2;
@ -99,7 +99,7 @@ void_t WelsI4x4LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + kiStride3, kuiMean32); ST32 (pPred + kiStride3, kuiMean32);
} }
void_t WelsI4x4LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride2 + kiStride; const int32_t kiStride3 = kiStride2 + kiStride;
const uint8_t kuiMean = (pPred[-kiStride] + pPred[-kiStride + 1] + pPred[-kiStride + 2] + pPred[-kiStride + 3] + 2) >> const uint8_t kuiMean = (pPred[-kiStride] + pPred[-kiStride + 1] + pPred[-kiStride + 2] + pPred[-kiStride + 3] + 2) >>
@ -112,7 +112,7 @@ void_t WelsI4x4LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + kiStride3, kuiMean32); ST32 (pPred + kiStride3, kuiMean32);
} }
void_t WelsI4x4LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) {
const uint32_t kuiDC32 = 0x80808080U; const uint32_t kuiDC32 = 0x80808080U;
ST32 (pPred , kuiDC32); ST32 (pPred , kuiDC32);
@ -122,7 +122,7 @@ void_t WelsI4x4LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) {
} }
/*down pLeft*/ /*down pLeft*/
void_t WelsI4x4LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
/*get pTop*/ /*get pTop*/
@ -151,7 +151,7 @@ void_t WelsI4x4LumaPredDDL_c (uint8_t* pPred, const int32_t kiStride) {
} }
/*down pLeft*/ /*down pLeft*/
void_t WelsI4x4LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
/*get pTop*/ /*get pTop*/
@ -178,7 +178,7 @@ void_t WelsI4x4LumaPredDDLTop_c (uint8_t* pPred, const int32_t kiStride) {
/*down right*/ /*down right*/
void_t WelsI4x4LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride) {
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* ptopleft = &pPred[- (kiStride + 1)]; uint8_t* ptopleft = &pPred[- (kiStride + 1)];
@ -218,7 +218,7 @@ void_t WelsI4x4LumaPredDDR_c (uint8_t* pPred, const int32_t kiStride) {
/*vertical pLeft*/ /*vertical pLeft*/
void_t WelsI4x4LumaPredVL_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredVL_c (uint8_t* pPred, const int32_t kiStride) {
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* ptopleft = &pPred[- (kiStride + 1)]; uint8_t* ptopleft = &pPred[- (kiStride + 1)];
@ -255,7 +255,7 @@ void_t WelsI4x4LumaPredVL_c (uint8_t* pPred, const int32_t kiStride) {
} }
/*vertical pLeft*/ /*vertical pLeft*/
void_t WelsI4x4LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride) {
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* ptopleft = &pPred[- (kiStride + 1)]; uint8_t* ptopleft = &pPred[- (kiStride + 1)];
@ -286,7 +286,7 @@ void_t WelsI4x4LumaPredVLTop_c (uint8_t* pPred, const int32_t kiStride) {
/*vertical right*/ /*vertical right*/
void_t WelsI4x4LumaPredVR_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredVR_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
const uint8_t kuiLT = pPred[-kiStride - 1]; const uint8_t kuiLT = pPred[-kiStride - 1];
@ -317,7 +317,7 @@ void_t WelsI4x4LumaPredVR_c (uint8_t* pPred, const int32_t kiStride) {
} }
/*horizontal up*/ /*horizontal up*/
void_t WelsI4x4LumaPredHU_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredHU_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
/*get pLeft*/ /*get pLeft*/
@ -343,7 +343,7 @@ void_t WelsI4x4LumaPredHU_c (uint8_t* pPred, const int32_t kiStride) {
} }
/*horizontal down*/ /*horizontal down*/
void_t WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride) { void WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride3 = kiStride + kiStride2; const int32_t kiStride3 = kiStride + kiStride2;
const uint8_t kuiLT = pPred[- (kiStride + 1)]; const uint8_t kuiLT = pPred[- (kiStride + 1)];
@ -380,7 +380,7 @@ void_t WelsI4x4LumaPredHD_c (uint8_t* pPred, const int32_t kiStride) {
ST32 (pPred + kiStride3, LD32 (kuiList)); ST32 (pPred + kiStride3, LD32 (kuiList));
} }
void_t WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride) {
const uint64_t kuiVal64 = LD64 (&pPred[-kiStride]); const uint64_t kuiVal64 = LD64 (&pPred[-kiStride]);
const int32_t kiStride2 = kiStride << 1; const int32_t kiStride2 = kiStride << 1;
const int32_t kiStride4 = kiStride2 << 1; const int32_t kiStride4 = kiStride2 << 1;
@ -395,7 +395,7 @@ void_t WelsIChromaPredV_c (uint8_t* pPred, const int32_t kiStride) {
ST64 (pPred + (kiStride << 3) - kiStride , kuiVal64); ST64 (pPred + (kiStride << 3) - kiStride , kuiVal64);
} }
void_t WelsIChromaPredH_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredH_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 3) - kiStride; int32_t iTmp = (kiStride << 3) - kiStride;
uint8_t i = 7; uint8_t i = 7;
@ -410,7 +410,7 @@ void_t WelsIChromaPredH_c (uint8_t* pPred, const int32_t kiStride) {
} }
void_t WelsIChromaPredPlane_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredPlane_c (uint8_t* pPred, const int32_t kiStride) {
int32_t a = 0, b = 0, c = 0, H = 0, V = 0; int32_t a = 0, b = 0, c = 0, H = 0, V = 0;
int32_t i, j; int32_t i, j;
uint8_t* pTop = &pPred[-kiStride]; uint8_t* pTop = &pPred[-kiStride];
@ -436,7 +436,7 @@ void_t WelsIChromaPredPlane_c (uint8_t* pPred, const int32_t kiStride) {
} }
void_t WelsIChromaPredDc_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiL1 = kiStride - 1; const int32_t kiL1 = kiStride - 1;
const int32_t kiL2 = kiL1 + kiStride; const int32_t kiL2 = kiL1 + kiStride;
const int32_t kiL3 = kiL2 + kiStride; const int32_t kiL3 = kiL2 + kiStride;
@ -467,7 +467,7 @@ void_t WelsIChromaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
ST64 (pPred + kiL7 + 1, kuiDN64); ST64 (pPred + kiL7 + 1, kuiDN64);
} }
void_t WelsIChromaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
const int32_t kiL1 = -1 + kiStride; const int32_t kiL1 = -1 + kiStride;
const int32_t kiL2 = kiL1 + kiStride; const int32_t kiL2 = kiL1 + kiStride;
const int32_t kiL3 = kiL2 + kiStride; const int32_t kiL3 = kiL2 + kiStride;
@ -491,7 +491,7 @@ void_t WelsIChromaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
ST64 (pPred + kiL7 + 1, kuiDN64); ST64 (pPred + kiL7 + 1, kuiDN64);
} }
void_t WelsIChromaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 3) - kiStride; int32_t iTmp = (kiStride << 3) - kiStride;
/*caculate the kMean value*/ /*caculate the kMean value*/
const uint8_t kuiM1 = (pPred[-kiStride] + pPred[1 - kiStride] + pPred[2 - kiStride] + pPred[3 - kiStride] + 2) >> 2; const uint8_t kuiM1 = (pPred[-kiStride] + pPred[1 - kiStride] + pPred[2 - kiStride] + pPred[3 - kiStride] + 2) >> 2;
@ -508,7 +508,7 @@ void_t WelsIChromaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsIChromaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) { void WelsIChromaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 3) - kiStride; int32_t iTmp = (kiStride << 3) - kiStride;
const uint64_t kuiDC64 = 0x8080808080808080ULL; const uint64_t kuiDC64 = 0x8080808080808080ULL;
uint8_t i = 7; uint8_t i = 7;
@ -520,7 +520,7 @@ void_t WelsIChromaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsI16x16LumaPredV_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredV_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
const uint64_t kuiTop1 = LD64 (pPred - kiStride); const uint64_t kuiTop1 = LD64 (pPred - kiStride);
const uint64_t kuiTop2 = LD64 (pPred - kiStride + 8); const uint64_t kuiTop2 = LD64 (pPred - kiStride + 8);
@ -534,7 +534,7 @@ void_t WelsI16x16LumaPredV_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsI16x16LumaPredH_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredH_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
uint8_t i = 15; uint8_t i = 15;
@ -549,7 +549,7 @@ void_t WelsI16x16LumaPredH_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsI16x16LumaPredPlane_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredPlane_c (uint8_t* pPred, const int32_t kiStride) {
int32_t a = 0, b = 0, c = 0, H = 0, V = 0; int32_t a = 0, b = 0, c = 0, H = 0, V = 0;
int32_t i, j; int32_t i, j;
uint8_t* pTop = &pPred[-kiStride]; uint8_t* pTop = &pPred[-kiStride];
@ -574,7 +574,7 @@ void_t WelsI16x16LumaPredPlane_c (uint8_t* pPred, const int32_t kiStride) {
} }
} }
void_t WelsI16x16LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
int32_t iSum = 0; int32_t iSum = 0;
uint8_t i = 15; uint8_t i = 15;
@ -596,7 +596,7 @@ void_t WelsI16x16LumaPredDc_c (uint8_t* pPred, const int32_t kiStride) {
} }
void_t WelsI16x16LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
int32_t iSum = 0; int32_t iSum = 0;
uint8_t i = 15; uint8_t i = 15;
@ -615,7 +615,7 @@ void_t WelsI16x16LumaPredDcTop_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsI16x16LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
int32_t iSum = 0; int32_t iSum = 0;
uint64_t uiMean64 = 0; uint64_t uiMean64 = 0;
@ -640,7 +640,7 @@ void_t WelsI16x16LumaPredDcLeft_c (uint8_t* pPred, const int32_t kiStride) {
} while (i-- > 0); } while (i-- > 0);
} }
void_t WelsI16x16LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) { void WelsI16x16LumaPredDcNA_c (uint8_t* pPred, const int32_t kiStride) {
const uint64_t kuiDC64 = 0x8080808080808080ULL; const uint64_t kuiDC64 = 0x8080808080808080ULL;
int32_t iTmp = (kiStride << 4) - kiStride; int32_t iTmp = (kiStride << 4) - kiStride;
uint8_t i = 15; uint8_t i = 15;

4
codec/decoder/core/src/manage_dec_ref.cpp
View File

@ -44,7 +44,7 @@
namespace WelsDec { namespace WelsDec {
static void_t SetUnRef (PPicture pRef) { static void SetUnRef (PPicture pRef) {
if (NULL != pRef) { if (NULL != pRef) {
pRef->bUsedAsRef = false; pRef->bUsedAsRef = false;
pRef->bIsLongRef = false; pRef->bIsLongRef = false;
@ -63,7 +63,7 @@ static void_t SetUnRef (PPicture pRef) {
// 1.sps arrived that is new sequence starting // 1.sps arrived that is new sequence starting
// 2.IDR NAL i.e. 1st layer in IDR AU // 2.IDR NAL i.e. 1st layer in IDR AU
void_t WelsResetRefPic (PWelsDecoderContext pCtx) { void WelsResetRefPic (PWelsDecoderContext pCtx) {
int32_t i = 0; int32_t i = 0;
PRefPic pRefPic = &pCtx->sRefPic; PRefPic pRefPic = &pCtx->sRefPic;
pCtx->sRefPic.uiLongRefCount[0] = pCtx->sRefPic.uiShortRefCount[0] = 0; pCtx->sRefPic.uiLongRefCount[0] = pCtx->sRefPic.uiShortRefCount[0] = 0;

94
codec/decoder/core/src/mc.cpp
View File

@ -84,13 +84,13 @@ static const uint8_t g_kuiABCD[8][8][4] = { //g_kA[dy][dx], g_kB[dy][dx], g_kC[d
} }
}; };
typedef void_t (*PWelsMcWidthHeightFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, typedef void (*PWelsMcWidthHeightFunc) (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight); int32_t iWidth, int32_t iHeight);
//***************************************************************************// //***************************************************************************//
// C code implementation // // C code implementation //
//***************************************************************************// //***************************************************************************//
static inline void_t McCopyWidthEq2_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McCopyWidthEq2_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
int32_t i; int32_t i;
for (i = 0; i < iHeight; i++) { // iWidth == 2 only for chroma for (i = 0; i < iHeight; i++) { // iWidth == 2 only for chroma
@ -100,7 +100,7 @@ static inline void_t McCopyWidthEq2_c (uint8_t* pSrc, int32_t iSrcStride, uint8_
} }
} }
static inline void_t McCopyWidthEq4_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McCopyWidthEq4_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
int32_t i; int32_t i;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -110,7 +110,7 @@ static inline void_t McCopyWidthEq4_c (uint8_t* pSrc, int32_t iSrcStride, uint8_
} }
} }
static inline void_t McCopyWidthEq8_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McCopyWidthEq8_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
int32_t i; int32_t i;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -120,7 +120,7 @@ static inline void_t McCopyWidthEq8_c (uint8_t* pSrc, int32_t iSrcStride, uint8_
} }
} }
static inline void_t McCopyWidthEq16_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McCopyWidthEq16_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
int32_t i; int32_t i;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -152,7 +152,7 @@ static inline int32_t FilterInput8bitWithStride_c (uint8_t* pSrc, const int32_t
return (kuiPix05 - ((kuiPix14 << 2) + kuiPix14) + (kuiPix23 << 4) + (kuiPix23 << 2)); return (kuiPix05 - ((kuiPix14 << 2) + kuiPix14) + (kuiPix23 << 4) + (kuiPix23 << 2));
} }
static inline void_t PixelAvg_c (uint8_t* pDst, int32_t iDstStride, uint8_t* pSrcA, int32_t iSrcAStride, static inline void PixelAvg_c (uint8_t* pDst, int32_t iDstStride, uint8_t* pSrcA, int32_t iSrcAStride,
uint8_t* pSrcB, int32_t iSrcBStride, int32_t iWidth, int32_t iHeight) { uint8_t* pSrcB, int32_t iSrcBStride, int32_t iWidth, int32_t iHeight) {
int32_t i, j; int32_t i, j;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -164,7 +164,7 @@ static inline void_t PixelAvg_c (uint8_t* pDst, int32_t iDstStride, uint8_t* pSr
pSrcB += iSrcBStride; pSrcB += iSrcBStride;
} }
} }
static inline void_t McCopy_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McCopy_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
if (iWidth == 16) if (iWidth == 16)
McCopyWidthEq16_c (pSrc, iSrcStride, pDst, iDstStride, iHeight); McCopyWidthEq16_c (pSrc, iSrcStride, pDst, iDstStride, iHeight);
@ -176,7 +176,7 @@ static inline void_t McCopy_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst,
McCopyWidthEq2_c (pSrc, iSrcStride, pDst, iDstStride, iHeight); McCopyWidthEq2_c (pSrc, iSrcStride, pDst, iDstStride, iHeight);
} }
static inline void_t McHorVer20_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer20_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
int32_t i, j; int32_t i, j;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -188,7 +188,7 @@ static inline void_t McHorVer20_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
} }
} }
static inline void_t McHorVer02_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer02_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
int32_t i, j; int32_t i, j;
for (i = 0; i < iHeight; i++) { for (i = 0; i < iHeight; i++) {
@ -200,7 +200,7 @@ static inline void_t McHorVer02_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
} }
} }
static inline void_t McHorVer22_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer22_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
int16_t iTmp[16 + 5] = {0}; //16 int16_t iTmp[16 + 5] = {0}; //16
int32_t i, j, k; int32_t i, j, k;
@ -218,25 +218,25 @@ static inline void_t McHorVer22_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
} }
/////////////////////luma MC////////////////////////// /////////////////////luma MC//////////////////////////
static inline void_t McHorVer01_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer01_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiTmp[256] = { 0 }; uint8_t uiTmp[256] = { 0 };
McHorVer02_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight); McHorVer02_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer03_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer03_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiTmp[256] = { 0 }; uint8_t uiTmp[256] = { 0 };
McHorVer02_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight); McHorVer02_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, pSrc + iSrcStride, iSrcStride, uiTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, pSrc + iSrcStride, iSrcStride, uiTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer10_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer10_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiTmp[256] = { 0 }; uint8_t uiTmp[256] = { 0 };
McHorVer20_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight); McHorVer20_c (pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, pSrc, iSrcStride, uiTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer11_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer11_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
@ -244,7 +244,7 @@ static inline void_t McHorVer11_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer02_c (pSrc, iSrcStride, uiVerTmp, 16, iWidth, iHeight); McHorVer02_c (pSrc, iSrcStride, uiVerTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer12_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer12_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
uint8_t uiCtrTmp[256] = { 0 }; uint8_t uiCtrTmp[256] = { 0 };
@ -252,7 +252,7 @@ static inline void_t McHorVer12_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight); McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiVerTmp, 16, uiCtrTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiVerTmp, 16, uiCtrTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer13_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer13_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
@ -260,7 +260,7 @@ static inline void_t McHorVer13_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer02_c (pSrc, iSrcStride, uiVerTmp, 16, iWidth, iHeight); McHorVer02_c (pSrc, iSrcStride, uiVerTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer21_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer21_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiCtrTmp[256] = { 0 }; uint8_t uiCtrTmp[256] = { 0 };
@ -268,7 +268,7 @@ static inline void_t McHorVer21_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight); McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiCtrTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiCtrTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer23_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer23_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiCtrTmp[256] = { 0 }; uint8_t uiCtrTmp[256] = { 0 };
@ -276,13 +276,13 @@ static inline void_t McHorVer23_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight); McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiCtrTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiCtrTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer30_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer30_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
McHorVer20_c (pSrc, iSrcStride, uiHorTmp, 16, iWidth, iHeight); McHorVer20_c (pSrc, iSrcStride, uiHorTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, pSrc + 1, iSrcStride, uiHorTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, pSrc + 1, iSrcStride, uiHorTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer31_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer31_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
@ -290,7 +290,7 @@ static inline void_t McHorVer31_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer02_c (pSrc + 1, iSrcStride, uiVerTmp, 16, iWidth, iHeight); McHorVer02_c (pSrc + 1, iSrcStride, uiVerTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer32_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer32_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
uint8_t uiCtrTmp[256] = { 0 }; uint8_t uiCtrTmp[256] = { 0 };
@ -298,7 +298,7 @@ static inline void_t McHorVer32_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight); McHorVer22_c (pSrc, iSrcStride, uiCtrTmp, 16, iWidth, iHeight);
PixelAvg_c (pDst, iDstStride, uiVerTmp, 16, uiCtrTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiVerTmp, 16, uiCtrTmp, 16, iWidth, iHeight);
} }
static inline void_t McHorVer33_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McHorVer33_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
uint8_t uiHorTmp[256] = { 0 }; uint8_t uiHorTmp[256] = { 0 };
uint8_t uiVerTmp[256] = { 0 }; uint8_t uiVerTmp[256] = { 0 };
@ -307,7 +307,7 @@ static inline void_t McHorVer33_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* p
PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight); PixelAvg_c (pDst, iDstStride, uiHorTmp, 16, uiVerTmp, 16, iWidth, iHeight);
} }
void_t McLuma_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, void McLuma_c (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)
//pSrc has been added the offset of mv //pSrc has been added the offset of mv
{ {
@ -321,7 +321,7 @@ void_t McLuma_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstS
pWelsMcFunc[iMvX & 0x03][iMvY & 0x03] (pSrc, iSrcStride, pDst, iDstStride, iWidth, iHeight); pWelsMcFunc[iMvX & 0x03][iMvY & 0x03] (pSrc, iSrcStride, pDst, iDstStride, iWidth, iHeight);
} }
static inline void_t McChromaWithFragMv_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McChromaWithFragMv_c (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) {
int32_t i, j; int32_t i, j;
int32_t iA, iB, iC, iD; int32_t iA, iB, iC, iD;
@ -341,7 +341,7 @@ static inline void_t McChromaWithFragMv_c (uint8_t* pSrc, int32_t iSrcStride, ui
} }
} }
void_t McChroma_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, void McChroma_c (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)
//pSrc has been added the offset of mv //pSrc has been added the offset of mv
{ {
@ -357,26 +357,26 @@ void_t McChroma_c (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDs
//***************************************************************************// //***************************************************************************//
// SSE2 implement // // SSE2 implement //
//***************************************************************************// //***************************************************************************//
static inline void_t McHorVer22WidthEq8_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer22WidthEq8_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
ENFORCE_STACK_ALIGN_2D (int16_t, iTap, 21, 8, 16) ENFORCE_STACK_ALIGN_2D (int16_t, iTap, 21, 8, 16)
McHorVer22Width8HorFirst_sse2 (pSrc - 2, iSrcStride, (uint8_t*)iTap, 16, iHeight + 5); McHorVer22Width8HorFirst_sse2 (pSrc - 2, iSrcStride, (uint8_t*)iTap, 16, iHeight + 5);
McHorVer22Width8VerLastAlign_sse2 ((uint8_t*)iTap, 16, pDst, iDstStride, 8, iHeight); McHorVer22Width8VerLastAlign_sse2 ((uint8_t*)iTap, 16, pDst, iDstStride, 8, iHeight);
} }
static inline void_t McHorVer02WidthEq16_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer02WidthEq16_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
McHorVer02WidthEq8_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer02WidthEq8_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
McHorVer02WidthEq8_sse2 (&pSrc[8], iSrcStride, &pDst[8], iDstStride, iHeight); McHorVer02WidthEq8_sse2 (&pSrc[8], iSrcStride, &pDst[8], iDstStride, iHeight);
} }
static inline void_t McHorVer22WidthEq16_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer22WidthEq16_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iHeight) { int32_t iHeight) {
McHorVer22WidthEq8_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer22WidthEq8_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
McHorVer22WidthEq8_sse2 (&pSrc[8], iSrcStride, &pDst[8], iDstStride, iHeight); McHorVer22WidthEq8_sse2 (&pSrc[8], iSrcStride, &pDst[8], iDstStride, iHeight);
} }
static inline void_t McCopy_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth, static inline void McCopy_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, int32_t iWidth,
int32_t iHeight) { int32_t iHeight) {
if (iWidth == 16) if (iWidth == 16)
McCopyWidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McCopyWidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
@ -388,7 +388,7 @@ static inline void_t McCopy_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pD
McCopyWidthEq2_c (pSrc, iSrcStride, pDst, iDstStride, iHeight); McCopyWidthEq2_c (pSrc, iSrcStride, pDst, iDstStride, iHeight);
} }
static inline void_t McHorVer20_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer20_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
if (iWidth == 16) if (iWidth == 16)
McHorVer20WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer20WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
@ -398,7 +398,7 @@ static inline void_t McHorVer20_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
McHorVer20WidthEq4_mmx (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer20WidthEq4_mmx (pSrc, iSrcStride, pDst, iDstStride, iHeight);
} }
static inline void_t McHorVer02_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer02_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
if (iWidth == 16) if (iWidth == 16)
McHorVer02WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer02WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
@ -408,7 +408,7 @@ static inline void_t McHorVer02_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
McHorVer02_c (pSrc, iSrcStride, pDst, iDstStride, 4, iHeight); McHorVer02_c (pSrc, iSrcStride, pDst, iDstStride, 4, iHeight);
} }
static inline void_t McHorVer22_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer22_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
if (iWidth == 16) if (iWidth == 16)
McHorVer22WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight); McHorVer22WidthEq16_sse2 (pSrc, iSrcStride, pDst, iDstStride, iHeight);
@ -418,7 +418,7 @@ static inline void_t McHorVer22_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
McHorVer22_c (pSrc, iSrcStride, pDst, iDstStride, 4, iHeight); McHorVer22_c (pSrc, iSrcStride, pDst, iDstStride, 4, iHeight);
} }
static inline void_t McHorVer01_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer01_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16);
if (iWidth == 16) { if (iWidth == 16) {
@ -432,7 +432,7 @@ static inline void_t McHorVer01_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc, iSrcStride, pTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc, iSrcStride, pTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer03_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer03_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16);
if (iWidth == 16) { if (iWidth == 16) {
@ -446,7 +446,7 @@ static inline void_t McHorVer03_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc + iSrcStride, iSrcStride, pTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc + iSrcStride, iSrcStride, pTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer10_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer10_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pTmp, 256, 16);
if (iWidth == 16) { if (iWidth == 16) {
@ -460,7 +460,7 @@ static inline void_t McHorVer10_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc, iSrcStride, pTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc, iSrcStride, pTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer11_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer11_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
@ -478,7 +478,7 @@ static inline void_t McHorVer11_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer12_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer12_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16);
@ -496,7 +496,7 @@ static inline void_t McHorVer12_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pVerTmp, 16, pCtrTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pVerTmp, 16, pCtrTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer13_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer13_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
@ -514,7 +514,7 @@ static inline void_t McHorVer13_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer21_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer21_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16);
@ -532,7 +532,7 @@ static inline void_t McHorVer21_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pCtrTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pCtrTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer23_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer23_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16);
@ -550,7 +550,7 @@ static inline void_t McHorVer23_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pCtrTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pCtrTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer30_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer30_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
if (iWidth == 16) { if (iWidth == 16) {
@ -564,7 +564,7 @@ static inline void_t McHorVer30_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc + 1, iSrcStride, pHorTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pSrc + 1, iSrcStride, pHorTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer31_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer31_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
@ -582,7 +582,7 @@ static inline void_t McHorVer31_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pHorTmp, 16, pVerTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer32_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer32_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pCtrTmp, 256, 16);
@ -600,7 +600,7 @@ static inline void_t McHorVer32_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
PixelAvgWidthEq4_mmx (pDst, iDstStride, pVerTmp, 16, pCtrTmp, 16, iHeight); PixelAvgWidthEq4_mmx (pDst, iDstStride, pVerTmp, 16, pCtrTmp, 16, iHeight);
} }
} }
static inline void_t McHorVer33_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, static inline void McHorVer33_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride,
int32_t iWidth, int32_t iHeight) { int32_t iWidth, int32_t iHeight) {
ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pHorTmp, 256, 16);
ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16); ENFORCE_STACK_ALIGN_1D (uint8_t, pVerTmp, 256, 16);
@ -619,7 +619,7 @@ static inline void_t McHorVer33_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t
} }
} }
void_t McLuma_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, void McLuma_sse2 (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)
//pSrc has been added the offset of mv //pSrc has been added the offset of mv
{ {
@ -633,7 +633,7 @@ void_t McLuma_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iD
pWelsMcFunc[iMvX & 0x03][iMvY & 0x03] (pSrc, iSrcStride, pDst, iDstStride, iWidth, iHeight); pWelsMcFunc[iMvX & 0x03][iMvY & 0x03] (pSrc, iSrcStride, pDst, iDstStride, iWidth, iHeight);
} }
void_t McChroma_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t iDstStride, void McChroma_sse2 (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) {
static const PMcChromaWidthExtFunc kpMcChromaWidthFuncs[2] = { static const PMcChromaWidthExtFunc kpMcChromaWidthFuncs[2] = {
McChromaWidthEq4_mmx, McChromaWidthEq4_mmx,
@ -654,7 +654,7 @@ void_t McChroma_sse2 (uint8_t* pSrc, int32_t iSrcStride, uint8_t* pDst, int32_t
#endif //X86_ASM #endif //X86_ASM
void_t InitMcFunc (SMcFunc* pMcFunc, int32_t iCpu) { void InitMcFunc (SMcFunc* pMcFunc, int32_t iCpu) {
pMcFunc->pMcLumaFunc = McLuma_c; pMcFunc->pMcLumaFunc = McLuma_c;
pMcFunc->pMcChromaFunc = McChroma_c; pMcFunc->pMcChromaFunc = McChroma_c;

14
codec/decoder/core/src/mem_align.cpp
View File

@ -44,8 +44,8 @@ int32_t iCountMalloc = 0;
#endif #endif
// //
void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) { void* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
const int32_t kiSizeVoidPtr = sizeof (void_t**); const int32_t kiSizeVoidPtr = sizeof (void**);
const int32_t kiSizeInt = sizeof (int32_t); const int32_t kiSizeInt = sizeof (int32_t);
const int32_t kiAlignBytes = 15; const int32_t kiAlignBytes = 15;
uint8_t* pBuf = (uint8_t*) malloc (kuiSize + kiAlignBytes + kiSizeVoidPtr + kiSizeInt); uint8_t* pBuf = (uint8_t*) malloc (kuiSize + kiAlignBytes + kiSizeVoidPtr + kiSizeInt);
@ -59,7 +59,7 @@ void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
if (kpTag != NULL) { if (kpTag != NULL) {
if (pMemCheckMalloc != NULL) { if (pMemCheckMalloc != NULL) {
fprintf (pMemCheckMalloc, "0x%x, size: %d , malloc %s\n", (void_t*)pBuf, fprintf (pMemCheckMalloc, "0x%x, size: %d , malloc %s\n", (void*)pBuf,
(kuiSize + kiAlignBytes + kiSizeVoidPtr + kiSizeInt), kpTag); (kuiSize + kiAlignBytes + kiSizeVoidPtr + kiSizeInt), kpTag);
} }
if (pMemCheckMalloc != NULL) { if (pMemCheckMalloc != NULL) {
@ -76,7 +76,7 @@ void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
pAlignBuf = pBuf + kiAlignBytes + kiSizeVoidPtr + kiSizeInt; pAlignBuf = pBuf + kiAlignBytes + kiSizeVoidPtr + kiSizeInt;
pAlignBuf -= (uintptr_t) pAlignBuf & kiAlignBytes; pAlignBuf -= (uintptr_t) pAlignBuf & kiAlignBytes;
* ((void_t**) (pAlignBuf - kiSizeVoidPtr)) = pBuf; * ((void**) (pAlignBuf - kiSizeVoidPtr)) = pBuf;
* ((int32_t*) (pAlignBuf - (kiSizeVoidPtr + kiSizeInt))) = kuiSize; * ((int32_t*) (pAlignBuf - (kiSizeVoidPtr + kiSizeInt))) = kuiSize;
return (pAlignBuf); return (pAlignBuf);
@ -84,15 +84,15 @@ void_t* WelsMalloc (const uint32_t kuiSize, const str_t* kpTag) {
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
void_t WelsFree (void_t* pPtr, const str_t* kpTag) { void WelsFree (void* pPtr, const str_t* kpTag) {
if (pPtr) { if (pPtr) {
#ifdef MEMORY_CHECK #ifdef MEMORY_CHECK
if (NULL != pMemCheckFree && kpTag != NULL) { if (NULL != pMemCheckFree && kpTag != NULL) {
fprintf (pMemCheckFree, "0x%x, free %s\n", (void_t*) (* (((void_t**) pPtr) - 1)), kpTag); fprintf (pMemCheckFree, "0x%x, free %s\n", (void*) (* (((void**) pPtr) - 1)), kpTag);
fflush (pMemCheckFree); fflush (pMemCheckFree);
} }
#endif #endif
free (* (((void_t**) pPtr) - 1)); free (* (((void**) pPtr) - 1));
} }
} }

14
codec/decoder/core/src/mv_pred.cpp
View File

@ -43,7 +43,7 @@
#include "mb_cache.h" #include "mb_cache.h"
namespace WelsDec { namespace WelsDec {
void_t PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]) { void PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]) {
bool bTopAvail, bLeftTopAvail, bRightTopAvail, bLeftAvail; bool bTopAvail, bLeftTopAvail, bRightTopAvail, bLeftAvail;
int32_t iCurSliceIdc, iTopSliceIdc, iLeftTopSliceIdc, iRightTopSliceIdc, iLeftSliceIdc; int32_t iCurSliceIdc, iTopSliceIdc, iLeftTopSliceIdc, iRightTopSliceIdc, iLeftSliceIdc;
@ -194,7 +194,7 @@ void_t PredPSkipMvFromNeighbor (PDqLayer pCurLayer, int16_t iMvp[2]) {
//basic iMVs prediction unit for iMVs partition width (4, 2, 1) //basic iMVs prediction unit for iMVs partition width (4, 2, 1)
void_t PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int32_t iPartWidth, int8_t iRef, int16_t iMVP[2]) { int32_t iPartIdx, int32_t iPartWidth, int8_t iRef, int16_t iMVP[2]) {
const uint8_t kuiLeftIdx = g_kuiCache30ScanIdx[iPartIdx] - 1; const uint8_t kuiLeftIdx = g_kuiCache30ScanIdx[iPartIdx] - 1;
const uint8_t kuiTopIdx = g_kuiCache30ScanIdx[iPartIdx] - 6; const uint8_t kuiTopIdx = g_kuiCache30ScanIdx[iPartIdx] - 6;
@ -241,7 +241,7 @@ void_t PredMv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A]
iMVP[1] = WelsMedian (iAMV[1], iBMV[1], iCMV[1]); iMVP[1] = WelsMedian (iAMV[1], iBMV[1], iCMV[1]);
} }
} }
void_t PredInter8x16Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredInter8x16Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]) { int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]) {
if (0 == iPartIdx) { if (0 == iPartIdx) {
const int8_t kiLeftRef = iRefIndex[0][6]; const int8_t kiLeftRef = iRefIndex[0][6];
@ -264,7 +264,7 @@ void_t PredInter8x16Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefInde
PredMv (iMotionVector, iRefIndex, iPartIdx, 2, iRef, iMVP); PredMv (iMotionVector, iRefIndex, iPartIdx, 2, iRef, iMVP);
} }
void_t PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30], void PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]) { int32_t iPartIdx, int8_t iRef, int16_t iMVP[2]) {
if (0 == iPartIdx) { if (0 == iPartIdx) {
const int8_t kiTopRef = iRefIndex[0][1]; const int8_t kiTopRef = iRefIndex[0][1];
@ -285,7 +285,7 @@ void_t PredInter16x8Mv (int16_t iMotionVector[LIST_A][30][MV_A], int8_t iRefInde
//update iMVs and iRefIndex cache for current MB, only for P_16*16 (SKIP inclusive) //update iMVs and iRefIndex cache for current MB, only for P_16*16 (SKIP inclusive)
/* can be further optimized */ /* can be further optimized */
void_t UpdateP16x16MotionInfo (PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2]) { void UpdateP16x16MotionInfo (PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2]) {
const int16_t kiRef2 = (iRef << 8) | iRef; const int16_t kiRef2 = (iRef << 8) | iRef;
const int32_t kiMV32 = LD32 (iMVs); const int32_t kiMV32 = LD32 (iMVs);
int32_t i; int32_t i;
@ -308,7 +308,7 @@ void_t UpdateP16x16MotionInfo (PDqLayer pCurDqLayer, int8_t iRef, int16_t iMVs[2
//update iRefIndex and iMVs of Mb, only for P16x8 //update iRefIndex and iMVs of Mb, only for P16x8
/*need further optimization, mb_cache not work */ /*need further optimization, mb_cache not work */
void_t UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], void UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A],
int8_t iRefIndex[LIST_A][30], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]) { int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]) {
const int16_t kiRef2 = (iRef << 8) | iRef; const int16_t kiRef2 = (iRef << 8) | iRef;
@ -338,7 +338,7 @@ void_t UpdateP16x8MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A
} }
} }
//update iRefIndex and iMVs of both Mb and Mb_cache, only for P8x16 //update iRefIndex and iMVs of both Mb and Mb_cache, only for P8x16
void_t UpdateP8x16MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A], void UpdateP8x16MotionInfo (PDqLayer pCurDqLayer, int16_t iMotionVector[LIST_A][30][MV_A],
int8_t iRefIndex[LIST_A][30], int8_t iRefIndex[LIST_A][30],
int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]) { int32_t iPartIdx, int8_t iRef, int16_t iMVs[2]) {
const int16_t kiRef2 = (iRef << 8) | iRef; const int16_t kiRef2 = (iRef << 8) | iRef;

14
codec/decoder/core/src/parse_mb_syn_cavlc.cpp
View File

@ -45,7 +45,7 @@
namespace WelsDec { namespace WelsDec {
void_t GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer) { void GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer) {
int32_t iCurSliceIdc, iTopSliceIdc, iLeftTopSliceIdc, iRightTopSliceIdc, iLeftSliceIdc; int32_t iCurSliceIdc, iTopSliceIdc, iLeftTopSliceIdc, iRightTopSliceIdc, iLeftSliceIdc;
int32_t iCurXy, iTopXy, iLeftXy, iLeftTopXy, iRightTopXy; int32_t iCurXy, iTopXy, iLeftXy, iLeftTopXy, iRightTopXy;
int32_t iCurX, iCurY; int32_t iCurX, iCurY;
@ -92,7 +92,7 @@ void_t GetNeighborAvailMbType (PNeighAvail pNeighAvail, PDqLayer pCurLayer) {
pNeighAvail->iLeftTopType = (pNeighAvail->iLeftTopAvail ? pCurLayer->pMbType[iLeftTopXy] : 0); pNeighAvail->iLeftTopType = (pNeighAvail->iLeftTopAvail ? pCurLayer->pMbType[iLeftTopXy] : 0);
pNeighAvail->iRightTopType = (pNeighAvail->iRightTopAvail ? pCurLayer->pMbType[iRightTopXy] : 0); pNeighAvail->iRightTopType = (pNeighAvail->iRightTopAvail ? pCurLayer->pMbType[iRightTopXy] : 0);
} }
void_t WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, void WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
PDqLayer pCurLayer) { //no matter slice type, intra_pred_constrained_flag PDqLayer pCurLayer) { //no matter slice type, intra_pred_constrained_flag
int32_t iCurXy = pCurLayer->iMbXyIndex; int32_t iCurXy = pCurLayer->iMbXyIndex;
int32_t iTopXy = 0; int32_t iTopXy = 0;
@ -143,7 +143,7 @@ void_t WelsFillCacheNonZeroCount (PNeighAvail pNeighAvail, uint8_t* pNonZeroCoun
pNonZeroCount[5 + 8 * 5] = -1;//unavailable pNonZeroCount[5 + 8 * 5] = -1;//unavailable
} }
} }
void_t WelsFillCacheConstrain1Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, void WelsFillCacheConstrain1Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode,
PDqLayer pCurLayer) { //no matter slice type PDqLayer pCurLayer) { //no matter slice type
int32_t iCurXy = pCurLayer->iMbXyIndex; int32_t iCurXy = pCurLayer->iMbXyIndex;
int32_t iTopXy = 0; int32_t iTopXy = 0;
@ -189,7 +189,7 @@ void_t WelsFillCacheConstrain1Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZe
} }
} }
void_t WelsFillCacheConstrain0Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode, void WelsFillCacheConstrain0Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, int8_t* pIntraPredMode,
PDqLayer pCurLayer) { //no matter slice type PDqLayer pCurLayer) { //no matter slice type
int32_t iCurXy = pCurLayer->iMbXyIndex; int32_t iCurXy = pCurLayer->iMbXyIndex;
int32_t iTopXy = 0; int32_t iTopXy = 0;
@ -235,7 +235,7 @@ void_t WelsFillCacheConstrain0Intra4x4 (PNeighAvail pNeighAvail, uint8_t* pNonZe
} }
} }
void_t WelsFillCacheInter (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount, void WelsFillCacheInter (PNeighAvail pNeighAvail, uint8_t* pNonZeroCount,
int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PDqLayer pCurLayer) { int16_t iMvArray[LIST_A][30][MV_A], int8_t iRefIdxArray[LIST_A][30], PDqLayer pCurLayer) {
int32_t iCurXy = pCurLayer->iMbXyIndex; int32_t iCurXy = pCurLayer->iMbXyIndex;
int32_t iTopXy = 0; int32_t iTopXy = 0;
@ -472,10 +472,10 @@ int32_t CheckIntra4x4PredMode (int32_t* pSampleAvail, int8_t* pMode, int32_t iIn
return iFinalMode; return iFinalMode;
} }
void_t BsStartCavlc (PBitStringAux pBs) { void BsStartCavlc (PBitStringAux pBs) {
pBs->iIndex = ((pBs->pCurBuf - pBs->pStartBuf) << 3) - (16 - pBs->iLeftBits); pBs->iIndex = ((pBs->pCurBuf - pBs->pStartBuf) << 3) - (16 - pBs->iLeftBits);
} }
void_t BsEndCavlc (PBitStringAux pBs) { void BsEndCavlc (PBitStringAux pBs) {
pBs->pCurBuf = pBs->pStartBuf + (pBs->iIndex >> 3); pBs->pCurBuf = pBs->pStartBuf + (pBs->iIndex >> 3);
pBs->uiCurBits = ((((pBs->pCurBuf[0] << 8) | pBs->pCurBuf[1]) << 16) | (pBs->pCurBuf[2] << 8) | pBs->pCurBuf[3]) << pBs->uiCurBits = ((((pBs->pCurBuf[0] << 8) | pBs->pCurBuf[1]) << 16) | (pBs->pCurBuf[2] << 8) | pBs->pCurBuf[3]) <<
(pBs->iIndex & 0x07); (pBs->iIndex & 0x07);

4
codec/decoder/core/src/pic_queue.cpp
View File

@ -44,7 +44,7 @@
namespace WelsDec { namespace WelsDec {
void_t FreePicture (PPicture pPic); void FreePicture (PPicture pPic);
///////////////////////////////////Recycled queue management for pictures/////////////////////////////////// ///////////////////////////////////Recycled queue management for pictures///////////////////////////////////
@ -106,7 +106,7 @@ PPicture AllocPicture (PWelsDecoderContext pCtx, const int32_t kiPicWidth, const
return pPic; return pPic;
} }
void_t FreePicture (PPicture pPic) { void FreePicture (PPicture pPic) {
if (NULL != pPic) { if (NULL != pPic) {
if (pPic->pBuffer[0]) { if (pPic->pBuffer[0]) {

10
codec/decoder/core/src/rec_mb.cpp
View File

@ -44,7 +44,7 @@
namespace WelsDec { namespace WelsDec {
void_t WelsFillRecNeededMbInfo (PWelsDecoderContext pCtx, bool bOutput, PDqLayer pCurLayer) { void WelsFillRecNeededMbInfo (PWelsDecoderContext pCtx, bool bOutput, PDqLayer pCurLayer) {
PPicture pCurPic = pCtx->pDec; PPicture pCurPic = pCtx->pDec;
int32_t iLumaStride = pCurPic->iLinesize[0]; int32_t iLumaStride = pCurPic->iLinesize[0];
int32_t iChromaStride = pCurPic->iLinesize[1]; int32_t iChromaStride = pCurPic->iLinesize[1];
@ -183,7 +183,7 @@ typedef struct TagMCRefMember {
int32_t iPicHeight; int32_t iPicHeight;
} sMCRefMember; } sMCRefMember;
//according to current 8*8 block ref_index to gain reference picture //according to current 8*8 block ref_index to gain reference picture
static inline void_t GetRefPic (sMCRefMember* pMCRefMem, PWelsDecoderContext pCtx, int8_t* pRefIdxList, static inline void GetRefPic (sMCRefMember* pMCRefMem, PWelsDecoderContext pCtx, int8_t* pRefIdxList,
int32_t iIndex) { int32_t iIndex) {
PPicture pRefPic; PPicture pRefPic;
@ -202,7 +202,7 @@ static inline void_t GetRefPic (sMCRefMember* pMCRefMem, PWelsDecoderContext pCt
#ifndef MC_FLOW_SIMPLE_JUDGE #ifndef MC_FLOW_SIMPLE_JUDGE
#define MC_FLOW_SIMPLE_JUDGE 1 #define MC_FLOW_SIMPLE_JUDGE 1
#endif //MC_FLOW_SIMPLE_JUDGE #endif //MC_FLOW_SIMPLE_JUDGE
static inline void_t BaseMC (sMCRefMember* pMCRefMem, int32_t iXOffset, int32_t iYOffset, SMcFunc* pMCFunc, static inline void BaseMC (sMCRefMember* pMCRefMem, int32_t iXOffset, int32_t iYOffset, SMcFunc* pMCFunc,
int32_t iBlkWidth, int32_t iBlkHeight, int16_t iMVs[2]) { int32_t iBlkWidth, int32_t iBlkHeight, int16_t iMVs[2]) {
int32_t iExpandWidth = PADDING_LENGTH; int32_t iExpandWidth = PADDING_LENGTH;
int32_t iExpandHeight = PADDING_LENGTH; int32_t iExpandHeight = PADDING_LENGTH;
@ -289,7 +289,7 @@ static inline void_t BaseMC (sMCRefMember* pMCRefMem, int32_t iXOffset, int32_t
} }
} }
void_t GetInterPred (uint8_t* pPredY, uint8_t* pPredCb, uint8_t* pPredCr, PWelsDecoderContext pCtx) { void GetInterPred (uint8_t* pPredY, uint8_t* pPredCb, uint8_t* pPredCr, PWelsDecoderContext pCtx) {
sMCRefMember pMCRefMem; sMCRefMember pMCRefMem;
PDqLayer pCurDqLayer = pCtx->pCurDqLayer; PDqLayer pCurDqLayer = pCtx->pCurDqLayer;
SMcFunc* pMCFunc = &pCtx->sMcFunc; SMcFunc* pMCFunc = &pCtx->sMcFunc;
@ -464,7 +464,7 @@ int32_t RecChroma (int32_t iMBXY, PWelsDecoderContext pCtx, int16_t* pScoeffLeve
return ERR_NONE; return ERR_NONE;
} }
void_t FillBufForMc (uint8_t* pBuf, int32_t iBufStride, uint8_t* pSrc, int32_t iSrcStride, int32_t iSrcOffset, void FillBufForMc (uint8_t* pBuf, int32_t iBufStride, uint8_t* pSrc, int32_t iSrcStride, int32_t iSrcOffset,
int32_t iBlockWidth, int32_t iBlockHeight, int32_t iSrcX, int32_t iSrcY, int32_t iPicWidth, int32_t iPicHeight) { int32_t iBlockWidth, int32_t iBlockHeight, int32_t iSrcX, int32_t iSrcY, int32_t iPicWidth, int32_t iPicHeight) {
int32_t iY; int32_t iY;
int32_t iStartY, iStartX, iEndY, iEndX; int32_t iStartY, iStartX, iEndY, iEndX;

2
codec/decoder/core/src/utils.cpp
View File

@ -48,7 +48,7 @@ PWelsLogCallbackFunc g_pLog = NULL;
void_t WelsLog (void_t* pPtr, int32_t iLevel, const char* kpFmt, ...) { void WelsLog (void* pPtr, int32_t iLevel, const char* kpFmt, ...) {
va_list pVl; va_list pVl;
PWelsDecoderContext pCtx = (PWelsDecoderContext)pPtr; PWelsDecoderContext pCtx = (PWelsDecoderContext)pPtr;

6
codec/decoder/plus/inc/welsCodecTrace.h
View File

@ -68,7 +68,7 @@ virtual ~IWelsTrace() {};
virtual int32_t SetTraceLevel (int32_t iLevel) = 0; virtual int32_t SetTraceLevel (int32_t iLevel) = 0;
virtual int32_t Trace (const int32_t kLevel, const str_t* kpFormat, va_list pVl) = 0; virtual int32_t Trace (const int32_t kLevel, const str_t* kpFormat, va_list pVl) = 0;
static void_t WelsTrace (void_t* pObject, const int32_t kLevel, const str_t* kpFormat, va_list pVl) { static void WelsTrace (void* pObject, const int32_t kLevel, const str_t* kpFormat, va_list pVl) {
IWelsTrace* pThis = (IWelsTrace*) (pObject); IWelsTrace* pThis = (IWelsTrace*) (pObject);
if (pThis) { if (pThis) {
@ -76,7 +76,7 @@ static void_t WelsTrace (void_t* pObject, const int32_t kLevel, const str_t* kp
} }
} }
static void_t WelsVTrace (void_t* pObject, const int32_t kLevel, const str_t* kpFormat, ...) { static void WelsVTrace (void* pObject, const int32_t kLevel, const str_t* kpFormat, ...) {
IWelsTrace* pThis = (IWelsTrace*) (pObject); IWelsTrace* pThis = (IWelsTrace*) (pObject);
va_list argptr; va_list argptr;
@ -152,7 +152,7 @@ CM_WELS_TRACE m_fpErrorTrace;
}; };
IWelsTrace* CreateWelsTrace (EWelsTraceType eType, void_t* pParam = NULL); IWelsTrace* CreateWelsTrace (EWelsTraceType eType, void* pParam = NULL);
} // namespace WelsDec } // namespace WelsDec

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

@ -56,10 +56,10 @@ namespace WelsDec {
class CWelsDecoder : public ISVCDecoder { class CWelsDecoder : public ISVCDecoder {
public: public:
CWelsDecoder (void_t); CWelsDecoder (void);
virtual ~CWelsDecoder(); virtual ~CWelsDecoder();
virtual long EXTAPI Initialize (void_t* pParam, const INIT_TYPE keInitType); virtual long EXTAPI Initialize (void* pParam, const INIT_TYPE keInitType);
virtual long EXTAPI Uninitialize(); virtual long EXTAPI Uninitialize();
/*************************************************************************** /***************************************************************************
@ -83,7 +83,7 @@ virtual DECODING_STATE EXTAPI DecodeFrame (const unsigned char* kpSrc,
virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* kpSrc, virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* kpSrc,
const int kiSrcLen, const int kiSrcLen,
void_t** ppDst, void** 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,
@ -94,15 +94,15 @@ virtual DECODING_STATE EXTAPI DecodeFrameEx (const unsigned char* kpSrc,
int& iHeight, int& iHeight,
int& color_format); int& color_format);
virtual long EXTAPI SetOption (DECODER_OPTION eOptID, void_t* pOption); virtual long EXTAPI SetOption (DECODER_OPTION eOptID, void* pOption);
virtual long EXTAPI GetOption (DECODER_OPTION eOptID, void_t* pOption); virtual long EXTAPI GetOption (DECODER_OPTION eOptID, void* pOption);
private: private:
PWelsDecoderContext m_pDecContext; PWelsDecoderContext m_pDecContext;
IWelsTrace* m_pTrace; IWelsTrace* m_pTrace;
void_t InitDecoder (void_t); void InitDecoder (void);
void_t UninitDecoder (void_t); void UninitDecoder (void);
XMMREG_PROTECT_DECLARE(CWelsH264Decoder); XMMREG_PROTECT_DECLARE(CWelsH264Decoder);

2
codec/decoder/plus/src/welsCodecTrace.cpp
View File

@ -164,7 +164,7 @@ int32_t CWelsCodecTrace::WriteString (int32_t iLevel, const str_t* pStr) {
} }
IWelsTrace* CreateWelsTrace (EWelsTraceType eType, void_t* pParam) { IWelsTrace* CreateWelsTrace (EWelsTraceType eType, void* pParam) {
IWelsTrace* pTrace = NULL; IWelsTrace* pTrace = NULL;
switch (eType) { switch (eType) {
case Wels_Trace_Type: case Wels_Trace_Type:

22
codec/decoder/plus/src/welsDecoderExt.cpp
View File

@ -83,7 +83,7 @@ namespace WelsDec {
* *
* return: none * return: none
***************************************************************************/ ***************************************************************************/
CWelsDecoder::CWelsDecoder (void_t) CWelsDecoder::CWelsDecoder (void)
: m_pDecContext (NULL), : m_pDecContext (NULL),
m_pTrace (NULL) { m_pTrace (NULL) {
#ifdef OUTPUT_BIT_STREAM #ifdef OUTPUT_BIT_STREAM
@ -108,8 +108,8 @@ CWelsDecoder::CWelsDecoder (void_t)
WelsGetTimeOfDay (&sCurTime); WelsGetTimeOfDay (&sCurTime);
iCurUsed = WelsSnprintf (chFileName, iBufLeft, "bs_0x%p_", (void_t*)this); iCurUsed = WelsSnprintf (chFileName, iBufLeft, "bs_0x%p_", (void*)this);
iCurUsedSize = WelsSnprintf (chFileNameSize, iBufLeftSize, "size_0x%p_", (void_t*)this); iCurUsedSize = WelsSnprintf (chFileNameSize, iBufLeftSize, "size_0x%p_", (void*)this);
if (iCurUsed > 0) { if (iCurUsed > 0) {
iBufUsed += iCurUsed; iBufUsed += iCurUsed;
@ -186,7 +186,7 @@ CWelsDecoder::~CWelsDecoder() {
} }
} }
long CWelsDecoder::Initialize (void_t* pParam, const INIT_TYPE keInitType) { long CWelsDecoder::Initialize (void* pParam, const INIT_TYPE keInitType) {
if (pParam == NULL || keInitType != INIT_TYPE_PARAMETER_BASED) { if (pParam == NULL || keInitType != INIT_TYPE_PARAMETER_BASED) {
IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument."); IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
return cmInitParaError; return cmInitParaError;
@ -206,7 +206,7 @@ long CWelsDecoder::Uninitialize() {
return ERR_NONE; return ERR_NONE;
} }
void_t CWelsDecoder::UninitDecoder (void_t) { void CWelsDecoder::UninitDecoder (void) {
if (NULL == m_pDecContext) if (NULL == m_pDecContext)
return; return;
@ -224,7 +224,7 @@ void_t CWelsDecoder::UninitDecoder (void_t) {
} }
// the return value of this function is not suitable, it need report failure info to upper layer. // the return value of this function is not suitable, it need report failure info to upper layer.
void_t CWelsDecoder::InitDecoder (void_t) { void CWelsDecoder::InitDecoder (void) {
IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::init_decoder().."); IWelsTrace::WelsVTrace (m_pTrace, IWelsTrace::WELS_LOG_INFO, "CWelsDecoder::init_decoder()..");
m_pDecContext = (PWelsDecoderContext)WelsMalloc (sizeof (SWelsDecoderContext), "m_pDecContext"); m_pDecContext = (PWelsDecoderContext)WelsMalloc (sizeof (SWelsDecoderContext), "m_pDecContext");
@ -237,7 +237,7 @@ void_t CWelsDecoder::InitDecoder (void_t) {
/* /*
* Set Option * Set Option
*/ */
long CWelsDecoder::SetOption (DECODER_OPTION eOptID, void_t* pOption) { long CWelsDecoder::SetOption (DECODER_OPTION eOptID, void* pOption) {
int iVal = 0; int iVal = 0;
if (m_pDecContext == NULL) if (m_pDecContext == NULL)
@ -294,7 +294,7 @@ long CWelsDecoder::SetOption (DECODER_OPTION eOptID, void_t* pOption) {
/* /*
* Get Option * Get Option
*/ */
long CWelsDecoder::GetOption (DECODER_OPTION eOptID, void_t* pOption) { long CWelsDecoder::GetOption (DECODER_OPTION eOptID, void* pOption) {
int iVal = 0; int iVal = 0;
if (m_pDecContext == NULL) if (m_pDecContext == NULL)
@ -359,7 +359,7 @@ long CWelsDecoder::GetOption (DECODER_OPTION eOptID, void_t* pOption) {
DECODING_STATE CWelsDecoder::DecodeFrame2 (const unsigned char* kpSrc, DECODING_STATE CWelsDecoder::DecodeFrame2 (const unsigned char* kpSrc,
const int kiSrcLen, const int kiSrcLen,
void_t** ppDst, void** ppDst,
SBufferInfo* pDstInfo) { SBufferInfo* pDstInfo) {
if (kiSrcLen > MAX_ACCESS_UNIT_CAPACITY) { if (kiSrcLen > MAX_ACCESS_UNIT_CAPACITY) {
m_pDecContext->iErrorCode |= dsOutOfMemory; m_pDecContext->iErrorCode |= dsOutOfMemory;
@ -449,7 +449,7 @@ DECODING_STATE CWelsDecoder::DecodeFrame (const unsigned char* kpSrc,
DstInfo.UsrData.sSystemBuffer.iHeight = iHeight; DstInfo.UsrData.sSystemBuffer.iHeight = iHeight;
DstInfo.eBufferProperty = BUFFER_HOST; DstInfo.eBufferProperty = BUFFER_HOST;
eDecState = DecodeFrame2 (kpSrc, kiSrcLen, (void_t**)ppDst, &DstInfo); eDecState = DecodeFrame2 (kpSrc, kiSrcLen, (void**)ppDst, &DstInfo);
if (eDecState == dsErrorFree) { if (eDecState == dsErrorFree) {
pStride[0] = DstInfo.UsrData.sSystemBuffer.iStride[0]; pStride[0] = DstInfo.UsrData.sSystemBuffer.iStride[0];
pStride[1] = DstInfo.UsrData.sSystemBuffer.iStride[1]; pStride[1] = DstInfo.UsrData.sSystemBuffer.iStride[1];
@ -503,7 +503,7 @@ long CreateDecoder (ISVCDecoder** ppDecoder) {
/* /*
* DestroyDecoder * DestroyDecoder
*/ */
void_t DestroyDecoder (ISVCDecoder* pDecoder) { void DestroyDecoder (ISVCDecoder* pDecoder) {
if (NULL != pDecoder) { if (NULL != pDecoder) {
delete (CWelsDecoder*)pDecoder; delete (CWelsDecoder*)pDecoder;
} }