@scrypted/libav 1.0.180 → 1.0.181

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

@@ -0,0 +1,102 @@
+/*!
+ * \copy
+ *     Copyright (c)  2010-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    svc_base_layer_md.h
+ *
+ * \brief   mode decision
+ *
+ * \date    2009.08.10 Created
+ *
+ *************************************************************************************
+ */
+#ifndef SVC_BASE_LAYER_MACROBLOCK_MODE_DECISION_H__
+#define SVC_BASE_LAYER_MACROBLOCK_MODE_DECISION_H__
+
+#include "md.h"
+#include "mb_cache.h"
+
+namespace WelsEnc {
+void WelsMdIntraInit (sWelsEncCtx* pEncCtx, SMB* pCurMb, SMbCache* pMbCache, const int32_t kiSliceFirstMbXY);
+int32_t WelsMdI16x16 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SMbCache* pMbCache, int32_t iLambda);
+int32_t WelsMdIntraChroma (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SMbCache* pMbCache, int32_t iLambda);
+
+int32_t WelsMdI4x4 (sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache* pMbCache);
+int32_t WelsMdI4x4Fast (sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache* pMbCache);
+
+int32_t WelsMdIntraFinePartition (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SMB* pCurMb, SMbCache* pMbCache);
+int32_t WelsMdIntraFinePartitionVaa (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SMB* pCurMb, SMbCache* pMbCache);
+
+void WelsMdIntraMb (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SMB* pCurMb, SMbCache* pMbCache);
+
+void WelsMdBackgroundMbEnc (sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache* pMbCache, SSlice* pSlice, bool bSkipMbFlag);
+bool WelsMdPSkipEnc (sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache* pMbCache);
+int32_t WelsMdP16x16 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb);
+
+int32_t WelsMdP16x8 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice);
+int32_t WelsMdP8x16 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice);
+int32_t WelsMdP8x8 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice);
+int32_t WelsMdP4x4 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice, const int32_t ki8x8Idx);
+int32_t WelsMdP8x4 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice, const int32_t ki8x8Idx);
+int32_t WelsMdP4x8 (SWelsFuncPtrList* pFunc, SDqLayer* pCurDqLayer, SWelsMD* pWelsMd, SSlice* pSlice, const int32_t ki8x8Idx);
+/*static*/  void WelsMdInterInit (sWelsEncCtx* pEncCtx, SSlice* pSlice, SMB* pCurMb, const int32_t kiSliceFirstMbXY);
+/*static*/ void WelsMdInterFinePartition (sWelsEncCtx* pEnc, SWelsMD* pMd, SSlice* pSlice, SMB* pCurMb, int32_t bestCost);
+/*static*/ void WelsMdInterFinePartitionVaa (sWelsEncCtx* pEnc, SWelsMD* pMd, SSlice* pSlice, SMB* pCurMb, int32_t bestCost);
+/*static*/ void WelsMdInterFinePartitionVaaOnScreen (sWelsEncCtx* pEnc, SWelsMD* pMd, SSlice* pSlice, SMB* pCurMb,
+    int32_t bestCost);
+void WelsMdInterMbRefinement (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SMB* pCurMb, SMbCache* pMbCache);
+bool WelsMdFirstIntraMode (sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache* pMbCache);
+//bool svc_md_first_intra_mode_constrained(sWelsEncCtx* pEnc, SWelsMD* pMd, SMB* pCurMb, SMbCache *pMbCache);
+void WelsMdInterMb (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb, SMbCache* pUnused);
+
+//both used in BL and EL
+//void wels_md_inter_init ( SWelsMD* pMd, const uint8_t ref_idx, const bool is_highest_dlayer_flag );
+
+
+
+bool WelsMdInterJudgePskip (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb, SMbCache* pMbCache,
+                            bool bTrySkip);
+void WelsMdInterUpdatePskip (SDqLayer* pCurDqLayer, SSlice* pSlice, SMB* pCurMb, SMbCache* pMbCache);
+void WelsMdInterDecidedPskip (sWelsEncCtx* pEncCtx, SSlice* pSlice, SMB* pCurMb, SMbCache* pMbCache);
+
+void WelsMdInterDoubleCheckPskip (SMB* pCurMb, SMbCache* pMbCache);
+void WelsMdInterEncode (sWelsEncCtx* pEncCtx, SSlice* pSlice, SMB* pCurMb, SMbCache* pMbCache);
+
+void WelsMdInterSaveSadAndRefMbType (Mb_Type* pRefMbTypeList, SMbCache* pMbCache, const SMB*  kpCurMb,
+                                     const SWelsMD* kpMd);
+
+void WelsMdInterSecondaryModesEnc (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb,
+                                   SMbCache* pMbCache, const bool kbSkip);
+void WelsMdIntraSecondaryModesEnc (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SMB* pCurMb, SMbCache* pMbCache);
+//end of: both used in BL and EL
+
+
+}
+#endif//WELS_MACROBLOCK_MODE_DECISION_H__

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

