@scrypted/libav 1.0.180 → 1.0.181

package/openh264/codec/encoder/core/inc/deblocking.h

@@ -0,0 +1,92 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2013, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    deblocking.h
+ *
+ * \brief   Interfaces introduced in frame deblocking filtering
+ *
+ * \date    08/03/2009 Created
+ *
+ *************************************************************************************
+ */
+
+#ifndef WELS_DEBLOCKING_H_
+#define WELS_DEBLOCKING_H_
+
+#include "encoder_context.h"
+#include "wels_func_ptr_def.h"
+#include "deblocking_common.h"
+namespace WelsEnc {
+
+
+//struct tagDeblockingFunc;
+
+typedef struct TagDeblockingFilter {
+  uint8_t*    pCsData[3];     // pointer to reconstructed picture pData
+  int32_t     iCsStride[3];   // Cs iStride
+  int16_t     iMbStride;
+  int8_t      iSliceAlphaC0Offset;
+  int8_t      iSliceBetaOffset;
+  uint8_t     uiLumaQP;
+  uint8_t     uiChromaQP;
+  uint8_t     uiFilterIdc;
+  uint8_t     uiReserved;
+} SDeblockingFilter;
+
+#if defined(__cplusplus)
+extern "C" {
+#endif//__cplusplus
+#if defined(HAVE_NEON)
+void DeblockingBSCalcEnc_neon (int8_t* pNzc, SMVUnitXY* pMv, int32_t iBoundryFlag, int32_t iMbStride,
+                               uint8_t (*pBS)[4][4]);
+#endif
+#if defined(HAVE_NEON_AARCH64)
+void DeblockingBSCalcEnc_AArch64_neon (int8_t* pNzc, SMVUnitXY* pMv, int32_t iBoundryFlag, int32_t iMbStride,
+                                       uint8_t (*pBS)[4][4]);
+#endif
+#if defined(__cplusplus)
+}
+#endif//__cplusplus
+void DeblockingInit (DeblockingFunc*   pFunc,  int32_t iCpu);
+
+void WelsBlockFuncInit (PSetNoneZeroCountZeroFunc* pfSetNZCZero,  int32_t iCpu);
+
+void PerformDeblockingFilter (sWelsEncCtx* pEnc);
+
+void DeblockingFilterFrameAvcbase (SDqLayer* pCurDq, SWelsFuncPtrList* pFunc);
+
+void DeblockingFilterSliceAvcbase (SDqLayer* pCurDq, SWelsFuncPtrList* pFunc, SSlice* pSlice);
+void DeblockingFilterSliceAvcbaseNull (SDqLayer* pCurDq, SWelsFuncPtrList* pFunc, SSlice* pSlice);
+}
+
+#endif
+
+

package/openh264/codec/encoder/core/inc/decode_mb_aux.h