@@ -0,0 +1,136 @@
+/*!
+ * \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.
+ *
+ */
+
+//wels_svc_layer.h
+#ifndef WELS_SVC_EXTENSION_LAYER_H__
+#define WELS_SVC_EXTENSION_LAYER_H__
+
+#include "typedefs.h"
+#include "wels_const.h"
+#include "wels_common_basis.h"
+#include "parameter_sets.h"
+#include "slice.h"
+#include "picture.h"
+#include "svc_enc_macroblock.h"
+
+
+#include "svc_enc_slice_segment.h"
+namespace WelsEnc {
+
+/*
+ *  Frame level in SVC DQLayer instead.
+ *  Dependency-Quaility layer struction definition for SVC extension of H.264/AVC
+ */
+
+///////////////////////////////////DQ Layer level///////////////////////////////////
+
+typedef struct TagDqLayer   SDqLayer;
+typedef SDqLayer*           pDqLayer;
+
+typedef struct TagFeatureSearchPreparation {
+SScreenBlockFeatureStorage*     pRefBlockFeature;//point the the ref frame storage
+
+uint16_t*       pFeatureOfBlock;                // Feature of every block (8x8), begin with the point
+uint8_t         uiFeatureStrategyIndex;// index of hash strategy
+
+/* for FME frame-level switch */
+bool bFMESwitchFlag;
+uint8_t uiFMEGoodFrameCount;
+int32_t iHighFreMbCount;
+} SFeatureSearchPreparation; //maintain only one
+
+typedef struct TagSliceBufferInfo {
+SSlice*                 pSliceBuffer;  // slice buffer for multi thread,
+int32_t                 iMaxSliceNum;
+int32_t                 iCodedSliceNum;
+}SSliceBufferInfo;
+
+typedef struct TagLayerInfo {
+SNalUnitHeaderExt       sNalHeaderExt;
+SSubsetSps*             pSubsetSpsP;    // current pSubsetSps used, memory alloc in external
+SWelsSPS*               pSpsP;          // current pSps based avc used, memory alloc in external
+SWelsPPS*               pPpsP;          // current pPps used
+} SLayerInfo;
+/* Layer Representation */
+struct TagDqLayer {
+SLayerInfo              sLayerInfo;
+SSliceBufferInfo        sSliceBufferInfo[MAX_THREADS_NUM];
+SSlice**                ppSliceInLayer;
+SSliceCtx               sSliceEncCtx;   // current slice context
+uint8_t*                pCsData[3];     // pointer to reconstructed picture pData
+int32_t                 iCsStride[3];   // Cs stride
+
+uint8_t*                pEncData[3];    // pData picture to be encoded in current layer
+int32_t                 iEncStride[3];  // pData picture stride
+
+SMB*                    sMbDataP;       // pointer to mb of mbAddr equal to 0 in slice, mb_data_ptr = mb_base_ptr + (1+iMbStride).
+int16_t                 iMbWidth;       // MB width of this picture, equal to pSps.iMbWidth
+int16_t                 iMbHeight;      // MB height of this picture, equal to pSps.iMbHeight;
+
+bool                    bBaseLayerAvailableFlag;        // whether base layer is available for prediction?
+bool                    bSatdInMdFlag; // whether SATD is calculated in ME and integer-pel MD
+
+uint8_t                 iLoopFilterDisableIdc;  // 0: on, 1: off, 2: on except for slice boundaries
+int8_t                  iLoopFilterAlphaC0Offset;// AlphaOffset: valid range [-6, 6], default 0
+int8_t                  iLoopFilterBetaOffset;  // BetaOffset:  valid range [-6, 6], default 0
+uint8_t                 uiDisableInterLayerDeblockingFilterIdc;
+int8_t                  iInterLayerSliceAlphaC0Offset;
+int8_t                  iInterLayerSliceBetaOffset;
+bool                    bDeblockingParallelFlag; //parallel_deblocking_flag
+
+SPicture*               pRefPic;        // reference picture pointer
+SPicture*               pDecPic;        // reconstruction picture pointer for layer
+SPicture*               pRefOri[MAX_REF_PIC_COUNT];
+
+bool                    bThreadSlcBufferFlag;
+bool                    bSliceBsBufferFlag;
+int32_t                 iMaxSliceNum;
+int32_t                 NumSliceCodedOfPartition[MAX_THREADS_NUM];      // for dynamic slicing mode
+int32_t                 LastCodedMbIdxOfPartition[MAX_THREADS_NUM];     // for dynamic slicing mode
+int32_t                 FirstMbIdxOfPartition[MAX_THREADS_NUM];         // for dynamic slicing mode
+int32_t                 EndMbIdxOfPartition[MAX_THREADS_NUM];           // for dynamic slicing mode
+int32_t*                pFirstMbIdxOfSlice;
+int32_t*                pCountMbNumInSlice;
+
+bool                    bNeedAdjustingSlicing;
+
+SFeatureSearchPreparation* pFeatureSearchPreparation;
+
+SDqLayer*               pRefLayer;              // pointer to referencing dq_layer of current layer to be decoded
+};
+
+///////////////////////////////////////////////////////////////////////
+
+// frame structure for svc
+typedef SDqLayer SWelsSvcFrame;
+}
+#endif//WELS_SVC_EXTENSION_LAYER_H__

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

@@ -0,0 +1,123 @@
+/*!
+ * \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    svc_enc_golomb.h
+ *
+ * \brief   Exponential Golomb entropy coding routine
+ *
+ * \date    03/13/2009 Created
+ *
+ *************************************************************************************
+ */
+#ifndef WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__
+#define WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__
+
+#include "wels_common_defs.h"
+#include "golomb_common.h"
+
+using namespace WelsCommon;
+
+namespace WelsEnc {
+
+/************************************************************************/
+/* GOLOMB CODIMG FOR WELS ENCODER ONLY                                  */
+/************************************************************************/
+
+
+/*
+ *  Get size of unsigned exp golomb codes
+ */
+static inline uint32_t BsSizeUE (const uint32_t kiValue) {
+if (256 > kiValue) {
+  return g_kuiGolombUELength[kiValue];
+} else {
+  uint32_t n = 0;
+  uint32_t iTmpValue = kiValue + 1;
+
+  if (iTmpValue & 0xffff0000) {
+    iTmpValue >>= 16;
+    n += 16;
+  }
+  if (iTmpValue & 0xff00) {
+    iTmpValue >>= 8;
+    n += 8;
+  }
+
+  //n += (g_kuiGolombUELength[iTmpValue] >> 1);
+  n += (g_kuiGolombUELength[iTmpValue - 1] >> 1);
+  return ((n << 1) + 1);
+
+}
+}
+
+/*
+ *  Get size of signed exp golomb codes
+ */
+static inline uint32_t BsSizeSE (const int32_t kiValue) {
+uint32_t iTmpValue;
+if (0 == kiValue) {
+  return 1;
+} else if (0 < kiValue) {
+  iTmpValue = (kiValue << 1) - 1;
+  return BsSizeUE (iTmpValue);
+} else {
+  iTmpValue = ((-kiValue) << 1);
+  return BsSizeUE (iTmpValue);
+}
+}
+
+/*
+ *  Write truncated exp golomb codes
+ */
+static inline void BsWriteTE (SBitStringAux* pBs, const int32_t kiX, const uint32_t kuiValue) {
+if (1 == kiX) {
+  BsWriteOneBit (pBs, !kuiValue);
+} else {
+  BsWriteUE (pBs, kuiValue);
+}
+}
+
+static inline int32_t BsGetBitsPos (SBitStringAux* pBs) {
+return (int32_t) (((pBs->pCurBuf - pBs->pStartBuf) << 3) + 32 - pBs->iLeftBits);
+}
+
+static inline void BsAlign( SBitStringAux* pBs )
+{
+   if( pBs->iLeftBits&7 )
+   {
+      pBs->uiCurBits <<= pBs->iLeftBits&7;
+      pBs->uiCurBits |= (1 << (pBs->iLeftBits&7)) - 1;
+      pBs->iLeftBits &= ~7;
+   }
+   BsFlush(pBs );
+}
+}
+#endif//WELS_EXPONENTIAL_GOLOMB_ENTROPY_CODING_H__

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