@@ -0,0 +1,112 @@
+/*!
+ * \copy
+ *     Copyright (c)  2013, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef DECODE_MB_AUX_H
+#define DECODE_MB_AUX_H
+
+#include "typedefs.h"
+#include "macros.h"
+#include "wels_func_ptr_def.h"
+
+namespace WelsEnc {
+void WelsDequantLumaDc4x4 (int16_t* pRes, const int32_t kiQp);
+void WelsIHadamard4x4Dc (int16_t* pRes);
+
+void WelsInitReconstructionFuncs (SWelsFuncPtrList* pList, uint32_t  iCpuFlags);
+void WelsGetEncBlockStrideOffset (int32_t* pBlock, const int32_t kiStrideY, const int32_t kiStrideUV);
+
+void WelsDequantFour4x4_c (int16_t* pRes, const uint16_t* kpQpTable);
+void WelsDequant4x4_c (int16_t* pRes, const uint16_t* kpQpTable);
+void WelsDequantIHadamard4x4_c (int16_t* pRes, const uint16_t kuiMF);
+void WelsDequantIHadamard2x2Dc (int16_t* pDct, const uint16_t kuiMF);
+
+void WelsIDctT4RecOnMb (uint8_t* pDst, int32_t iDstStride, uint8_t* pPred, int32_t iPredStride, int16_t* pDct,
+                        PIDctFunc pfIDctFourT4);
+void WelsIDctT4Rec_c (uint8_t* pRec, int32_t iStride, uint8_t* pPred, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_c (uint8_t* pRec, int32_t iStride, uint8_t* pPred, int32_t iPredStride, int16_t* pDct);
+void WelsIDctRecI16x16Dc_c (uint8_t* pRec, int32_t iStride, uint8_t* pPred, int32_t iPredStride, int16_t* pDctDc);
+
+#if defined(__cplusplus)
+extern "C" {
+#endif//__cplusplus
+
+#if defined(X86_ASM)
+void WelsDequant4x4_sse2 (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequantFour4x4_sse2 (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequantIHadamard4x4_sse2 (int16_t* pRes, const uint16_t kuiMF);
+
+void WelsIDctT4Rec_mmx (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctT4Rec_sse2 (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_sse2 (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctRecI16x16Dc_sse2 (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride,
+                               int16_t* pDctDc);
+void WelsIDctT4Rec_avx2 (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_avx2 (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+#endif//X86_ASM
+
+#ifdef HAVE_NEON
+void WelsDequantFour4x4_neon (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequant4x4_neon (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequantIHadamard4x4_neon (int16_t* pRes, const uint16_t kuiMF);
+
+void WelsIDctT4Rec_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctRecI16x16Dc_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride,
+                               int16_t* pDctDc);
+#endif
+
+#ifdef HAVE_NEON_AARCH64
+void WelsDequantFour4x4_AArch64_neon (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequant4x4_AArch64_neon (int16_t* pDct, const uint16_t* kpMF);
+void WelsDequantIHadamard4x4_AArch64_neon (int16_t* pRes, const uint16_t kuiMF);
+
+void WelsIDctT4Rec_AArch64_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_AArch64_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctRecI16x16Dc_AArch64_neon (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride,
+                                 int16_t* pDctDc);
+#endif
+
+#if defined(HAVE_MMI)
+void WelsIDctT4Rec_mmi (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_mmi (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctRecI16x16Dc_mmi (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDctDc);
+#endif//HAVE_MMI
+
+#if defined(HAVE_LASX)
+void WelsIDctT4Rec_lasx (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+void WelsIDctFourT4Rec_lasx (uint8_t* pRec, int32_t iStride, uint8_t* pPrediction, int32_t iPredStride, int16_t* pDct);
+#endif
+#if defined(__cplusplus)
+}
+#endif//__cplusplus
+}
+#endif

package/openh264/codec/encoder/core/inc/dq_map.h

@@ -0,0 +1,58 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2013, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    dq_map.h
+ *
+ * \brief   Dependency Quality layer IDC mapping for cross layer selection and jumpping.
+ *          DQ layer idc map for svc encoding, might be a better scheme than that of design before,
+ *          can aware idc of referencing layer and that idc of successive layer to be coded
+ *
+ * \date    4/22/2009 Created
+ *
+ *************************************************************************************
+ */
+#if !defined(WELS_ENCODER_DEPENDENCY_QUAILITY_IDC_MAP_H__)
+#define WELS_ENCODER_DEPENDENCY_QUAILITY_IDC_MAP_H__
+
+namespace WelsEnc {
+/*
+ *  Dependency Quality IDC
+ */
+
+typedef struct TagDqIdc {
+uint16_t    iPpsId;         // pPps id
+uint8_t     iSpsId;         // pSps id
+int8_t      uiSpatialId;    // spatial id
+} SDqIdc;
+
+}
+
+#endif//WELS_ENCODER_DEPENDENCY_QUAILITY_IDC_MAP_H__

package/openh264/codec/encoder/core/inc/encode_mb_aux.h