@@ -0,0 +1,82 @@
+/*!
+ * \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.
+ *
+ */
+
+//macroblock.h
+#ifndef WELS_MACROBLOCK_H__
+#define WELS_MACROBLOCK_H__
+
+#include "typedefs.h"
+#include "wels_const.h"
+#include "wels_common_basis.h"
+#include "macros.h"
+
+namespace WelsEnc {
+
+//struct Mb_s;
+
+/* MB syntax and context, refer to Page 399 in JVT X201wcm */
+// keep the most essential level pData structure be 64 Bytes, which matches cache line size; if so, the order with structure maybe negligible.
+// pls take care when modify MB structure size
+typedef struct TagMB {
+/*************************mb_layer() syntax and generated********************************/
+/*mb_layer():*/
+Mb_Type         uiMbType;       // including MB detailed partition type, number and type of reference list
+uint8_t         uiSubMbType[4]; // sub MB types
+int32_t         iMbXY;          // offset position of MB top left point based
+int16_t         iMbX;           // position of MB in horizontal axis [0..32767]
+int16_t         iMbY;           // position of MB in vertical axis [0..32767]
+
+uint8_t         uiNeighborAvail;        // avail && same_slice: LEFT_MB_POS:0x01, TOP_MB_POS:0x02, TOPRIGHT_MB_POS = 0x04 ,TOPLEFT_MB_POS = 0x08;
+uint8_t         uiCbp;
+
+SMVUnitXY*      sMv;
+int8_t*         pRefIndex;
+
+int32_t*        pSadCost;          // mb sad. set to 0 for intra mb
+int8_t*         pIntra4x4PredMode; // [MB_BLOCK4x4_NUM]
+int8_t*         pNonZeroCount;     // [MB_LUMA_CHROMA_BLOCK4x4_NUM]
+
+SMVUnitXY       sP16x16Mv;
+
+uint8_t         uiLumaQp;       // uiLumaQp: pPps->iInitialQp + sSliceHeader->delta_qp + mb->dquant.
+uint8_t         uiChromaQp;
+uint16_t        uiSliceIdc;     // 2^16=65536 > MaxFS(36864) of level 5.1; AVC: iFirstMbInSlice?; SVC: (iFirstMbInSlice << 7) | ((uiDependencyId << 4) | uiQualityId);
+uint32_t        uiChromPredMode;
+int32_t         iLumaDQp;
+SMVUnitXY       sMvd[MB_BLOCK4x4_NUM]; //only for CABAC writing; storage structure the same as sMv, in 4x4 scan order.
+int32_t         iCbpDc;
+//uint8_t         reserved_filling_bytes[1];      // not deleting this line for further changes of this structure. filling bytes reserved to make structure aligned with 4 bytes, higher cache hit on less structure size by 2 cache lines( 2 * 64 bytes) once hit
+} SMB, *PMb;
+
+}
+
+#endif//WELS_MACROBLOCK_H__

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

@@ -0,0 +1,212 @@
+/*!
+ * \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    slice_segment.h
+ *
+ * \brief   SSlice segment routine (Single slice/multiple slice/fmo arrangement exclusive)
+ *
+ * \date    2/4/2009 Created
+ *
+ *************************************************************************************
+ */
+#ifndef WELS_SLICE_SEGMENT_H__
+#define WELS_SLICE_SEGMENT_H__
+
+#include "typedefs.h"
+#include "macros.h"
+#include "as264_common.h"
+#include "memory_align.h"
+
+#include "codec_app_def.h"
+#include "set_mb_syn_cabac.h"
+
+using namespace WelsCommon;
+
+namespace WelsEnc {
+
+
+// NOTE:
+// if PREFIX_NALs are used in base layer(iDid=0, qid=0), MAX_SLICES_NUM will be half of MAX_NAL_UNITS_IN_LAYER in case ST or MT without PACKING_ONE_SLICE_PER_LAYER
+// in case MT and PACKING_ONE_SLICE_PER_LAYER, MAX_SLICES_NUM should not be exceeding MAX_LAYER_NUM_OF_FRAME
+// for AVC cases, maximal resolution we can support up to (?x1024) for SM_ROWMB_SLICE slice mode
+// fine solution for MAX_SLICES_NUM, need us use the variable instead of MACRO for any resolution combining any multiple-slice mode adaptive
+#define SAVED_NALUNIT_NUM                       ( (MAX_SPATIAL_LAYER_NUM*MAX_QUALITY_LAYER_NUM) + 1 + MAX_SPATIAL_LAYER_NUM ) // SPS/PPS + SEI/SSEI + PADDING_NAL
+#define MAX_SLICES_NUM                          ( ( MAX_NAL_UNITS_IN_LAYER - SAVED_NALUNIT_NUM ) / 3 )  // Also MAX_SLICES_NUM need constrained by implementation: uiSliceIdc allocated in SSliceCtx.pOverallMbMap need a byte range as expected
+#define AVERSLICENUM_CONSTRAINT         (MAX_SLICES_NUM)                        // used in sNalList initialization,
+
+#define MIN_NUM_MB_PER_SLICE                    48                                                      // (128/16 * 96/16), addressing the lowest resolution for multiple slicing is 128x96 above
+
+#define DEFAULT_MAXPACKETSIZE_CONSTRAINT        (1200)          //in bytes
+//#define MINPACKETSIZE_CONSTRAINT                (1200)
+
+#define AVER_MARGIN_BYTES                       ( 100 ) //in bytes
+#define JUMPPACKETSIZE_CONSTRAINT(max_byte)             ( max_byte - AVER_MARGIN_BYTES ) //in bytes
+#define JUMPPACKETSIZE_JUDGE(len,mb_idx,max_byte)       ( (len) > JUMPPACKETSIZE_CONSTRAINT(max_byte) ) //( (mb_idx+1)%40/*16slice for compare*/ == 0 )        //
+//cur_mb_idx is for early tests, can be omit in optimization
+typedef struct TagSlice      SSlice;
+typedef struct TagDqLayer    SDqLayer;
+typedef struct TagWelsEncCtx sWelsEncCtx;
+/*!
+ * \brief   SSlice context
+ */
+/* Single/multiple slices */
+typedef struct SlicepEncCtx_s {
+SliceModeEnum           uiSliceMode;            /* 0: single slice in frame; 1: multiple slices in frame; */
+int16_t                 iMbWidth;               /* width of picture size in mb */
+int16_t                 iMbHeight;              /* height of picture size in mb */
+int32_t                 iSliceNumInFrame;       /* count number of slices in frame; */
+int32_t                 iMbNumInFrame;          /* count number of MBs in frame */
+uint16_t*               pOverallMbMap;          /* overall MB map in frame, store virtual slice idc; */
+uint32_t                uiSliceSizeConstraint;  /* in byte */
+int32_t                 iMaxSliceNumConstraint; /* maximal number of slices constraint */
+
+} SSliceCtx;
+
+
+typedef struct TagDynamicSlicingStack {
+int32_t         iStartPos;
+int32_t         iCurrentPos;
+
+uint8_t*        pBsStackBufPtr; // current writing position
+uint32_t        uiBsStackCurBits;
+int32_t         iBsStackLeftBits;
+
+SCabacCtx       sStoredCabac;
+int32_t         iMbSkipRunStack;
+uint8_t         uiLastMbQp;
+uint8_t*        pRestoreBuffer;
+} SDynamicSlicingStack;
+
+/*!
+ * \brief   Initialize Wels SSlice context (Single/multiple slices and FMO)
+ *
+ * \param   pCurDq          current layer which its SSlice context will be initialized
+ * \param   bFmoUseFlag     flag of using fmo
+ * \param   iMbWidth        MB width
+ * \param   iMbHeight       MB height
+ * \param   uiSliceMode     slice mode
+ * \param   mul_slice_arg   argument for multiple slice if it is applicable
+ * \param   pPpsArg         argument for pPps parameter
+ *
+ * \return  0 - successful; none 0 - failed;
+ */
+int32_t InitSlicePEncCtx (SDqLayer* pCurDq,
+                          CMemoryAlign* pMa,
+                          bool bFmoUseFlag,
+                          int32_t iMbWidth,
+                          int32_t iMbHeight,
+                          SSliceArgument* pSliceArgument,
+                          void* pPpsArg);
+
+
+/*!
+ * \brief   Uninitialize Wels SSlice context (Single/multiple slices and FMO)
+ *
+ * \param   pCurDq       curent layer which its SSlice context will be initialized
+ *
+ * \return  NONE;
+ */
+void UninitSlicePEncCtx (SDqLayer* pCurDq, CMemoryAlign* pMa);
+
+/*!
+ * \brief   Get slice idc for given iMbXY (apply in Single/multiple slices and FMO)
+ *
+ * \param   pCurDq    current layer info
+ * \param   kiMbXY    MB xy index
+ *
+ * \return  uiSliceIdc - successful; (uint8_t)(-1) - failed;
+ */
+uint16_t WelsMbToSliceIdc (SDqLayer* pCurDq, const int32_t kiMbXY);
+
+/*!
+ * \brief   Get first mb in slice/slice_group: uiSliceIdc (apply in Single/multiple slices and FMO)
+ *
+ * \param   pCurLayer       current layer
+ * \param   kiSliceIdc      slice idc
+ *
+ * \return  first_mb - successful; -1 - failed;
+ */
+int32_t WelsGetFirstMbOfSlice (SDqLayer* pCurLayer, const int32_t kiSliceIdc);
+
+/*!
+ * \brief   Get successive mb to be processed in slice/slice_group: uiSliceIdc (apply in Single/multiple slices and FMO)
+ *
+ * \param   pCurDq       current layer info
+ * \param   kiMbXY       MB xy index
+ *
+ * \return  next_mb - successful; -1 - failed;
+ */
+int32_t WelsGetNextMbOfSlice (SDqLayer* pCurDq, const int32_t kiMbXY);
+
+/*!
+ * \brief   Get previous mb to be processed in slice/slice_group: uiSliceIdc (apply in Single/multiple slices and FMO)
+ *
+ * \param   pCurDq          current layer info
+ * \param   kiMbXY          MB xy index
+ *
+ * \return  prev_mb - successful; -1 - failed;
+ */
+int32_t WelsGetPrevMbOfSlice (SDqLayer* pCurDq, const int32_t kiMbXY);
+
+/*!
+ * \brief   Get number of mb in slice/slice_group: uiSliceIdc (apply in Single/multiple slices and FMO)
+ *
+ * \param   pCurDq          current layer info
+ * \param   pSlice          slice which request slice num
+ * \param   kiSliceIdc      slice/slice_group idc
+ *
+ * \return  count_num_of_mb - successful; -1 - failed;
+ */
+int32_t WelsGetNumMbInSlice (SDqLayer* pCurDq, SSlice* pSlice, const int32_t kuiSliceIdc);
+
+/*!
+ *  Get slice count for multiple slice segment
+ *
+ */
+int32_t GetInitialSliceNum (SSliceArgument* pSliceArgument);
+int32_t GetCurrentSliceNum (const SDqLayer* pCurDq);
+SSlice* GetSliceByIndex(sWelsEncCtx* pCtx, const int32_t kiSliceIdc);
+
+//checking valid para
+int32_t DynamicMaxSliceNumConstraint (uint32_t uiMaximumNum, int32_t uiConsumedNum, uint32_t uiDulplicateTimes);
+
+bool CheckFixedSliceNumMultiSliceSetting (const int32_t kiMbNumInFrame,  SSliceArgument* pSliceArg);
+bool CheckRasterMultiSliceSetting (const int32_t kiMbNumInFrame, SSliceArgument* pSliceArg);
+bool CheckRowMbMultiSliceSetting (const int32_t kiMbWidth,  SSliceArgument* pSliceArg);
+
+bool GomValidCheckSliceNum (const int32_t kiMbWidth, const int32_t kiMbHeight, uint32_t* pSliceNum);
+bool GomValidCheckSliceMbNum (const int32_t kiMbWidth, const int32_t kiMbHeight,  SSliceArgument* pSliceArg);
+//end of checking valid para
+
+int32_t DynamicAdjustSlicePEncCtxAll (SDqLayer* pCurDq,
+                                      int32_t* pRunLength);
+}
+#endif//WELS_SLICE_SEGMENT_H__