@@ -0,0 +1,199 @@
+/*!
+ * \copy
+ *     Copyright (c)  2013, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef ENCODE_MB_AUX_H
+#define ENCODE_MB_AUX_H
+
+#include "typedefs.h"
+#include "wels_func_ptr_def.h"
+#include "copy_mb.h"
+
+namespace WelsEnc {
+void WelsInitEncodingFuncs (SWelsFuncPtrList* pFuncList, uint32_t  uiCpuFlag);
+int32_t WelsGetNoneZeroCount_c (int16_t* pLevel);
+
+/****************************************************************************
+ * Scan and Score functions
+ ****************************************************************************/
+void    WelsScan4x4Ac_c (int16_t* pZigValue, int16_t* pDct);
+void    WelsScan4x4Dc (int16_t* pLevel, int16_t* pDct);
+void    WelsScan4x4DcAc_c (int16_t* pLevel, int16_t* pDct);
+int32_t WelsCalculateSingleCtr4x4_c (int16_t* pDct);
+
+/****************************************************************************
+ * HDM and Quant functions
+ ****************************************************************************/
+void WelsHadamardT4Dc_c (int16_t* pLumaDc, int16_t* pDct);
+int32_t WelsHadamardQuant2x2_c (int16_t* pRes, const int16_t kiFF, int16_t iMF, int16_t* pDct, int16_t* pBlock);
+int32_t WelsHadamardQuant2x2Skip_c (int16_t* pRes, int16_t iFF,  int16_t iMF);
+
+void WelsQuant4x4_c (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_c (int16_t* pDct, int16_t iFF,  int16_t iMF);
+void WelsQuantFour4x4_c (int16_t* pDct, const int16_t* pFF, const int16_t* pQpTable);
+void WelsQuantFour4x4Max_c (int16_t* pDct, const int16_t* pF, const int16_t* pQpTable, int16_t* pMax);
+
+
+/****************************************************************************
+ * DCT functions
+ ****************************************************************************/
+void WelsDctT4_c (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+// dct_data is no-use here, just for the same interface with dct_save functions
+void WelsDctFourT4_c (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+
+#if defined(__cplusplus)
+extern "C" {
+#endif//__cplusplus
+
+#ifdef X86_ASM
+
+int32_t WelsGetNoneZeroCount_sse2 (int16_t* pLevel);
+int32_t WelsGetNoneZeroCount_sse42 (int16_t* pLevel);
+
+/****************************************************************************
+ * Scan and Score functions
+ ****************************************************************************/
+void WelsScan4x4Ac_sse2 (int16_t* zig_value, int16_t* pDct);
+void WelsScan4x4DcAc_ssse3 (int16_t* pLevel, int16_t* pDct);
+void WelsScan4x4DcAc_sse2 (int16_t* pLevel, int16_t* pDct);
+int32_t WelsCalculateSingleCtr4x4_sse2 (int16_t* pDct);
+
+/****************************************************************************
+ * DCT functions
+ ****************************************************************************/
+void WelsDctT4_mmx (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctT4_sse2 (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_sse2 (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctT4_avx2 (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_avx2 (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+
+/****************************************************************************
+ * HDM and Quant functions
+ ****************************************************************************/
+int32_t WelsHadamardQuant2x2_mmx (int16_t* pRes, const int16_t kiFF, int16_t iMF, int16_t* pDct, int16_t* pBlock);
+void WelsHadamardT4Dc_sse2 (int16_t* pLumaDc, int16_t* pDct);
+int32_t WelsHadamardQuant2x2Skip_mmx (int16_t* pRes, int16_t iFF,  int16_t iMF);
+
+void WelsQuant4x4_sse2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_sse2 (int16_t* pDct, int16_t iFF, int16_t iMF);
+void WelsQuantFour4x4_sse2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_sse2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+
+void WelsQuant4x4_avx2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_avx2 (int16_t* pDct, int16_t iFF, int16_t iMF);
+void WelsQuantFour4x4_avx2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_avx2 (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+
+#endif
+
+#ifdef HAVE_NEON
+void WelsHadamardT4Dc_neon (int16_t* pLumaDc, int16_t* pDct);
+int32_t WelsHadamardQuant2x2_neon (int16_t* pRes, const int16_t kiFF, int16_t iMF, int16_t* pDct, int16_t* pBlock);
+int32_t WelsHadamardQuant2x2Skip_neon (int16_t* pRes, int16_t iFF,  int16_t iMF);
+int32_t WelsHadamardQuant2x2SkipKernel_neon (int16_t* pRes, int16_t iThreshold); // avoid divide operator
+
+void WelsDctT4_neon (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_neon (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+
+int32_t WelsGetNoneZeroCount_neon (int16_t* pLevel);
+
+void WelsQuant4x4_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_neon (int16_t* pDct, int16_t iFF, int16_t iMF);
+void WelsQuantFour4x4_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+#endif
+
+#ifdef HAVE_NEON_AARCH64
+void WelsHadamardT4Dc_AArch64_neon (int16_t* pLumaDc, int16_t* pDct);
+int32_t WelsHadamardQuant2x2_AArch64_neon (int16_t* pRes, const int16_t kiFF, int16_t iMF, int16_t* pDct, int16_t* pBlock);
+int32_t WelsHadamardQuant2x2Skip_AArch64_neon (int16_t* pRes, int16_t iFF,  int16_t iMF);
+int32_t WelsHadamardQuant2x2SkipKernel_AArch64_neon (int16_t* pRes, int16_t iThreshold); // avoid divide operator
+
+void WelsDctT4_AArch64_neon (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_AArch64_neon (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+
+int32_t WelsGetNoneZeroCount_AArch64_neon (int16_t* pLevel);
+
+void WelsQuant4x4_AArch64_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_AArch64_neon (int16_t* pDct, int16_t iFF, int16_t iMF);
+void WelsQuantFour4x4_AArch64_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_AArch64_neon (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+#endif
+
+#ifdef HAVE_MMI
+int32_t WelsGetNoneZeroCount_mmi (int16_t* pLevel);
+
+/****************************************************************************
+ *  * Scan and Score functions
+ *   ****************************************************************************/
+void WelsScan4x4Ac_mmi (int16_t* zig_value, int16_t* pDct);
+void WelsScan4x4DcAc_mmi (int16_t* pLevel, int16_t* pDct);
+int32_t WelsCalculateSingleCtr4x4_mmi (int16_t* pDct);
+
+/****************************************************************************
+ *  * DCT functions
+ *   ****************************************************************************/
+void WelsDctT4_mmi (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_mmi (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+
+/****************************************************************************
+ *  * HDM and Quant functions
+ *   ****************************************************************************/
+void WelsHadamardT4Dc_mmi (int16_t* pLumaDc, int16_t* pDct);
+
+void WelsQuant4x4_mmi (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuant4x4Dc_mmi (int16_t* pDct, int16_t iFF, int16_t iMF);
+void WelsQuantFour4x4_mmi (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_mmi (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+#endif//HAVE_MMI
+
+#ifdef HAVE_LSX
+void WelsQuantFour4x4_lsx (int16_t* pDct, const int16_t* pFF, const int16_t* pMF);
+void WelsQuantFour4x4Max_lsx (int16_t* pDct, const int16_t* pFF, const int16_t* pMF, int16_t* pMax);
+#endif//HAVE_LSX
+
+#ifdef HAVE_LASX
+/****************************************************************************
+ *  * DCT functions
+ *   ****************************************************************************/
+void WelsDctT4_lasx (int16_t* pDct,  uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+void WelsDctFourT4_lasx (int16_t* pDct, uint8_t* pPixel1, int32_t iStride1, uint8_t* pPixel2, int32_t iStride2);
+#endif
+
+#if defined(__cplusplus)
+}
+#endif//__cplusplus
+
+ALIGNED_DECLARE (extern const int16_t, g_kiQuantInterFF[58][8], 16);
+#define g_iQuantIntraFF (g_kiQuantInterFF +6 )
+ALIGNED_DECLARE (extern const int16_t, g_kiQuantMF[52][8], 16);
+}
+#endif//ENCODE_MB_AUX_H

package/openh264/codec/encoder/core/inc/encoder.h

@@ -0,0 +1,148 @@
+/*!
+ * \copy
+ *     Copyright (c)  2009-2013, Cisco Systems
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted provided that the following conditions
+ *     are met:
+ *
+ *        * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions and the following disclaimer.
+ *
+ *        * Redistributions in binary form must reproduce the above copyright
+ *          notice, this list of conditions and the following disclaimer in
+ *          the documentation and/or other materials provided with the
+ *          distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *     POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * \file    encoder.h
+ *
+ * \brief   core encoder
+ *
+ * \date    5/14/2009
+ *
+ *************************************************************************************
+ */
+#if !defined(WELS_CORE_ENCODER_H__)
+#define WELS_CORE_ENCODER_H__
+
+#include "encoder_context.h"
+
+namespace WelsEnc {
+/*!
+ * \brief   request specific memory for SVC
+ * \param   pEncCtx     sWelsEncCtx*
+ * \return  successful - 0; otherwise none 0 for failed
+ */
+int32_t RequestMemorySvc (sWelsEncCtx** ppCtx, SExistingParasetList* pExistingParasetList);
+
+/*!
+ * \brief   free memory in SVC core encoder
+ * \param   pEncCtx     sWelsEncCtx**
+ * \return  none
+ */
+void FreeMemorySvc (sWelsEncCtx** ppCtx);
+
+/*!
+ * \brief    allocate or reallocate the output bs buffer
+ * \return:  successful - 0; otherwise none 0 for failed
+ */
+int32_t AllocateBsOutputBuffer (CMemoryAlign* pMa, const int32_t iNeededLen, int32_t iOrigLen, const char* kpTag,
+                                uint8_t*& pOutputBuffer);
+//TODO: to finish this function and call it
+
+/*!
+ * \brief   initialize function pointers that potentially used in Wels encoding
+ * \param   pEncCtx     sWelsEncCtx*
+ * \return  successful - 0; otherwise none 0 for failed
+ */
+int32_t InitFunctionPointers (sWelsEncCtx* pEncCtx, SWelsSvcCodingParam* _param, uint32_t  uiCpuFlag);
+
+///*!
+// * \brief decide frame type (IDR/P frame)
+// * \param uiFrameType frame type output
+// * \param frame_idx   frame index elapsed currently
+// * \param idr         IDR interval
+// * \return    successful - 0; otherwise none 0 for failed
+// */
+/*!
+ * \brief   initialize frame coding
+ */
+void InitFrameCoding (sWelsEncCtx* pEncCtx, const EVideoFrameType keFrameType, const int32_t kiDidx);
+void LoadBackFrameNum (sWelsEncCtx* pEncCtx, const int32_t kiDidx);
+
+EVideoFrameType DecideFrameType (sWelsEncCtx* pEncCtx, const int8_t kiSpatialNum, const int32_t kiDidx,
+                                 bool bSkipFrameFlag);
+void InitBitStream (sWelsEncCtx* pEncCtx);
+int32_t GetTemporalLevel (SSpatialLayerInternal* fDlp, const int32_t kiFrameNum, const int32_t kiGopSize);
+/*!
+ * \brief   Dump reconstruction for dependency layer
+ */
+
+extern "C" void DumpDependencyRec (SPicture* pSrcPic, const char* kpFileName, const int8_t kiDid, bool bAppend,
+                                   SDqLayer* pDqLayer, bool bSimulCastAVC);
+
+/*!
+ * \brief   Dump the reconstruction pictures
+ */
+void DumpRecFrame (SPicture* pSrcPic, const char* kpFileName, const int8_t kiDid, bool bAppend, SDqLayer* pDqLayer);
+
+
+/*!
+ * \brief   encode overall slices pData in a frame
+ * \param   pEncCtx             sWelsEncCtx*, encoder context
+ * \param   count_slice_num     count number of slices in a frame
+ * \param   eNalType            EWelsNalUnitType for a frame
+ * \param   nal_idc             EWelsNalRefIdc for a frame
+ * \return  successful - 0; otherwise none 0 for failed
+ */
+int32_t EncodeFrame (sWelsEncCtx* pEncCtx,
+                     const int32_t kiSliceNumCount,
+                     const EWelsNalUnitType keNalType,
+                     const EWelsNalRefIdc keNalIdc);
+
+
+/**********************************************************************************
+ * memzero Function
+***********************************************************************************/
+void WelsSetMemZero_c (void* pDst, int32_t iSize); // confirmed_safe_unsafe_usage
+
+#if defined(__cplusplus)
+extern "C" {
+#endif//__cplusplus
+
+#ifdef X86_ASM
+void WelsSetMemZeroAligned64_sse2 (void* pDst, int32_t iSize);
+void WelsSetMemZeroSize64_mmx (void* pDst, int32_t iSize);
+void WelsSetMemZeroSize8_mmx (void* pDst, int32_t iSize);
+void WelsPrefetchZero_mmx (int8_t const* kpDst);
+#elif defined(HAVE_NEON)
+void WelsSetMemZero_neon (void* pDst, int32_t iSize);
+#elif defined(HAVE_NEON_AARCH64)
+void WelsSetMemZero_AArch64_neon (void* pDst, int32_t iSize);
+#endif
+
+#if defined(__cplusplus)
+}
+#endif//__cplusplus
+
+/**********************************************************************************
+ * Function points type
+***********************************************************************************/
+}
+
+#endif//WELS_CORE_ENCODER_H__