Changeset 837 – JCT-3V 3D-HEVC

branches/HTM-10.0rc1-dev0/COPYING

r56	r837
4	4	granted under this license.
5	5
6		Copyright (c) 2010-2012, ITU/ISO/IEC
	6	Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	All rights reserved.
8	8

branches/HTM-10.0rc1-dev0/HM.xcodeproj/project.pbxproj

-                      r608
+                      r837
                                 HEADER_SEARCH_PATHS = source/Lib;
                                 ONLY_ACTIVE_ARCH = YES;
                                 SDKROOT = macosx;
+                                SDKROOT = "";
                         };
                         name = Debug;
 …
                                 GCC_WARN_UNUSED_VARIABLE = YES;
                                 HEADER_SEARCH_PATHS = source/Lib;
                                 SDKROOT = macosx;
+                                SDKROOT = "";
                         };
                         name = Release;

branches/HTM-10.0rc1-dev0/build/linux/common/makefile.base

-                      r608
+                      r837
 CPP     = g++
+CC      = gcc
 AR      = ar
 LD      = $(CPP)
 …
 # default cpp flags for all configurations
 #CPPFLAGS          = -Wall -fPIC $(DEFS) -I$(CURDIR)/$(INC_DIR) $(USER_INC_DIRS)
 CPPFLAGS          = -fPIC $(DEFS) $(ADDDEFS) -I$(CURDIR)/$(INC_DIR) $(USER_INC_DIRS) -Wall -Wshadow -Wno-sign-compare -Werror
+CPPFLAGS          = -fPIC $(DEFS) -I$(CURDIR)/$(INC_DIR) $(USER_INC_DIRS) -Wall -Wshadow -Wno-sign-compare -Werror
 ##########
 …
+#
 # release cpp
 RELEASE_CPPFLAGS  =  -O3 -ffloat-store -Wuninitialized
+RELEASE_CPPFLAGS  =  -O3 -Wuninitialized
 …
                 rm -f $(OBJ_DIR)/$*.d.d
 endef
+define COMPILE_AND_DEPEND_RELEASE_C
+        $(CC) -c -MMD -MF $(OBJ_DIR)/$*.r.d -MT $(OBJ_DIR)/$*.r.o $(CPPFLAGS) $(RELEASE_CPPFLAGS) -o $@ $(CURDIR)/$<
+        @cp $(OBJ_DIR)/$*.r.d $(OBJ_DIR)/$*.r.P; \
+                sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+                -e '/^$$/ d' -e 's/$$/ :/' < $(OBJ_DIR)/$*.r.d >> $(OBJ_DIR)/$*.r.P; \
+                rm -f $(OBJ_DIR)/$*.r.d
+endef
+define COMPILE_AND_DEPEND_DEBUG_C
+        $(CC) -c -MMD -MF $(OBJ_DIR)/$*.d.d -MT $(OBJ_DIR)/$*.d.o $(CPPFLAGS) $(DEBUG_CPPFLAGS) -o $@ $(CURDIR)/$<
+        @cp $(OBJ_DIR)/$*.d.d $(OBJ_DIR)/$*.d.P; \
+                sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+                -e '/^$$/ d' -e 's/$$/ :/' < $(OBJ_DIR)/$*.d.d >> $(OBJ_DIR)/$*.d.P; \
+                rm -f $(OBJ_DIR)/$*.d.d
+endef
 # create release objects
 …
 # create release objects
 $(OBJ_DIR)/%.r.o: $(SRC_DIR)/%.c
         $(COMPILE_AND_DEPEND_RELEASE)
+        $(COMPILE_AND_DEPEND_RELEASE_C)
 # create debug objects
 $(OBJ_DIR)/%.d.o: $(SRC_DIR)/%.c
         $(COMPILE_AND_DEPEND_DEBUG)
+        $(COMPILE_AND_DEPEND_DEBUG_C)
 # create release objects
 $(OBJ_DIR)/%.r.o: $(SRC_DIR1)/%.c
         $(COMPILE_AND_DEPEND_RELEASE)
+        $(COMPILE_AND_DEPEND_RELEASE_C)
 # create debug objects
 $(OBJ_DIR)/%.d.o: $(SRC_DIR1)/%.c
         $(COMPILE_AND_DEPEND_DEBUG)
+        $(COMPILE_AND_DEPEND_DEBUG_C)
 # create release objects
 $(OBJ_DIR)/%.r.o: $(SRC_DIR2)/%.c
         $(COMPILE_AND_DEPEND_RELEASE)
+        $(COMPILE_AND_DEPEND_RELEASE_C)
 # create debug objects
 $(OBJ_DIR)/%.d.o: $(SRC_DIR2)/%.c
         $(COMPILE_AND_DEPEND_DEBUG)
+        $(COMPILE_AND_DEPEND_DEBUG_C)
 # create release objects
 $(OBJ_DIR)/%.r.o: $(SRC_DIR3)/%.c
         $(COMPILE_AND_DEPEND_RELEASE)
+        $(COMPILE_AND_DEPEND_RELEASE_C)
 # create debug objects
 $(OBJ_DIR)/%.d.o: $(SRC_DIR3)/%.c
         $(COMPILE_AND_DEPEND_DEBUG)
+        $(COMPILE_AND_DEPEND_DEBUG_C)
 # create release objects
 $(OBJ_DIR)/%.r.o: $(SRC_DIR4)/%.c
         $(COMPILE_AND_DEPEND_RELEASE)
+        $(COMPILE_AND_DEPEND_RELEASE_C)
 # create debug objects
 $(OBJ_DIR)/%.d.o: $(SRC_DIR4)/%.c
         $(COMPILE_AND_DEPEND_DEBUG)
+        $(COMPILE_AND_DEPEND_DEBUG_C)

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/allintra/baseCfg_2view+depth_AllIntra.cfg

r738	r837
149	149	#============ Lossless ================
150	150	TransquantBypassEnableFlag: 0 # Value of PPS flag.
151		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	151	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
152	152
153	153	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/allintra/baseCfg_2view_AllIntra.cfg

r655	r837
122	122	#============ Lossless ================
123	123	TransquantBypassEnableFlag: 0 # Value of PPS flag.
124		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	124	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
125	125
126	126	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/allintra/baseCfg_3view+depth_AllIntra.cfg

r738	r837
164	164	#============ Lossless ================
165	165	TransquantBypassEnableFlag: 0 # Value of PPS flag.
166		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	166	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
167	167
168	168	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/allintra/baseCfg_3view_AllIntra.cfg

r655	r837
124	124	#============ Lossless ================
125	125	TransquantBypassEnableFlag: 0 # Value of PPS flag.
126		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	126	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
127	127
128	128	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/fco/baseCfg_3view+depth.cfg

r833	r837
213	213	#============ Lossless ================
214	214	TransquantBypassEnableFlag: 0 # Value of PPS flag.
215		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	215	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
216	216
217	217	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/NonCTC/rc/baseCfg_3view+depth_rate_control.cfg

r724	r837
213	213	#============ Lossless ================
214	214	TransquantBypassEnableFlag: 0 # Value of PPS flag.
215		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	215	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
216	216
217	217	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/baseCfg_2view+depth.cfg

r833	r837
183	183	#============ Lossless ================
184	184	TransquantBypassEnableFlag: 0 # Value of PPS flag.
185		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	185	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
186	186
187	187	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/baseCfg_2view.cfg

r724	r837
156	156	#============ Lossless ================
157	157	TransquantBypassEnableFlag: 0 # Value of PPS flag.
158		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	158	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
159	159
160	160	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/baseCfg_3view+depth.cfg

r833	r837
213	213	#============ Lossless ================
214	214	TransquantBypassEnableFlag: 0 # Value of PPS flag.
215		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	215	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
216	216
217	217	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/baseCfg_3view.cfg

r622	r837
171	171	#============ Lossless ================
172	172	TransquantBypassEnableFlag: 0 # Value of PPS flag.
173		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	173	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
174	174
175	175	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/3D-HEVC/fullCfg.cfg

r735	r837
219	219	#============ Lossless ================
220	220	TransquantBypassEnableFlag: 0 # Value of PPS flag.
221		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	221	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
222	222
223	223	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_intra_main.cfg

r655	r837
97	97	#============ Lossless ================
98	98	TransquantBypassEnableFlag: 0 # Value of PPS flag.
99		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	99	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
100	100
101	101	### DO NOT ADD ANYTHING BELOW THIS LINE ###

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_intra_main10.cfg

r655	r837
97	97	#============ Lossless ================
98	98	TransquantBypassEnableFlag: 0 # Value of PPS flag.
99		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	99	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
100	100
101	101

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_lowdelay_P_main.cfg

r655	r837
102	102	#============ Lossless ================
103	103	TransquantBypassEnableFlag: 0 # Value of PPS flag.
104		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	104	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
105	105
106	106	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_lowdelay_P_main10.cfg

r655	r837
102	102	#============ Lossless ================
103	103	TransquantBypassEnableFlag: 0 # Value of PPS flag.
104		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	104	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
105	105
106	106	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_lowdelay_main.cfg

r655	r837
102	102	#============ Lossless ================
103	103	TransquantBypassEnableFlag: 0 # Value of PPS flag.
104		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	104	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
105	105
106	106	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_lowdelay_main10.cfg

r655	r837
102	102	#============ Lossless ================
103	103	TransquantBypassEnableFlag: 0 # Value of PPS flag.
104		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	104	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
105	105
106	106	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_randomaccess_main.cfg

r655	r837
106	106	#============ Lossless ================
107	107	TransquantBypassEnableFlag: 0 # Value of PPS flag.
108		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	108	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
109	109
110	110	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/encoder_randomaccess_main10.cfg

r655	r837
106	106	#============ Lossless ================
107	107	TransquantBypassEnableFlag: 0 # Value of PPS flag.
108		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	108	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
109	109
110	110	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/per-sequence/Kimono.cfg

r655	r837
8	8	FramesToBeEncoded : 240 # Number of frames to be coded
9	9
10		Level : 4.0
	10	Level : 4

branches/HTM-10.0rc1-dev0/cfg/HEVC/HM/per-sequence/ParkScene.cfg

r655	r837
8	8	FramesToBeEncoded : 240 # Number of frames to be coded
9	9
10		Level : 4.0
	10	Level : 4

branches/HTM-10.0rc1-dev0/cfg/MV-HEVC/baseCfg_2view.cfg

r622	r837
150	150	#============ Lossless ================
151	151	TransquantBypassEnableFlag: 0 # Value of PPS flag.
152		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	152	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
153	153
154	154	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/MV-HEVC/baseCfg_3view.cfg

r622	r837
167	167	#============ Lossless ================
168	168	TransquantBypassEnableFlag: 0 # Value of PPS flag.
169		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	169	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
170	170
171	171	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/cfg/MV-HEVC/fullCfg.cfg

r622	r837
164	164	#============ Lossless ================
165	165	TransquantBypassEnableFlag: 0 # Value of PPS flag.
166		CUTransquantBypassFlag~~Valu~~e: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
	166	CUTransquantBypassFlagForce: 0 # Constant lossless-value signaling per CU, if TransquantBypassEnableFlag is 1.
167	167
168	168	#============ Rate Control ======================

branches/HTM-10.0rc1-dev0/doc/Doxyfile

r608	r837
33	33	# if some version control system is used.
34	34
35		PROJECT_NUMBER = HM-11.0
	35	PROJECT_NUMBER = HM-13.0
36	36
37	37	# Using the PROJECT_BRIEF tag one can provide an optional one line description

branches/HTM-10.0rc1-dev0/doc/mainpage.h

r608	r837
25	25	* granted under this license.
26	26	*
27		* Copyright (c) 2010-2012, ITU/ISO/IEC
	27	* Copyright (c) 2010-2014, ITU/ISO/IEC
28	28	* All rights reserved.
29	29	*

branches/HTM-10.0rc1-dev0/doc/software-manual.tex

-                      r608
+                      r837
 \author{%
         Frank Bossen
         \email{bossen@docomoinnovations.com}
+        \email{frank@bossentech.com}
         \and
         David Flynn
         \email{davidf@rd.bbc.co.uk}
+        \email{dflynn@blackberry.com}
         \and
         Karsten S\"uhring
 …
 \begin{abstract}
 This document is a user manual describing usage of reference software
 for the HEVC project. It applies to version 11.0
+for the HEVC project. It applies to version 13.0
 of the software.
 \end{abstract}
 …
-%%
-%% Entropy coding parameters
-%%
-\begin{OptionTable}{Entropy coding parameters}
-\Option{SBACRD} &
-\ShortOption{\None} &
-\Default{true} &
-Enables or disables the use of bit counts from arithmetic coder in
-rate-distortion decisions.
-\\
-\end{OptionTable}
 %%
 %% Slice coding parameters
 …
 transquant_bypass_enable_flag that is transmitted in the PPS.
 See CUTransquantBypassFlagValue for further details.
 \\
 \Option{CUTransquantBypassFlagValue} &
+See CUTransquantBypassFlagForce for further details.
+\\
+\Option{CUTransquantBypassFlagForce} &
 \ShortOption{\None} &
 \Default{0} &
 Controls the per CU transformation, quantization and filtering
 mode decision.
 This option corresponds to the value of the per CU cu_transquant_bypass_flag.
 \par
 \begin{tabular}{cp{0.45\textwidth}}
 & Bypass is not performed on any CU \\
 & Bypass is performed on all CUs \\
+This option controls the value of the per CU cu_transquant_bypass_flag.
+\par
+\begin{tabular}{cp{0.45\textwidth}}
+& Bypass is searched on a CU-by-CU basis and will be used if the cost is lower than not bypassing. \\
+& Bypass is forced for all CUs. \\
 \end{tabular}
 …
 \ShortOption{\None} &
 \Default{false} &
 Enables or disables the use of PCM.
+Enables or disables the use of PCM. The encoder will use cost measures on a CU-by-CU basis to determine if PCM mode is to be applied.
 \\
 …
 \section{Using the decoder}
 \begin{verbatim}
 TappDecoder -b str.bin -o dec.yuv [options]
+TAppDecoder -b str.bin -o dec.yuv [options]
 \end{verbatim}

branches/HTM-10.0rc1-dev0/source/App/TAppDecoder/TAppDecCfg.cpp

r773	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/TAppDecoder/TAppDecCfg.h

r773	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/TAppDecoder/TAppDecTop.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Bool firstSlice        = true;
 #endif
+  Bool loopFiltered = false;
   while (!!bitstreamFile)
+  {
 …
+      }
+    }
     if (bNewPicture || !bitstreamFile)
+    if (bNewPicture || !bitstreamFile || nalu.m_nalUnitType == NAL_UNIT_EOS )
+    {
 #if H_MV
       assert( decIdxLastPic != -1 );
+      // TODO add loop filtered variable here
       m_tDecTop[decIdxLastPic]->endPicDecoding(poc, pcListPic, m_targetDecLayerIdSet );
 #else
+      m_cTDecTop.executeLoopFilters(poc, pcListPic);
+      if (!loopFiltered || bitstreamFile)
+      {
+        m_cTDecTop.executeLoopFilters(poc, pcListPic);
+      }
+      loopFiltered = (nalu.m_nalUnitType == NAL_UNIT_EOS);
 #endif
+    }
 …
 #endif
+      }
+      if (nalu.m_nalUnitType == NAL_UNIT_EOS)
+      {
+#if H_MV
+        xFlushOutput( pcListPic, decIdxLastPic );
+#else
+        xFlushOutput( pcListPic );
+#endif
+      }
       // write reconstruction to file
       if(bNewPicture)
 …
 #endif
+{
+  if (pcListPic->empty())
+  {
+    return;
+  }
   TComList<TComPic*>::iterator iterPic   = pcListPic->begin();
   Int numPicsNotYetDisplayed = 0;
 …
 #endif
+{
   if(!pcListPic)
+  if(!pcListPic || pcListPic->empty())
+  {
     return;

branches/HTM-10.0rc1-dev0/source/App/TAppDecoder/TAppDecTop.h

r773	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/TAppDecoder/decmain.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/TAppEncoder/TAppEncCfg.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   ("RDOQTS",                        m_useRDOQTS,                true )
   ("RDpenalty",                     m_rdPenalty,                0,  "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled  1:RD-penalty  2:maximum RD-penalty")
-  // Entropy coding parameters
-  ("SBACRD",                         m_bUseSBACRD,                      true, "SBAC based RD estimation")
   // Deblocking filter parameters
 …
   ("MaxNumOffsetsPerPic",      m_maxNumOffsetsPerPic,       2048,  "Max number of SAO offset per picture (Default: 2048)")
   ("SAOLcuBoundary",           m_saoLcuBoundary,            false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
-  ("SAOLcuBasedOptimization",  m_saoLcuBasedOptimization,   true,  "0: SAO picture-based optimization, 1: SAO LCU-based optimization ")
   ("SliceMode",                m_sliceMode,                0,     "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice")
   ("SliceArgument",            m_sliceArgument,            0,     "Depending on SliceMode being:"
 …
   ("PCMInputBitDepthFlag",     m_bPCMInputBitDepthFlag,     true)
   ("PCMFilterDisableFlag",     m_bPCMFilterDisableFlag,    false)
-  ("LosslessCuEnabled",        m_useLossless, false)
   ("WeightedPredP,-wpP",          m_useWeightedPred,               false,      "Use weighted prediction in P slices")
 …
   ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting")
   ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting")
-#if RATE_CONTROL_LAMBDA_DOMAIN
   ( "RateControl",         m_RCEnableRateControl,   false, "Rate control: enable rate control" )
   ( "TargetBitrate",       m_RCTargetBitrate,           0, "Rate control: target bitrate" )
-#if M0036_RC_IMPROVEMENT
   ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit,     0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" )
-#else
-  ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, false, "Rate control: keep hierarchical bit allocation in rate control algorithm" )
-#endif
   ( "LCULevelRateControl", m_RCLCULevelRC,           true, "Rate control: true: LCU level RC; false: picture level RC" )
   ( "RCLCUSeparateModel",  m_RCUseLCUSeparateModel,  true, "Rate control: use LCU level separate R-lambda model" )
 …
   ("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
 #endif
-#else
-  ("RateCtrl,-rc", m_enableRateCtrl, false, "Rate control on/off")
-  ("TargetBitrate,-tbr", m_targetBitrate, 0, "Input target bitrate")
-  ("NumLCUInUnit,-nu", m_numLCUInUnit, 0, "Number of LCUs in an Unit")
-#if KWU_RC_VIEWRC_E0227
-  ("ViewWiseTargetBits, -vtbr" ,  m_viewTargetBits,  std::vector<Int>(1, 32), "View-wise target bit-rate setting")
-  ("TargetBitAssign, -ta", m_viewWiseRateCtrl, false, "View-wise rate control on/off")
-#endif
-#if KWU_RC_MADPRED_E0227
-  ("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
-#endif
-#endif
 #if H_MV
 …
       m_maxTempLayer = m_GOPList[i].m_temporalId+1;
+    }
     xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P', "Slice type must be equal to B or P");
+    xConfirmPara(m_GOPList[i].m_sliceType!='B'&&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");
+  }
   for(Int i=0; i<MAX_TLAYER; i++)
 …
+  }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_RCEnableRateControl )
+  {
 …
     xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
+  }
-#else
-  if(m_enableRateCtrl)
+  {
-    Int numLCUInWidth  = (m_iSourceWidth  / m_uiMaxCUWidth) + (( m_iSourceWidth  %  m_uiMaxCUWidth ) ? 1 : 0);
-    Int numLCUInHeight = (m_iSourceHeight / m_uiMaxCUHeight)+ (( m_iSourceHeight %  m_uiMaxCUHeight) ? 1 : 0);
-    Int numLCUInPic    =  numLCUInWidth * numLCUInHeight;
-    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
-#if !KWU_FIX_URQ
-    m_iMaxDeltaQP       = MAX_DELTA_QP;
-#endif
-    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
+  }
-#endif
 #if H_MV
   // VPS VUI
 …
 #endif
   xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
+  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce, "CUTransquantBypassFlagForce cannot be 1 when TransquantBypassEnableFlag is 0");
   xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2");
 …
   printf("Internal bit depth           : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC );
   printf("PCM sample bit depth         : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma );
-#if RATE_CONTROL_LAMBDA_DOMAIN
   printf("RateControl                  : %d\n", m_RCEnableRateControl );
   if(m_RCEnableRateControl)
 …
 #endif
+  }
-#else
-  printf("RateControl                  : %d\n", m_enableRateCtrl);
-  if(m_enableRateCtrl)
+  {
-    printf("TargetBitrate                : %d\n", m_targetBitrate);
-    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
-#if KWU_RC_MADPRED_E0227
-    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
-#endif
-#if KWU_RC_VIEWRC_E0227
-    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
-    if(m_viewWiseRateCtrl)
+    {
-      printf("ViewWiseTargetBits           : ");
-      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
-        printf("%d ", m_viewTargetBits[i]);
-      printf("\n");
+    }
-    else
+    {
-      printf("TargetBitrate                : %d\n", m_targetBitrate );
+    }
-#endif
+  }
-#endif
   printf("Max Num Merge Candidates     : %d\n", m_maxNumMergeCand);
 #if H_3D
 …
 #endif
   printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
+  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
+  printf("LosslessCuEnabled:%d ", (m_useLossless)? 1:0 );
+  if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce)
+  {
+    printf("TransQuantBypassEnabled: =1 ");
+  }
+  else
+  {
+    printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 );
+  }
   printf("WPP:%d ", (Int)m_useWeightedPred);
   printf("WPB:%d ", (Int)m_useWeightedBiPred);

branches/HTM-10.0rc1-dev0/source/App/TAppEncoder/TAppEncCfg.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Bool      m_bPCMInputBitDepthFlag;                          ///< 0: PCM bit-depth is internal bit-depth. 1: PCM bit-depth is input bit-depth.
+  // coding tool (lossless)
+  Bool      m_useLossless;                                    ///< flag for using lossless coding
+  // coding tool (SAO)
 #if H_MV
   std::vector<Bool> m_bUseSAO;
 …
   Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
   Bool      m_saoLcuBoundary;                                 ///< SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
-  Bool      m_saoLcuBasedOptimization;                        ///< SAO LCU-based optimization
   // coding tools (loop filter)
 #if H_MV
 …
   Int       m_TMVPModeId;
   Int       m_signHideFlag;
-#if RATE_CONTROL_LAMBDA_DOMAIN
   Bool      m_RCEnableRateControl;                ///< enable rate control or not
   Int       m_RCTargetBitrate;                    ///< target bitrate when rate control is enabled
-#if M0036_RC_IMPROVEMENT
   Int       m_RCKeepHierarchicalBit;              ///< 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation
-#else
-  Bool      m_RCKeepHierarchicalBit;              ///< whether keeping hierarchical bit allocation structure or not
-#endif
   Bool      m_RCLCULevelRC;                       ///< true: LCU level rate control; false: picture level rate control
   Bool      m_RCUseLCUSeparateModel;              ///< use separate R-lambda model at LCU level
 …
   Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
   Bool      m_CUTransquantBypassFlagValue;                    ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
+  Bool      m_CUTransquantBypassFlagForce;                    ///< if transquant_bypass_enable_flag, then, if true, all CU transquant bypass flags will be set to true.
   Bool      m_recalculateQPAccordingToLambda;                 ///< recalculate QP value according to the lambda value

branches/HTM-10.0rc1-dev0/source/App/TAppEncoder/TAppEncTop.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #endif
-  Int lowestQP;
-  lowestQP =  - 6*(g_bitDepthY - 8); // XXX: check
-#if H_MV
-  if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layerIdInVps] == lowestQP) && (m_useLossless == true))
-#else
-  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
-#endif
+  {
-    m_bUseAdaptiveQP = false;
+  }
   m_cTEncTop.setUseAdaptiveQP                ( m_bUseAdaptiveQP  );
   m_cTEncTop.setQPAdaptationRange            ( m_iQPAdaptationRange );
   //====== Tool list ========
-  m_cTEncTop.setUseSBACRD                    ( m_bUseSBACRD   );
   m_cTEncTop.setDeltaQpRD                    ( m_uiDeltaQpRD  );
   m_cTEncTop.setUseASR                       ( m_bUseASR      );
   m_cTEncTop.setUseHADME                     ( m_bUseHADME    );
-  m_cTEncTop.setUseLossless                  ( m_useLossless );
 #if H_MV
   m_cTEncTop.setdQPs                         ( m_aidQP[layerIdInVps]   );
 …
   m_cTEncTop.setSaoLcuBoundary (m_saoLcuBoundary);
-  m_cTEncTop.setSaoLcuBasedOptimization (m_saoLcuBasedOptimization);
   m_cTEncTop.setPCMInputBitDepthFlag  ( m_bPCMInputBitDepthFlag);
   m_cTEncTop.setPCMFilterDisableFlag  ( m_bPCMFilterDisableFlag);
 …
   m_cTEncTop.setScalingListFile            ( m_scalingListFile   );
   m_cTEncTop.setSignHideFlag(m_signHideFlag);
-#if RATE_CONTROL_LAMBDA_DOMAIN
 #if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
   if(!m_cTEncTop.getIsDepth())    //only for texture
 …
   m_cTEncTop.setInitialQP           ( m_RCInitialQP );
   m_cTEncTop.setForceIntraQP        ( m_RCForceIntraQP );
 #if KWU_RC_MADPRED_E0227
   if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
+  {
     m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred       : 0);
     if(m_cTEncTop.getUseDepthMADPred())
+    {
 …
+  {
     m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
     if(m_iNumberOfViews == 1)
+    {
 …
+  }
 #endif
-#else
-#if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
-  if(!m_cTEncTop.getIsDepth())    //only for texture
+  {
-    m_cTEncTop.setUseRateCtrl         ( m_enableRateCtrl );
-    m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
-    m_cTEncTop.setNumLCUInUnit        ( m_numLCUInUnit);
+  }
-  else
+  {
-    m_cTEncTop.setUseRateCtrl         ( 0 );
+  }
-#else
-  m_cTEncTop.setUseRateCtrl         ( m_enableRateCtrl );
-  m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
-  m_cTEncTop.setNumLCUInUnit        ( m_numLCUInUnit);
-#endif
-#if KWU_RC_MADPRED_E0227
-  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
+  {
-    m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred       : 0);
-    if(m_cTEncTop.getUseDepthMADPred())
+    {
-      m_cTEncTop.setCamParam(&m_cCameraData);
+    }
+  }
-#endif
-#if KWU_RC_VIEWRC_E0227
-  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
+  {
-    m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
-    if(m_iNumberOfViews == 1)
+    {
-      if(m_viewWiseRateCtrl)
+      {
-        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
+      }
-      else
+      {
-        m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
+      }
+    }
-    else
+    {
-      if(m_viewWiseRateCtrl)
+      {
-        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
+      }
-      else
+      {
-        if(m_iNumberOfViews == 2)
+        {
-          if(m_cTEncTop.getViewId() == 0)
+          {
-            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*80)/100 );
+          }
-          else if(m_cTEncTop.getViewId() == 1)
+          {
-            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*20)/100 );
+          }
+        }
-        else if(m_iNumberOfViews == 3)
+        {
-          if(m_cTEncTop.getViewId() == 0)
+          {
-            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*66)/100 );
+          }
-          else if(m_cTEncTop.getViewId() == 1)
+          {
-            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*17)/100 );
+          }
-          else if(m_cTEncTop.getViewId() == 2)
+          {
-            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*17)/100 );
+          }
+        }
-        else
+        {
-          m_cTEncTop.setTargetBitrate              ( m_targetBitrate );
+        }
+      }
+    }
+  }
-#endif
-#endif
   m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
   m_cTEncTop.setCUTransquantBypassFlagValue(m_CUTransquantBypassFlagValue);
+  m_cTEncTop.setCUTransquantBypassFlagForceValue(m_CUTransquantBypassFlagForce);
   m_cTEncTop.setUseRecalculateQPAccordingToLambda( m_recalculateQPAccordingToLambda );
   m_cTEncTop.setUseStrongIntraSmoothing( m_useStrongIntraSmoothing );
 …
       rateStatsAccum(au, stats);
+    }
-#endif
+  }
+}
 …
     case NAL_UNIT_CODED_SLICE_TRAIL_R:
     case NAL_UNIT_CODED_SLICE_TRAIL_N:
     case NAL_UNIT_CODED_SLICE_TLA_R:
+    case NAL_UNIT_CODED_SLICE_TSA_R:
     case NAL_UNIT_CODED_SLICE_TSA_N:
     case NAL_UNIT_CODED_SLICE_STSA_R:

branches/HTM-10.0rc1-dev0/source/App/TAppEncoder/TAppEncTop.h

r773	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/TAppEncoder/encmain.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/ExtractBitrates.cpp

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/ExtractBitrates.h

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/ExtractBitratesMain.cpp

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiers.cpp

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiers.h

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/GuessLambdaModifiersMain.cpp

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/RuntimeError.h

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/encode.shl

r56	r837
4	4	# granted under this license.
5	5	#
6		# Copyright (c) 2010-2012, ITU/ISO/IEC
	6	# Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	# All rights reserved.
8	8	#

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/encodeCommand.sh

r56	r837
6	6	# granted under this license.
7	7	#
8		# Copyright (c) 2010-2012, ITU/ISO/IEC
	8	# Copyright (c) 2010-2014, ITU/ISO/IEC
9	9	# All rights reserved.
10	10	#

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/makefile

r56	r837
4	4	# granted under this license.
5	5	#
6		# Copyright (c) 2010-2012, ITU/ISO/IEC
	6	# Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	# All rights reserved.
8	8	#

branches/HTM-10.0rc1-dev0/source/App/utils/BitrateTargeting/targetBitrates.sh

r56	r837
6	6	# granted under this license.
7	7	#
8		# Copyright (c) 2010-2012, ITU/ISO/IEC
	8	# Copyright (c) 2010-2014, ITU/ISO/IEC
9	9	# All rights reserved.
10	10	#

branches/HTM-10.0rc1-dev0/source/App/utils/annexBbytecount.cpp

r56	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/App/utils/convert_NtoMbit_YCbCr.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2012, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TAppCommon/program_options_lite.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #include <list>
 #include <map>
+#include <algorithm>
 #include "program_options_lite.h"
 #include  "../TLibCommon/TypeDef.h"

branches/HTM-10.0rc1-dev0/source/Lib/TAppCommon/program_options_lite.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/AccessUnit.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/CommonDef.h

-                      r834
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #if H_MV
 #define NV_VERSION        "10.0rc1"              ///< Current software version
 #define HM_VERSION        "12.0"                ///<
+#define HM_VERSION        "13.0"                ///<
 #else
 #define NV_VERSION        "12.0"                 ///< Current software version
+#define NV_VERSION        "13.0"                 ///< Current software version
 #endif
 …
   NAL_UNIT_CODED_SLICE_TSA_N,     // 2
   NAL_UNIT_CODED_SLICE_TLA_R,       // 3
+  NAL_UNIT_CODED_SLICE_TSA_R,       // 3
   NAL_UNIT_CODED_SLICE_STSA_N,    // 4

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/ContextModel.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/ContextModel.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/ContextModel3DBuffer.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/ContextModel3DBuffer.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/ContextTables.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 //! \ingroup TLibCommon
 //! \{
-#define FIX827 1 ///< Fix for issue #827: CABAC init tables
-#define FIX712 1 ///< Fix for issue #712: CABAC init tables
 // ====================================================================================================================
 …
 #define NUM_PART_SIZE_CTX             4       ///< number of context models for partition size
-#define NUM_CU_AMP_CTX                1       ///< number of context models for partition size (AMP)
 #define NUM_PRED_MODE_CTX             1       ///< number of context models for prediction mode
 …
 #define NUM_REF_NO_CTX                2       ///< number of context models for reference index
 #define NUM_TRANS_SUBDIV_FLAG_CTX     3       ///< number of context models for transform subdivision flags
 #define NUM_QT_CBF_CTX                5       ///< number of context models for QT CBF
+#define NUM_QT_CBF_CTX                4       ///< number of context models for QT CBF
 #define NUM_QT_ROOT_CBF_CTX           1       ///< number of context models for QT ROOT CBF
 #define NUM_DELTA_QP_CTX              3       ///< number of context models for dQP
 …
 #define NUM_ABS_FLAG_CTX_CHROMA        2      ///< number of context models for greater than 2 flag of chroma
 #define NUM_MVP_IDX_CTX               2       ///< number of context models for MVP index
+#define NUM_MVP_IDX_CTX               1       ///< number of context models for MVP index
 #define NUM_SAO_MERGE_FLAG_CTX        1       ///< number of context models for SAO merge flags
 …
 INIT_PART_SIZE[3][NUM_PART_SIZE_CTX] =
+{
+  { 154,  139,  CNU,  CNU, },
+  { 154,  139,  CNU,  CNU, },
+  { 184,  CNU,  CNU,  CNU, },
+};
+static const UChar
+INIT_CU_AMP_POS[3][NUM_CU_AMP_CTX] =
+{
+  { 154, },
+  { 154, },
+  { CNU, },
+  { 154,  139,  154,  154 },
+  { 154,  139,  154,  154 },
+  { 184,  CNU,  CNU,  CNU },
 };
 …
 INIT_QT_CBF[3][2*NUM_QT_CBF_CTX] =
+{
   { 153,  111,  CNU,  CNU,  CNU,  149,   92,  167,  CNU,  CNU, },
   { 153,  111,  CNU,  CNU,  CNU,  149,  107,  167,  CNU,  CNU, },
   { 111,  141,  CNU,  CNU,  CNU,   94,  138,  182,  CNU,  CNU, },
+  { 153,  111,  CNU,  CNU,   149,   92,  167,  154 },
+  { 153,  111,  CNU,  CNU,   149,  107,  167,  154 },
+  { 111,  141,  CNU,  CNU,    94,  138,  182,  154 },
 };
 …
 INIT_MVP_IDX[3][NUM_MVP_IDX_CTX] =
+{
   { 168,  CNU, },
   { 168,  CNU, },
   { CNU,  CNU, },
+  { 168 },
+  { 168 },
+  { CNU },
 };
 …
 INIT_SAO_TYPE_IDX[3][NUM_SAO_TYPE_IDX_CTX] =
+{
-#if FIX827
   { 160, },
   { 185, },
   { 200, },
-#else
-  { 200, },
-  { 185, },
-  { 160, },
-#endif
 };
 …
 INIT_TRANS_SUBDIV_FLAG[3][NUM_TRANS_SUBDIV_FLAG_CTX] =
+{
-#if FIX712
   { 224,  167,  122, },
   { 124,  138,   94, },
   { 153,  138,  138, },
-#else
-  { 153,  138,  138, },
-  { 124,  138,   94, },
-  { 224,  167,  122, },
-#endif
 };

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/NAL.h

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
     return m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TRAIL_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TLA_R
+        || m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_R
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_TSA_N
         || m_nalUnitType == NAL_UNIT_CODED_SLICE_STSA_R

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/SEI.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/SEI.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComBitCounter.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComBitStream.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComBitStream.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComCABACTables.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComCABACTables.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComDataCU.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
+}
-const NDBFBlockInfo& NDBFBlockInfo::operator= (const NDBFBlockInfo& src)
+{
-  this->tileID = src.tileID;
-  this->sliceID= src.sliceID;
-  this->startSU= src.startSU;
-  this->endSU  = src.endSU;
-  this->widthSU= src.widthSU;
-  this->heightSU=src.heightSU;
-  this->posX   = src.posX;
-  this->posY   = src.posY;
-  this->width  = src.width;
-  this->height = src.height;
-  ::memcpy(this->isBorderAvailable, src.isBorderAvailable, sizeof(Bool)*((Int)NUM_SGU_BORDER));
-  this->allBordersAvailable = src.allBordersAvailable;
-  return *this;
+}
 // ====================================================================================================================
 // Public member functions
 …
 *- set last-coded qp value according to input last-coded qp
 */
 Void TComDataCU::initEstData( UInt uiDepth, Int qp )
+Void TComDataCU::initEstData( UInt uiDepth, Int qp, Bool bTransquantBypass )
+{
   m_dTotalCost         = MAX_DOUBLE;
 …
       m_pePartSize[ui] = SIZE_NONE;
       m_pePredMode[ui] = MODE_NONE;
       m_CUTransquantBypass[ui] = false;
+      m_CUTransquantBypass[ui] = bTransquantBypass;
       m_pbIPCMFlag[ui] = 0;
       m_phQP[ui] = qp;
 …
     xAddMVPCand( pInfo, eRefPicList, iRefIdx, uiPartIdxLT, MD_ABOVE_LEFT);
+  }
+  bAdded = bAddedSmvp;
+  if (pInfo->iN==2) bAdded = true;
+  if(!bAdded)
+  if (!bAddedSmvp)
+  {
     bAdded = xAddMVPCandOrder( pInfo, eRefPicList, iRefIdx, uiPartIdxRT, MD_ABOVE_RIGHT);
 …
+{
   return getPic()->getPicSym()->getInverseCUOrderMap(m_uiCUAddr)*(1<<(m_pcSlice->getSPS()->getMaxCUDepth()<<1))+m_uiAbsIdxInLCU;
+}
-/** Set neighboring blocks availabilities for non-deblocked filtering
- * \param numLCUInPicWidth number of LCUs in picture width
- * \param numLCUInPicHeight number of LCUs in picture height
- * \param numSUInLCUWidth number of SUs in LCU width
- * \param numSUInLCUHeight number of SUs in LCU height
- * \param picWidth picture width
- * \param picHeight picture height
- * \param bIndependentSliceBoundaryEnabled true for independent slice boundary enabled
- * \param bTopTileBoundary true means that top boundary coincides tile boundary
- * \param bDownTileBoundary true means that bottom boundary coincides tile boundary
- * \param bLeftTileBoundary true means that left boundary coincides tile boundary
- * \param bRightTileBoundary true means that right boundary coincides tile boundary
- * \param bIndependentTileBoundaryEnabled true for independent tile boundary enabled
- */
-Void TComDataCU::setNDBFilterBlockBorderAvailability(UInt numLCUInPicWidth, UInt /*numLCUInPicHeight*/, UInt numSUInLCUWidth, UInt numSUInLCUHeight, UInt picWidth, UInt picHeight
-                                                    ,std::vector<Bool>& LFCrossSliceBoundary
-                                                    ,Bool bTopTileBoundary, Bool bDownTileBoundary, Bool bLeftTileBoundary, Bool bRightTileBoundary
-                                                    ,Bool bIndependentTileBoundaryEnabled)
+{
-  UInt numSUInLCU = numSUInLCUWidth*numSUInLCUHeight;
-  Int* pSliceIDMapLCU = m_piSliceSUMap;
-  Bool onlyOneSliceInPic = ((Int)LFCrossSliceBoundary.size() == 1);
-  UInt uiLPelX, uiTPelY;
-  UInt width, height;
-  Bool bPicRBoundary, bPicBBoundary, bPicTBoundary, bPicLBoundary;
-  Bool bLCURBoundary= false, bLCUBBoundary= false, bLCUTBoundary= false, bLCULBoundary= false;
-  Bool* pbAvailBorder;
-  Bool* pbAvail;
-  UInt rTLSU, rBRSU, widthSU, heightSU;
-  UInt zRefSU;
-  Int* pRefID;
-  Int* pRefMapLCU;
-  UInt rTRefSU= 0, rBRefSU= 0, rLRefSU= 0, rRRefSU= 0;
-  Int* pRRefMapLCU= NULL;
-  Int* pLRefMapLCU= NULL;
-  Int* pTRefMapLCU= NULL;
-  Int* pBRefMapLCU= NULL;
-  Int  sliceID;
-  UInt numSGU = (UInt)m_vNDFBlock.size();
-  for(Int i=0; i< numSGU; i++)
+  {
-    NDBFBlockInfo& rSGU = m_vNDFBlock[i];
-    sliceID = rSGU.sliceID;
-    uiLPelX = rSGU.posX;
-    uiTPelY = rSGU.posY;
-    width   = rSGU.width;
-    height  = rSGU.height;
-    rTLSU     = g_auiZscanToRaster[ rSGU.startSU ];
-    rBRSU     = g_auiZscanToRaster[ rSGU.endSU   ];
-    widthSU   = rSGU.widthSU;
-    heightSU  = rSGU.heightSU;
-    pbAvailBorder = rSGU.isBorderAvailable;
-    bPicTBoundary= (uiTPelY == 0                       )?(true):(false);
-    bPicLBoundary= (uiLPelX == 0                       )?(true):(false);
-    bPicRBoundary= (!(uiLPelX+ width < picWidth )  )?(true):(false);
-    bPicBBoundary= (!(uiTPelY + height < picHeight))?(true):(false);
-    bLCULBoundary = (rTLSU % numSUInLCUWidth == 0)?(true):(false);
-    bLCURBoundary = ( (rTLSU+ widthSU) % numSUInLCUWidth == 0)?(true):(false);
-    bLCUTBoundary = ( (UInt)(rTLSU / numSUInLCUWidth)== 0)?(true):(false);
-    bLCUBBoundary = ( (UInt)(rBRSU / numSUInLCUWidth) == (numSUInLCUHeight-1) )?(true):(false);
-    //       SGU_L
-    pbAvail = &(pbAvailBorder[SGU_L]);
-    if(bPicLBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      //      bLCULBoundary = (rTLSU % uiNumSUInLCUWidth == 0)?(true):(false);
-      if(bLCULBoundary)
+      {
-        rLRefSU     = rTLSU + numSUInLCUWidth -1;
-        zRefSU      = g_auiRasterToZscan[rLRefSU];
-        pRefMapLCU = pLRefMapLCU= (pSliceIDMapLCU - numSUInLCU);
+      }
-      else
+      {
-        zRefSU   = g_auiRasterToZscan[rTLSU - 1];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_R
-    pbAvail = &(pbAvailBorder[SGU_R]);
-    if(bPicRBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      //       bLCURBoundary = ( (rTLSU+ uiWidthSU) % uiNumSUInLCUWidth == 0)?(true):(false);
-      if(bLCURBoundary)
+      {
-        rRRefSU      = rTLSU + widthSU - numSUInLCUWidth;
-        zRefSU       = g_auiRasterToZscan[rRRefSU];
-        pRefMapLCU  = pRRefMapLCU= (pSliceIDMapLCU + numSUInLCU);
+      }
-      else
+      {
-        zRefSU       = g_auiRasterToZscan[rTLSU + widthSU];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_T
-    pbAvail = &(pbAvailBorder[SGU_T]);
-    if(bPicTBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      //      bLCUTBoundary = ( (UInt)(rTLSU / uiNumSUInLCUWidth)== 0)?(true):(false);
-      if(bLCUTBoundary)
+      {
-        rTRefSU      = numSUInLCU - (numSUInLCUWidth - rTLSU);
-        zRefSU       = g_auiRasterToZscan[rTRefSU];
-        pRefMapLCU  = pTRefMapLCU= (pSliceIDMapLCU - (numLCUInPicWidth*numSUInLCU));
+      }
-      else
+      {
-        zRefSU       = g_auiRasterToZscan[rTLSU - numSUInLCUWidth];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_B
-    pbAvail = &(pbAvailBorder[SGU_B]);
-    if(bPicBBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      //      bLCUBBoundary = ( (UInt)(rBRSU / uiNumSUInLCUWidth) == (uiNumSUInLCUHeight-1) )?(true):(false);
-      if(bLCUBBoundary)
+      {
-        rBRefSU      = rTLSU % numSUInLCUWidth;
-        zRefSU       = g_auiRasterToZscan[rBRefSU];
-        pRefMapLCU  = pBRefMapLCU= (pSliceIDMapLCU + (numLCUInPicWidth*numSUInLCU));
+      }
-      else
+      {
-        zRefSU       = g_auiRasterToZscan[rTLSU + (heightSU*numSUInLCUWidth)];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_TL
-    pbAvail = &(pbAvailBorder[SGU_TL]);
-    if(bPicTBoundary || bPicLBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      if(bLCUTBoundary && bLCULBoundary)
+      {
-        zRefSU       = numSUInLCU -1;
-        pRefMapLCU  = pSliceIDMapLCU - ( (numLCUInPicWidth+1)*numSUInLCU);
+      }
-      else if(bLCUTBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rTRefSU- 1];
-        pRefMapLCU  = pTRefMapLCU;
+      }
-      else if(bLCULBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rLRefSU- numSUInLCUWidth ];
-        pRefMapLCU  = pLRefMapLCU;
+      }
-      else //inside LCU
+      {
-        zRefSU       = g_auiRasterToZscan[ rTLSU - numSUInLCUWidth -1];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_TR
-    pbAvail = &(pbAvailBorder[SGU_TR]);
-    if(bPicTBoundary || bPicRBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      if(bLCUTBoundary && bLCURBoundary)
+      {
-        zRefSU      = g_auiRasterToZscan[numSUInLCU - numSUInLCUWidth];
-        pRefMapLCU  = pSliceIDMapLCU - ( (numLCUInPicWidth-1)*numSUInLCU);
+      }
-      else if(bLCUTBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rTRefSU+ widthSU];
-        pRefMapLCU  = pTRefMapLCU;
+      }
-      else if(bLCURBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rRRefSU- numSUInLCUWidth ];
-        pRefMapLCU  = pRRefMapLCU;
+      }
-      else //inside LCU
+      {
-        zRefSU       = g_auiRasterToZscan[ rTLSU - numSUInLCUWidth +widthSU];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_BL
-    pbAvail = &(pbAvailBorder[SGU_BL]);
-    if(bPicBBoundary || bPicLBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      if(bLCUBBoundary && bLCULBoundary)
+      {
-        zRefSU      = g_auiRasterToZscan[numSUInLCUWidth - 1];
-        pRefMapLCU  = pSliceIDMapLCU + ( (numLCUInPicWidth-1)*numSUInLCU);
+      }
-      else if(bLCUBBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rBRefSU - 1];
-        pRefMapLCU  = pBRefMapLCU;
+      }
-      else if(bLCULBoundary)
+      {
-        zRefSU       = g_auiRasterToZscan[ rLRefSU+ heightSU*numSUInLCUWidth ];
-        pRefMapLCU  = pLRefMapLCU;
+      }
-      else //inside LCU
+      {
-        zRefSU       = g_auiRasterToZscan[ rTLSU + heightSU*numSUInLCUWidth -1];
-        pRefMapLCU  = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    //       SGU_BR
-    pbAvail = &(pbAvailBorder[SGU_BR]);
-    if(bPicBBoundary || bPicRBoundary)
+    {
-      *pbAvail = false;
+    }
-    else if (onlyOneSliceInPic)
+    {
-      *pbAvail = true;
+    }
-    else
+    {
-      if(bLCUBBoundary && bLCURBoundary)
+      {
-        zRefSU = 0;
-        pRefMapLCU = pSliceIDMapLCU+ ( (numLCUInPicWidth+1)*numSUInLCU);
+      }
-      else if(bLCUBBoundary)
+      {
-        zRefSU      = g_auiRasterToZscan[ rBRefSU + widthSU];
-        pRefMapLCU = pBRefMapLCU;
+      }
-      else if(bLCURBoundary)
+      {
-        zRefSU      = g_auiRasterToZscan[ rRRefSU + (heightSU*numSUInLCUWidth)];
-        pRefMapLCU = pRRefMapLCU;
+      }
-      else //inside LCU
+      {
-        zRefSU      = g_auiRasterToZscan[ rTLSU + (heightSU*numSUInLCUWidth)+ widthSU];
-        pRefMapLCU = pSliceIDMapLCU;
+      }
-      pRefID = pRefMapLCU + zRefSU;
-      *pbAvail = (*pRefID == sliceID)?(true):((*pRefID > sliceID)?(LFCrossSliceBoundary[*pRefID]):(LFCrossSliceBoundary[sliceID]));
+    }
-    if(bIndependentTileBoundaryEnabled)
+    {
-      //left LCU boundary
-      if(!bPicLBoundary && bLCULBoundary)
+      {
-        if(bLeftTileBoundary)
+        {
-          pbAvailBorder[SGU_L] = pbAvailBorder[SGU_TL] = pbAvailBorder[SGU_BL] = false;
+        }
+      }
-      //right LCU boundary
-      if(!bPicRBoundary && bLCURBoundary)
+      {
-        if(bRightTileBoundary)
+        {
-          pbAvailBorder[SGU_R] = pbAvailBorder[SGU_TR] = pbAvailBorder[SGU_BR] = false;
+        }
+      }
-      //top LCU boundary
-      if(!bPicTBoundary && bLCUTBoundary)
+      {
-        if(bTopTileBoundary)
+        {
-          pbAvailBorder[SGU_T] = pbAvailBorder[SGU_TL] = pbAvailBorder[SGU_TR] = false;
+        }
+      }
-      //down LCU boundary
-      if(!bPicBBoundary && bLCUBBoundary)
+      {
-        if(bDownTileBoundary)
+        {
-          pbAvailBorder[SGU_B] = pbAvailBorder[SGU_BL] = pbAvailBorder[SGU_BR] = false;
+        }
+      }
+    }
-    rSGU.allBordersAvailable = true;
-    for(Int b=0; b< NUM_SGU_BORDER; b++)
+    {
-      if(pbAvailBorder[b] == false)
+      {
-        rSGU.allBordersAvailable = false;
-        break;
+      }
+    }
+  }
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComDataCU.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 //! \{
-// ====================================================================================================================
-// Non-deblocking in-loop filter processing block data structure
-// ====================================================================================================================
-/// Non-deblocking filter processing block border tag
-enum NDBFBlockBorderTag
+{
-  SGU_L = 0,
-  SGU_R,
-  SGU_T,
-  SGU_B,
-  SGU_TL,
-  SGU_TR,
-  SGU_BL,
-  SGU_BR,
-  NUM_SGU_BORDER
-};
-/// Non-deblocking filter processing block information
-struct NDBFBlockInfo
+{
-  Int   tileID;   //!< tile ID
-  Int   sliceID;  //!< slice ID
-  UInt  startSU;  //!< starting SU z-scan address in LCU
-  UInt  endSU;    //!< ending SU z-scan address in LCU
-  UInt  widthSU;  //!< number of SUs in width
-  UInt  heightSU; //!< number of SUs in height
-  UInt  posX;     //!< top-left X coordinate in picture
-  UInt  posY;     //!< top-left Y coordinate in picture
-  UInt  width;    //!< number of pixels in width
-  UInt  height;   //!< number of pixels in height
-  Bool  isBorderAvailable[NUM_SGU_BORDER];  //!< the border availabilities
-  Bool  allBordersAvailable;
-  NDBFBlockInfo():tileID(0), sliceID(0), startSU(0), endSU(0) {} //!< constructor
-  const NDBFBlockInfo& operator= (const NDBFBlockInfo& src);  //!< "=" operator
-};
 #if H_3D_DBBP
 …
   Pel*          m_pcIPCMSampleCr;     ///< PCM sample buffer (Cr)
-  Int*          m_piSliceSUMap;       ///< pointer of slice ID map
-  std::vector<NDBFBlockInfo> m_vNDFBlock;
   // -------------------------------------------------------------------------------------------------------------------
   // neighbour access variables
 …
   Void          initCU                ( TComPic* pcPic, UInt uiCUAddr );
   Void          initEstData           ( UInt uiDepth, Int qp );
+  Void          initEstData           ( UInt uiDepth, Int qp, Bool bTransquantBypass );
   Void          initSubCU             ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp );
   Void          setOutsideCUPart      ( UInt uiAbsPartIdx, UInt uiDepth );
 …
   DisInfo       getDvInfo             (UInt uiIdx)              { return m_pDvInfo[uiIdx];          }
 #endif
-  /// get slice ID for SU
-  Int           getSUSliceID          (UInt uiIdx)              {return m_piSliceSUMap[uiIdx];      }
-  /// get the pointer of slice ID map
-  Int*          getSliceSUMap         ()                        {return m_piSliceSUMap;             }
-  /// set the pointer of slice ID map
-  Void          setSliceSUMap         (Int *pi)                 {m_piSliceSUMap = pi;               }
-  std::vector<NDBFBlockInfo>* getNDBFilterBlocks()      {return &m_vNDFBlock;}
-  Void setNDBFilterBlockBorderAvailability(UInt numLCUInPicWidth, UInt numLCUInPicHeight, UInt numSUInLCUWidth, UInt numSUInLCUHeight, UInt picWidth, UInt picHeight
-                                          ,std::vector<Bool>& LFCrossSliceBoundary
-                                          ,Bool bTopTileBoundary, Bool bDownTileBoundary, Bool bLeftTileBoundary, Bool bRightTileBoundary
-                                          ,Bool bIndependentTileBoundaryEnabled );
 #if H_3D_NBDV
   Void          xDeriveRightBottomNbIdx(Int &uiLCUIdxRBNb, Int &uiPartIdxRBNb );

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComInterpolationFilter.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComInterpolationFilter.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComList.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComLoopFilter.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComLoopFilter.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComMotionInfo.cpp

r773	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComMotionInfo.h

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComMv.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPattern.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPattern.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPic.cpp

-                      r738
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 , m_bNeededForOutput                      (false)
 , m_uiCurrSliceIdx                        (0)
-, m_pSliceSUMap                           (NULL)
-, m_pbValidSlice                          (NULL)
-, m_sliceGranularityForNDBFilter          (0)
-, m_bIndependentSliceBoundaryForNDBFilter (false)
-, m_bIndependentTileBoundaryForNDBFilter  (false)
-, m_pNDBFilterYuvTmp                      (NULL)
 , m_bCheckLTMSB                           (false)
 #if H_MV
 …
+}
+/** Create non-deblocked filter information
+ * \param pSliceStartAddress array for storing slice start addresses
+ * \param numSlices number of slices in picture
+ * \param sliceGranularityDepth slice granularity
+ * \param bNDBFilterCrossSliceBoundary cross-slice-boundary in-loop filtering; true for "cross".
+ * \param numTiles number of tiles in picture
+ * \param bNDBFilterCrossTileBoundary cross-tile-boundary in-loop filtering; true for "cross".
+ */
+Void TComPic::createNonDBFilterInfo(std::vector<Int> sliceStartAddress, Int sliceGranularityDepth
+                                    ,std::vector<Bool>* LFCrossSliceBoundary
+                                    ,Int numTiles
+                                    ,Bool bNDBFilterCrossTileBoundary)
+{
+  UInt maxNumSUInLCU = getNumPartInCU();
+  UInt numLCUInPic   = getNumCUsInFrame();
+  UInt picWidth      = getSlice(0)->getSPS()->getPicWidthInLumaSamples();
+  UInt picHeight     = getSlice(0)->getSPS()->getPicHeightInLumaSamples();
+  Int  numLCUsInPicWidth = getFrameWidthInCU();
+  Int  numLCUsInPicHeight= getFrameHeightInCU();
+  UInt maxNumSUInLCUWidth = getNumPartInWidth();
+  UInt maxNumSUInLCUHeight= getNumPartInHeight();
+  Int  numSlices = (Int) sliceStartAddress.size() - 1;
+  m_bIndependentSliceBoundaryForNDBFilter = false;
+  if(numSlices > 1)
+  {
+    for(Int s=0; s< numSlices; s++)
+    {
+      if((*LFCrossSliceBoundary)[s] == false)
+      {
+        m_bIndependentSliceBoundaryForNDBFilter = true;
+      }
+    }
+  }
+  m_sliceGranularityForNDBFilter = sliceGranularityDepth;
+  m_bIndependentTileBoundaryForNDBFilter  = (bNDBFilterCrossTileBoundary)?(false) :((numTiles > 1)?(true):(false));
+  m_pbValidSlice = new Bool[numSlices];
+  for(Int s=0; s< numSlices; s++)
+  {
+    m_pbValidSlice[s] = true;
+  }
+  m_pSliceSUMap = new Int[maxNumSUInLCU * numLCUInPic];
+  //initialization
+  for(UInt i=0; i< (maxNumSUInLCU * numLCUInPic); i++ )
+  {
+    m_pSliceSUMap[i] = -1;
+  }
+  for( UInt CUAddr = 0; CUAddr < numLCUInPic ; CUAddr++ )
+  {
+    TComDataCU* pcCU = getCU( CUAddr );
+    pcCU->setSliceSUMap(m_pSliceSUMap + (CUAddr* maxNumSUInLCU));
+    pcCU->getNDBFilterBlocks()->clear();
+  }
+  m_vSliceCUDataLink.clear();
+  m_vSliceCUDataLink.resize(numSlices);
+  UInt startAddr, endAddr, firstCUInStartLCU, startLCU, endLCU, lastCUInEndLCU, uiAddr;
+  UInt LPelX, TPelY, LCUX, LCUY;
+  UInt currSU;
+  UInt startSU, endSU;
+  for(Int s=0; s< numSlices; s++)
+  {
+    //1st step: decide the real start address
+    startAddr = sliceStartAddress[s];
+    endAddr   = sliceStartAddress[s+1] -1;
+    startLCU            = startAddr / maxNumSUInLCU;
+    firstCUInStartLCU   = startAddr % maxNumSUInLCU;
+    endLCU              = endAddr   / maxNumSUInLCU;
+    lastCUInEndLCU      = endAddr   % maxNumSUInLCU;
+    uiAddr = m_apcPicSym->getCUOrderMap(startLCU);
+    LCUX      = getCU(uiAddr)->getCUPelX();
+    LCUY      = getCU(uiAddr)->getCUPelY();
+    LPelX     = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[firstCUInStartLCU] ];
+    TPelY     = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[firstCUInStartLCU] ];
+    currSU    = firstCUInStartLCU;
+    Bool bMoveToNextLCU = false;
+    Bool bSliceInOneLCU = (startLCU == endLCU);
+    while(!( LPelX < picWidth ) || !( TPelY < picHeight ))
+    {
+      currSU ++;
+      if(bSliceInOneLCU)
+      {
+        if(currSU > lastCUInEndLCU)
+        {
+          m_pbValidSlice[s] = false;
+          break;
+        }
+      }
+      if(currSU >= maxNumSUInLCU )
+      {
+        bMoveToNextLCU = true;
+        break;
+      }
+      LPelX = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[currSU] ];
+      TPelY = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[currSU] ];
+    }
+    if(!m_pbValidSlice[s])
+    {
+      continue;
+    }
+    if(currSU != firstCUInStartLCU)
+    {
+      if(!bMoveToNextLCU)
+      {
+        firstCUInStartLCU = currSU;
+      }
+      else
+      {
+        startLCU++;
+        firstCUInStartLCU = 0;
+        assert( startLCU < getNumCUsInFrame());
+      }
+      assert(startLCU*maxNumSUInLCU + firstCUInStartLCU < endAddr);
+    }
+    //2nd step: assign NonDBFilterInfo to each processing block
+    for(UInt i= startLCU; i <= endLCU; i++)
+    {
+      startSU = (i == startLCU)?(firstCUInStartLCU):(0);
+      endSU   = (i == endLCU  )?(lastCUInEndLCU   ):(maxNumSUInLCU -1);
+      uiAddr = m_apcPicSym->getCUOrderMap(i);
+      Int iTileID= m_apcPicSym->getTileIdxMap(uiAddr);
+      TComDataCU* pcCU = getCU(uiAddr);
+      m_vSliceCUDataLink[s].push_back(pcCU);
+      createNonDBFilterInfoLCU(iTileID, s, pcCU, startSU, endSU, m_sliceGranularityForNDBFilter, picWidth, picHeight);
+    }
+  }
+  //step 3: border availability
+  for(Int s=0; s< numSlices; s++)
+  {
+    if(!m_pbValidSlice[s])
+    {
+      continue;
+    }
+    for(Int i=0; i< m_vSliceCUDataLink[s].size(); i++)
+    {
+      TComDataCU* pcCU = m_vSliceCUDataLink[s][i];
+      uiAddr = pcCU->getAddr();
+      if(pcCU->getPic()==0)
+      {
+        continue;
+      }
+      Int iTileID= m_apcPicSym->getTileIdxMap(uiAddr);
+      Bool bTopTileBoundary = false, bDownTileBoundary= false, bLeftTileBoundary= false, bRightTileBoundary= false;
+      if(m_bIndependentTileBoundaryForNDBFilter)
+      {
+        //left
+        if( uiAddr % numLCUsInPicWidth != 0)
+        {
+          bLeftTileBoundary = ( m_apcPicSym->getTileIdxMap(uiAddr -1) != iTileID )?true:false;
+        }
+        //right
+        if( (uiAddr % numLCUsInPicWidth) != (numLCUsInPicWidth -1) )
+        {
+          bRightTileBoundary = ( m_apcPicSym->getTileIdxMap(uiAddr +1) != iTileID)?true:false;
+        }
+        //top
+        if( uiAddr >= numLCUsInPicWidth)
+        {
+          bTopTileBoundary = (m_apcPicSym->getTileIdxMap(uiAddr - numLCUsInPicWidth) !=  iTileID )?true:false;
+        }
+        //down
+        if( uiAddr + numLCUsInPicWidth < numLCUInPic )
+        {
+          bDownTileBoundary = (m_apcPicSym->getTileIdxMap(uiAddr + numLCUsInPicWidth) != iTileID)?true:false;
+        }
+      }
+      pcCU->setNDBFilterBlockBorderAvailability(numLCUsInPicWidth, numLCUsInPicHeight, maxNumSUInLCUWidth, maxNumSUInLCUHeight,picWidth, picHeight
+        , *LFCrossSliceBoundary
+        ,bTopTileBoundary, bDownTileBoundary, bLeftTileBoundary, bRightTileBoundary
+        ,m_bIndependentTileBoundaryForNDBFilter);
+    }
+  }
+  if( m_bIndependentSliceBoundaryForNDBFilter || m_bIndependentTileBoundaryForNDBFilter)
+  {
+    m_pNDBFilterYuvTmp = new TComPicYuv();
+    m_pNDBFilterYuvTmp->create(picWidth, picHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
+  }
+}
+/** Create non-deblocked filter information for LCU
+ * \param tileID tile index
+ * \param sliceID slice index
+ * \param pcCU CU data pointer
+ * \param startSU start SU index in LCU
+ * \param endSU end SU index in LCU
+ * \param sliceGranularyDepth slice granularity
+ * \param picWidth picture width
+ * \param picHeight picture height
+ */
+Void TComPic::createNonDBFilterInfoLCU(Int tileID, Int sliceID, TComDataCU* pcCU, UInt startSU, UInt endSU, Int sliceGranularyDepth, UInt picWidth, UInt picHeight)
+{
+  UInt LCUX          = pcCU->getCUPelX();
+  UInt LCUY          = pcCU->getCUPelY();
+  Int* pCUSliceMap    = pcCU->getSliceSUMap();
+  UInt maxNumSUInLCU = getNumPartInCU();
+  UInt maxNumSUInSGU = maxNumSUInLCU >> (sliceGranularyDepth << 1);
+  UInt maxNumSUInLCUWidth = getNumPartInWidth();
+  UInt LPelX, TPelY;
+  UInt currSU;
+  //get the number of valid NBFilterBLock
+  currSU   = startSU;
+  while(currSU <= endSU)
+  {
+    LPelX = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[currSU] ];
+    TPelY = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[currSU] ];
+    while(!( LPelX < picWidth ) || !( TPelY < picHeight ))
+    {
+      currSU += maxNumSUInSGU;
+      if(currSU >= maxNumSUInLCU || currSU > endSU)
+      {
+        break;
+      }
+      LPelX = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[currSU] ];
+      TPelY = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[currSU] ];
+    }
+    if(currSU >= maxNumSUInLCU || currSU > endSU)
+    {
+      break;
+    }
+    NDBFBlockInfo NDBFBlock;
+    NDBFBlock.tileID  = tileID;
+    NDBFBlock.sliceID = sliceID;
+    NDBFBlock.posY    = TPelY;
+    NDBFBlock.posX    = LPelX;
+    NDBFBlock.startSU = currSU;
+    UInt uiLastValidSU  = currSU;
+    UInt uiIdx, uiLPelX_su, uiTPelY_su;
+    for(uiIdx = currSU; uiIdx < currSU + maxNumSUInSGU; uiIdx++)
+    {
+      if(uiIdx > endSU)
+      {
+        break;
+      }
+      uiLPelX_su   = LCUX + g_auiRasterToPelX[ g_auiZscanToRaster[uiIdx] ];
+      uiTPelY_su   = LCUY + g_auiRasterToPelY[ g_auiZscanToRaster[uiIdx] ];
+      if( !(uiLPelX_su < picWidth ) || !( uiTPelY_su < picHeight ))
+      {
+        continue;
+      }
+      pCUSliceMap[uiIdx] = sliceID;
+      uiLastValidSU = uiIdx;
+    }
+    NDBFBlock.endSU = uiLastValidSU;
+    UInt rTLSU = g_auiZscanToRaster[ NDBFBlock.startSU ];
+    UInt rBRSU = g_auiZscanToRaster[ NDBFBlock.endSU   ];
+    NDBFBlock.widthSU  = (rBRSU % maxNumSUInLCUWidth) - (rTLSU % maxNumSUInLCUWidth)+ 1;
+    NDBFBlock.heightSU = (UInt)(rBRSU / maxNumSUInLCUWidth) - (UInt)(rTLSU / maxNumSUInLCUWidth)+ 1;
+    NDBFBlock.width    = NDBFBlock.widthSU  * getMinCUWidth();
+    NDBFBlock.height   = NDBFBlock.heightSU * getMinCUHeight();
+    pcCU->getNDBFilterBlocks()->push_back(NDBFBlock);
+    currSU += maxNumSUInSGU;
+  }
+}
+/** destroy non-deblocked filter information for LCU
+ */
+Void TComPic::destroyNonDBFilterInfo()
+{
+  if(m_pbValidSlice != NULL)
+  {
+    delete[] m_pbValidSlice;
+    m_pbValidSlice = NULL;
+  }
+  if(m_pSliceSUMap != NULL)
+  {
+    delete[] m_pSliceSUMap;
+    m_pSliceSUMap = NULL;
+  }
+  for( UInt CUAddr = 0; CUAddr < getNumCUsInFrame() ; CUAddr++ )
+  {
+    TComDataCU* pcCU = getCU( CUAddr );
+    pcCU->getNDBFilterBlocks()->clear();
+  }
+  if( m_bIndependentSliceBoundaryForNDBFilter || m_bIndependentTileBoundaryForNDBFilter)
+  {
+    m_pNDBFilterYuvTmp->destroy();
+    delete m_pNDBFilterYuvTmp;
+    m_pNDBFilterYuvTmp = NULL;
+  }
+}
+Bool  TComPic::getSAOMergeAvailability(Int currAddr, Int mergeAddr)
+{
+  Bool mergeCtbInSliceSeg = (mergeAddr >= getPicSym()->getCUOrderMap(getCU(currAddr)->getSlice()->getSliceCurStartCUAddr()/getNumPartInCU()));
+  Bool mergeCtbInTile     = (getPicSym()->getTileIdxMap(mergeAddr) == getPicSym()->getTileIdxMap(currAddr));
+  return (mergeCtbInSliceSeg && mergeCtbInTile);
+}
 #if H_MV
 Void TComPic::print( Bool legend )

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPic.h

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Bool                  m_bNeededForOutput;
   UInt                  m_uiCurrSliceIdx;         // Index of current slice
-  Int*                  m_pSliceSUMap;
-  Bool*                 m_pbValidSlice;
-  Int                   m_sliceGranularityForNDBFilter;
-  Bool                  m_bIndependentSliceBoundaryForNDBFilter;
-  Bool                  m_bIndependentTileBoundaryForNDBFilter;
-  TComPicYuv*           m_pNDBFilterYuvTmp;    //!< temporary picture buffer when non-cross slice/tile boundary in-loop filtering is enabled
   Bool                  m_bCheckLTMSB;
 …
   Window&       getConformanceWindow()  { return m_conformanceWindow; }
   Window&       getDefDisplayWindow()   { return m_defaultDisplayWindow; }
-  Void          createNonDBFilterInfo   (std::vector<Int> sliceStartAddress, Int sliceGranularityDepth
-                                        ,std::vector<Bool>* LFCrossSliceBoundary
-                                        ,Int  numTiles = 1
-                                        ,Bool bNDBFilterCrossTileBoundary = true);
-  Void          createNonDBFilterInfoLCU(Int tileID, Int sliceID, TComDataCU* pcCU, UInt startSU, UInt endSU, Int sliceGranularyDepth, UInt picWidth, UInt picHeight);
-  Void          destroyNonDBFilterInfo();
-  Bool          getValidSlice                                  (Int sliceID)  {return m_pbValidSlice[sliceID];}
-  Bool          getIndependentSliceBoundaryForNDBFilter        ()             {return m_bIndependentSliceBoundaryForNDBFilter;}
-  Bool          getIndependentTileBoundaryForNDBFilter         ()             {return m_bIndependentTileBoundaryForNDBFilter; }
-  TComPicYuv*   getYuvPicBufferForIndependentBoundaryProcessing()             {return m_pNDBFilterYuvTmp;}
-  std::vector<TComDataCU*>& getOneSliceCUDataForNDBFilter      (Int sliceID) { return m_vSliceCUDataLink[sliceID];}

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPicSym.cpp

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 ,m_puiTileIdxMap(NULL)
 ,m_puiInverseCUOrderMap(NULL)
+,m_saoBlkParams(NULL)
 {};
 …
     m_puiInverseCUOrderMap[i] = i;
+  }
-  m_saoParam = NULL;
+}
 …
   m_puiInverseCUOrderMap = NULL;
+  if (m_saoParam)
+  {
+    TComSampleAdaptiveOffset::freeSaoParam(m_saoParam);
+    delete m_saoParam;
+    m_saoParam = NULL;
+  if(m_saoBlkParams)
+  {
+    delete[] m_saoBlkParams; m_saoBlkParams = NULL;
+  }
+}
 …
+}
+Void TComPicSym::allocSaoParam(TComSampleAdaptiveOffset *sao)
+{
+  m_saoParam = new SAOParam;
+  sao->allocSaoParam(m_saoParam);
+Void TComPicSym::deriveLoopFilterBoundaryAvailibility(Int ctu,
+                                                      Bool& isLeftAvail,
+                                                      Bool& isRightAvail,
+                                                      Bool& isAboveAvail,
+                                                      Bool& isBelowAvail,
+                                                      Bool& isAboveLeftAvail,
+                                                      Bool& isAboveRightAvail,
+                                                      Bool& isBelowLeftAvail,
+                                                      Bool& isBelowRightAvail
+                                                      )
+{
+  isLeftAvail      = (ctu % m_uiWidthInCU != 0);
+  isRightAvail     = (ctu % m_uiWidthInCU != m_uiWidthInCU-1);
+  isAboveAvail     = (ctu >= m_uiWidthInCU );
+  isBelowAvail     = (ctu <  m_uiNumCUsInFrame - m_uiWidthInCU);
+  isAboveLeftAvail = (isAboveAvail && isLeftAvail);
+  isAboveRightAvail= (isAboveAvail && isRightAvail);
+  isBelowLeftAvail = (isBelowAvail && isLeftAvail);
+  isBelowRightAvail= (isBelowAvail && isRightAvail);
+  Bool isLoopFiltAcrossTilePPS = getCU(ctu)->getSlice()->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
+  {
+    TComDataCU* ctuCurr  = getCU(ctu);
+    TComDataCU* ctuLeft  = isLeftAvail ?getCU(ctu-1):NULL;
+    TComDataCU* ctuRight = isRightAvail?getCU(ctu+1):NULL;
+    TComDataCU* ctuAbove = isAboveAvail?getCU(ctu-m_uiWidthInCU):NULL;
+    TComDataCU* ctuBelow = isBelowAvail?getCU(ctu+m_uiWidthInCU):NULL;
+    TComDataCU* ctuAboveLeft  = isAboveLeftAvail ? getCU(ctu-m_uiWidthInCU-1):NULL;
+    TComDataCU* ctuAboveRigtht= isAboveRightAvail? getCU(ctu-m_uiWidthInCU+1):NULL;
+    TComDataCU* ctuBelowLeft  = isBelowLeftAvail ? getCU(ctu+m_uiWidthInCU-1):NULL;
+    TComDataCU* ctuBelowRight = isBelowRightAvail? getCU(ctu+m_uiWidthInCU+1):NULL;
+    {
+      //left
+      if(ctuLeft != NULL)
+      {
+        isLeftAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuLeft->getSlice()->getSliceCurStartCUAddr())?ctuCurr->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //above
+      if(ctuAbove != NULL)
+      {
+        isAboveAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuAbove->getSlice()->getSliceCurStartCUAddr())?ctuCurr->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //right
+      if(ctuRight != NULL)
+      {
+        isRightAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuRight->getSlice()->getSliceCurStartCUAddr())?ctuRight->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //below
+      if(ctuBelow != NULL)
+      {
+        isBelowAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuBelow->getSlice()->getSliceCurStartCUAddr())?ctuBelow->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //above-left
+      if(ctuAboveLeft != NULL)
+      {
+        isAboveLeftAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuAboveLeft->getSlice()->getSliceCurStartCUAddr())?ctuCurr->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //below-right
+      if(ctuBelowRight != NULL)
+{
+        isBelowRightAvail = (ctuCurr->getSlice()->getSliceCurStartCUAddr() != ctuBelowRight->getSlice()->getSliceCurStartCUAddr())?ctuBelowRight->getSlice()->getLFCrossSliceBoundaryFlag():true;
+      }
+      //above-right
+      if(ctuAboveRigtht != NULL)
+      {
+        Int curSliceStartEncOrder  = ctuCurr->getSlice()->getSliceCurStartCUAddr();
+        Int aboveRigthtSliceStartEncOrder = ctuAboveRigtht->getSlice()->getSliceCurStartCUAddr();
+        isAboveRightAvail = (curSliceStartEncOrder == aboveRigthtSliceStartEncOrder)?(true):
+          (
+          (curSliceStartEncOrder > aboveRigthtSliceStartEncOrder)?(ctuCurr->getSlice()->getLFCrossSliceBoundaryFlag())
+          :(ctuAboveRigtht->getSlice()->getLFCrossSliceBoundaryFlag())
+          );
+      }
+      //below-left
+      if(ctuBelowLeft != NULL)
+      {
+        Int curSliceStartEncOrder  = ctuCurr->getSlice()->getSliceCurStartCUAddr();
+        Int belowLeftSliceStartEncOrder = ctuBelowLeft->getSlice()->getSliceCurStartCUAddr();
+        isBelowLeftAvail = (curSliceStartEncOrder == belowLeftSliceStartEncOrder)?(true):
+          (
+          (curSliceStartEncOrder > belowLeftSliceStartEncOrder)?(ctuCurr->getSlice()->getLFCrossSliceBoundaryFlag())
+          :(ctuBelowLeft->getSlice()->getLFCrossSliceBoundaryFlag())
+          );
+      }
+    }
+    if(!isLoopFiltAcrossTilePPS)
+    {
+      isLeftAvail      = (!isLeftAvail      ) ?false:(getTileIdxMap( ctuLeft->getAddr()         ) == getTileIdxMap( ctu ));
+      isAboveAvail     = (!isAboveAvail     ) ?false:(getTileIdxMap( ctuAbove->getAddr()        ) == getTileIdxMap( ctu ));
+      isRightAvail     = (!isRightAvail     ) ?false:(getTileIdxMap( ctuRight->getAddr()        ) == getTileIdxMap( ctu ));
+      isBelowAvail     = (!isBelowAvail     ) ?false:(getTileIdxMap( ctuBelow->getAddr()        ) == getTileIdxMap( ctu ));
+      isAboveLeftAvail = (!isAboveLeftAvail ) ?false:(getTileIdxMap( ctuAboveLeft->getAddr()    ) == getTileIdxMap( ctu ));
+      isAboveRightAvail= (!isAboveRightAvail) ?false:(getTileIdxMap( ctuAboveRigtht->getAddr()  ) == getTileIdxMap( ctu ));
+      isBelowLeftAvail = (!isBelowLeftAvail ) ?false:(getTileIdxMap( ctuBelowLeft->getAddr()    ) == getTileIdxMap( ctu ));
+      isBelowRightAvail= (!isBelowRightAvail) ?false:(getTileIdxMap( ctuBelowRight->getAddr()   ) == getTileIdxMap( ctu ));
+    }
+  }
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPicSym.h

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   UInt*         m_puiInverseCUOrderMap;
   SAOParam *m_saoParam;
+  SAOBlkParam *m_saoBlkParams;
 public:
   Void        create  ( Int iPicWidth, Int iPicHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth );
 …
   Void         xInitTiles();
   UInt         xCalculateNxtCUAddr( UInt uiCurrCUAddr );
+  Void allocSaoParam(TComSampleAdaptiveOffset *sao);
+  SAOParam *getSaoParam() { return m_saoParam; }
+  SAOBlkParam* getSAOBlkParam() { return m_saoBlkParams;}
+  Void deriveLoopFilterBoundaryAvailibility(Int ctu, Bool& isLeftAvail,Bool& isRightAvail,Bool& isAboveAvail,Bool& isBelowAvail,Bool& isAboveLeftAvail,Bool& isAboveRightAvail,Bool& isBelowLeftAvail,Bool& isBelowRightAvail);
 };// END CLASS DEFINITION TComPicSym

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPicYuv.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPicYuv.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPicYuvMD5.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPrediction.cpp

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComPrediction.h

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRdCost.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 Double TComRdCost::m_dDisparityCoeff = 1.0;
 #endif
 TComRdCost::TComRdCost()
+{
 …
+  }
 #endif
   // initialize
   rcDistParam.iSubShift  = 0;
 …
+  }
 #endif
   // initialize
   rcDistParam.iSubShift  = 0;
 …
 // Setting the Distortion Parameter for Inter (subpel ME with step)
-#if NS_HAD
-Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME, Bool bUseNSHAD )
-#else
 Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME )
-#endif
+{
   // set Original & Curr Pointer / Stride
 …
   rcDistParam.iCols    = pcPatternKey->getROIYWidth();
   rcDistParam.iRows    = pcPatternKey->getROIYHeight();
-#if NS_HAD
-  rcDistParam.bUseNSHAD = bUseNSHAD;
-#endif
   // set distortion function
 …
+  }
 #endif
   // initialize
   rcDistParam.iSubShift  = 0;
 …
 Void
-#if NS_HAD
-TComRdCost::setDistParam( DistParam& rcDP, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard, Bool bUseNSHAD )
-#else
 TComRdCost::setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard )
-#endif
+{
   rcDP.pOrg       = p1;
 …
   rcDP.bitDepth   = bitDepth;
   rcDP.DistFunc   = m_afpDistortFunc[ ( bHadamard ? DF_HADS : DF_SADS ) + g_aucConvertToBit[ iWidth ] + 1 ];
 #if H_3D_DBBP
   if( m_bUseMask )
 …
     rcDP.DistFunc = (bHadamard)?TComRdCost::xGetMaskedHADs:TComRdCost::xGetMaskedSAD;
+  }
-#endif
-#if NS_HAD
-  rcDP.bUseNSHAD  = bUseNSHAD;
 #endif
+}
 …
+    }
+  }
+  else if ( ( (iWidth % 4) == 0 ) && ( (iHeight % 4) == 0 ) )
+  {
+  else
+  {
+    assert(iWidth % 4 == 0 && iHeight % 4 == 0);
     for ( y=0; y<iHeight; y+= 4 )
+    {
 …
+    }
+  }
-  else
+  {
-    for ( y=0; y<iHeight; y+= 2 )
+    {
-      for ( x=0; x<iWidth; x+= 2 )
+      {
-        uiSum += xCalcHADs8x8( &pi0[x], &pi1[x], iStride0, iStride1, 1 );
+      }
-      pi0 += iStride0*2;
-      pi1 += iStride1*2;
+    }
+  }
   return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8);
 …
-#if WEIGHTED_CHROMA_DISTORTION
 UInt TComRdCost::getDistPart(Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, TextType eText, DFunc eDFunc)
-#else
-UInt TComRdCost::getDistPart(Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc )
-#endif
+{
   DistParam cDtParam;
 …
   cDtParam.bUseSDCMRSAD = false;
 #endif
-#if WEIGHTED_CHROMA_DISTORTION
   if (eText == TEXT_CHROMA_U)
+  {
 …
     return cDtParam.DistFunc( &cDtParam );
+  }
-#else
-  return cDtParam.DistFunc( &cDtParam );
-#endif
+}
 #if H_3D_VSO
 …
 #endif
 #if (RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT) || KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
 UInt TComRdCost::getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height )
+{
 …
+}
 #endif
 // --------------------------------------------------------------------------------------------------------------------
 // SAD
 …
+}
-#if NS_HAD
-UInt TComRdCost::xCalcHADs16x4( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
+{
-  Int k, i, j, jj, sad=0;
-  Int diff[64], m1[4][16], m2[4][16];
-  assert( iStep == 1 );
-  for( k = 0; k < 64; k += 16 )
+  {
-    diff[k+0] = piOrg[0] - piCur[0];
-    diff[k+1] = piOrg[1] - piCur[1];
-    diff[k+2] = piOrg[2] - piCur[2];
-    diff[k+3] = piOrg[3] - piCur[3];
-    diff[k+4] = piOrg[4] - piCur[4];
-    diff[k+5] = piOrg[5] - piCur[5];
-    diff[k+6] = piOrg[6] - piCur[6];
-    diff[k+7] = piOrg[7] - piCur[7];
-    diff[k+8]  = piOrg[8]  - piCur[8] ;
-    diff[k+9]  = piOrg[9]  - piCur[9] ;
-    diff[k+10] = piOrg[10] - piCur[10];
-    diff[k+11] = piOrg[11] - piCur[11];
-    diff[k+12] = piOrg[12] - piCur[12];
-    diff[k+13] = piOrg[13] - piCur[13];
-    diff[k+14] = piOrg[14] - piCur[14];
-    diff[k+15] = piOrg[15] - piCur[15];
-    piCur += iStrideCur;
-    piOrg += iStrideOrg;
+  }
-  //horizontal
-  for (j=0; j < 4; j++)
+  {
-    jj = j << 4;
-    m2[j][0]  = diff[jj  ] + diff[jj+8];
-    m2[j][1]  = diff[jj+1] + diff[jj+9];
-    m2[j][2]  = diff[jj+2] + diff[jj+10];
-    m2[j][3]  = diff[jj+3] + diff[jj+11];
-    m2[j][4]  = diff[jj+4] + diff[jj+12];
-    m2[j][5]  = diff[jj+5] + diff[jj+13];
-    m2[j][6]  = diff[jj+6] + diff[jj+14];
-    m2[j][7]  = diff[jj+7] + diff[jj+15];
-    m2[j][8]  = diff[jj  ] - diff[jj+8];
-    m2[j][9]  = diff[jj+1] - diff[jj+9];
-    m2[j][10] = diff[jj+2] - diff[jj+10];
-    m2[j][11] = diff[jj+3] - diff[jj+11];
-    m2[j][12] = diff[jj+4] - diff[jj+12];
-    m2[j][13] = diff[jj+5] - diff[jj+13];
-    m2[j][14] = diff[jj+6] - diff[jj+14];
-    m2[j][15] = diff[jj+7] - diff[jj+15];
-    m1[j][0]  = m2[j][0]  + m2[j][4];
-    m1[j][1]  = m2[j][1]  + m2[j][5];
-    m1[j][2]  = m2[j][2]  + m2[j][6];
-    m1[j][3]  = m2[j][3]  + m2[j][7];
-    m1[j][4]  = m2[j][0]  - m2[j][4];
-    m1[j][5]  = m2[j][1]  - m2[j][5];
-    m1[j][6]  = m2[j][2]  - m2[j][6];
-    m1[j][7]  = m2[j][3]  - m2[j][7];
-    m1[j][8]  = m2[j][8]  + m2[j][12];
-    m1[j][9]  = m2[j][9]  + m2[j][13];
-    m1[j][10] = m2[j][10] + m2[j][14];
-    m1[j][11] = m2[j][11] + m2[j][15];
-    m1[j][12] = m2[j][8]  - m2[j][12];
-    m1[j][13] = m2[j][9]  - m2[j][13];
-    m1[j][14] = m2[j][10] - m2[j][14];
-    m1[j][15] = m2[j][11] - m2[j][15];
-    m2[j][0]  = m1[j][0]  + m1[j][2];
-    m2[j][1]  = m1[j][1]  + m1[j][3];
-    m2[j][2]  = m1[j][0]  - m1[j][2];
-    m2[j][3]  = m1[j][1]  - m1[j][3];
-    m2[j][4]  = m1[j][4]  + m1[j][6];
-    m2[j][5]  = m1[j][5]  + m1[j][7];
-    m2[j][6]  = m1[j][4]  - m1[j][6];
-    m2[j][7]  = m1[j][5]  - m1[j][7];
-    m2[j][8]  = m1[j][8]  + m1[j][10];
-    m2[j][9]  = m1[j][9]  + m1[j][11];
-    m2[j][10] = m1[j][8]  - m1[j][10];
-    m2[j][11] = m1[j][9]  - m1[j][11];
-    m2[j][12] = m1[j][12] + m1[j][14];
-    m2[j][13] = m1[j][13] + m1[j][15];
-    m2[j][14] = m1[j][12] - m1[j][14];
-    m2[j][15] = m1[j][13] - m1[j][15];
-    m1[j][0]  = m2[j][0]  + m2[j][1];
-    m1[j][1]  = m2[j][0]  - m2[j][1];
-    m1[j][2]  = m2[j][2]  + m2[j][3];
-    m1[j][3]  = m2[j][2]  - m2[j][3];
-    m1[j][4]  = m2[j][4]  + m2[j][5];
-    m1[j][5]  = m2[j][4]  - m2[j][5];
-    m1[j][6]  = m2[j][6]  + m2[j][7];
-    m1[j][7]  = m2[j][6]  - m2[j][7];
-    m1[j][8]  = m2[j][8]  + m2[j][9];
-    m1[j][9]  = m2[j][8]  - m2[j][9];
-    m1[j][10] = m2[j][10] + m2[j][11];
-    m1[j][11] = m2[j][10] - m2[j][11];
-    m1[j][12] = m2[j][12] + m2[j][13];
-    m1[j][13] = m2[j][12] - m2[j][13];
-    m1[j][14] = m2[j][14] + m2[j][15];
-    m1[j][15] = m2[j][14] - m2[j][15];
+  }
-  //vertical
-  for (i=0; i < 16; i++)
+  {
-    m2[0][i] = m1[0][i] + m1[2][i];
-    m2[1][i] = m1[1][i] + m1[3][i];
-    m2[2][i] = m1[0][i] - m1[2][i];
-    m2[3][i] = m1[1][i] - m1[3][i];
-    m1[0][i] = m2[0][i] + m2[1][i];
-    m1[1][i] = m2[0][i] - m2[1][i];
-    m1[2][i] = m2[2][i] + m2[3][i];
-    m1[3][i] = m2[2][i] - m2[3][i];
+  }
-  for (i = 0; i < 4; i++)
+  {
-    for (j = 0; j < 16; j++)
+    {
-      sad += abs(m1[i][j]);
+    }
+  }
-  sad=((sad+2)>>2);
-  return sad;
+}
-UInt TComRdCost::xCalcHADs4x16( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
+{
-  Int k, i, j, jj, sad=0;
-  Int diff[64], m1[16][4], m2[16][4], m3[16][4];
-  assert( iStep == 1 );
-  for( k = 0; k < 64; k += 4 )
+  {
-    diff[k+0] = piOrg[0] - piCur[0];
-    diff[k+1] = piOrg[1] - piCur[1];
-    diff[k+2] = piOrg[2] - piCur[2];
-    diff[k+3] = piOrg[3] - piCur[3];
-    piCur += iStrideCur;
-    piOrg += iStrideOrg;
+  }
-  //horizontal
-  for (j=0; j < 16; j++)
+  {
-    jj = j << 2;
-    m2[j][0] = diff[jj  ] + diff[jj+2];
-    m2[j][1] = diff[jj+1] + diff[jj+3];
-    m2[j][2] = diff[jj  ] - diff[jj+2];
-    m2[j][3] = diff[jj+1] - diff[jj+3];
-    m1[j][0] = m2[j][0] + m2[j][1];
-    m1[j][1] = m2[j][0] - m2[j][1];
-    m1[j][2] = m2[j][2] + m2[j][3];
-    m1[j][3] = m2[j][2] - m2[j][3];
+  }
-  //vertical
-  for (i=0; i < 4; i++)
+  {
-    m2[0][i]  = m1[0][i] + m1[8][i];
-    m2[1][i]  = m1[1][i] + m1[9][i];
-    m2[2][i]  = m1[2][i] + m1[10][i];
-    m2[3][i]  = m1[3][i] + m1[11][i];
-    m2[4][i]  = m1[4][i] + m1[12][i];
-    m2[5][i]  = m1[5][i] + m1[13][i];
-    m2[6][i]  = m1[6][i] + m1[14][i];
-    m2[7][i]  = m1[7][i] + m1[15][i];
-    m2[8][i]  = m1[0][i] - m1[8][i];
-    m2[9][i]  = m1[1][i] - m1[9][i];
-    m2[10][i] = m1[2][i] - m1[10][i];
-    m2[11][i] = m1[3][i] - m1[11][i];
-    m2[12][i] = m1[4][i] - m1[12][i];
-    m2[13][i] = m1[5][i] - m1[13][i];
-    m2[14][i] = m1[6][i] - m1[14][i];
-    m2[15][i] = m1[7][i] - m1[15][i];
-    m3[0][i]  = m2[0][i]  + m2[4][i];
-    m3[1][i]  = m2[1][i]  + m2[5][i];
-    m3[2][i]  = m2[2][i]  + m2[6][i];
-    m3[3][i]  = m2[3][i]  + m2[7][i];
-    m3[4][i]  = m2[0][i]  - m2[4][i];
-    m3[5][i]  = m2[1][i]  - m2[5][i];
-    m3[6][i]  = m2[2][i]  - m2[6][i];
-    m3[7][i]  = m2[3][i]  - m2[7][i];
-    m3[8][i]  = m2[8][i]  + m2[12][i];
-    m3[9][i]  = m2[9][i]  + m2[13][i];
-    m3[10][i] = m2[10][i] + m2[14][i];
-    m3[11][i] = m2[11][i] + m2[15][i];
-    m3[12][i] = m2[8][i]  - m2[12][i];
-    m3[13][i] = m2[9][i]  - m2[13][i];
-    m3[14][i] = m2[10][i] - m2[14][i];
-    m3[15][i] = m2[11][i] - m2[15][i];
-    m1[0][i]  = m3[0][i]  + m3[2][i];
-    m1[1][i]  = m3[1][i]  + m3[3][i];
-    m1[2][i]  = m3[0][i]  - m3[2][i];
-    m1[3][i]  = m3[1][i]  - m3[3][i];
-    m1[4][i]  = m3[4][i]  + m3[6][i];
-    m1[5][i]  = m3[5][i]  + m3[7][i];
-    m1[6][i]  = m3[4][i]  - m3[6][i];
-    m1[7][i]  = m3[5][i]  - m3[7][i];
-    m1[8][i]  = m3[8][i]  + m3[10][i];
-    m1[9][i]  = m3[9][i]  + m3[11][i];
-    m1[10][i] = m3[8][i]  - m3[10][i];
-    m1[11][i] = m3[9][i]  - m3[11][i];
-    m1[12][i] = m3[12][i] + m3[14][i];
-    m1[13][i] = m3[13][i] + m3[15][i];
-    m1[14][i] = m3[12][i] - m3[14][i];
-    m1[15][i] = m3[13][i] - m3[15][i];
-    m2[0][i]  = m1[0][i]  + m1[1][i];
-    m2[1][i]  = m1[0][i]  - m1[1][i];
-    m2[2][i]  = m1[2][i]  + m1[3][i];
-    m2[3][i]  = m1[2][i]  - m1[3][i];
-    m2[4][i]  = m1[4][i]  + m1[5][i];
-    m2[5][i]  = m1[4][i]  - m1[5][i];
-    m2[6][i]  = m1[6][i]  + m1[7][i];
-    m2[7][i]  = m1[6][i]  - m1[7][i];
-    m2[8][i]  = m1[8][i]  + m1[9][i];
-    m2[9][i]  = m1[8][i]  - m1[9][i];
-    m2[10][i] = m1[10][i] + m1[11][i];
-    m2[11][i] = m1[10][i] - m1[11][i];
-    m2[12][i] = m1[12][i] + m1[13][i];
-    m2[13][i] = m1[12][i] - m1[13][i];
-    m2[14][i] = m1[14][i] + m1[15][i];
-    m2[15][i] = m1[14][i] - m1[15][i];
+  }
-  for (i = 0; i < 16; i++)
+  {
-    for (j = 0; j < 4; j++)
+    {
-      sad += abs(m2[i][j]);
+    }
+  }
-  sad=((sad+2)>>2);
-  return sad;
+}
-#endif
 UInt TComRdCost::xGetHADs4( DistParam* pcDtParam )
+{
 …
   UInt uiSum = 0;
-#if NS_HAD
-  if( ( ( iRows % 8 == 0) && (iCols % 8 == 0) && ( iRows == iCols ) ) || ( ( iRows % 8 == 0 ) && (iCols % 8 == 0) && !pcDtParam->bUseNSHAD ) )
-#else
   if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
-#endif
+  {
     Int  iOffsetOrg = iStrideOrg<<3;
 …
+    }
+  }
-#if NS_HAD
-  else if ( ( iCols > 8 ) && ( iCols > iRows ) && pcDtParam->bUseNSHAD )
+  {
-    Int  iOffsetOrg = iStrideOrg<<2;
-    Int  iOffsetCur = iStrideCur<<2;
-    for ( y=0; y<iRows; y+= 4 )
+    {
-      for ( x=0; x<iCols; x+= 16 )
+      {
-        uiSum += xCalcHADs16x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
+      }
-      piOrg += iOffsetOrg;
-      piCur += iOffsetCur;
+    }
+  }
-  else if ( ( iRows > 8 ) && ( iCols < iRows ) && pcDtParam->bUseNSHAD )
+  {
-    Int  iOffsetOrg = iStrideOrg<<4;
-    Int  iOffsetCur = iStrideCur<<4;
-    for ( y=0; y<iRows; y+= 16 )
+    {
-      for ( x=0; x<iCols; x+= 4 )
+      {
-        uiSum += xCalcHADs4x16( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
+      }
-      piOrg += iOffsetOrg;
-      piCur += iOffsetCur;
+    }
+  }
-#endif
   else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
+  {

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRdCost.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   UInt            uiComp;           // uiComp = 0 (luma Y), 1 (chroma U), 2 (chroma V)
-#if NS_HAD
-  Bool            bUseNSHAD;
-#endif
   // (vertical) subsampling shift (for reducing complexity)
   // - 0 = no subsampling, 1 = even rows, 2 = every 4th, etc.
 …
     iSubShift = 0;
     bitDepth = 0;
-#if NS_HAD
-    bUseNSHAD = false;
-#endif
 #if H_3D_VSO
     // SAIT_VSO_EST_A0033
 …
 #endif
-#if WEIGHTED_CHROMA_DISTORTION
   Double                  m_cbDistortionWeight;
   Double                  m_crDistortionWeight;
-#endif
   Double                  m_dLambda;
   Double                  m_sqrtLambda;
 …
-#if WEIGHTED_CHROMA_DISTORTION
   Void    setCbDistortionWeight      ( Double cbDistortionWeight) { m_cbDistortionWeight = cbDistortionWeight; };
   Void    setCrDistortionWeight      ( Double crDistortionWeight) { m_crDistortionWeight = crDistortionWeight; };
-#endif
   Void    setLambda      ( Double dLambda );
   Void    setFrameLambda ( Double dLambda ) { m_dFrameLambda = dLambda; }
 …
 #endif
-#if RATE_CONTROL_LAMBDA_DOMAIN
   Double  getLambda() { return m_dLambda; }
-#if M0036_RC_IMPROVEMENT
   Double  getChromaWeight () {return((m_cbDistortionWeight+m_crDistortionWeight)/2.0);}
-#endif
-#endif
   // Distortion Functions
 …
   Void    setDistParam( UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc, DistParam& rcDistParam );
   Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride,            DistParam& rcDistParam );
-#if NS_HAD
-  Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false, Bool bUseNSHAD=false );
-  Void    setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard = false, Bool bUseNSHAD=false );
-#else
   Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false );
   Void    setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard = false );
-#endif
 #if H_3D_DBBP
 …
   static UInt xCalcHADs4x4      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
   static UInt xCalcHADs8x8      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
-#if NS_HAD
-  static UInt xCalcHADs16x4     ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
-  static UInt xCalcHADs4x16     ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
-#endif
 #if H_3D_DBBP
   static UInt xGetMaskedSSE     ( DistParam* pcDtParam );
 …
 public:
-#if WEIGHTED_CHROMA_DISTORTION
   UInt   getDistPart(Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, TextType eText = TEXT_LUMA, DFunc eDFunc = DF_SSE );
+#else
+  UInt   getDistPart(Int bitDepth, Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc = DF_SSE );
+#endif
+#if (RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT) || KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
   UInt   getSADPart ( Int bitDepth, Pel* pelCur, Int curStride,  Pel* pelOrg, Int orgStride, UInt width, UInt height );
 #endif

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRdCostWeightPrediction.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRdCostWeightPrediction.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRom.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 const UInt g_uiGroupIdx[ 32 ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
-// Rice parameters for absolute transform levels
-const UInt g_auiGoRiceRange[5] =
+{
-, 14, 26, 46, 78
-};
-const UInt g_auiGoRicePrefixLen[5] =
+{
-, 7, 6, 5, 4
-};
 Void initSigLastScan(UInt* pBuffD, UInt* pBuffH, UInt* pBuffV, Int iWidth, Int iHeight)
+{

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComRom.h

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 extern const UInt   g_uiMinInGroup[ 10 ];
-extern const UInt   g_auiGoRiceRange[5];                  //!< maximum value coded with Rice codes
-extern const UInt   g_auiGoRicePrefixLen[5];              //!< prefix length for each maximum value
 extern const UInt   g_sigLastScan8x8[ 3 ][ 4 ];           //!< coefficient group scan order for 8x8 TUs
 extern       UInt   g_sigLastScanCG32x32[ 64 ];

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComSampleAdaptiveOffset.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+ * Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 //! \ingroup TLibCommon
 //! \{
+SAOParam::~SAOParam()
+{
+  for (Int i = 0 ; i<3; i++)
+  {
+    if (psSaoPart[i])
+    {
+      delete [] psSaoPart[i];
+    }
+  }
+}
+// ====================================================================================================================
+// Tables
+// ====================================================================================================================
+UInt g_saoMaxOffsetQVal[NUM_SAO_COMPONENTS];
+SAOOffset::SAOOffset()
+{
+  reset();
+}
+SAOOffset::~SAOOffset()
+{
+}
+Void SAOOffset::reset()
+{
+  modeIdc = SAO_MODE_OFF;
+  typeIdc = -1;
+  typeAuxInfo = -1;
+  ::memset(offset, 0, sizeof(Int)* MAX_NUM_SAO_CLASSES);
+}
+const SAOOffset& SAOOffset::operator= (const SAOOffset& src)
+{
+  modeIdc = src.modeIdc;
+  typeIdc = src.typeIdc;
+  typeAuxInfo = src.typeAuxInfo;
+  ::memcpy(offset, src.offset, sizeof(Int)* MAX_NUM_SAO_CLASSES);
+  return *this;
+}
+SAOBlkParam::SAOBlkParam()
+{
+  reset();
+}
+SAOBlkParam::~SAOBlkParam()
+{
+}
+Void SAOBlkParam::reset()
+{
+  for(Int compIdx=0; compIdx< 3; compIdx++)
+  {
+    offsetParam[compIdx].reset();
+  }
+}
+const SAOBlkParam& SAOBlkParam::operator= (const SAOBlkParam& src)
+{
+  for(Int compIdx=0; compIdx< 3; compIdx++)
+  {
+    offsetParam[compIdx] = src.offsetParam[compIdx];
+  }
+  return *this;
+}
 TComSampleAdaptiveOffset::TComSampleAdaptiveOffset()
+{
+  m_pClipTable = NULL;
+  m_pClipTableBase = NULL;
+  m_pChromaClipTable = NULL;
+  m_pChromaClipTableBase = NULL;
+  m_iOffsetBo = NULL;
+  m_iChromaOffsetBo = NULL;
+  m_lumaTableBo = NULL;
+  m_chromaTableBo = NULL;
+  m_iUpBuff1 = NULL;
+  m_iUpBuff2 = NULL;
+  m_iUpBufft = NULL;
+  ipSwap = NULL;
+  m_pTmpU1 = NULL;
+  m_pTmpU2 = NULL;
+  m_pTmpL1 = NULL;
+  m_pTmpL2 = NULL;
+}
+  m_tempPicYuv = NULL;
+  for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+  {
+    m_offsetClipTable[compIdx] = NULL;
+  }
+  m_signTable = NULL;
+  m_lineBufWidth = 0;
+  m_signLineBuf1 = NULL;
+  m_signLineBuf2 = NULL;
+}
 TComSampleAdaptiveOffset::~TComSampleAdaptiveOffset()
+{
+}
+const Int TComSampleAdaptiveOffset::m_aiNumCulPartsLevel[5] =
+{
+,   //level 0
+,   //level 1
+,  //level 2
+,  //level 3
+, //level 4
+};
+const UInt TComSampleAdaptiveOffset::m_auiEoTable[9] =
+{
+, //0
+, //1
+, //2
+, //3
+, //4
+, //5
+, //6
+, //7
+};
+const Int TComSampleAdaptiveOffset::m_iNumClass[MAX_NUM_SAO_TYPE] =
+{
+  SAO_EO_LEN,
+  SAO_EO_LEN,
+  SAO_EO_LEN,
+  SAO_EO_LEN,
+  SAO_BO_LEN
+};
+const UInt TComSampleAdaptiveOffset::m_uiMaxDepth = SAO_MAX_DEPTH;
+/** convert Level Row Col to Idx
+ * \param   level,  row,  col
+ */
+Int  TComSampleAdaptiveOffset::convertLevelRowCol2Idx(Int level, Int row, Int col)
+{
+  Int idx;
+  if (level == 0)
+  {
+    idx = 0;
+  }
+  else if (level == 1)
+  {
+    idx = 1 + row*2 + col;
+  }
+  else if (level == 2)
+  {
+    idx = 5 + row*4 + col;
+  }
+  else if (level == 3)
+  {
+    idx = 21 + row*8 + col;
+  }
+  else // (level == 4)
+  {
+    idx = 85 + row*16 + col;
+  }
+  return idx;
+}
+/** create SampleAdaptiveOffset memory.
+ * \param
+ */
+Void TComSampleAdaptiveOffset::create( UInt uiSourceWidth, UInt uiSourceHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight )
+{
+  m_iPicWidth  = uiSourceWidth;
+  m_iPicHeight = uiSourceHeight;
+  m_uiMaxCUWidth  = uiMaxCUWidth;
+  m_uiMaxCUHeight = uiMaxCUHeight;
+  m_iNumCuInWidth  = m_iPicWidth / m_uiMaxCUWidth;
+  m_iNumCuInWidth += ( m_iPicWidth % m_uiMaxCUWidth ) ? 1 : 0;
+  m_iNumCuInHeight  = m_iPicHeight / m_uiMaxCUHeight;
+  m_iNumCuInHeight += ( m_iPicHeight % m_uiMaxCUHeight ) ? 1 : 0;
+  Int iMaxSplitLevelHeight = (Int)(logf((Float)m_iNumCuInHeight)/logf(2.0));
+  Int iMaxSplitLevelWidth  = (Int)(logf((Float)m_iNumCuInWidth )/logf(2.0));
+  m_uiMaxSplitLevel = (iMaxSplitLevelHeight < iMaxSplitLevelWidth)?(iMaxSplitLevelHeight):(iMaxSplitLevelWidth);
+  m_uiMaxSplitLevel = (m_uiMaxSplitLevel< m_uiMaxDepth)?(m_uiMaxSplitLevel):(m_uiMaxDepth);
+  /* various structures are overloaded to store per component data.
+   * m_iNumTotalParts must allow for sufficient storage in any allocated arrays */
+  m_iNumTotalParts  = max(3,m_aiNumCulPartsLevel[m_uiMaxSplitLevel]);
+  UInt uiPixelRangeY = 1 << g_bitDepthY;
+  UInt uiBoRangeShiftY = g_bitDepthY - SAO_BO_BITS;
+  m_lumaTableBo = new Pel [uiPixelRangeY];
+  for (Int k2=0; k2<uiPixelRangeY; k2++)
+  {
+    m_lumaTableBo[k2] = 1 + (k2>>uiBoRangeShiftY);
+  }
+  UInt uiPixelRangeC = 1 << g_bitDepthC;
+  UInt uiBoRangeShiftC = g_bitDepthC - SAO_BO_BITS;
+  m_chromaTableBo = new Pel [uiPixelRangeC];
+  for (Int k2=0; k2<uiPixelRangeC; k2++)
+  {
+    m_chromaTableBo[k2] = 1 + (k2>>uiBoRangeShiftC);
+  }
+  m_iUpBuff1 = new Int[m_iPicWidth+2];
+  m_iUpBuff2 = new Int[m_iPicWidth+2];
+  m_iUpBufft = new Int[m_iPicWidth+2];
+  m_iUpBuff1++;
+  m_iUpBuff2++;
+  m_iUpBufft++;
+  Pel i;
+  UInt uiMaxY  = (1 << g_bitDepthY) - 1;;
+  UInt uiMinY  = 0;
+  Int iCRangeExt = uiMaxY>>1;
+  m_pClipTableBase = new Pel[uiMaxY+2*iCRangeExt];
+  m_iOffsetBo      = new Int[uiMaxY+2*iCRangeExt];
+  for(i=0;i<(uiMinY+iCRangeExt);i++)
+  {
+    m_pClipTableBase[i] = uiMinY;
+  }
+  for(i=uiMinY+iCRangeExt;i<(uiMaxY+  iCRangeExt);i++)
+  {
+    m_pClipTableBase[i] = i-iCRangeExt;
+  }
+  for(i=uiMaxY+iCRangeExt;i<(uiMaxY+2*iCRangeExt);i++)
+  {
+    m_pClipTableBase[i] = uiMaxY;
+  }
+  m_pClipTable = &(m_pClipTableBase[iCRangeExt]);
+  UInt uiMaxC  = (1 << g_bitDepthC) - 1;
+  UInt uiMinC  = 0;
+  Int iCRangeExtC = uiMaxC>>1;
+  m_pChromaClipTableBase = new Pel[uiMaxC+2*iCRangeExtC];
+  m_iChromaOffsetBo      = new Int[uiMaxC+2*iCRangeExtC];
+  for(i=0;i<(uiMinC+iCRangeExtC);i++)
+  {
+    m_pChromaClipTableBase[i] = uiMinC;
+  }
+  for(i=uiMinC+iCRangeExtC;i<(uiMaxC+  iCRangeExtC);i++)
+  {
+    m_pChromaClipTableBase[i] = i-iCRangeExtC;
+  }
+  for(i=uiMaxC+iCRangeExtC;i<(uiMaxC+2*iCRangeExtC);i++)
+  {
+    m_pChromaClipTableBase[i] = uiMaxC;
+  }
+  m_pChromaClipTable = &(m_pChromaClipTableBase[iCRangeExtC]);
+  m_pTmpL1 = new Pel [m_uiMaxCUHeight+1];
+  m_pTmpL2 = new Pel [m_uiMaxCUHeight+1];
+  m_pTmpU1 = new Pel [m_iPicWidth];
+  m_pTmpU2 = new Pel [m_iPicWidth];
+}
+/** destroy SampleAdaptiveOffset memory.
+ * \param
+ */
+  destroy();
+  if (m_signLineBuf1) delete[] m_signLineBuf1; m_signLineBuf1 = NULL;
+  if (m_signLineBuf2) delete[] m_signLineBuf2; m_signLineBuf2 = NULL;
+}
+Void TComSampleAdaptiveOffset::create( Int picWidth, Int picHeight, UInt maxCUWidth, UInt maxCUHeight, UInt maxCUDepth )
+{
+  destroy();
+  m_picWidth = picWidth;
+  m_picHeight= picHeight;
+  m_maxCUWidth= maxCUWidth;
+  m_maxCUHeight= maxCUHeight;
+  m_numCTUInWidth = (m_picWidth/m_maxCUWidth) + ((m_picWidth % m_maxCUWidth)?1:0);
+  m_numCTUInHeight= (m_picHeight/m_maxCUHeight) + ((m_picHeight % m_maxCUHeight)?1:0);
+  m_numCTUsPic = m_numCTUInHeight*m_numCTUInWidth;
+  //temporary picture buffer
+  if ( !m_tempPicYuv )
+  {
+    m_tempPicYuv = new TComPicYuv;
+    m_tempPicYuv->create( m_picWidth, m_picHeight, m_maxCUWidth, m_maxCUHeight, maxCUDepth );
+  }
+  //bit-depth related
+  for(Int compIdx =0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+  {
+    Int bitDepthSample = (compIdx == SAO_Y)?g_bitDepthY:g_bitDepthC;
+    m_offsetStepLog2  [compIdx] = max(bitDepthSample - MAX_SAO_TRUNCATED_BITDEPTH, 0);
+    g_saoMaxOffsetQVal[compIdx] = (1<<(min(bitDepthSample,MAX_SAO_TRUNCATED_BITDEPTH)-5))-1; //Table 9-32, inclusive
+  }
+  //look-up table for clipping
+  for(Int compIdx =0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+  {
+    Int bitDepthSample = (compIdx == SAO_Y)?g_bitDepthY:g_bitDepthC; //exclusive
+    Int maxSampleValue = (1<< bitDepthSample); //exclusive
+    Int maxOffsetValue = (g_saoMaxOffsetQVal[compIdx] << m_offsetStepLog2[compIdx]);
+    m_offsetClipTable[compIdx] = new Int[(maxSampleValue + maxOffsetValue -1)+ (maxOffsetValue)+1 ]; //positive & negative range plus 0
+    m_offsetClip[compIdx] = &(m_offsetClipTable[compIdx][maxOffsetValue]);
+    //assign clipped values
+    Int* offsetClipPtr = m_offsetClip[compIdx];
+    for(Int k=0; k< maxSampleValue; k++)
+    {
+      *(offsetClipPtr + k) = k;
+    }
+    for(Int k=0; k< maxOffsetValue; k++ )
+    {
+      *(offsetClipPtr + maxSampleValue+ k) = maxSampleValue-1;
+      *(offsetClipPtr -k -1 )              = 0;
+    }
+    if(compIdx == SAO_Y) //g_bitDepthY is always larger than or equal to g_bitDepthC
+    {
+      m_signTable = new Short[ 2*(maxSampleValue-1) + 1 ];
+      m_sign = &(m_signTable[maxSampleValue-1]);
+      m_sign[0] = 0;
+      for(Int k=1; k< maxSampleValue; k++)
+      {
+        m_sign[k] = 1;
+        m_sign[-k]= -1;
+      }
+    }
+  }
+}
 Void TComSampleAdaptiveOffset::destroy()
+{
+  if (m_pClipTableBase)
+  {
+    delete [] m_pClipTableBase; m_pClipTableBase = NULL;
+  }
+  if (m_iOffsetBo)
+  {
+    delete [] m_iOffsetBo; m_iOffsetBo = NULL;
+  }
+  if (m_lumaTableBo)
+  {
+    delete[] m_lumaTableBo; m_lumaTableBo = NULL;
+  }
+  if (m_pChromaClipTableBase)
+  {
+    delete [] m_pChromaClipTableBase; m_pChromaClipTableBase = NULL;
+  }
+  if (m_iChromaOffsetBo)
+  {
+    delete [] m_iChromaOffsetBo; m_iChromaOffsetBo = NULL;
+  }
+  if (m_chromaTableBo)
+  {
+    delete[] m_chromaTableBo; m_chromaTableBo = NULL;
+  }
+  if (m_iUpBuff1)
+  {
+    m_iUpBuff1--;
+    delete [] m_iUpBuff1; m_iUpBuff1 = NULL;
+  }
+  if (m_iUpBuff2)
+  {
+    m_iUpBuff2--;
+    delete [] m_iUpBuff2; m_iUpBuff2 = NULL;
+  }
+  if (m_iUpBufft)
+  {
+    m_iUpBufft--;
+    delete [] m_iUpBufft; m_iUpBufft = NULL;
+  }
+  if (m_pTmpL1)
+  {
+    delete [] m_pTmpL1; m_pTmpL1 = NULL;
+  }
+  if (m_pTmpL2)
+  {
+    delete [] m_pTmpL2; m_pTmpL2 = NULL;
+  }
+  if (m_pTmpU1)
+  {
+    delete [] m_pTmpU1; m_pTmpU1 = NULL;
+  }
+  if (m_pTmpU2)
+  {
+    delete [] m_pTmpU2; m_pTmpU2 = NULL;
+  }
+}
+/** allocate memory for SAO parameters
+ * \param    *pcSaoParam
+ */
+Void TComSampleAdaptiveOffset::allocSaoParam(SAOParam *pcSaoParam)
+{
+  pcSaoParam->iMaxSplitLevel = m_uiMaxSplitLevel;
+  pcSaoParam->psSaoPart[0] = new SAOQTPart[ m_aiNumCulPartsLevel[pcSaoParam->iMaxSplitLevel] ];
+  initSAOParam(pcSaoParam, 0, 0, 0, -1, 0, m_iNumCuInWidth-1,  0, m_iNumCuInHeight-1,0);
+  pcSaoParam->psSaoPart[1] = new SAOQTPart[ m_aiNumCulPartsLevel[pcSaoParam->iMaxSplitLevel] ];
+  pcSaoParam->psSaoPart[2] = new SAOQTPart[ m_aiNumCulPartsLevel[pcSaoParam->iMaxSplitLevel] ];
+  initSAOParam(pcSaoParam, 0, 0, 0, -1, 0, m_iNumCuInWidth-1,  0, m_iNumCuInHeight-1,1);
+  initSAOParam(pcSaoParam, 0, 0, 0, -1, 0, m_iNumCuInWidth-1,  0, m_iNumCuInHeight-1,2);
+  pcSaoParam->numCuInWidth  = m_iNumCuInWidth;
+  pcSaoParam->numCuInHeight = m_iNumCuInHeight;
+  pcSaoParam->saoLcuParam[0] = new SaoLcuParam [m_iNumCuInHeight*m_iNumCuInWidth];
+  pcSaoParam->saoLcuParam[1] = new SaoLcuParam [m_iNumCuInHeight*m_iNumCuInWidth];
+  pcSaoParam->saoLcuParam[2] = new SaoLcuParam [m_iNumCuInHeight*m_iNumCuInWidth];
+}
+/** initialize SAO parameters
+ * \param    *pcSaoParam,  iPartLevel,  iPartRow,  iPartCol,  iParentPartIdx,  StartCUX,  EndCUX,  StartCUY,  EndCUY,  iYCbCr
+ */
+Void TComSampleAdaptiveOffset::initSAOParam(SAOParam *pcSaoParam, Int iPartLevel, Int iPartRow, Int iPartCol, Int iParentPartIdx, Int StartCUX, Int EndCUX, Int StartCUY, Int EndCUY, Int iYCbCr)
+{
+  Int j;
+  Int iPartIdx = convertLevelRowCol2Idx(iPartLevel, iPartRow, iPartCol);
+  SAOQTPart* pSaoPart;
+  pSaoPart = &(pcSaoParam->psSaoPart[iYCbCr][iPartIdx]);
+  pSaoPart->PartIdx   = iPartIdx;
+  pSaoPart->PartLevel = iPartLevel;
+  pSaoPart->PartRow   = iPartRow;
+  pSaoPart->PartCol   = iPartCol;
+  pSaoPart->StartCUX  = StartCUX;
+  pSaoPart->EndCUX    = EndCUX;
+  pSaoPart->StartCUY  = StartCUY;
+  pSaoPart->EndCUY    = EndCUY;
+  pSaoPart->UpPartIdx = iParentPartIdx;
+  pSaoPart->iBestType   = -1;
+  pSaoPart->iLength     =  0;
+  pSaoPart->subTypeIdx = 0;
+  for (j=0;j<MAX_NUM_SAO_OFFSETS;j++)
+  {
+    pSaoPart->iOffset[j] = 0;
+  }
+  if(pSaoPart->PartLevel != m_uiMaxSplitLevel)
+  {
+    Int DownLevel    = (iPartLevel+1 );
+    Int DownRowStart = (iPartRow << 1);
+    Int DownColStart = (iPartCol << 1);
+    Int iDownRowIdx, iDownColIdx;
+    Int NumCUWidth,  NumCUHeight;
+    Int NumCULeft;
+    Int NumCUTop;
+    Int DownStartCUX, DownStartCUY;
+    Int DownEndCUX, DownEndCUY;
+    NumCUWidth  = EndCUX - StartCUX +1;
+    NumCUHeight = EndCUY - StartCUY +1;
+    NumCULeft   = (NumCUWidth  >> 1);
+    NumCUTop    = (NumCUHeight >> 1);
+    DownStartCUX= StartCUX;
+    DownEndCUX  = DownStartCUX + NumCULeft - 1;
+    DownStartCUY= StartCUY;
+    DownEndCUY  = DownStartCUY + NumCUTop  - 1;
+    iDownRowIdx = DownRowStart + 0;
+    iDownColIdx = DownColStart + 0;
+    pSaoPart->DownPartsIdx[0]= convertLevelRowCol2Idx(DownLevel, iDownRowIdx, iDownColIdx);
+    initSAOParam(pcSaoParam, DownLevel, iDownRowIdx, iDownColIdx, iPartIdx, DownStartCUX, DownEndCUX, DownStartCUY, DownEndCUY, iYCbCr);
+    DownStartCUX = StartCUX + NumCULeft;
+    DownEndCUX   = EndCUX;
+    DownStartCUY = StartCUY;
+    DownEndCUY   = DownStartCUY + NumCUTop -1;
+    iDownRowIdx  = DownRowStart + 0;
+    iDownColIdx  = DownColStart + 1;
+    pSaoPart->DownPartsIdx[1] = convertLevelRowCol2Idx(DownLevel, iDownRowIdx, iDownColIdx);
+    initSAOParam(pcSaoParam, DownLevel, iDownRowIdx, iDownColIdx, iPartIdx,  DownStartCUX, DownEndCUX, DownStartCUY, DownEndCUY, iYCbCr);
+    DownStartCUX = StartCUX;
+    DownEndCUX   = DownStartCUX + NumCULeft -1;
+    DownStartCUY = StartCUY + NumCUTop;
+    DownEndCUY   = EndCUY;
+    iDownRowIdx  = DownRowStart + 1;
+    iDownColIdx  = DownColStart + 0;
+    pSaoPart->DownPartsIdx[2] = convertLevelRowCol2Idx(DownLevel, iDownRowIdx, iDownColIdx);
+    initSAOParam(pcSaoParam, DownLevel, iDownRowIdx, iDownColIdx, iPartIdx, DownStartCUX, DownEndCUX, DownStartCUY, DownEndCUY, iYCbCr);
+    DownStartCUX = StartCUX+ NumCULeft;
+    DownEndCUX   = EndCUX;
+    DownStartCUY = StartCUY + NumCUTop;
+    DownEndCUY   = EndCUY;
+    iDownRowIdx  = DownRowStart + 1;
+    iDownColIdx  = DownColStart + 1;
+    pSaoPart->DownPartsIdx[3] = convertLevelRowCol2Idx(DownLevel, iDownRowIdx, iDownColIdx);
+    initSAOParam(pcSaoParam, DownLevel, iDownRowIdx, iDownColIdx, iPartIdx,DownStartCUX, DownEndCUX, DownStartCUY, DownEndCUY, iYCbCr);
+  }
+  else
+  {
+    pSaoPart->DownPartsIdx[0]=pSaoPart->DownPartsIdx[1]= pSaoPart->DownPartsIdx[2]= pSaoPart->DownPartsIdx[3]= -1;
+  }
+}
+/** free memory of SAO parameters
+ * \param   pcSaoParam
+ */
+Void TComSampleAdaptiveOffset::freeSaoParam(SAOParam *pcSaoParam)
+{
+  delete [] pcSaoParam->psSaoPart[0];
+  delete [] pcSaoParam->psSaoPart[1];
+  delete [] pcSaoParam->psSaoPart[2];
+  pcSaoParam->psSaoPart[0] = 0;
+  pcSaoParam->psSaoPart[1] = 0;
+  pcSaoParam->psSaoPart[2] = 0;
+  if( pcSaoParam->saoLcuParam[0])
+  {
+    delete [] pcSaoParam->saoLcuParam[0]; pcSaoParam->saoLcuParam[0] = NULL;
+  }
+  if( pcSaoParam->saoLcuParam[1])
+  {
+    delete [] pcSaoParam->saoLcuParam[1]; pcSaoParam->saoLcuParam[1] = NULL;
+  }
+  if( pcSaoParam->saoLcuParam[2])
+  {
+    delete [] pcSaoParam->saoLcuParam[2]; pcSaoParam->saoLcuParam[2] = NULL;
+  }
+}
+/** reset SAO parameters
+ * \param   pcSaoParam
+ */
+Void TComSampleAdaptiveOffset::resetSAOParam(SAOParam *pcSaoParam)
+{
+  Int iNumComponet = 3;
+  for(Int c=0; c<iNumComponet; c++)
+  {
+if (c<2)
+  {
+    pcSaoParam->bSaoFlag[c] = 0;
+  }
+    for(Int i=0; i< m_aiNumCulPartsLevel[m_uiMaxSplitLevel]; i++)
+    {
+      pcSaoParam->psSaoPart[c][i].iBestType     = -1;
+      pcSaoParam->psSaoPart[c][i].iLength       =  0;
+      pcSaoParam->psSaoPart[c][i].bSplit        = false;
+      pcSaoParam->psSaoPart[c][i].bProcessed    = false;
+      pcSaoParam->psSaoPart[c][i].dMinCost      = MAX_DOUBLE;
+      pcSaoParam->psSaoPart[c][i].iMinDist      = MAX_INT;
+      pcSaoParam->psSaoPart[c][i].iMinRate      = MAX_INT;
+      pcSaoParam->psSaoPart[c][i].subTypeIdx    = 0;
+      for (Int j=0;j<MAX_NUM_SAO_OFFSETS;j++)
+      {
+        pcSaoParam->psSaoPart[c][i].iOffset[j] = 0;
+        pcSaoParam->psSaoPart[c][i].iOffset[j] = 0;
+        pcSaoParam->psSaoPart[c][i].iOffset[j] = 0;
+      }
+    }
+    pcSaoParam->oneUnitFlag[0]   = 0;
+    pcSaoParam->oneUnitFlag[1]   = 0;
+    pcSaoParam->oneUnitFlag[2]   = 0;
+    resetLcuPart(pcSaoParam->saoLcuParam[0]);
+    resetLcuPart(pcSaoParam->saoLcuParam[1]);
+    resetLcuPart(pcSaoParam->saoLcuParam[2]);
+  }
+}
+/** get the sign of input variable
+ * \param   x
+ */
+inline Int xSign(Int x)
+{
+  return ((x >> 31) | ((Int)( (((UInt) -x)) >> 31)));
+}
+/** initialize variables for SAO process
+ * \param  pcPic picture data pointer
+ */
+Void TComSampleAdaptiveOffset::createPicSaoInfo(TComPic* pcPic)
+{
+  m_pcPic   = pcPic;
+  m_bUseNIF = ( pcPic->getIndependentSliceBoundaryForNDBFilter() || pcPic->getIndependentTileBoundaryForNDBFilter() );
+  if(m_bUseNIF)
+  {
+    m_pcYuvTmp = pcPic->getYuvPicBufferForIndependentBoundaryProcessing();
+  }
+}
+Void TComSampleAdaptiveOffset::destroyPicSaoInfo()
+{
+}
+/** sample adaptive offset process for one LCU
+ * \param   iAddr, iSaoType, iYCbCr
+ */
+Void TComSampleAdaptiveOffset::processSaoCu(Int iAddr, Int iSaoType, Int iYCbCr)
+{
+  if(!m_bUseNIF)
+  {
+    processSaoCuOrg( iAddr, iSaoType, iYCbCr);
+  }
+  else
+  {
+    Int  isChroma = (iYCbCr != 0)? 1:0;
+    Int  stride   = (iYCbCr != 0)?(m_pcPic->getCStride()):(m_pcPic->getStride());
+    Pel* pPicRest = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr);
+    Pel* pPicDec  = getPicYuvAddr(m_pcYuvTmp, iYCbCr);
+    std::vector<NDBFBlockInfo>& vFilterBlocks = *(m_pcPic->getCU(iAddr)->getNDBFilterBlocks());
+    //variables
+    UInt  xPos, yPos, width, height;
+    Bool* pbBorderAvail;
+    UInt  posOffset;
+    for(Int i=0; i< vFilterBlocks.size(); i++)
+    {
+      xPos        = vFilterBlocks[i].posX   >> isChroma;
+      yPos        = vFilterBlocks[i].posY   >> isChroma;
+      width       = vFilterBlocks[i].width  >> isChroma;
+      height      = vFilterBlocks[i].height >> isChroma;
+      pbBorderAvail = vFilterBlocks[i].isBorderAvailable;
+      posOffset = (yPos* stride) + xPos;
+      processSaoBlock(pPicDec+ posOffset, pPicRest+ posOffset, stride, iSaoType, width, height, pbBorderAvail, iYCbCr);
+    }
+  }
+}
+/** Perform SAO for non-cross-slice or non-cross-tile process
+ * \param  pDec to-be-filtered block buffer pointer
+ * \param  pRest filtered block buffer pointer
+ * \param  stride picture buffer stride
+ * \param  saoType SAO offset type
+ * \param  xPos x coordinate
+ * \param  yPos y coordinate
+ * \param  width block width
+ * \param  height block height
+ * \param  pbBorderAvail availabilities of block border pixels
+ */
+Void TComSampleAdaptiveOffset::processSaoBlock(Pel* pDec, Pel* pRest, Int stride, Int saoType, UInt width, UInt height, Bool* pbBorderAvail, Int iYCbCr)
+{
+  //variables
+  Int startX, startY, endX, endY, x, y;
+  Int signLeft,signRight,signDown,signDown1;
+  UInt edgeType;
+  Pel *pClipTbl = (iYCbCr==0)?m_pClipTable:m_pChromaClipTable;
+  Int *pOffsetBo = (iYCbCr==0)?m_iOffsetBo: m_iChromaOffsetBo;
+  switch (saoType)
+  {
+  case SAO_EO_0: // dir: -
+    {
+      startX = (pbBorderAvail[SGU_L]) ? 0 : 1;
+      endX   = (pbBorderAvail[SGU_R]) ? width : (width -1);
+  if ( m_tempPicYuv )
+  {
+    m_tempPicYuv->destroy();
+    delete m_tempPicYuv;
+    m_tempPicYuv = NULL;
+  }
+  for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+  {
+    if(m_offsetClipTable[compIdx])
+    {
+      delete[] m_offsetClipTable[compIdx]; m_offsetClipTable[compIdx] = NULL;
+    }
+  }
+  if( m_signTable )
+  {
+    delete[] m_signTable; m_signTable = NULL;
+  }
+}
+Void TComSampleAdaptiveOffset::invertQuantOffsets(Int compIdx, Int typeIdc, Int typeAuxInfo, Int* dstOffsets, Int* srcOffsets)
+{
+  Int codedOffset[MAX_NUM_SAO_CLASSES];
+  ::memcpy(codedOffset, srcOffsets, sizeof(Int)*MAX_NUM_SAO_CLASSES);
+  ::memset(dstOffsets, 0, sizeof(Int)*MAX_NUM_SAO_CLASSES);
+  if(typeIdc == SAO_TYPE_START_BO)
+  {
+    for(Int i=0; i< 4; i++)
+    {
+      dstOffsets[(typeAuxInfo+ i)%NUM_SAO_BO_CLASSES] = codedOffset[(typeAuxInfo+ i)%NUM_SAO_BO_CLASSES]*(1<<m_offsetStepLog2[compIdx]);
+    }
+  }
+  else //EO
+  {
+    for(Int i=0; i< NUM_SAO_EO_CLASSES; i++)
+    {
+      dstOffsets[i] = codedOffset[i] *(1<<m_offsetStepLog2[compIdx]);
+    }
+    assert(dstOffsets[SAO_CLASS_EO_PLAIN] == 0); //keep EO plain offset as zero
+  }
+}
+Int TComSampleAdaptiveOffset::getMergeList(TComPic* pic, Int ctu, SAOBlkParam* blkParams, std::vector<SAOBlkParam*>& mergeList)
+{
+  Int ctuX = ctu % m_numCTUInWidth;
+  Int ctuY = ctu / m_numCTUInWidth;
+  Int mergedCTUPos;
+  Int numValidMergeCandidates = 0;
+  for(Int mergeType=0; mergeType< NUM_SAO_MERGE_TYPES; mergeType++)
+  {
+    SAOBlkParam* mergeCandidate = NULL;
+    switch(mergeType)
+    {
+    case SAO_MERGE_ABOVE:
+      {
+        if(ctuY > 0)
+        {
+          mergedCTUPos = ctu- m_numCTUInWidth;
+          if( pic->getSAOMergeAvailability(ctu, mergedCTUPos) )
+          {
+            mergeCandidate = &(blkParams[mergedCTUPos]);
+          }
+        }
+      }
+      break;
+    case SAO_MERGE_LEFT:
+      {
+        if(ctuX > 0)
+        {
+          mergedCTUPos = ctu- 1;
+          if( pic->getSAOMergeAvailability(ctu, mergedCTUPos) )
+          {
+            mergeCandidate = &(blkParams[mergedCTUPos]);
+          }
+        }
+      }
+      break;
+    default:
+      {
+        printf("not a supported merge type");
+        assert(0);
+        exit(-1);
+      }
+    }
+    mergeList.push_back(mergeCandidate);
+    if (mergeCandidate != NULL)
+    {
+      numValidMergeCandidates++;
+    }
+  }
+  return numValidMergeCandidates;
+}
+Void TComSampleAdaptiveOffset::reconstructBlkSAOParam(SAOBlkParam& recParam, std::vector<SAOBlkParam*>& mergeList)
+{
+  for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+  {
+    SAOOffset& offsetParam = recParam[compIdx];
+    if(offsetParam.modeIdc == SAO_MODE_OFF)
+    {
+      continue;
+    }
+    switch(offsetParam.modeIdc)
+    {
+    case SAO_MODE_NEW:
+      {
+        invertQuantOffsets(compIdx, offsetParam.typeIdc, offsetParam.typeAuxInfo, offsetParam.offset, offsetParam.offset);
+      }
+      break;
+    case SAO_MODE_MERGE:
+      {
+        SAOBlkParam* mergeTarget = mergeList[offsetParam.typeIdc];
+        assert(mergeTarget != NULL);
+        offsetParam = (*mergeTarget)[compIdx];
+      }
+      break;
+    default:
+      {
+        printf("Not a supported mode");
+        assert(0);
+        exit(-1);
+      }
+    }
+  }
+}
+Void TComSampleAdaptiveOffset::reconstructBlkSAOParams(TComPic* pic, SAOBlkParam* saoBlkParams)
+{
+  m_picSAOEnabled[SAO_Y] = m_picSAOEnabled[SAO_Cb] = m_picSAOEnabled[SAO_Cr] = false;
+  for(Int ctu=0; ctu< m_numCTUsPic; ctu++)
+  {
+    std::vector<SAOBlkParam*> mergeList;
+    getMergeList(pic, ctu, saoBlkParams, mergeList);
+    reconstructBlkSAOParam(saoBlkParams[ctu], mergeList);
+    for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+    {
+      if(saoBlkParams[ctu][compIdx].modeIdc != SAO_MODE_OFF)
+      {
+        m_picSAOEnabled[compIdx] = true;
+      }
+    }
+  }
+}
+Void TComSampleAdaptiveOffset::offsetBlock(Int compIdx, Int typeIdx, Int* offset
+                                          , Pel* srcBlk, Pel* resBlk, Int srcStride, Int resStride,  Int width, Int height
+                                          , Bool isLeftAvail,  Bool isRightAvail, Bool isAboveAvail, Bool isBelowAvail, Bool isAboveLeftAvail, Bool isAboveRightAvail, Bool isBelowLeftAvail, Bool isBelowRightAvail)
+{
+  if(m_lineBufWidth != m_maxCUWidth)
+  {
+    m_lineBufWidth = m_maxCUWidth;
+    if (m_signLineBuf1) delete[] m_signLineBuf1; m_signLineBuf1 = NULL;
+    m_signLineBuf1 = new Char[m_lineBufWidth+1];
+    if (m_signLineBuf2) delete[] m_signLineBuf2; m_signLineBuf2 = NULL;
+    m_signLineBuf2 = new Char[m_lineBufWidth+1];
+  }
+  Int* offsetClip = m_offsetClip[compIdx];
+  Int x,y, startX, startY, endX, endY, edgeType;
+  Int firstLineStartX, firstLineEndX, lastLineStartX, lastLineEndX;
+  Char signLeft, signRight, signDown;
+  Pel* srcLine = srcBlk;
+  Pel* resLine = resBlk;
+  switch(typeIdx)
+  {
+  case SAO_TYPE_EO_0:
+    {
+      offset += 2;
+      startX = isLeftAvail ? 0 : 1;
+      endX   = isRightAvail ? width : (width -1);
       for (y=0; y< height; y++)
+      {
         signLeft = xSign(pDec[startX] - pDec[startX-1]);
+        signLeft = (Char)m_sign[srcLine[startX] - srcLine[startX-1]];
         for (x=startX; x< endX; x++)
+        {
           signRight =  xSign(pDec[x] - pDec[x+1]);
           edgeType =  signRight + signLeft + 2;
+          signRight = (Char)m_sign[srcLine[x] - srcLine[x+1]];
+          edgeType =  signRight + signLeft;
           signLeft  = -signRight;
           pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+          resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+        }
+        pDec  += stride;
+        pRest += stride;
+      }
+      break;
+    }
+  case SAO_EO_1: // dir: |
+    {
+      startY = (pbBorderAvail[SGU_T]) ? 0 : 1;
+      endY   = (pbBorderAvail[SGU_B]) ? height : height-1;
+      if (!pbBorderAvail[SGU_T])
+      {
+        pDec  += stride;
+        pRest += stride;
+      }
+        srcLine  += srcStride;
+        resLine += resStride;
+      }
+    }
+    break;
+  case SAO_TYPE_EO_90:
+    {
+      offset += 2;
+      Char *signUpLine = m_signLineBuf1;
+      startY = isAboveAvail ? 0 : 1;
+      endY   = isBelowAvail ? height : height-1;
+      if (!isAboveAvail)
+      {
+        srcLine += srcStride;
+        resLine += resStride;
+      }
+      Pel* srcLineAbove= srcLine- srcStride;
       for (x=0; x< width; x++)
+      {
+        m_iUpBuff1[x] = xSign(pDec[x] - pDec[x-stride]);
+      }
+        signUpLine[x] = (Char)m_sign[srcLine[x] - srcLineAbove[x]];
+      }
+      Pel* srcLineBelow;
       for (y=startY; y<endY; y++)
+      {
+        srcLineBelow= srcLine+ srcStride;
         for (x=0; x< width; x++)
+        {
           signDown  = xSign(pDec[x] - pDec[x+stride]);
           edgeType = signDown + m_iUpBuff1[x] + 2;
           m_iUpBuff1[x]= -signDown;
           pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+          signDown  = (Char)m_sign[srcLine[x] - srcLineBelow[x]];
+          edgeType = signDown + signUpLine[x];
+          signUpLine[x]= -signDown;
+          resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+        }
+        pDec  += stride;
+        pRest += stride;
+      }
+      break;
+    }
+  case SAO_EO_2: // dir: 135
+    {
+      Int posShift= stride + 1;
+      startX = (pbBorderAvail[SGU_L]) ? 0 : 1 ;
+      endX   = (pbBorderAvail[SGU_R]) ? width : (width-1);
+      //prepare 2nd line upper sign
+      pDec += stride;
+        srcLine += srcStride;
+        resLine += resStride;
+      }
+    }
+    break;
+  case SAO_TYPE_EO_135:
+    {
+      offset += 2;
+      Char *signUpLine, *signDownLine, *signTmpLine;
+      signUpLine  = m_signLineBuf1;
+      signDownLine= m_signLineBuf2;
+      startX = isLeftAvail ? 0 : 1 ;
+      endX   = isRightAvail ? width : (width-1);
+      //prepare 2nd line's upper sign
+      Pel* srcLineBelow= srcLine+ srcStride;
       for (x=startX; x< endX+1; x++)
+      {
         m_iUpBuff1[x] = xSign(pDec[x] - pDec[x- posShift]);
+        signUpLine[x] = (Char)m_sign[srcLineBelow[x] - srcLine[x- 1]];
+      }
       //1st line
+      pDec -= stride;
+      if(pbBorderAvail[SGU_TL])
+      {
+        x= 0;
+        edgeType      =  xSign(pDec[x] - pDec[x- posShift]) - m_iUpBuff1[x+1] + 2;
+        pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+      }
+      if(pbBorderAvail[SGU_T])
+      {
+        for(x= 1; x< endX; x++)
+        {
+          edgeType      =  xSign(pDec[x] - pDec[x- posShift]) - m_iUpBuff1[x+1] + 2;
+          pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+        }
+      }
+      pDec   += stride;
+      pRest  += stride;
+      Pel* srcLineAbove= srcLine- srcStride;
+      firstLineStartX = isAboveLeftAvail ? 0 : 1;
+      firstLineEndX   = isAboveAvail? endX: 1;
+      for(x= firstLineStartX; x< firstLineEndX; x++)
+      {
+        edgeType  =  m_sign[srcLine[x] - srcLineAbove[x- 1]] - signUpLine[x+1];
+        resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+      }
+      srcLine  += srcStride;
+      resLine  += resStride;
 …
       for (y= 1; y< height-1; y++)
+      {
+        srcLineBelow= srcLine+ srcStride;
         for (x=startX; x<endX; x++)
+        {
           signDown1      =  xSign(pDec[x] - pDec[x+ posShift]) ;
           edgeType      =  signDown1 + m_iUpBuff1[x] + 2;
           pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
           m_iUpBufft[x+1] = -signDown1;
+          signDown =  (Char)m_sign[srcLine[x] - srcLineBelow[x+ 1]] ;
+          edgeType =  signDown + signUpLine[x];
+          resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+          signDownLine[x+1] = -signDown;
+        }
         m_iUpBufft[startX] = xSign(pDec[stride+startX] - pDec[startX-1]);
         ipSwap     = m_iUpBuff1;
         m_iUpBuff1 = m_iUpBufft;
         m_iUpBufft = ipSwap;
         pDec  += stride;
         pRest += stride;
+        signDownLine[startX] = (Char)m_sign[srcLineBelow[startX] - srcLine[startX-1]];
+        signTmpLine  = signUpLine;
+        signUpLine   = signDownLine;
+        signDownLine = signTmpLine;
+        srcLine += srcStride;
+        resLine += resStride;
+      }
       //last line
+      if(pbBorderAvail[SGU_B])
+      {
+        for(x= startX; x< width-1; x++)
+        {
+          edgeType =  xSign(pDec[x] - pDec[x+ posShift]) + m_iUpBuff1[x] + 2;
+          pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+        }
+      }
+      if(pbBorderAvail[SGU_BR])
+      {
+        x= width -1;
+        edgeType =  xSign(pDec[x] - pDec[x+ posShift]) + m_iUpBuff1[x] + 2;
+        pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+      }
+      break;
+    }
+  case SAO_EO_3: // dir: 45
+    {
+      Int  posShift     = stride - 1;
+      startX = (pbBorderAvail[SGU_L]) ? 0 : 1;
+      endX   = (pbBorderAvail[SGU_R]) ? width : (width -1);
+      srcLineBelow= srcLine+ srcStride;
+      lastLineStartX = isBelowAvail ? startX : (width -1);
+      lastLineEndX   = isBelowRightAvail ? width : (width -1);
+      for(x= lastLineStartX; x< lastLineEndX; x++)
+      {
+        edgeType =  m_sign[srcLine[x] - srcLineBelow[x+ 1]] + signUpLine[x];
+        resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+      }
+    }
+    break;
+  case SAO_TYPE_EO_45:
+    {
+      offset += 2;
+      Char *signUpLine = m_signLineBuf1+1;
+      startX = isLeftAvail ? 0 : 1;
+      endX   = isRightAvail ? width : (width -1);
       //prepare 2nd line upper sign
       pDec += stride;
+      Pel* srcLineBelow= srcLine+ srcStride;
       for (x=startX-1; x< endX; x++)
+      {
         m_iUpBuff1[x] = xSign(pDec[x] - pDec[x- posShift]);
+        signUpLine[x] = (Char)m_sign[srcLineBelow[x] - srcLine[x+1]];
+      }
       //first line
+      pDec -= stride;
+      if(pbBorderAvail[SGU_T])
+      {
+        for(x= startX; x< width -1; x++)
+        {
+          edgeType = xSign(pDec[x] - pDec[x- posShift]) -m_iUpBuff1[x-1] + 2;
+          pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+        }
+      }
+      if(pbBorderAvail[SGU_TR])
+      {
+        x= width-1;
+        edgeType = xSign(pDec[x] - pDec[x- posShift]) -m_iUpBuff1[x-1] + 2;
+        pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+      }
+      pDec  += stride;
+      pRest += stride;
+      Pel* srcLineAbove= srcLine- srcStride;
+      firstLineStartX = isAboveAvail ? startX : (width -1 );
+      firstLineEndX   = isAboveRightAvail ? width : (width-1);
+      for(x= firstLineStartX; x< firstLineEndX; x++)
+      {
+        edgeType = m_sign[srcLine[x] - srcLineAbove[x+1]] -signUpLine[x-1];
+        resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+      }
+      srcLine += srcStride;
+      resLine += resStride;
       //middle lines
       for (y= 1; y< height-1; y++)
+      {
+        srcLineBelow= srcLine+ srcStride;
         for(x= startX; x< endX; x++)
+        {
+          signDown1      =  xSign(pDec[x] - pDec[x+ posShift]) ;
+          edgeType      =  signDown1 + m_iUpBuff1[x] + 2;
+          pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+          m_iUpBuff1[x-1] = -signDown1;
+          signDown =  (Char)m_sign[srcLine[x] - srcLineBelow[x-1]] ;
+          edgeType =  signDown + signUpLine[x];
+          resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+          signUpLine[x-1] = -signDown;
+        }
+        m_iUpBuff1[endX-1] = xSign(pDec[endX-1 + stride] - pDec[endX]);
+        pDec  += stride;
+        pRest += stride;
+        signUpLine[endX-1] = (Char)m_sign[srcLineBelow[endX-1] - srcLine[endX]];
+        srcLine  += srcStride;
+        resLine += resStride;
+      }
       //last line
+      if(pbBorderAvail[SGU_BL])
+      {
+        x= 0;
+        edgeType = xSign(pDec[x] - pDec[x+ posShift]) + m_iUpBuff1[x] + 2;
+        pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+      }
+      if(pbBorderAvail[SGU_B])
+      {
+        for(x= 1; x< endX; x++)
+        {
+          edgeType = xSign(pDec[x] - pDec[x+ posShift]) + m_iUpBuff1[x] + 2;
+          pRest[x] = pClipTbl[pDec[x] + m_iOffsetEo[edgeType]];
+        }
+      }
+      break;
+    }
+  case SAO_BO:
+    {
+      srcLineBelow= srcLine+ srcStride;
+      lastLineStartX = isBelowLeftAvail ? 0 : 1;
+      lastLineEndX   = isBelowAvail ? endX : 1;
+      for(x= lastLineStartX; x< lastLineEndX; x++)
+      {
+        edgeType = m_sign[srcLine[x] - srcLineBelow[x-1]] + signUpLine[x];
+        resLine[x] = offsetClip[srcLine[x] + offset[edgeType]];
+      }
+    }
+    break;
+  case SAO_TYPE_BO:
+    {
+      Int shiftBits = ((compIdx == SAO_Y)?g_bitDepthY:g_bitDepthC)- NUM_SAO_BO_CLASSES_LOG2;
       for (y=0; y< height; y++)
+      {
         for (x=0; x< width; x++)
+        {
           pRest[x] = pOffsetBo[pDec[x]];
+          resLine[x] = offsetClip[ srcLine[x] + offset[srcLine[x] >> shiftBits] ];
+        }
+        pRest += stride;
+        pDec  += stride;
+      }
+      break;
+    }
+  default: break;
+  }
+}
+/** sample adaptive offset process for one LCU crossing LCU boundary
+ * \param   iAddr, iSaoType, iYCbCr
+ */
+Void TComSampleAdaptiveOffset::processSaoCuOrg(Int iAddr, Int iSaoType, Int iYCbCr)
+{
+  Int x,y;
+  TComDataCU *pTmpCu = m_pcPic->getCU(iAddr);
+  Pel* pRec;
+  Int  iStride;
+  Int  iLcuWidth  = m_uiMaxCUWidth;
+  Int  iLcuHeight = m_uiMaxCUHeight;
+  UInt uiLPelX    = pTmpCu->getCUPelX();
+  UInt uiTPelY    = pTmpCu->getCUPelY();
+  UInt uiRPelX;
+  UInt uiBPelY;
+  Int  iSignLeft;
+  Int  iSignRight;
+  Int  iSignDown;
+  Int  iSignDown1;
+  Int  iSignDown2;
+  UInt uiEdgeType;
+  Int iPicWidthTmp;
+  Int iPicHeightTmp;
+  Int iStartX;
+  Int iStartY;
+  Int iEndX;
+  Int iEndY;
+  Int iIsChroma = (iYCbCr!=0)? 1:0;
+  Int iShift;
+  Int iCuHeightTmp;
+  Pel *pTmpLSwap;
+  Pel *pTmpL;
+  Pel *pTmpU;
+  Pel *pClipTbl = NULL;
+  Int *pOffsetBo = NULL;
+  iPicWidthTmp  = m_iPicWidth  >> iIsChroma;
+  iPicHeightTmp = m_iPicHeight >> iIsChroma;
+  iLcuWidth     = iLcuWidth    >> iIsChroma;
+  iLcuHeight    = iLcuHeight   >> iIsChroma;
+  uiLPelX       = uiLPelX      >> iIsChroma;
+  uiTPelY       = uiTPelY      >> iIsChroma;
+  uiRPelX       = uiLPelX + iLcuWidth  ;
+  uiBPelY       = uiTPelY + iLcuHeight ;
+  uiRPelX       = uiRPelX > iPicWidthTmp  ? iPicWidthTmp  : uiRPelX;
+  uiBPelY       = uiBPelY > iPicHeightTmp ? iPicHeightTmp : uiBPelY;
+  iLcuWidth     = uiRPelX - uiLPelX;
+  iLcuHeight    = uiBPelY - uiTPelY;
+  if(pTmpCu->getPic()==0)
+  {
+    return;
+  }
+  if (iYCbCr == 0)
+  {
+    pRec       = m_pcPic->getPicYuvRec()->getLumaAddr(iAddr);
+    iStride    = m_pcPic->getStride();
+  }
+  else if (iYCbCr == 1)
+  {
+    pRec       = m_pcPic->getPicYuvRec()->getCbAddr(iAddr);
+    iStride    = m_pcPic->getCStride();
+  }
+  else
+  {
+    pRec       = m_pcPic->getPicYuvRec()->getCrAddr(iAddr);
+    iStride    = m_pcPic->getCStride();
+  }
+//   if (iSaoType!=SAO_BO_0 || iSaoType!=SAO_BO_1)
+  {
+    iCuHeightTmp = (m_uiMaxCUHeight >> iIsChroma);
+    iShift = (m_uiMaxCUWidth>> iIsChroma)-1;
+    for (Int i=0;i<iCuHeightTmp+1;i++)
+    {
+      m_pTmpL2[i] = pRec[iShift];
+      pRec += iStride;
+    }
+    pRec -= (iStride*(iCuHeightTmp+1));
+    pTmpL = m_pTmpL1;
+    pTmpU = &(m_pTmpU1[uiLPelX]);
+  }
+  pClipTbl = (iYCbCr==0)? m_pClipTable:m_pChromaClipTable;
+  pOffsetBo = (iYCbCr==0)? m_iOffsetBo:m_iChromaOffsetBo;
+  switch (iSaoType)
+  {
+  case SAO_EO_0: // dir: -
+    {
+      iStartX = (uiLPelX == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth;
+      for (y=0; y<iLcuHeight; y++)
+      {
+        iSignLeft = xSign(pRec[iStartX] - pTmpL[y]);
+        for (x=iStartX; x< iEndX; x++)
+        {
+          iSignRight =  xSign(pRec[x] - pRec[x+1]);
+          uiEdgeType =  iSignRight + iSignLeft + 2;
+          iSignLeft  = -iSignRight;
+          pRec[x] = pClipTbl[pRec[x] + m_iOffsetEo[uiEdgeType]];
+        }
+        pRec += iStride;
+      }
+      break;
+    }
+  case SAO_EO_1: // dir: |
+    {
+      iStartY = (uiTPelY == 0) ? 1 : 0;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight;
+      if (uiTPelY == 0)
+      {
+        pRec += iStride;
+      }
+      for (x=0; x< iLcuWidth; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pTmpU[x]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        for (x=0; x<iLcuWidth; x++)
+        {
+          iSignDown  = xSign(pRec[x] - pRec[x+iStride]);
+          uiEdgeType = iSignDown + m_iUpBuff1[x] + 2;
+          m_iUpBuff1[x]= -iSignDown;
+          pRec[x] = pClipTbl[pRec[x] + m_iOffsetEo[uiEdgeType]];
+        }
+        pRec += iStride;
+      }
+      break;
+    }
+  case SAO_EO_2: // dir: 135
+    {
+      iStartX = (uiLPelX == 0)            ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth;
+      iStartY = (uiTPelY == 0) ?             1 : 0;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight;
+      if (uiTPelY == 0)
+      {
+        pRec += iStride;
+      }
+      for (x=iStartX; x<iEndX; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pTmpU[x-1]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        iSignDown2 = xSign(pRec[iStride+iStartX] - pTmpL[y]);
+        for (x=iStartX; x<iEndX; x++)
+        {
+          iSignDown1      =  xSign(pRec[x] - pRec[x+iStride+1]) ;
+          uiEdgeType      =  iSignDown1 + m_iUpBuff1[x] + 2;
+          m_iUpBufft[x+1] = -iSignDown1;
+          pRec[x] = pClipTbl[pRec[x] + m_iOffsetEo[uiEdgeType]];
+        }
+        m_iUpBufft[iStartX] = iSignDown2;
+        ipSwap     = m_iUpBuff1;
+        m_iUpBuff1 = m_iUpBufft;
+        m_iUpBufft = ipSwap;
+        pRec += iStride;
+      }
+      break;
+    }
+  case SAO_EO_3: // dir: 45
+    {
+      iStartX = (uiLPelX == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth;
+      iStartY = (uiTPelY == 0) ? 1 : 0;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight;
+      if (iStartY == 1)
+      {
+        pRec += iStride;
+      }
+      for (x=iStartX-1; x<iEndX; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pTmpU[x+1]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        x=iStartX;
+        iSignDown1      =  xSign(pRec[x] - pTmpL[y+1]) ;
+        uiEdgeType      =  iSignDown1 + m_iUpBuff1[x] + 2;
+        m_iUpBuff1[x-1] = -iSignDown1;
+        pRec[x] = pClipTbl[pRec[x] + m_iOffsetEo[uiEdgeType]];
+        for (x=iStartX+1; x<iEndX; x++)
+        {
+          iSignDown1      =  xSign(pRec[x] - pRec[x+iStride-1]) ;
+          uiEdgeType      =  iSignDown1 + m_iUpBuff1[x] + 2;
+          m_iUpBuff1[x-1] = -iSignDown1;
+          pRec[x] = pClipTbl[pRec[x] + m_iOffsetEo[uiEdgeType]];
+        }
+        m_iUpBuff1[iEndX-1] = xSign(pRec[iEndX-1 + iStride] - pRec[iEndX]);
+        pRec += iStride;
+      }
+      break;
+    }
+  case SAO_BO:
+    {
+      for (y=0; y<iLcuHeight; y++)
+      {
+        for (x=0; x<iLcuWidth; x++)
+        {
+          pRec[x] = pOffsetBo[pRec[x]];
+        }
+        pRec += iStride;
+      }
+      break;
+    }
+  default: break;
+  }
+//   if (iSaoType!=SAO_BO_0 || iSaoType!=SAO_BO_1)
+  {
+    pTmpLSwap = m_pTmpL1;
+    m_pTmpL1  = m_pTmpL2;
+    m_pTmpL2  = pTmpLSwap;
+  }
+}
+/** Sample adaptive offset process
+ * \param pcPic, pcSaoParam
+ */
+Void TComSampleAdaptiveOffset::SAOProcess(SAOParam* pcSaoParam)
+{
+  {
+    m_uiSaoBitIncreaseY = max(g_bitDepthY - 10, 0);
+    m_uiSaoBitIncreaseC = max(g_bitDepthC - 10, 0);
+    if(m_bUseNIF)
+    {
+      m_pcPic->getPicYuvRec()->copyToPic(m_pcYuvTmp);
+    }
+    if (m_saoLcuBasedOptimization)
+    {
+      pcSaoParam->oneUnitFlag[0] = 0;
+      pcSaoParam->oneUnitFlag[1] = 0;
+      pcSaoParam->oneUnitFlag[2] = 0;
+    }
+    Int iY  = 0;
+    {
+      processSaoUnitAll( pcSaoParam->saoLcuParam[iY], pcSaoParam->oneUnitFlag[iY], iY);
+    }
+    {
+       processSaoUnitAll( pcSaoParam->saoLcuParam[1], pcSaoParam->oneUnitFlag[1], 1);//Cb
+       processSaoUnitAll( pcSaoParam->saoLcuParam[2], pcSaoParam->oneUnitFlag[2], 2);//Cr
+    }
+    m_pcPic = NULL;
+  }
+}
+Pel* TComSampleAdaptiveOffset::getPicYuvAddr(TComPicYuv* pcPicYuv, Int iYCbCr, Int iAddr)
+{
+  switch (iYCbCr)
+  {
+  case 0:
+    return pcPicYuv->getLumaAddr(iAddr);
+    break;
+  case 1:
+    return pcPicYuv->getCbAddr(iAddr);
+    break;
+  case 2:
+    return pcPicYuv->getCrAddr(iAddr);
+        srcLine += srcStride;
+        resLine += resStride;
+      }
+    }
     break;
   default:
+    return NULL;
+    {
+      printf("Not a supported SAO types\n");
+      assert(0);
+      exit(-1);
+    }
+  }
+}
+Void TComSampleAdaptiveOffset::offsetCTU(Int ctu, TComPicYuv* srcYuv, TComPicYuv* resYuv, SAOBlkParam& saoblkParam, TComPic* pPic)
+{
+  Bool isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail;
+  if(
+    (saoblkParam[SAO_Y ].modeIdc == SAO_MODE_OFF) &&
+    (saoblkParam[SAO_Cb].modeIdc == SAO_MODE_OFF) &&
+    (saoblkParam[SAO_Cr].modeIdc == SAO_MODE_OFF)
+    )
+  {
+    return;
+  }
+  //block boundary availability
+  pPic->getPicSym()->deriveLoopFilterBoundaryAvailibility(ctu, isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail);
+  Int yPos   = (ctu / m_numCTUInWidth)*m_maxCUHeight;
+  Int xPos   = (ctu % m_numCTUInWidth)*m_maxCUWidth;
+  Int height = (yPos + m_maxCUHeight > m_picHeight)?(m_picHeight- yPos):m_maxCUHeight;
+  Int width  = (xPos + m_maxCUWidth  > m_picWidth )?(m_picWidth - xPos):m_maxCUWidth;
+  for(Int compIdx= 0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+  {
+    SAOOffset& ctbOffset = saoblkParam[compIdx];
+    if(ctbOffset.modeIdc != SAO_MODE_OFF)
+    {
+      Bool isLuma     = (compIdx == SAO_Y);
+      Int  formatShift= isLuma?0:1;
+      Int  blkWidth   = (width  >> formatShift);
+      Int  blkHeight  = (height >> formatShift);
+      Int  blkYPos    = (yPos   >> formatShift);
+      Int  blkXPos    = (xPos   >> formatShift);
+      Int  srcStride = isLuma?srcYuv->getStride():srcYuv->getCStride();
+      Pel* srcBlk    = getPicBuf(srcYuv, compIdx)+ (yPos >> formatShift)*srcStride+ (xPos >> formatShift);
+      Int  resStride  = isLuma?resYuv->getStride():resYuv->getCStride();
+      Pel* resBlk     = getPicBuf(resYuv, compIdx)+ blkYPos*resStride+ blkXPos;
+      offsetBlock( compIdx, ctbOffset.typeIdc, ctbOffset.offset
+                  , srcBlk, resBlk, srcStride, resStride, blkWidth, blkHeight
+                  , isLeftAvail, isRightAvail
+                  , isAboveAvail, isBelowAvail
+                  , isAboveLeftAvail, isAboveRightAvail
+                  , isBelowLeftAvail, isBelowRightAvail
+                  );
+    }
+  } //compIdx
+}
+Void TComSampleAdaptiveOffset::SAOProcess(TComPic* pDecPic)
+{
+  if(!m_picSAOEnabled[SAO_Y] && !m_picSAOEnabled[SAO_Cb] && !m_picSAOEnabled[SAO_Cr])
+  {
+    return;
+  }
+  TComPicYuv* resYuv = pDecPic->getPicYuvRec();
+  TComPicYuv* srcYuv = m_tempPicYuv;
+  resYuv->copyToPic(srcYuv);
+  for(Int ctu= 0; ctu < m_numCTUsPic; ctu++)
+  {
+    offsetCTU(ctu, srcYuv, resYuv, (pDecPic->getPicSym()->getSAOBlkParam())[ctu], pDecPic);
+  } //ctu
+}
+Pel* TComSampleAdaptiveOffset::getPicBuf(TComPicYuv* pPicYuv, Int compIdx)
+{
+  Pel* pBuf = NULL;
+  switch(compIdx)
+  {
+  case SAO_Y:
+    {
+      pBuf = pPicYuv->getLumaAddr();
+    }
     break;
+  }
+}
+/** Process SAO all units
+ * \param saoLcuParam SAO LCU parameters
+ * \param oneUnitFlag one unit flag
+ * \param yCbCr color componet index
+ */
+Void TComSampleAdaptiveOffset::processSaoUnitAll(SaoLcuParam* saoLcuParam, Bool oneUnitFlag, Int yCbCr)
+{
+  Pel *pRec;
+  Int picWidthTmp;
+  if (yCbCr == 0)
+  {
+    pRec        = m_pcPic->getPicYuvRec()->getLumaAddr();
+    picWidthTmp = m_iPicWidth;
+  }
+  else if (yCbCr == 1)
+  {
+    pRec        = m_pcPic->getPicYuvRec()->getCbAddr();
+    picWidthTmp = m_iPicWidth>>1;
+  }
+  else
+  {
+    pRec        = m_pcPic->getPicYuvRec()->getCrAddr();
+    picWidthTmp = m_iPicWidth>>1;
+  }
+  memcpy(m_pTmpU1, pRec, sizeof(Pel)*picWidthTmp);
+  Int  i;
+  UInt edgeType;
+  Pel* ppLumaTable = NULL;
+  Pel* pClipTable = NULL;
+  Int* pOffsetBo = NULL;
+  Int  typeIdx;
+  Int offset[LUMA_GROUP_NUM+1];
+  Int idxX;
+  Int idxY;
+  Int addr;
+  Int frameWidthInCU = m_pcPic->getFrameWidthInCU();
+  Int frameHeightInCU = m_pcPic->getFrameHeightInCU();
+  Int stride;
+  Pel *tmpUSwap;
+  Int isChroma = (yCbCr == 0) ? 0:1;
+  Bool mergeLeftFlag;
+  Int saoBitIncrease = (yCbCr == 0) ? m_uiSaoBitIncreaseY : m_uiSaoBitIncreaseC;
+  pOffsetBo = (yCbCr==0) ? m_iOffsetBo : m_iChromaOffsetBo;
+  offset[0] = 0;
+  for (idxY = 0; idxY< frameHeightInCU; idxY++)
+  {
+    addr = idxY * frameWidthInCU;
+    if (yCbCr == 0)
+    {
+      pRec  = m_pcPic->getPicYuvRec()->getLumaAddr(addr);
+      stride = m_pcPic->getStride();
+      picWidthTmp = m_iPicWidth;
+    }
+    else if (yCbCr == 1)
+    {
+      pRec  = m_pcPic->getPicYuvRec()->getCbAddr(addr);
+      stride = m_pcPic->getCStride();
+      picWidthTmp = m_iPicWidth>>1;
+    }
+    else
+    {
+      pRec  = m_pcPic->getPicYuvRec()->getCrAddr(addr);
+      stride = m_pcPic->getCStride();
+      picWidthTmp = m_iPicWidth>>1;
+    }
+    //     pRec += iStride*(m_uiMaxCUHeight-1);
+    for (i=0;i<(m_uiMaxCUHeight>>isChroma)+1;i++)
+    {
+      m_pTmpL1[i] = pRec[0];
+      pRec+=stride;
+    }
+    pRec-=(stride<<1);
+    memcpy(m_pTmpU2, pRec, sizeof(Pel)*picWidthTmp);
+    for (idxX = 0; idxX < frameWidthInCU; idxX++)
+    {
+      addr = idxY * frameWidthInCU + idxX;
+      if (oneUnitFlag)
+      {
+        typeIdx = saoLcuParam[0].typeIdx;
+        mergeLeftFlag = (addr == 0)? 0:1;
+      }
+      else
+      {
+        typeIdx = saoLcuParam[addr].typeIdx;
+        mergeLeftFlag = saoLcuParam[addr].mergeLeftFlag;
+      }
+      if (typeIdx>=0)
+      {
+        if (!mergeLeftFlag)
+        {
+          if (typeIdx == SAO_BO)
+          {
+            for (i=0; i<SAO_MAX_BO_CLASSES+1;i++)
+            {
+              offset[i] = 0;
+            }
+            for (i=0; i<saoLcuParam[addr].length; i++)
+            {
+              offset[ (saoLcuParam[addr].subTypeIdx +i)%SAO_MAX_BO_CLASSES  +1] = saoLcuParam[addr].offset[i] << saoBitIncrease;
+            }
+            ppLumaTable = (yCbCr==0)?m_lumaTableBo:m_chromaTableBo;
+            pClipTable = (yCbCr==0)?m_pClipTable:m_pChromaClipTable;
+            Int bitDepth = (yCbCr==0) ? g_bitDepthY : g_bitDepthC;
+            for (i=0;i<(1<<bitDepth);i++)
+            {
+              pOffsetBo[i] = pClipTable[i + offset[ppLumaTable[i]]];
+            }
+          }
+          if (typeIdx == SAO_EO_0 || typeIdx == SAO_EO_1 || typeIdx == SAO_EO_2 || typeIdx == SAO_EO_3)
+          {
+            for (i=0;i<saoLcuParam[addr].length;i++)
+            {
+              offset[i+1] = saoLcuParam[addr].offset[i] << saoBitIncrease;
+            }
+            for (edgeType=0;edgeType<6;edgeType++)
+            {
+              m_iOffsetEo[edgeType]= offset[m_auiEoTable[edgeType]];
+            }
+          }
+        }
+        processSaoCu(addr, typeIdx, yCbCr);
+      }
+      else
+      {
+        if (idxX != (frameWidthInCU-1))
+        {
+          if (yCbCr == 0)
+          {
+            pRec  = m_pcPic->getPicYuvRec()->getLumaAddr(addr);
+            stride = m_pcPic->getStride();
+          }
+          else if (yCbCr == 1)
+          {
+            pRec  = m_pcPic->getPicYuvRec()->getCbAddr(addr);
+            stride = m_pcPic->getCStride();
+          }
+          else
+          {
+            pRec  = m_pcPic->getPicYuvRec()->getCrAddr(addr);
+            stride = m_pcPic->getCStride();
+          }
+          Int widthShift = m_uiMaxCUWidth>>isChroma;
+          for (i=0;i<(m_uiMaxCUHeight>>isChroma)+1;i++)
+          {
+            m_pTmpL1[i] = pRec[widthShift-1];
+            pRec+=stride;
+          }
+        }
+      }
+    }
+    tmpUSwap = m_pTmpU1;
+    m_pTmpU1 = m_pTmpU2;
+    m_pTmpU2 = tmpUSwap;
+  }
+}
+/** Reset SAO LCU part
+ * \param saoLcuParam
+ */
+Void TComSampleAdaptiveOffset::resetLcuPart(SaoLcuParam* saoLcuParam)
+{
+  Int i,j;
+  for (i=0;i<m_iNumCuInWidth*m_iNumCuInHeight;i++)
+  {
+    saoLcuParam[i].mergeUpFlag     =  1;
+    saoLcuParam[i].mergeLeftFlag =  0;
+    saoLcuParam[i].partIdx   =  0;
+    saoLcuParam[i].typeIdx      = -1;
+    for (j=0;j<MAX_NUM_SAO_OFFSETS;j++)
+    {
+      saoLcuParam[i].offset[j] = 0;
+    }
+    saoLcuParam[i].subTypeIdx = 0;
+  }
+}
+/** convert QP part to SAO unit
+* \param saoParam SAO parameter
+* \param partIdx SAO part index
+* \param yCbCr color component index
+ */
+Void TComSampleAdaptiveOffset::convertQT2SaoUnit(SAOParam *saoParam, UInt partIdx, Int yCbCr)
+{
+  SAOQTPart*  saoPart= &(saoParam->psSaoPart[yCbCr][partIdx]);
+  if (!saoPart->bSplit)
+  {
+    convertOnePart2SaoUnit(saoParam, partIdx, yCbCr);
+    return;
+  }
+  if (saoPart->PartLevel < m_uiMaxSplitLevel)
+  {
+    convertQT2SaoUnit(saoParam, saoPart->DownPartsIdx[0], yCbCr);
+    convertQT2SaoUnit(saoParam, saoPart->DownPartsIdx[1], yCbCr);
+    convertQT2SaoUnit(saoParam, saoPart->DownPartsIdx[2], yCbCr);
+    convertQT2SaoUnit(saoParam, saoPart->DownPartsIdx[3], yCbCr);
+  }
+}
+/** convert one SAO part to SAO unit
+* \param saoParam SAO parameter
+* \param partIdx SAO part index
+* \param yCbCr color component index
+ */
+Void TComSampleAdaptiveOffset::convertOnePart2SaoUnit(SAOParam *saoParam, UInt partIdx, Int yCbCr)
+{
+  Int j;
+  Int idxX;
+  Int idxY;
+  Int addr;
+  Int frameWidthInCU = m_pcPic->getFrameWidthInCU();
+  SAOQTPart* saoQTPart = saoParam->psSaoPart[yCbCr];
+  SaoLcuParam* saoLcuParam = saoParam->saoLcuParam[yCbCr];
+  for (idxY = saoQTPart[partIdx].StartCUY; idxY<= saoQTPart[partIdx].EndCUY; idxY++)
+  {
+    for (idxX = saoQTPart[partIdx].StartCUX; idxX<= saoQTPart[partIdx].EndCUX; idxX++)
+    {
+      addr = idxY * frameWidthInCU + idxX;
+      saoLcuParam[addr].partIdxTmp = (Int)partIdx;
+      saoLcuParam[addr].typeIdx    = saoQTPart[partIdx].iBestType;
+      saoLcuParam[addr].subTypeIdx = saoQTPart[partIdx].subTypeIdx;
+      if (saoLcuParam[addr].typeIdx!=-1)
+      {
+        saoLcuParam[addr].length    = saoQTPart[partIdx].iLength;
+        for (j=0;j<MAX_NUM_SAO_OFFSETS;j++)
+        {
+          saoLcuParam[addr].offset[j] = saoQTPart[partIdx].iOffset[j];
+        }
+      }
+      else
+      {
+        saoLcuParam[addr].length    = 0;
+        saoLcuParam[addr].subTypeIdx = saoQTPart[partIdx].subTypeIdx;
+        for (j=0;j<MAX_NUM_SAO_OFFSETS;j++)
+        {
+          saoLcuParam[addr].offset[j] = 0;
+        }
+      }
+    }
+  }
+}
+Void TComSampleAdaptiveOffset::resetSaoUnit(SaoLcuParam* saoUnit)
+{
+  saoUnit->partIdx       = 0;
+  saoUnit->partIdxTmp    = 0;
+  saoUnit->mergeLeftFlag = 0;
+  saoUnit->mergeUpFlag   = 0;
+  saoUnit->typeIdx       = -1;
+  saoUnit->length        = 0;
+  saoUnit->subTypeIdx    = 0;
+  for (Int i=0;i<4;i++)
+  {
+    saoUnit->offset[i] = 0;
+  }
+}
+Void TComSampleAdaptiveOffset::copySaoUnit(SaoLcuParam* saoUnitDst, SaoLcuParam* saoUnitSrc )
+{
+  saoUnitDst->mergeLeftFlag = saoUnitSrc->mergeLeftFlag;
+  saoUnitDst->mergeUpFlag   = saoUnitSrc->mergeUpFlag;
+  saoUnitDst->typeIdx       = saoUnitSrc->typeIdx;
+  saoUnitDst->length        = saoUnitSrc->length;
+  saoUnitDst->subTypeIdx  = saoUnitSrc->subTypeIdx;
+  for (Int i=0;i<4;i++)
+  {
+    saoUnitDst->offset[i] = saoUnitSrc->offset[i];
+  }
+}
+/** PCM LF disable process.
+  case SAO_Cb:
+    {
+      pBuf = pPicYuv->getCbAddr();
+    }
+    break;
+  case SAO_Cr:
+    {
+      pBuf = pPicYuv->getCrAddr();
+    }
+    break;
+  default:
+    {
+      printf("Not a legal component ID for SAO\n");
+      assert(0);
+      exit(-1);
+    }
+  }
+  return pBuf;
+}
+/** PCM LF disable process.
  * \param pcPic picture (TComPic) pointer
  * \returns Void

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComSampleAdaptiveOffset.h

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+ * Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 // ====================================================================================================================
+#define SAO_MAX_DEPTH                 4
+#define SAO_BO_BITS                   5
+#define LUMA_GROUP_NUM                (1<<SAO_BO_BITS)
+#define MAX_NUM_SAO_OFFSETS           4
+#define MAX_NUM_SAO_CLASS             33
+#define MAX_SAO_TRUNCATED_BITDEPTH     10
 // ====================================================================================================================
 // Class definition
 // ====================================================================================================================
+extern UInt g_saoMaxOffsetQVal[NUM_SAO_COMPONENTS];
-/// Sample Adaptive Offset class
 class TComSampleAdaptiveOffset
+{
+public:
+  TComSampleAdaptiveOffset();
+  virtual ~TComSampleAdaptiveOffset();
+  Void SAOProcess(TComPic* pDecPic);
+  Void create( Int picWidth, Int picHeight, UInt maxCUWidth, UInt maxCUHeight, UInt maxCUDepth );
+  Void destroy();
+  Void reconstructBlkSAOParams(TComPic* pic, SAOBlkParam* saoBlkParams);
+  Void PCMLFDisableProcess (TComPic* pcPic);
 protected:
+  TComPic*          m_pcPic;
+  Void offsetBlock(Int compIdx, Int typeIdx, Int* offset, Pel* srcBlk, Pel* resBlk, Int srcStride, Int resStride,  Int width, Int height
+                  , Bool isLeftAvail, Bool isRightAvail, Bool isAboveAvail, Bool isBelowAvail, Bool isAboveLeftAvail, Bool isAboveRightAvail, Bool isBelowLeftAvail, Bool isBelowRightAvail);
+  Pel* getPicBuf(TComPicYuv* pPicYuv, Int compIdx);
+  Void invertQuantOffsets(Int compIdx, Int typeIdc, Int typeAuxInfo, Int* dstOffsets, Int* srcOffsets);
+  Void reconstructBlkSAOParam(SAOBlkParam& recParam, std::vector<SAOBlkParam*>& mergeList);
+  Int  getMergeList(TComPic* pic, Int ctu, SAOBlkParam* blkParams, std::vector<SAOBlkParam*>& mergeList);
+  Void offsetCTU(Int ctu, TComPicYuv* srcYuv, TComPicYuv* resYuv, SAOBlkParam& saoblkParam, TComPic* pPic);
+  Void xPCMRestoration(TComPic* pcPic);
+  Void xPCMCURestoration ( TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth );
+  Void xPCMSampleRestoration (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, TextType ttText);
+protected:
+  UInt m_offsetStepLog2[NUM_SAO_COMPONENTS]; //offset step
+  Int* m_offsetClip[NUM_SAO_COMPONENTS]; //clip table for fast operation
+  Short* m_sign; //sign table for fast operation
+  TComPicYuv*   m_tempPicYuv; //temporary buffer
+  Int m_picWidth;
+  Int m_picHeight;
+  Int m_maxCUWidth;
+  Int m_maxCUHeight;
+  Int m_numCTUInWidth;
+  Int m_numCTUInHeight;
+  Int m_numCTUsPic;
+  Int m_lineBufWidth;
+  Char* m_signLineBuf1;
+  Char* m_signLineBuf2;
+private:
+  Bool m_picSAOEnabled[NUM_SAO_COMPONENTS];
+  Int*   m_offsetClipTable[NUM_SAO_COMPONENTS];
+  Short* m_signTable;
-  static const UInt m_uiMaxDepth;
-  static const Int m_aiNumCulPartsLevel[5];
-  static const UInt m_auiEoTable[9];
-  Int *m_iOffsetBo;
-  Int *m_iChromaOffsetBo;
-  Int m_iOffsetEo[LUMA_GROUP_NUM];
-  Int  m_iPicWidth;
-  Int  m_iPicHeight;
-  UInt m_uiMaxSplitLevel;
-  UInt m_uiMaxCUWidth;
-  UInt m_uiMaxCUHeight;
-  Int  m_iNumCuInWidth;
-  Int  m_iNumCuInHeight;
-  Int  m_iNumTotalParts;
-  static const Int m_iNumClass[MAX_NUM_SAO_TYPE];
-  UInt m_uiSaoBitIncreaseY;
-  UInt m_uiSaoBitIncreaseC;  //for chroma
-  UInt m_uiQP;
-  Pel   *m_pClipTable;
-  Pel   *m_pClipTableBase;
-  Pel   *m_lumaTableBo;
-  Pel   *m_pChromaClipTable;
-  Pel   *m_pChromaClipTableBase;
-  Pel   *m_chromaTableBo;
-  Int   *m_iUpBuff1;
-  Int   *m_iUpBuff2;
-  Int   *m_iUpBufft;
-  Int   *ipSwap;
-  Bool  m_bUseNIF;       //!< true for performing non-cross slice boundary ALF
-  TComPicYuv* m_pcYuvTmp;    //!< temporary picture buffer pointer when non-across slice/tile boundary SAO is enabled
-  Pel* m_pTmpU1;
-  Pel* m_pTmpU2;
-  Pel* m_pTmpL1;
-  Pel* m_pTmpL2;
-  Int     m_maxNumOffsetsPerPic;
-  Bool    m_saoLcuBoundary;
-  Bool    m_saoLcuBasedOptimization;
-  Void xPCMRestoration        (TComPic* pcPic);
-  Void xPCMCURestoration      (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth);
-  Void xPCMSampleRestoration  (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, TextType ttText);
-public:
-  TComSampleAdaptiveOffset         ();
-  virtual ~TComSampleAdaptiveOffset();
-  Void create( UInt uiSourceWidth, UInt uiSourceHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight );
-  Void destroy ();
-  Int  convertLevelRowCol2Idx(Int level, Int row, Int col);
-  Void initSAOParam   (SAOParam *pcSaoParam, Int iPartLevel, Int iPartRow, Int iPartCol, Int iParentPartIdx, Int StartCUX, Int EndCUX, Int StartCUY, Int EndCUY, Int iYCbCr);
-  Void allocSaoParam  (SAOParam* pcSaoParam);
-  Void resetSAOParam  (SAOParam *pcSaoParam);
-  static Void freeSaoParam   (SAOParam *pcSaoParam);
-  Void SAOProcess(SAOParam* pcSaoParam);
-  Void processSaoCu(Int iAddr, Int iSaoType, Int iYCbCr);
-  Pel* getPicYuvAddr(TComPicYuv* pcPicYuv, Int iYCbCr,Int iAddr = 0);
-  Void processSaoCuOrg(Int iAddr, Int iPartIdx, Int iYCbCr);  //!< LCU-basd SAO process without slice granularity
-  Void createPicSaoInfo(TComPic* pcPic);
-  Void destroyPicSaoInfo();
-  Void processSaoBlock(Pel* pDec, Pel* pRest, Int stride, Int iSaoType, UInt width, UInt height, Bool* pbBorderAvail, Int iYCbCr);
-  Void resetLcuPart(SaoLcuParam* saoLcuParam);
-  Void convertQT2SaoUnit(SAOParam* saoParam, UInt partIdx, Int yCbCr);
-  Void convertOnePart2SaoUnit(SAOParam *saoParam, UInt partIdx, Int yCbCr);
-  Void processSaoUnitAll(SaoLcuParam* saoLcuParam, Bool oneUnitFlag, Int yCbCr);
-  Void setSaoLcuBoundary (Bool bVal)  {m_saoLcuBoundary = bVal;}
-  Bool getSaoLcuBoundary ()           {return m_saoLcuBoundary;}
-  Void setSaoLcuBasedOptimization (Bool bVal)  {m_saoLcuBasedOptimization = bVal;}
-  Bool getSaoLcuBasedOptimization ()           {return m_saoLcuBasedOptimization;}
-  Void resetSaoUnit(SaoLcuParam* saoUnit);
-  Void copySaoUnit(SaoLcuParam* saoUnitDst, SaoLcuParam* saoUnitSrc );
-  Void PCMLFDisableProcess    ( TComPic* pcPic);                        ///< interface function for ALF process
 };

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComSlice.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 , m_colFromL0Flag                 ( 1 )
 , m_colRefIdx                     ( 0 )
-#if SAO_CHROMA_LAMBDA
-, m_dLambdaLuma( 0.0 )
-, m_dLambdaChroma( 0.0 )
-#else
-, m_dLambda                       ( 0.0 )
-#endif
 , m_uiTLayer                      ( 0 )
 , m_bTLayerSwitchingFlag          ( false )
 …
   initEqualRef();
+  for (Int component = 0; component < 3; component++)
+  {
+    m_lambdas[component] = 0.0;
+  }
   for ( Int idx = 0; idx < MAX_NUM_REF; idx++ )
+  {
 …
   initWpAcDcParam();
   m_saoEnabledFlag = false;
+  m_saoEnabledFlagChroma = false;
 #if H_MV
   for (Int i = 0; i < MAX_NUM_LAYERS; i++ )
 …
+  }
+}
 #if !H_MV
-#if FIX1071
 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
+#else
+Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
+#endif
+{
+#if FIX1071
+{
   if (!checkNumPocTotalCurr)
-#endif
+  {
     if (m_eSliceType == I_SLICE)
 …
   TComPic*  rpsCurrList1[MAX_NUM_REF+1];
   Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
-#if FIX1071
   if (checkNumPocTotalCurr)
+  {
 …
     m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
+  }
-#endif
   Int cIdx = 0;
 …
+{
   TComPic*                 rpcPic;
+#if !FIX1172
   setAssociatedIRAPPOC(pocCRA);
+#endif
   Int pocCurr = getPOC();
 …
   m_colFromL0Flag        = pSrc->m_colFromL0Flag;
   m_colRefIdx            = pSrc->m_colRefIdx;
+#if SAO_CHROMA_LAMBDA
+  m_dLambdaLuma          = pSrc->m_dLambdaLuma;
+  m_dLambdaChroma        = pSrc->m_dLambdaChroma;
+#else
+  m_dLambda              = pSrc->m_dLambda;
+#endif
+  setLambdas(pSrc->getLambdas());
   for (i = 0; i < 2; i++)
+  {
 …
+  {
     rpcPic = *(iterPic++);
+#if BUGFIX_INTRAPERIOD
+    if(!rpcPic->getReconMark())
+    {
+      continue;
+    }
+#endif
     if (rpcPic->getPOC() == this->getPOC())
+    {
 …
     assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getUsedByCurr()==0||rpcPic->getTLayer()<=this->getTLayer());
     //check that pictures of higher or equal temporal layer are not in the RPS if the current picture is a TSA picture
     if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TLA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
+    if(this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_R || this->getNalUnitType() == NAL_UNIT_CODED_SLICE_TSA_N)
+    {
       assert(rpcPic->getSlice( 0 )->isReferenced()==0||rpcPic->getTLayer()<this->getTLayer());
 …
 /** Function for constructing an explicit Reference Picture Set out of the available pictures in a referenced Reference Picture Set
 */
-#if FIX1071
 Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP)
-#else
-Void TComSlice::createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet)
-#endif
+{
   TComPic* rpcPic;
 …
         // and should be added to the explicit Reference Picture Set
         pcRPS->setDeltaPOC(k, pReferencePictureSet->getDeltaPOC(i));
-#if FIX1071
         pcRPS->setUsed(k, pReferencePictureSet->getUsed(i) && (!isRAP));
-#else
-        pcRPS->setUsed(k, pReferencePictureSet->getUsed(i));
-#endif
         if(pcRPS->getDeltaPOC(k) < 0)
+        {
 …
 , m_qpBDOffsetY               (  0)
 , m_qpBDOffsetC               (  0)
-, m_useLossless               (false)
 , m_uiPCMBitDepthLuma         (  8)
 , m_uiPCMBitDepthChroma       (  8)
 …
     for(UInt listId=0;listId<g_scalingListNum[sizeId];listId++)
+    {
       getScalingList()->processDefaultMarix(sizeId, listId);
+      getScalingList()->processDefaultMatrix(sizeId, listId);
+    }
+  }
 …
  * \param Index of input matrix
  */
 Void TComScalingList::processDefaultMarix(UInt sizeId, UInt listId)
+Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)
+{
   ::memcpy(getScalingListAddress(sizeId, listId),getScalingListDefaultAddress(sizeId,listId),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]));
 …
       if(getScalingListDC(sizeId,listId) == 0)
+      {
         processDefaultMarix(sizeId, listId);
+        processDefaultMatrix(sizeId, listId);
+      }
+    }

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComSlice.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   UInt     getRefMatrixId                 (UInt sizeId, UInt listId)           { return m_refMatrixId[sizeId][listId]; }     //!< get reference matrix ID
   Int*     getScalingListDefaultAddress   (UInt sizeId, UInt listId);                                                        //!< get default matrix coefficient
   Void     processDefaultMarix            (UInt sizeId, UInt listId);
+  Void     processDefaultMatrix            (UInt sizeId, UInt listId);
   Void     setScalingListDC               (UInt sizeId, UInt listId, UInt u)   { m_scalingListDC[sizeId][listId] = u; }      //!< set DC value
 …
   UInt    getNumReorderPics(UInt tLayer)                        { return m_numReorderPics[tLayer]; }
   Void    setMaxDecPicBuffering(UInt v, UInt tLayer)            { m_uiMaxDecPicBuffering[tLayer] = v;    }
+  Void    setMaxDecPicBuffering(UInt v, UInt tLayer)            { assert(tLayer < MAX_TLAYER); m_uiMaxDecPicBuffering[tLayer] = v;    }
   UInt    getMaxDecPicBuffering(UInt tLayer)                    { return m_uiMaxDecPicBuffering[tLayer]; }
 …
   Int         m_qpBDOffsetY;
   Int         m_qpBDOffsetC;
-  Bool        m_useLossless;
   UInt        m_uiPCMBitDepthLuma;
 …
   UInt getMaxTrSize   ()         { return  m_uiMaxTrSize;   }
-  // Tool list
-  Bool getUseLossless ()         { return m_useLossless; }
-  Void setUseLossless ( Bool b ) { m_useLossless  = b; }
   // AMP accuracy
   Int       getAMPAcc   ( UInt uiDepth ) { return m_iAMPAcc[uiDepth]; }
 …
   TComScalingList* getScalingList ()       { return m_scalingList; }               //!< get ScalingList class pointer in SPS
   UInt getMaxDecPicBuffering  (UInt tlayer)            { return m_uiMaxDecPicBuffering[tlayer]; }
   Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { m_uiMaxDecPicBuffering[tlayer] = ui;   }
+  Void setMaxDecPicBuffering  ( UInt ui, UInt tlayer ) { assert(tlayer < MAX_TLAYER);  m_uiMaxDecPicBuffering[tlayer] = ui;   }
   UInt getMaxLatencyIncrease  (UInt tlayer)            { return m_uiMaxLatencyIncrease[tlayer];   }
   Void setMaxLatencyIncrease  ( UInt ui , UInt tlayer) { m_uiMaxLatencyIncrease[tlayer] = ui;      }
 …
   UInt        m_maxNumMergeCand;
+#if SAO_CHROMA_LAMBDA
+  Double      m_dLambdaLuma;
+  Double      m_dLambdaChroma;
+#else
+  Double      m_dLambda;
+#endif
+  Double      m_lambdas[3];
   Bool        m_abEqualRef  [2][MAX_NUM_REF][MAX_NUM_REF];
 …
   Void      setRefPicList        ( std::vector<TComPic*> rpsCurrList[2], std::vector<Bool> usedAsLongTerm[2], Int numPocTotalCurr, Bool checkNumPocTotalCurr = false );
 #else
-#if FIX1071
   Void      setRefPicList       ( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
-#else
-  Void      setRefPicList       ( TComList<TComPic*>& rcListPic );
-#endif
 #endif
   Void      setRefPOCList       ();
 …
   Bool      isInterP        ()                          { return  m_eSliceType == P_SLICE;  }
+#if SAO_CHROMA_LAMBDA
+  Void      setLambda( Double d, Double e ) { m_dLambdaLuma = d; m_dLambdaChroma = e;}
+  Double    getLambdaLuma() { return m_dLambdaLuma;        }
+  Double    getLambdaChroma() { return m_dLambdaChroma;        }
+#else
+  Void      setLambda( Double d ) { m_dLambda = d; }
+  Double    getLambda() { return m_dLambda;        }
+#endif
+  Void      setLambdas ( const Double lambdas[3] ) { for (Int component = 0; component < 3; component++) m_lambdas[component] = lambdas[component]; }
+  const Double* getLambdas() const { return m_lambdas; }
   Void      initEqualRef();
 …
   Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
   Int       checkThatAllRefPicsAreAvailable( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool printErrors, Int pocRandomAccess = 0);
-#if FIX1071
   Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet, Bool isRAP);
-#else
-  Void      createExplicitReferencePictureSetFromReference( TComList<TComPic*>& rcListPic, TComReferencePictureSet *pReferencePictureSet);
-#endif
   Void setMaxNumMergeCand               (UInt val )         { m_maxNumMergeCand = val;                    }

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComTrQuant.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
     UInt uiLog2TrSize = g_aucConvertToBit[ iWidth ] + 2;
     Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTType];
     assert(scalingListType < 6);
+    assert(scalingListType < SCALING_LIST_NUM);
     Int *piQuantCoeff = 0;
     piQuantCoeff = getQuantCoeff(scalingListType,m_cQP.m_iRem,uiLog2TrSize-2);
 …
     Pel* pResi = rpcResidual + uiAddr;
     Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTxt];
     assert(scalingListType < 6);
+    assert(scalingListType < SCALING_LIST_NUM);
     invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), eTxt, REG_DCT, pResi, uiStride, rpcCoeff, uiWidth, uiHeight, scalingListType, pcCU->getTransformSkip(uiAbsPartIdx, eTxt) );
+  }
 …
   const UInt uiMaxNumCoeff       = uiWidth * uiHeight;
   Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eTType];
   assert(scalingListType < 6);
+  assert(scalingListType < SCALING_LIST_NUM);
   Int iQBits = QUANT_SHIFT + m_cQP.m_iPer + iTransformShift;                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits
 …
               Int64 costUp   = rdFactor * ( - deltaU[uiBlkPos] ) + rateIncUp[uiBlkPos] ;
               Int64 costDown = rdFactor * (   deltaU[uiBlkPos] ) + rateIncDown[uiBlkPos]
               -   ( abs(piDstCoeff[uiBlkPos])==1?((1<<15)+sigRateDelta[uiBlkPos]):0 );
+              -   ((abs(piDstCoeff[uiBlkPos]) == 1) ? sigRateDelta[uiBlkPos] : 0);
               if(lastCG==1 && lastNZPosInCG==n && abs(piDstCoeff[uiBlkPos])==1)
 …
+  {
     Double dErr         = Double( lLevelDouble  - ( uiAbsLevel << iQBits ) );
     Double dCurrCost    = dErr * dErr * dTemp + xGetICRateCost( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice, c1Idx, c2Idx );
+    Double dCurrCost    = dErr * dErr * dTemp + xGetICost(xGetICRate( uiAbsLevel, ui16CtxNumOne, ui16CtxNumAbs, ui16AbsGoRice, c1Idx, c2Idx ));
     dCurrCost          += dCurrCostSig;
 …
  * \returns cost of given absolute transform level
  */
 __inline Double TComTrQuant::xGetICRateCost  ( UInt                            uiAbsLevel,
+__inline Int TComTrQuant::xGetICRate  ( UInt                            uiAbsLevel,
                                                UShort                          ui16CtxNumOne,
                                                UShort                          ui16CtxNumAbs,
 …
                                                ) const
+{
   Double iRate = xGetIEPRate();
+  Int iRate = Int(xGetIEPRate());
   UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
 …
   else
+  {
+    assert (0);
+  }
+  return xGetICost( iRate );
+}
+__inline Int TComTrQuant::xGetICRate  ( UInt                            uiAbsLevel,
+                                       UShort                          ui16CtxNumOne,
+                                       UShort                          ui16CtxNumAbs,
+                                       UShort                          ui16AbsGoRice
+                                     , UInt                            c1Idx,
+                                       UInt                            c2Idx
+                                       ) const
+{
+  Int iRate = 0;
+  UInt baseLevel  =  (c1Idx < C1FLAG_NUMBER)? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
+  if ( uiAbsLevel >= baseLevel )
+  {
+    UInt uiSymbol     = uiAbsLevel - baseLevel;
+    UInt uiMaxVlc     = g_auiGoRiceRange[ ui16AbsGoRice ];
+    Bool bExpGolomb   = ( uiSymbol > uiMaxVlc );
+    if( bExpGolomb )
+    {
+      uiAbsLevel  = uiSymbol - uiMaxVlc;
+      Int iEGS    = 1;  for( UInt uiMax = 2; uiAbsLevel >= uiMax; uiMax <<= 1, iEGS += 2 );
+      iRate      += iEGS << 15;
+      uiSymbol    = min<UInt>( uiSymbol, ( uiMaxVlc + 1 ) );
+    }
+    UShort ui16PrefLen = UShort( uiSymbol >> ui16AbsGoRice ) + 1;
+    UShort ui16NumBins = min<UInt>( ui16PrefLen, g_auiGoRicePrefixLen[ ui16AbsGoRice ] ) + ui16AbsGoRice;
+    iRate += ui16NumBins << 15;
+    if (c1Idx < C1FLAG_NUMBER)
+    {
+      iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
+      if (c2Idx < C2FLAG_NUMBER)
+      {
+        iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 1 ];
+      }
+    }
+  }
+  else
+  if( uiAbsLevel == 0 )
+  {
+    return 0;
+  }
+  else if( uiAbsLevel == 1 )
+  {
+    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 0 ];
+  }
+  else if( uiAbsLevel == 2 )
+  {
+    iRate += m_pcEstBitsSbac->m_greaterOneBits[ ui16CtxNumOne ][ 1 ];
+    iRate += m_pcEstBitsSbac->m_levelAbsBits[ ui16CtxNumAbs ][ 0 ];
+  }
+  else
+  {
+    assert(0);
+    iRate = 0;
+  }
   return iRate;

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComTrQuant.h

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #if RDOQ_CHROMA_LAMBDA
   Void setLambda(Double dLambdaLuma, Double dLambdaChroma) { m_dLambdaLuma = dLambdaLuma; m_dLambdaChroma = dLambdaChroma; }
   Void selectLambda(TextType eTType) { m_dLambda = (eTType == TEXT_LUMA) ? m_dLambdaLuma : m_dLambdaChroma; }
+  Void selectLambda(TextType eTType) { m_dLambda = (eTType == TEXT_LUMA) ? m_lambdas[0] : ((eTType == TEXT_CHROMA_U) ? m_lambdas[1] : m_lambdas[2]); }
 #else
   Void setLambda(Double dLambda) { m_dLambda = dLambda;}
 …
   QpParam  m_cQP;
 #if RDOQ_CHROMA_LAMBDA
+  Double   m_dLambdaLuma;
+  Double   m_dLambdaChroma;
+  Double   m_lambdas[3];
 #endif
   Double   m_dLambda;
 …
                                              Double                          dTemp,
                                              Bool                            bLast        ) const;
-  __inline Double xGetICRateCost   ( UInt                            uiAbsLevel,
-                                     UShort                          ui16CtxNumOne,
-                                     UShort                          ui16CtxNumAbs,
-                                     UShort                          ui16AbsGoRice
-                                   , UInt                            c1Idx,
-                                     UInt                            c2Idx
-                                     ) const;
 __inline Int xGetICRate  ( UInt                            uiAbsLevel,
                            UShort                          ui16CtxNumOne,

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComWeightPrediction.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComWeightPrediction.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComYuv.cpp

-                      r622
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
+  {
     ::memcpy( pDst, pSrc, sizeof(Pel)*iWidth);
 #if ENC_DEC_TRACE && H_MV_ENC_DEC_TRAC
     if ( g_traceCopyBack && g_nSymbolCounter >= g_stopAtCounter )
 …
+    }
 #endif
     pDst += iDstStride;
     pSrc += iSrcStride;
 …
+    {
 #if DISABLING_CLIP_FOR_BIPREDME
       pDst[x ] = (pDst[x ]<<1) - pSrc[x ] ;
+      pDst[x ] = 2 * pDst[x] - pSrc[x];
 #else
       pDst[x ] = Clip( (pDst[x ]<<1) - pSrc[x ] );
+      pDst[x ] = ClipY(2 * pDst[x] - pSrc[x]);
 #endif
+    }
 …
+    {
 #if DISABLING_CLIP_FOR_BIPREDME
       pDstU[x ] = (pDstU[x ]<<1) - pSrcU[x ] ;
       pDstV[x ] = (pDstV[x ]<<1) - pSrcV[x ] ;
+      pDstU[x ] = 2 * pDstU[x] - pSrcU[x];
+      pDstV[x ] = 2 * pDstV[x] - pSrcV[x];
 #else
       pDstU[x ] = Clip( (pDstU[x ]<<1) - pSrcU[x ] );
       pDstV[x ] = Clip( (pDstV[x ]<<1) - pSrcV[x ] );
+      pDstU[x ] = ClipC(2 * pDstU[x] - pSrcU[x]);
+      pDstV[x ] = ClipC(2 * pDstV[x] - pSrcV[x]);
 #endif
+    }
 …
+  }
+}
-#if H_3D
-Void TComYuv::addClipPartLuma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiTrUnitIdx, UInt uiPartSize )
+{
-  Int x, y;
-  Pel* pSrc0 = pcYuvSrc0->getLumaAddr( uiTrUnitIdx);
-  Pel* pSrc1 = pcYuvSrc1->getLumaAddr( uiTrUnitIdx);
-  Pel* pDst  = getLumaAddr( uiTrUnitIdx);
-  UInt iSrc0Stride = pcYuvSrc0->getStride();
-  UInt iSrc1Stride = pcYuvSrc1->getStride();
-  UInt iDstStride  = getStride();
-  for ( y = uiPartSize-1; y >= 0; y-- )
+  {
-    for ( x = uiPartSize-1; x >= 0; x-- )
+    {
-      pDst[x] = ClipY( pSrc0[x] + pSrc1[x] );
+    }
-    pSrc0 += iSrc0Stride;
-    pSrc1 += iSrc1Stride;
-    pDst  += iDstStride;
+  }
+}
-#if H_3D_ARP
-Void TComYuv::addARP( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Bool bClip )
+{
-  addARPLuma   ( pcYuvSrc0, pcYuvSrc1, uiAbsPartIdx, uiWidth   , uiHeight    , bClip );
-  addARPChroma ( pcYuvSrc0, pcYuvSrc1, uiAbsPartIdx, uiWidth>>1, uiHeight>>1 , bClip );
+}
-Void TComYuv::addARPLuma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Bool bClip )
+{
-  Int x, y;
-  Pel* pSrc0 = pcYuvSrc0->getLumaAddr( uiAbsPartIdx );
-  Pel* pSrc1 = pcYuvSrc1->getLumaAddr( uiAbsPartIdx );
-  Pel* pDst  = getLumaAddr( uiAbsPartIdx );
-  UInt iSrc0Stride = pcYuvSrc0->getStride();
-  UInt iSrc1Stride = pcYuvSrc1->getStride();
-  UInt iDstStride  = getStride();
-  for ( y = uiHeight-1; y >= 0; y-- )
+  {
-    for ( x = uiWidth-1; x >= 0; x-- )
+    {
-      pDst[x] = pSrc0[x] + pSrc1[x];
-      if( bClip )
+      {
-        pDst[x] = ClipY( pDst[x] );
+      }
+    }
-    pSrc0 += iSrc0Stride;
-    pSrc1 += iSrc1Stride;
-    pDst  += iDstStride;
+  }
+}
-Void TComYuv::addARPChroma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Bool bClip )
+{
-  Int x, y;
-  Pel* pSrcU0 = pcYuvSrc0->getCbAddr( uiAbsPartIdx );
-  Pel* pSrcU1 = pcYuvSrc1->getCbAddr( uiAbsPartIdx );
-  Pel* pSrcV0 = pcYuvSrc0->getCrAddr( uiAbsPartIdx );
-  Pel* pSrcV1 = pcYuvSrc1->getCrAddr( uiAbsPartIdx );
-  Pel* pDstU = getCbAddr( uiAbsPartIdx );
-  Pel* pDstV = getCrAddr( uiAbsPartIdx );
-  UInt  iSrc0Stride = pcYuvSrc0->getCStride();
-  UInt  iSrc1Stride = pcYuvSrc1->getCStride();
-  UInt  iDstStride  = getCStride();
-  for ( y = uiHeight-1; y >= 0; y-- )
+  {
-    for ( x = uiWidth-1; x >= 0; x-- )
+    {
-      pDstU[x] = pSrcU0[x] + pSrcU1[x];
-      pDstV[x] = pSrcV0[x] + pSrcV1[x];
-      if( bClip )
+      {
-        pDstU[x] = ClipC( pDstU[x] );
-        pDstV[x] = ClipC( pDstV[x] );
+      }
+    }
-    pSrcU0 += iSrc0Stride;
-    pSrcU1 += iSrc1Stride;
-    pSrcV0 += iSrc0Stride;
-    pSrcV1 += iSrc1Stride;
-    pDstU  += iDstStride;
-    pDstV  += iDstStride;
+  }
+}
-Void TComYuv::subtractARP( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth , UInt uiHeight )
+{
-  subtractARPLuma  ( pcYuvSrc0, pcYuvSrc1,  uiAbsPartIdx, uiWidth    , uiHeight    );
-  subtractARPChroma( pcYuvSrc0, pcYuvSrc1,  uiAbsPartIdx, uiWidth>>1 , uiHeight>>1 );
+}
-Void TComYuv::subtractARPLuma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth , UInt uiHeight )
+{
-  Int x, y;
-  Pel* pSrc0 = pcYuvSrc0->getLumaAddr( uiAbsPartIdx );
-  Pel* pSrc1 = pcYuvSrc1->getLumaAddr( uiAbsPartIdx );
-  Pel* pDst  = getLumaAddr( uiAbsPartIdx );
-  Int  iSrc0Stride = pcYuvSrc0->getStride();
-  Int  iSrc1Stride = pcYuvSrc1->getStride();
-  Int  iDstStride  = getStride();
-  for ( y = uiHeight-1; y >= 0; y-- )
+  {
-    for ( x = uiWidth-1; x >= 0; x-- )
+    {
-      pDst[x] = pSrc0[x] - pSrc1[x];
+    }
-    pSrc0 += iSrc0Stride;
-    pSrc1 += iSrc1Stride;
-    pDst  += iDstStride;
+  }
+}
-Void TComYuv::subtractARPChroma( TComYuv* pcYuvSrc0, TComYuv* pcYuvSrc1, UInt uiAbsPartIdx, UInt uiWidth , UInt uiHeight )
+{
-  Int x, y;
-  Pel* pSrcU0 = pcYuvSrc0->getCbAddr( uiAbsPartIdx );
-  Pel* pSrcU1 = pcYuvSrc1->getCbAddr( uiAbsPartIdx );
-  Pel* pSrcV0 = pcYuvSrc0->getCrAddr( uiAbsPartIdx );
-  Pel* pSrcV1 = pcYuvSrc1->getCrAddr( uiAbsPartIdx );
-  Pel* pDstU  = getCbAddr( uiAbsPartIdx );
-  Pel* pDstV  = getCrAddr( uiAbsPartIdx );
-  Int  iSrc0Stride = pcYuvSrc0->getCStride();
-  Int  iSrc1Stride = pcYuvSrc1->getCStride();
-  Int  iDstStride  = getCStride();
-  for ( y = uiHeight-1; y >= 0; y-- )
+  {
-    for ( x = uiWidth-1; x >= 0; x-- )
+    {
-      pDstU[x] = pSrcU0[x] - pSrcU1[x];
-      pDstV[x] = pSrcV0[x] - pSrcV1[x];
+    }
-    pSrcU0 += iSrc0Stride;
-    pSrcU1 += iSrc1Stride;
-    pSrcV0 += iSrc0Stride;
-    pSrcV1 += iSrc1Stride;
-    pDstU  += iDstStride;
-    pDstV  += iDstStride;
+  }
+}
-Void TComYuv::multiplyARP( UInt uiAbsPartIdx , UInt uiWidth , UInt uiHeight , UChar dW )
+{
-  multiplyARPLuma( uiAbsPartIdx , uiWidth , uiHeight , dW );
-  multiplyARPChroma( uiAbsPartIdx , uiWidth >> 1 , uiHeight >> 1 , dW );
+}
-Void TComYuv::xxMultiplyLine( Pel* pSrcDst , UInt uiWidth , UChar dW )
+{
-  assert( dW == 2 );
-  for( UInt x = 0 ; x < uiWidth ; x++ )
-    pSrcDst[x] =  pSrcDst[x] >> 1;
+}
-Void TComYuv::multiplyARPLuma( UInt uiAbsPartIdx , UInt uiWidth , UInt uiHeight , UChar dW )
+{
-  Pel* pDst  = getLumaAddr( uiAbsPartIdx );
-  Int  iDstStride  = getStride();
-  for ( Int y = uiHeight-1; y >= 0; y-- )
+  {
-    xxMultiplyLine( pDst , uiWidth , dW );
-    pDst  += iDstStride;
+  }
+}
-Void TComYuv::multiplyARPChroma( UInt uiAbsPartIdx , UInt uiWidth , UInt uiHeight , UChar dW )
+{
-  Pel* pDstU  = getCbAddr( uiAbsPartIdx );
-  Pel* pDstV  = getCrAddr( uiAbsPartIdx );
-  Int  iDstStride  = getCStride();
-  for ( Int y = uiHeight-1; y >= 0; y-- )
+  {
-    xxMultiplyLine( pDstU , uiWidth , dW );
-    xxMultiplyLine( pDstV , uiWidth , dW );
-    pDstU  += iDstStride;
-    pDstV  += iDstStride;
+  }
+}
-#endif
-#endif
 //! \}

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TComYuv.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibCommon/TypeDef.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 ///////////////////////////////////   HM RELATED DEFINES ////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
+#define FIX1071 1 ///< fix for issue #1071
+#define BUGFIX_INTRAPERIOD 1
+#define SAO_ENCODE_ALLOW_USE_PREDEBLOCK 1
+#define FIX1172 1 ///< fix ticket #1172
 #define MAX_NUM_PICS_IN_SOP           1024
 …
 #else
 #define MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1  1
-#endif
-#define RATE_CONTROL_LAMBDA_DOMAIN                  1  ///< JCTVC-K0103, rate control by R-lambda model
-#define M0036_RC_IMPROVEMENT                        1  ///< JCTVC-M0036, improvement for R-lambda model based rate control
-#define TICKET_1090_FIX                             1
-#if KWU_FIX_URQ
-#if RATE_CONTROL_LAMBDA_DOMAIN
-#define RC_FIX                                      1  /// suggested fix for M0036
-#define RATE_CONTROL_INTRA                          1  ///< JCTVC-M0257, rate control for intra
-#endif
-#else
-#define RC_FIX                                      1  /// suggested fix for M0036
-#define RATE_CONTROL_INTRA                          1  ///< JCTVC-M0257, rate control for intra
 #endif
 …
 #define C1FLAG_NUMBER               8 // maximum number of largerThan1 flag coded in one chunk :  16 in HM5
 #define C2FLAG_NUMBER               1 // maximum number of largerThan2 flag coded in one chunk:  16 in HM5
-#define REMOVE_SAO_LCU_ENC_CONSTRAINTS_3 1  ///< disable the encoder constraint that conditionally disable SAO for chroma for entire slice in interleaved mode
 #define SAO_ENCODING_CHOICE              1  ///< I0184: picture early termination
 #if SAO_ENCODING_CHOICE
 …
 #define MAX_NUM_PPS                64
-#define WEIGHTED_CHROMA_DISTORTION  1   ///< F386: weighting of chroma for RDO
 #define RDOQ_CHROMA_LAMBDA          1   ///< F386: weighting of chroma for RDOQ
-#define SAO_CHROMA_LAMBDA           1   ///< F386: weighting of chroma for SAO
 #define MIN_SCAN_POS_CROSS          4
 …
 #define LEVEL_RANGE                         30     ///< G382: max coefficient level in statistics collection
 #endif
-#define NS_HAD                               0
 #define HHI_RQT_INTRA_SPEEDUP             1           ///< tests one best mode with full rqt
 …
 #endif
-#define SCALING_LIST_OUTPUT_RESULT    0 //JCTVC-G880/JCTVC-G1016 quantization matrices
 #define CABAC_INIT_PRESENT_FLAG     1
 …
 typedef       bool                Bool;
+#ifdef __arm__
+typedef       signed char         Char;
+#else
 typedef       char                Char;
+#endif
 typedef       unsigned char       UChar;
 typedef       short               Short;
 …
 };
+#define NUM_DOWN_PART 4
+enum SAOTypeLen
+{
+  SAO_EO_LEN    = 4,
+  SAO_BO_LEN    = 4,
+  SAO_MAX_BO_CLASSES = 32
+};
+enum SAOType
+{
+  SAO_EO_0 = 0,
+  SAO_EO_1,
+  SAO_EO_2,
+  SAO_EO_3,
+  SAO_BO,
+  MAX_NUM_SAO_TYPE
+};
+typedef struct _SaoQTPart
+{
+  Int         iBestType;
+  Int         iLength;
+  Int         subTypeIdx ;                 ///< indicates EO class or BO band position
+  Int         iOffset[4];
+  Int         StartCUX;
+  Int         StartCUY;
+  Int         EndCUX;
+  Int         EndCUY;
+  Int         PartIdx;
+  Int         PartLevel;
+  Int         PartCol;
+  Int         PartRow;
+  Int         DownPartsIdx[NUM_DOWN_PART];
+  Int         UpPartIdx;
+  Bool        bSplit;
+  //---- encoder only start -----//
+  Bool        bProcessed;
+  Double      dMinCost;
+  Int64       iMinDist;
+  Int         iMinRate;
+  //---- encoder only end -----//
+} SAOQTPart;
+typedef struct _SaoLcuParam
+{
+  Bool       mergeUpFlag;
+  Bool       mergeLeftFlag;
+  Int        typeIdx;
+  Int        subTypeIdx;                  ///< indicates EO class or BO band position
+  Int        offset[4];
+  Int        partIdx;
+  Int        partIdxTmp;
+  Int        length;
+} SaoLcuParam;
+struct SAOParam
+{
+  Bool       bSaoFlag[2];
+  SAOQTPart* psSaoPart[3];
+  Int        iMaxSplitLevel;
+  Bool         oneUnitFlag[3];
+  SaoLcuParam* saoLcuParam[3];
+  Int          numCuInHeight;
+  Int          numCuInWidth;
+  ~SAOParam();
+enum SAOMode //mode
+{
+  SAO_MODE_OFF = 0,
+  SAO_MODE_NEW,
+  SAO_MODE_MERGE,
+  NUM_SAO_MODES
+};
+enum SAOModeMergeTypes
+{
+  SAO_MERGE_LEFT =0,
+  SAO_MERGE_ABOVE,
+  NUM_SAO_MERGE_TYPES
+};
+enum SAOModeNewTypes
+{
+  SAO_TYPE_START_EO =0,
+  SAO_TYPE_EO_0 = SAO_TYPE_START_EO,
+  SAO_TYPE_EO_90,
+  SAO_TYPE_EO_135,
+  SAO_TYPE_EO_45,
+  SAO_TYPE_START_BO,
+  SAO_TYPE_BO = SAO_TYPE_START_BO,
+  NUM_SAO_NEW_TYPES
+};
+#define NUM_SAO_EO_TYPES_LOG2 2
+enum SAOEOClasses
+{
+  SAO_CLASS_EO_FULL_VALLEY = 0,
+  SAO_CLASS_EO_HALF_VALLEY = 1,
+  SAO_CLASS_EO_PLAIN       = 2,
+  SAO_CLASS_EO_HALF_PEAK   = 3,
+  SAO_CLASS_EO_FULL_PEAK   = 4,
+  NUM_SAO_EO_CLASSES,
+};
+#define NUM_SAO_BO_CLASSES_LOG2  5
+enum SAOBOClasses
+{
+  //SAO_CLASS_BO_BAND0 = 0,
+  //SAO_CLASS_BO_BAND1,
+  //SAO_CLASS_BO_BAND2,
+  //...
+  //SAO_CLASS_BO_BAND31,
+  NUM_SAO_BO_CLASSES = (1<<NUM_SAO_BO_CLASSES_LOG2),
+};
+#define MAX_NUM_SAO_CLASSES  32  //(NUM_SAO_EO_GROUPS > NUM_SAO_BO_GROUPS)?NUM_SAO_EO_GROUPS:NUM_SAO_BO_GROUPS
+struct SAOOffset
+{
+  Int modeIdc; //NEW, MERGE, OFF
+  Int typeIdc; //NEW: EO_0, EO_90, EO_135, EO_45, BO. MERGE: left, above
+  Int typeAuxInfo; //BO: starting band index
+  Int offset[MAX_NUM_SAO_CLASSES];
+  SAOOffset();
+  ~SAOOffset();
+  Void reset();
+  const SAOOffset& operator= (const SAOOffset& src);
+};
+struct SAOBlkParam
+{
+  SAOBlkParam();
+  ~SAOBlkParam();
+  Void reset();
+  const SAOBlkParam& operator= (const SAOBlkParam& src);
+  SAOOffset& operator[](Int compIdx){ return offsetParam[compIdx];}
+private:
+  SAOOffset offsetParam[NUM_SAO_COMPONENTS];
 };

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/AnnexBread.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/AnnexBread.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/NALread.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*
…	…
70	70	break;
71	71	}
	72	assert(*it_read <= 0x03);
72	73	}
73	74	zeroCount = (*it_read == 0x00) ? zeroCount+1 : 0;
…	…
126	127	else
127	128	{
128		assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TLA_R
	129	assert( nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TSA_R
129	130	&& nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_TSA_N
130	131	&& nalu.m_nalUnitType != NAL_UNIT_CODED_SLICE_STSA_R

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/NALread.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/SEIread.cpp

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   if( !pHRD->getSubPicCpbParamsPresentFlag() )
+  {
+    READ_FLAG( code, "rap_cpb_params_present_flag" );                   sei.m_rapCpbParamsPresentFlag = code;
+    READ_FLAG( code, "irap_cpb_params_present_flag" );                   sei.m_rapCpbParamsPresentFlag = code;
+  }
+  if( sei.m_rapCpbParamsPresentFlag )
+  {
+    READ_CODE( pHRD->getCpbRemovalDelayLengthMinus1() + 1, code, "cpb_delay_offset" );      sei.m_cpbDelayOffset = code;
+    READ_CODE( pHRD->getDpbOutputDelayLengthMinus1()  + 1, code, "dpb_delay_offset" );      sei.m_dpbDelayOffset = code;
+  }
   //read splicing flag and cpb_removal_delay_delta
 …
   READ_CODE( ( pHRD->getCpbRemovalDelayLengthMinus1() + 1 ), code, "au_cpb_removal_delay_delta_minus1" );
   sei.m_auCpbRemovalDelayDelta = code + 1;
-  if( sei.m_rapCpbParamsPresentFlag )
+  {
-    READ_CODE( pHRD->getCpbRemovalDelayLengthMinus1() + 1, code, "cpb_delay_offset" );      sei.m_cpbDelayOffset = code;
-    READ_CODE( pHRD->getDpbOutputDelayLengthMinus1()  + 1, code, "dpb_delay_offset" );      sei.m_dpbDelayOffset = code;
+  }
   for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
+  {

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/SEIread.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/SyntaxElementParser.cpp

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/SyntaxElementParser.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecBinCoder.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecBinCoderCABAC.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecCAVLC.cpp

-                      r833
+                      r837
 * granted under this license.
+*
 * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
 * All rights reserved.
+*
 …
   READ_UVLC( uiCode, "log2_diff_max_min_coding_block_size" );
   pcSPS->setLog2DiffMaxMinCodingBlockSize(uiCode);
+  if (pcSPS->getPTL()->getGeneralPTL()->getLevelIdc() >= Level::LEVEL5)
+  {
+    assert(log2MinCUSize + pcSPS->getLog2DiffMaxMinCodingBlockSize() >= 5);
+  }
   Int maxCUDepthDelta = uiCode;
   pcSPS->setMaxCUWidth  ( 1<<(log2MinCUSize + maxCUDepthDelta) );

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecCAVLC.h

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecCu.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #endif
+  if ( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrDepth ) )
+  {
   //===== inverse transform =====
   m_pcTrQuant->setQPforQuant  ( pcCU->getQP(0), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );
   Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)TEXT_LUMA];
   assert(scalingListType < 6);
+    assert(scalingListType < SCALING_LIST_NUM);
   m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA, pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkip );
 …
     pReco     += uiStride;
     pRecIPred += uiRecIPredStride;
+  }
+}
+  else
+  {
+    //===== reconstruction =====
+    Pel* pPred      = piPred;
+    Pel* pReco      = piReco;
+    Pel* pRecIPred  = piRecIPred;
+    for ( Int y = 0; y < uiHeight; y++ )
+    {
+      for ( Int x = 0; x < uiWidth; x++ )
+      {
+        pReco    [ x ] = pPred[ x ];
+        pRecIPred[ x ] = pReco[ x ];
+      }
+      pPred     += uiStride;
+      pReco     += uiStride;
+      pRecIPred += uiRecIPredStride;
+    }
+  }
+}
 …
+  }
+  if ( pcCU->getCbf( uiAbsPartIdx, eText, uiTrDepth ) )
+  {
   //===== inverse transform =====
   Int curChromaQpOffset;
 …
   Int scalingListType = (pcCU->isIntra(uiAbsPartIdx) ? 0 : 3) + g_eTTable[(Int)eText];
   assert(scalingListType < 6);
+    assert(scalingListType < SCALING_LIST_NUM);
   m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), eText, REG_DCT, piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkipChroma );
 …
     pReco     += uiStride;
     pRecIPred += uiRecIPredStride;
+  }
+}
+  else
+  {
+    //===== reconstruction =====
+    Pel* pPred      = piPred;
+    Pel* pReco      = piReco;
+    Pel* pRecIPred  = piRecIPred;
+    for ( Int y = 0; y < uiHeight; y++ )
+    {
+      for ( Int x = 0; x < uiWidth; x++ )
+      {
+        pReco    [ x ] = pPred[ x ];
+        pRecIPred[ x ] = pReco[ x ];
+      }
+      pPred     += uiStride;
+      pReco     += uiStride;
+      pRecIPred += uiRecIPredStride;
+    }
+  }
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecCu.h

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecEntropy.cpp

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*
…	…
580	580	}
581	581
582		Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP)
	582	Void TDecEntropy::xDecodeTransform( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP, Int quadtreeTULog2MinSizeInCU)
583	583	{
584	584	UInt uiSubdiv;
…	…
604	604	else if( (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && (pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER) && ( pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N ) && (uiDepth == pcCU->getDepth(uiAbsPartIdx)) )
605	605	{
606		uiSubdiv = (uiLog2TrafoSize > ~~pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx)~~);
	606	uiSubdiv = (uiLog2TrafoSize > quadtreeTULog2MinSizeInCU);
607	607	}
608	608	else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
…	…
614	614	uiSubdiv = 0;
615	615	}
616		else if( uiLog2TrafoSize == ~~pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx)~~ )
	616	else if( uiLog2TrafoSize == quadtreeTULog2MinSizeInCU )
617	617	{
618	618	uiSubdiv = 0;
…	…
620	620	else
621	621	{
622		assert( uiLog2TrafoSize > ~~pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx)~~ );
	622	assert( uiLog2TrafoSize > quadtreeTULog2MinSizeInCU );
623	623	m_pcEntropyDecoderIf->parseTransformSubdivFlag( uiSubdiv, 5 - uiLog2TrafoSize );
624	624	}
…	…
666	666	for( Int i = 0; i < 4; i++ )
667	667	{
668		xDecodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP );
	668	xDecodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP, quadtreeTULog2MinSizeInCU );
669	669	uiYCbf \|= pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrDepth+1 );
670	670	uiUCbf \|= pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth+1 );
…	…
886	886
887	887	}
888		xDecodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, bCodeDQP );
	888
	889	Int getQuadtreeTULog2MinSizeInCU = pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx);
	890
	891	xDecodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, bCodeDQP, getQuadtreeTULog2MinSizeInCU );
889	892	}
890	893

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecEntropy.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 private:
   Void xDecodeTransform        ( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP );
+  Void xDecodeTransform        ( TComDataCU* pcCU, UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP, Int getQuadtreeTULog2MinSizeInCU );
 public:

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecGop.cpp

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   //-- For time output for each slice
   long iBeforeTime = clock();
-  UInt uiStartCUAddr   = pcSlice->getSliceSegmentCurStartCUAddr();
-  UInt uiSliceStartCuAddr = pcSlice->getSliceCurStartCUAddr();
-  if(uiSliceStartCuAddr == uiStartCUAddr)
+  {
-    m_sliceStartCUAddress.push_back(uiSliceStartCuAddr);
+  }
   m_pcSbacDecoder->init( (TDecBinIf*)m_pcBinCABAC );
   m_pcEntropyDecoder->setEntropyDecoder (m_pcSbacDecoder);
 …
   m_pcEntropyDecoder->setBitstream      ( ppcSubstreams[0] );
   m_pcEntropyDecoder->resetEntropy      (pcSlice);
-  if(uiSliceStartCuAddr == uiStartCUAddr)
+  {
-    m_LFCrossSliceBoundaryFlag.push_back( pcSlice->getLFCrossSliceBoundaryFlag());
+  }
 #if H_3D_NBDV
   if(pcSlice->getViewIndex() && !pcSlice->getIsDepth()) //Notes from QC: this condition shall be changed once the configuration is completed, e.g. in pcSlice->getSPS()->getMultiviewMvPredMode() || ARP in prev. HTM. Remove this comment once it is done.
 …
   m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
   m_pcLoopFilter->loopFilterPic( rpcPic );
-  if(pcSlice->getSPS()->getUseSAO())
+  {
-    m_sliceStartCUAddress.push_back(rpcPic->getNumCUsInFrame()* rpcPic->getNumPartInCU());
-    rpcPic->createNonDBFilterInfo(m_sliceStartCUAddress, 0, &m_LFCrossSliceBoundaryFlag, rpcPic->getPicSym()->getNumTiles(), bLFCrossTileBoundary);
+  }
   if( pcSlice->getSPS()->getUseSAO() )
+  {
+    {
+      SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
+      saoParam->bSaoFlag[0] = pcSlice->getSaoEnabledFlag();
+      saoParam->bSaoFlag[1] = pcSlice->getSaoEnabledFlagChroma();
+      m_pcSAO->setSaoLcuBasedOptimization(1);
+      m_pcSAO->createPicSaoInfo(rpcPic);
+      m_pcSAO->SAOProcess(saoParam);
+      m_pcSAO->PCMLFDisableProcess(rpcPic);
+      m_pcSAO->destroyPicSaoInfo();
+    }
+  }
+  if(pcSlice->getSPS()->getUseSAO())
+  {
+    rpcPic->destroyNonDBFilterInfo();
+    m_pcSAO->reconstructBlkSAOParams(rpcPic, rpcPic->getPicSym()->getSAOBlkParam());
+    m_pcSAO->SAOProcess(rpcPic);
+    m_pcSAO->PCMLFDisableProcess(rpcPic);
+  }
 #if H_3D
 …
   rpcPic->setOutputMark(true);
   rpcPic->setReconMark(true);
-  m_sliceStartCUAddress.clear();
-  m_LFCrossSliceBoundaryFlag.clear();
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecGop.h

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Int                   m_decodedPictureHashSEIEnabled;  ///< Checksum(3)/CRC(2)/MD5(1)/disable(0) acting on decoded picture hash SEI message
-  //! list that contains the CU address of each slice plus the end address
-  std::vector<Int> m_sliceStartCUAddress;
-  std::vector<Bool> m_LFCrossSliceBoundaryFlag;
 public:
   TDecGop();

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecSbac.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 , m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
-, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoMergeSCModel      ( 1,             1,               NUM_SAO_MERGE_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
 …
 #endif
   m_cCUPartSizeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PART_SIZE );
-  m_cCUAMPSCModel.initBuffer             ( sliceType, qp, (UChar*)INIT_CU_AMP_POS );
   m_cCUPredModeSCModel.initBuffer        ( sliceType, qp, (UChar*)INIT_PRED_MODE );
   m_cCUIntraPredSCModel.initBuffer       ( sliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
 …
         if (eMode == SIZE_2NxN)
+        {
           m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
+        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
           if (uiSymbol == 0)
+          {
 …
         else if (eMode == SIZE_Nx2N)
+        {
           m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUAMPSCModel.get( 0, 0, 0 ));
+        m_pcTDecBinIf->decodeBin(uiSymbol, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
           if (uiSymbol == 0)
+          {
 …
     if (uiCode == 0)
+    {
       ruiVal = 5;
+      ruiVal = 1;
+    }
     else
+    {
+      ruiVal = 1;
+    }
+  }
+}
+inline Void copySaoOneLcuParam(SaoLcuParam* psDst,  SaoLcuParam* psSrc)
+{
+  Int i;
+  psDst->partIdx = psSrc->partIdx;
+  psDst->typeIdx    = psSrc->typeIdx;
+  if (psDst->typeIdx != -1)
+  {
+    psDst->subTypeIdx = psSrc->subTypeIdx ;
+    psDst->length  = psSrc->length;
+    for (i=0;i<psDst->length;i++)
+    {
+      psDst->offset[i] = psSrc->offset[i];
+    }
+  }
+  else
+  {
+    psDst->length  = 0;
+    for (i=0;i<SAO_BO_LEN;i++)
+    {
+      psDst->offset[i] = 0;
+    }
+  }
+}
+Void TDecSbac::parseSaoOffset(SaoLcuParam* psSaoLcuParam, UInt compIdx)
+      ruiVal = 2;
+    }
+  }
+}
+{
+  m_pcTDecBinIf->decodeBinEP ( val );
+}
+Void TDecSbac::parseSAOBlkParam (SAOBlkParam& saoBlkParam
+                                , Bool* sliceEnabled
+                                , Bool leftMergeAvail
+                                , Bool aboveMergeAvail
+                                )
+{
   UInt uiSymbol;
+  static Int iTypeLength[MAX_NUM_SAO_TYPE] =
+  {
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_EO_LEN,
+    SAO_BO_LEN
+  };
+  if (compIdx==2)
+  {
+    uiSymbol = (UInt)( psSaoLcuParam->typeIdx + 1);
+  }
+  else
+  {
+    parseSaoTypeIdx(uiSymbol);
+  }
+  psSaoLcuParam->typeIdx = (Int)uiSymbol - 1;
+  if (uiSymbol)
+  {
+    psSaoLcuParam->length = iTypeLength[psSaoLcuParam->typeIdx];
+    Int bitDepth = compIdx ? g_bitDepthC : g_bitDepthY;
+    Int offsetTh = 1 << min(bitDepth - 5,5);
+    if( psSaoLcuParam->typeIdx == SAO_BO )
+    {
+      for(Int i=0; i< psSaoLcuParam->length; i++)
+      {
+        parseSaoMaxUvlc(uiSymbol, offsetTh -1 );
+        psSaoLcuParam->offset[i] = uiSymbol;
+  Bool isLeftMerge = false;
+  Bool isAboveMerge= false;
+  if(leftMergeAvail)
+  {
+    parseSaoMerge(uiSymbol); //sao_merge_left_flag
+    isLeftMerge = (uiSymbol?true:false);
+  }
+  if( aboveMergeAvail && !isLeftMerge)
+  {
+    parseSaoMerge(uiSymbol); //sao_merge_up_flag
+    isAboveMerge = (uiSymbol?true:false);
+  }
+  if(isLeftMerge || isAboveMerge) //merge mode
+      {
+    saoBlkParam[SAO_Y].modeIdc = saoBlkParam[SAO_Cb].modeIdc = saoBlkParam[SAO_Cr].modeIdc = SAO_MODE_MERGE;
+    saoBlkParam[SAO_Y].typeIdc = saoBlkParam[SAO_Cb].typeIdc = saoBlkParam[SAO_Cr].typeIdc = (isLeftMerge)?SAO_MERGE_LEFT:SAO_MERGE_ABOVE;
+      }
+      for(Int i=0; i< psSaoLcuParam->length; i++)
+      {
+        if (psSaoLcuParam->offset[i] != 0)
+        {
+          m_pcTDecBinIf->decodeBinEP ( uiSymbol);
+          if (uiSymbol)
+  else //new or off mode
+      {
+    for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+        {
+      SAOOffset& ctbParam = saoBlkParam[compIdx];
+      if(!sliceEnabled[compIdx])
+          {
+            psSaoLcuParam->offset[i] = -psSaoLcuParam->offset[i] ;
+          }
+        }
+      }
+      parseSaoUflc(5, uiSymbol );
+      psSaoLcuParam->subTypeIdx = uiSymbol;
+    }
+    else if( psSaoLcuParam->typeIdx < 4 )
+    {
+      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[0] = uiSymbol;
+      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[1] = uiSymbol;
+      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[2] = -(Int)uiSymbol;
+      parseSaoMaxUvlc(uiSymbol, offsetTh -1 ); psSaoLcuParam->offset[3] = -(Int)uiSymbol;
+     if (compIdx != 2)
+        //off
+        ctbParam.modeIdc = SAO_MODE_OFF;
+        continue;
+        }
+      //type
+      if(compIdx == SAO_Y || compIdx == SAO_Cb)
+    {
+        parseSaoTypeIdx(uiSymbol); //sao_type_idx_luma or sao_type_idx_chroma
+        assert(uiSymbol ==0 || uiSymbol ==1 || uiSymbol ==2);
+        if(uiSymbol ==0) //OFF
+     {
+       parseSaoUflc(2, uiSymbol );
+       psSaoLcuParam->subTypeIdx = uiSymbol;
+       psSaoLcuParam->typeIdx += psSaoLcuParam->subTypeIdx;
+     }
+          ctbParam.modeIdc = SAO_MODE_OFF;
+   }
+  }
+  else
+  {
+    psSaoLcuParam->length = 0;
+  }
+}
+Void TDecSbac::parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp)
+{
+  Int iAddr = pcCU->getAddr();
+  UInt uiSymbol;
+  for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
+  {
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag    = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag  = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx     = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx        = -1;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[0]     = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[1]     = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[2]     = 0;
+    pSaoParam->saoLcuParam[iCompIdx][iAddr].offset[3]     = 0;
+  }
+ if (pSaoParam->bSaoFlag[0] || pSaoParam->bSaoFlag[1] )
+  {
+    if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
+    {
+      parseSaoMerge(uiSymbol);
+      pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag = (Bool)uiSymbol;
+    }
+    if (pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag==0)
+    {
+      if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
+      {
+        parseSaoMerge(uiSymbol);
+        pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag = (Bool)uiSymbol;
+      }
+    }
+  }
+  for (Int iCompIdx=0; iCompIdx<3; iCompIdx++)
+  {
+    if ((iCompIdx == 0  && pSaoParam->bSaoFlag[0]) || (iCompIdx > 0  && pSaoParam->bSaoFlag[1]) )
+    {
+      if (rx>0 && iCUAddrInSlice!=0 && allowMergeLeft)
+      {
+        pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = pSaoParam->saoLcuParam[0][iAddr].mergeLeftFlag;
+      }
+      else
+      {
+        pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag = 0;
+      }
+      if (pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeLeftFlag==0)
+      {
+        if ((ry > 0) && (iCUAddrUpInSlice>=0) && allowMergeUp)
+        {
+          pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = pSaoParam->saoLcuParam[0][iAddr].mergeUpFlag;
+        else if(uiSymbol == 1) //BO
+        {
+          ctbParam.modeIdc = SAO_MODE_NEW;
+          ctbParam.typeIdc = SAO_TYPE_START_BO;
+  }
+        else //2, EO
+  {
+          ctbParam.modeIdc = SAO_MODE_NEW;
+          ctbParam.typeIdc = SAO_TYPE_START_EO;
+        }
+  }
+      else //Cr, follow Cb SAO type
+      {
+        ctbParam.modeIdc = saoBlkParam[SAO_Cb].modeIdc;
+        ctbParam.typeIdc = saoBlkParam[SAO_Cb].typeIdc;
+}
+      if(ctbParam.modeIdc == SAO_MODE_NEW)
+{
+        Int offset[4];
+        for(Int i=0; i< 4; i++)
+  {
+          parseSaoMaxUvlc(uiSymbol,  g_saoMaxOffsetQVal[compIdx] ); //sao_offset_abs
+          offset[i] = (Int)uiSymbol;
+  }
+        if(ctbParam.typeIdc == SAO_TYPE_START_BO)
+  {
+          for(Int i=0; i< 4; i++)
+    {
+            if(offset[i] != 0)
+    {
+              parseSaoSign(uiSymbol); //sao_offset_sign
+              if(uiSymbol)
+      {
+                offset[i] = -offset[i];
+      }
+    }
+  }
+          parseSaoUflc(NUM_SAO_BO_CLASSES_LOG2, uiSymbol ); //sao_band_position
+          ctbParam.typeAuxInfo = uiSymbol;
+          for(Int i=0; i<4; i++)
+      {
+            ctbParam.offset[(ctbParam.typeAuxInfo+i)%MAX_NUM_SAO_CLASSES] = offset[i];
+      }
+        }
+        else //EO
+        {
+          ctbParam.typeAuxInfo = 0;
+          if(compIdx == SAO_Y || compIdx == SAO_Cb)
+        {
+            parseSaoUflc(NUM_SAO_EO_TYPES_LOG2, uiSymbol ); //sao_eo_class_luma or sao_eo_class_chroma
+            ctbParam.typeIdc += uiSymbol;
+        }
         else
+        {
+          pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag = 0;
+        }
+        if (!pSaoParam->saoLcuParam[iCompIdx][iAddr].mergeUpFlag)
+        {
+          pSaoParam->saoLcuParam[2][iAddr].typeIdx = pSaoParam->saoLcuParam[1][iAddr].typeIdx;
+          parseSaoOffset(&(pSaoParam->saoLcuParam[iCompIdx][iAddr]), iCompIdx);
+        }
+        else
+        {
+          copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr], &pSaoParam->saoLcuParam[iCompIdx][iAddr-pSaoParam->numCuInWidth]);
+        }
+      }
+      else
+      {
+        copySaoOneLcuParam(&pSaoParam->saoLcuParam[iCompIdx][iAddr],  &pSaoParam->saoLcuParam[iCompIdx][iAddr-1]);
+      }
+    }
+    else
+    {
+      pSaoParam->saoLcuParam[iCompIdx][iAddr].typeIdx = -1;
+      pSaoParam->saoLcuParam[iCompIdx][iAddr].subTypeIdx = 0;
+            ctbParam.typeIdc = saoBlkParam[SAO_Cb].typeIdc;
+        }
+          ctbParam.offset[SAO_CLASS_EO_FULL_VALLEY] = offset[0];
+          ctbParam.offset[SAO_CLASS_EO_HALF_VALLEY] = offset[1];
+          ctbParam.offset[SAO_CLASS_EO_PLAIN      ] = 0;
+          ctbParam.offset[SAO_CLASS_EO_HALF_PEAK  ] = -offset[2];
+          ctbParam.offset[SAO_CLASS_EO_FULL_PEAK  ] = -offset[3];
+      }
+      }
+    }
+  }
 …
   xCopyContextsFrom(pScr);
+}
-#if H_3D_ARP
-Void TDecSbac::parseARPW( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-  UInt uiMaxW = pcCU->getSlice()->getARPStepNum() - 1;
-  UInt uiW = 0;
-  UInt uiOffset = pcCU->getCTXARPWFlag(uiAbsPartIdx);
-  UInt uiCode = 0;
-  assert ( uiMaxW > 0 );
-  m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 0 + uiOffset ) );
-  uiW = uiCode;
-  if( 1 == uiW )
+  {
-#if MTK_ARP_FLAG_CABAC_SIMP_G0061
-    m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 2 ) );
-#else
-    m_pcTDecBinIf->decodeBin( uiCode , m_cCUPUARPWSCModel.get( 0, 0, 3 ) );
-#endif
-    uiW += ( 1 == uiCode ? 1 : 0 );
+  }
-#if H_MV_ENC_DEC_TRAC
-  DTRACE_CU("iv_res_pred_weight_idx", uiW )
-#endif
-  pcCU->setARPWSubParts( ( UChar )( uiW ) , uiAbsPartIdx, uiDepth );
+}
-#endif
-#if H_3D_IC
-/** parse illumination compensation flag
- * \param pcCU
- * \param uiAbsPartIdx
- * \param uiDepth
- * \returns Void
- */
-Void TDecSbac::parseICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-  UInt uiSymbol = 0;
-#if MTK_IC_FLAG_CABAC_SIMP_G0061
-  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, 0 ) );
-#else
-  UInt uiCtxIC = pcCU->getCtxICFlag( uiAbsPartIdx );
-  m_pcTDecBinIf->decodeBin( uiSymbol, m_cCUICFlagSCModel.get( 0, 0, uiCtxIC ) );
-#endif
-#if !H_MV_ENC_DEC_TRAC
-  DTRACE_CABAC_VL( g_nSymbolCounter++ );
-  DTRACE_CABAC_T( "\tICFlag" );
-  DTRACE_CABAC_T( "\tuiCtxIC: ");
-  DTRACE_CABAC_V( uiCtxIC );
-  DTRACE_CABAC_T( "\tuiSymbol: ");
-  DTRACE_CABAC_V( uiSymbol );
-  DTRACE_CABAC_T( "\n");
-#else
-  DTRACE_CU("ic_flag", uiSymbol)
-#endif
-  pcCU->setICFlagSubParts( uiSymbol ? true : false , uiAbsPartIdx, 0, uiDepth );
+}
-#endif
-#if H_3D_INTER_SDC
-#if QC_SDC_UNIFY_G0130
-Void TDecSbac::parseDeltaDC( TComDataCU* pcCU, UInt absPartIdx, UInt depth )
+{
-  if( ! ( pcCU->getSDCFlag( absPartIdx ) || ( pcCU->isIntra( absPartIdx ) && getDimType( pcCU->getLumaIntraDir( absPartIdx ) ) < DIM_NUM_TYPE ) ) )
+  {
-    assert( 0 );
+  }
-  UInt symbol = 0;
-  UInt uiNumSegments = 0;
-  if( pcCU->isIntra( absPartIdx ) )
+  {
-    UInt dir     = pcCU->getLumaIntraDir( absPartIdx );
-    uiNumSegments = isDimMode( dir ) ? 2 : 1;
-    m_pcTDecBinIf->decodeBin( symbol, m_cDdcFlagSCModel.get( 0, 0, uiNumSegments-1 ) );
-    if( pcCU->getSDCFlag( absPartIdx ) )
+    {
-      assert( pcCU->getPartitionSize( absPartIdx ) == SIZE_2Nx2N );
-      pcCU->setTrIdxSubParts( 0, absPartIdx, depth );
-      pcCU->setCbfSubParts( 1, 1, 1, absPartIdx, depth );
+    }
-    else
+    {
-      pcCU->setLumaIntraDirSubParts( dir + symbol, absPartIdx, depth );
+    }
+  }
-  else
+  {
-#if SEC_INTER_SDC_G0101
-    uiNumSegments = 1;
-#else
-    PartSize cPartSize = pcCU->getPartitionSize( absPartIdx );
-    uiNumSegments = ( cPartSize == SIZE_2Nx2N ) ? 1 : ( cPartSize == SIZE_NxN ? 4 : 2 );
-#endif
-    symbol = 1;
+  }
-  for( UInt segment = 0; segment < uiNumSegments; segment++ )
+  {
-    Pel valDeltaDC = 0;
-    if( symbol )
+    {
-      xParseDimDeltaDC( valDeltaDC, uiNumSegments );
+    }
-    if( pcCU->isIntra( absPartIdx ) )
+    {
-      UInt dir     = pcCU->getLumaIntraDir( absPartIdx );
-      if( pcCU->getSDCFlag( absPartIdx ) )
+      {
-        pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
+      }
-      else
+      {
-        pcCU->setDimDeltaDC( getDimType( dir ), segment, absPartIdx, valDeltaDC );
+      }
+    }
-    else
+    {
-      pcCU->setSDCSegmentDCOffset( valDeltaDC, segment, absPartIdx );
+    }
+  }
+}
-Void TDecSbac::parseSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-  UInt uiSymbol = 0;
-  UInt uiCtxSDCFlag = pcCU->getCtxSDCFlag( uiAbsPartIdx );
-  m_pcTDecBinIf->decodeBin( uiSymbol, m_cSDCFlagSCModel.get( 0, 0, uiCtxSDCFlag ) );
-  if( uiSymbol )
+  {
-    pcCU->setSDCFlagSubParts( true, uiAbsPartIdx, uiDepth );
-    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
-    pcCU->setCbfSubParts( 1, 1, 1, uiAbsPartIdx, uiDepth );
+  }
-  else
+  {
-    pcCU->setSDCFlagSubParts( false, uiAbsPartIdx, uiDepth );
+  }
+}
-#else
-Void TDecSbac::parseInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-  UInt uiSymbol = 0;
-  UInt uiCtxInterSDCFlag = pcCU->getCtxInterSDCFlag( uiAbsPartIdx );
-  m_pcTDecBinIf->decodeBin( uiSymbol, m_cInterSDCFlagSCModel.get( 0, 0, uiCtxInterSDCFlag ) );
-  if( uiSymbol )
+  {
-    pcCU->setInterSDCFlagSubParts( true, uiAbsPartIdx, 0, uiDepth );
-    pcCU->setTrIdxSubParts( 0, uiAbsPartIdx, uiDepth );
-    pcCU->setCbfSubParts( 1, 1, 1, uiAbsPartIdx, uiDepth );
+  }
-  else
+  {
-    pcCU->setInterSDCFlagSubParts( false, uiAbsPartIdx, 0, uiDepth);
+  }
+}
-Void TDecSbac::parseInterSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSegment )
+{
-  UInt uiAbsIdx   = 0;
-  UInt uiSign     = 0;
-  Int  iIdx       = 0;
-  xReadExGolombLevel( uiAbsIdx, m_cInterSDCResidualSCModel.get( 0, 0, 0 ) );
-  uiAbsIdx++;
-  m_pcTDecBinIf->decodeBin( uiSign, m_cInterSDCResidualSignFlagSCModel.get( 0, 0, 0 ) );
-  iIdx = (Int)( uiSign ? -1 : 1 ) * uiAbsIdx;
-  pcCU->setInterSDCSegmentDCOffset( iIdx, uiSegment, uiAbsPartIdx );
+}
-#endif
-#endif
-#if H_3D_DBBP
-Void TDecSbac::parseDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
+{
-  PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
-  AOF( pcCU->getSlice()->getVPS()->getUseDBBP(pcCU->getSlice()->getLayerIdInVps()) );
-  AOF( !pcCU->getSlice()->getIsDepth() );
-  AOF( ePartSize == RWTH_DBBP_PACK_MODE );
-  UInt uiSymbol = 0;
-  m_pcTDecBinIf->decodeBin( uiSymbol, m_cDBBPFlagSCModel.get( 0, 0, 0 ) );
-  if( uiSymbol )
+  {
-    pcCU->setDBBPFlagSubParts(true, uiAbsPartIdx, 0, uiDepth);
+  }
+}
-#endif
 //! \}

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecSbac.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Void  parseSaoTypeIdx           ( UInt&  ruiVal  );
   Void  parseSaoUflc              ( UInt uiLength, UInt& ruiVal     );
-  Void  parseSaoOneLcuInterleaving(Int rx, Int ry, SAOParam* pSaoParam, TComDataCU* pcCU, Int iCUAddrInSlice, Int iCUAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp);
-  Void  parseSaoOffset            (SaoLcuParam* psSaoLcuParam, UInt compIdx);
 private:
   Void  xReadUnarySymbol    ( UInt& ruiSymbol, ContextModel* pcSCModel, Int iOffset );
 …
   ContextModel3DBuffer m_cMVPIdxSCModel;
-  ContextModel3DBuffer m_cCUAMPSCModel;
   ContextModel3DBuffer m_cSaoMergeSCModel;
   ContextModel3DBuffer m_cSaoTypeIdxSCModel;

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecSlice.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
     g_bJustDoIt = g_bEncDecTraceEnable;
 #endif
+    if ( pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma()) )
+    {
+      SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
+      saoParam->bSaoFlag[0] = pcSlice->getSaoEnabledFlag();
+      if (iCUAddr == iStartCUAddr)
+      {
+        saoParam->bSaoFlag[1] = pcSlice->getSaoEnabledFlagChroma();
+      }
+      Int numCuInWidth     = saoParam->numCuInWidth;
+      Int cuAddrInSlice = iCUAddr - rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU());
+      Int cuAddrUpInSlice  = cuAddrInSlice - numCuInWidth;
+      Int rx = iCUAddr % numCuInWidth;
+      Int ry = iCUAddr / numCuInWidth;
+      Int allowMergeLeft = 1;
+      Int allowMergeUp   = 1;
+      if (rx!=0)
+      {
+        if (rpcPic->getPicSym()->getTileIdxMap(iCUAddr-1) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr))
+        {
+          allowMergeLeft = 0;
+        }
+      }
+      if (ry!=0)
+      {
+        if (rpcPic->getPicSym()->getTileIdxMap(iCUAddr-numCuInWidth) != rpcPic->getPicSym()->getTileIdxMap(iCUAddr))
+        {
+          allowMergeUp = 0;
+        }
+      }
+      pcSbacDecoder->parseSaoOneLcuInterleaving(rx, ry, saoParam,pcCU, cuAddrInSlice, cuAddrUpInSlice, allowMergeLeft, allowMergeUp);
+    }
+    else if ( pcSlice->getSPS()->getUseSAO() )
+    {
+      Int addr = pcCU->getAddr();
+      SAOParam *saoParam = rpcPic->getPicSym()->getSaoParam();
+      for (Int cIdx=0; cIdx<3; cIdx++)
+      {
+        SaoLcuParam *saoLcuParam = &(saoParam->saoLcuParam[cIdx][addr]);
+        if ( ((cIdx == 0) && !pcSlice->getSaoEnabledFlag()) || ((cIdx == 1 || cIdx == 2) && !pcSlice->getSaoEnabledFlagChroma()))
+        {
+          saoLcuParam->mergeUpFlag   = 0;
+          saoLcuParam->mergeLeftFlag = 0;
+          saoLcuParam->subTypeIdx    = 0;
+          saoLcuParam->typeIdx       = -1;
+          saoLcuParam->offset[0]     = 0;
+          saoLcuParam->offset[1]     = 0;
+          saoLcuParam->offset[2]     = 0;
+          saoLcuParam->offset[3]     = 0;
+        }
+    if ( pcSlice->getSPS()->getUseSAO() )
+      {
+      SAOBlkParam& saoblkParam = (rpcPic->getPicSym()->getSAOBlkParam())[iCUAddr];
+      if (pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma())
+      {
+        Bool sliceEnabled[NUM_SAO_COMPONENTS];
+        sliceEnabled[SAO_Y] = pcSlice->getSaoEnabledFlag();
+        sliceEnabled[SAO_Cb]= sliceEnabled[SAO_Cr]= pcSlice->getSaoEnabledFlagChroma();
+        Bool leftMergeAvail = false;
+        Bool aboveMergeAvail= false;
+        //merge left condition
+        Int rx = (iCUAddr % uiWidthInLCUs);
+        if(rx > 0)
+        {
+          leftMergeAvail = rpcPic->getSAOMergeAvailability(iCUAddr, iCUAddr-1);
+        }
+        //merge up condition
+        Int ry = (iCUAddr / uiWidthInLCUs);
+        if(ry > 0)
+        {
+      }
+        pcSbacDecoder->parseSAOBlkParam( saoblkParam, sliceEnabled, leftMergeAvail, aboveMergeAvail);
+    }
+      else
+        {
+      }
+    }

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecSlice.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecTop.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
     rpcPic->create ( pcSlice->getSPS()->getPicWidthInLumaSamples(), pcSlice->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth,
                      conformanceWindow, defaultDisplayWindow, numReorderPics, true);
-    rpcPic->getPicSym()->allocSaoParam(&m_cSAO);
     m_cListPic.pushBack( rpcPic );
 …
   rpcPic->create ( pcSlice->getSPS()->getPicWidthInLumaSamples(), pcSlice->getSPS()->getPicHeightInLumaSamples(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth,
                    conformanceWindow, defaultDisplayWindow, numReorderPics, true);
-  rpcPic->getPicSym()->allocSaoParam(&m_cSAO);
+}
 …
   m_cSAO.destroy();
   m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getMaxCUWidth(), sps->getMaxCUHeight() );
+  m_cSAO.create( sps->getPicWidthInLumaSamples(), sps->getPicHeightInLumaSamples(), sps->getMaxCUWidth(), sps->getMaxCUHeight(), sps->getMaxCUDepth() );
   m_cLoopFilter.create( sps->getMaxCUDepth() );
+}
 …
+{
   assert( nalu.m_layerId == m_layerId );
 #else
 Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
 …
     m_uiSliceIdx     = 0;
+  }
+  {
+    m_apcSlicePilot->copySliceInfo( pcPic->getPicSym()->getSlice(m_uiSliceIdx-1) );
+  }
   m_apcSlicePilot->setSliceIdx(m_uiSliceIdx);
-  if (!m_bFirstSliceInPicture)
+  {
-    m_apcSlicePilot->copySliceInfo( pcPic->getPicSym()->getSlice(m_uiSliceIdx-1) );
+  }
   m_apcSlicePilot->setNalUnitType(nalu.m_nalUnitType);
 …
 #endif
 #else
-#if FIX1071
     pcSlice->setRefPicList( m_cListPic, true );
-#else
-    pcSlice->setRefPicList( m_cListPic );
-#endif
 #endif
 …
     case NAL_UNIT_CODED_SLICE_TRAIL_R:
     case NAL_UNIT_CODED_SLICE_TRAIL_N:
     case NAL_UNIT_CODED_SLICE_TLA_R:
+    case NAL_UNIT_CODED_SLICE_TSA_R:
     case NAL_UNIT_CODED_SLICE_TSA_N:
     case NAL_UNIT_CODED_SLICE_STSA_R:
 …
 #endif
       break;
+    case NAL_UNIT_EOS:
+      m_associatedIRAPType = NAL_UNIT_INVALID;
+      m_pocCRA = 0;
+      m_pocRandomAccess = MAX_INT;
+      m_prevPOC = MAX_INT;
+      m_bFirstSliceInPicture = true;
+      m_bFirstSliceInSequence = true;
+      m_prevSliceSkipped = false;
+      m_skippedPOC = 0;
+      return false;
+    case NAL_UNIT_ACCESS_UNIT_DELIMITER:
+      // TODO: process AU delimiter
+      return false;
+    case NAL_UNIT_EOB:
+      return false;
+    case NAL_UNIT_RESERVED_VCL_N10:
+    case NAL_UNIT_RESERVED_VCL_R11:
+    case NAL_UNIT_RESERVED_VCL_N12:
+    case NAL_UNIT_RESERVED_VCL_R13:
+    case NAL_UNIT_RESERVED_VCL_N14:
+    case NAL_UNIT_RESERVED_VCL_R15:
+    case NAL_UNIT_RESERVED_IRAP_VCL22:
+    case NAL_UNIT_RESERVED_IRAP_VCL23:
+    case NAL_UNIT_RESERVED_VCL24:
+    case NAL_UNIT_RESERVED_VCL25:
+    case NAL_UNIT_RESERVED_VCL26:
+    case NAL_UNIT_RESERVED_VCL27:
+    case NAL_UNIT_RESERVED_VCL28:
+    case NAL_UNIT_RESERVED_VCL29:
+    case NAL_UNIT_RESERVED_VCL30:
+    case NAL_UNIT_RESERVED_VCL31:
+    case NAL_UNIT_FILLER_DATA:
+    case NAL_UNIT_RESERVED_NVCL41:
+    case NAL_UNIT_RESERVED_NVCL42:
+    case NAL_UNIT_RESERVED_NVCL43:
+    case NAL_UNIT_RESERVED_NVCL44:
+    case NAL_UNIT_RESERVED_NVCL45:
+    case NAL_UNIT_RESERVED_NVCL46:
+    case NAL_UNIT_RESERVED_NVCL47:
+    case NAL_UNIT_UNSPECIFIED_48:
+    case NAL_UNIT_UNSPECIFIED_49:
+    case NAL_UNIT_UNSPECIFIED_50:
+    case NAL_UNIT_UNSPECIFIED_51:
+    case NAL_UNIT_UNSPECIFIED_52:
+    case NAL_UNIT_UNSPECIFIED_53:
+    case NAL_UNIT_UNSPECIFIED_54:
+    case NAL_UNIT_UNSPECIFIED_55:
+    case NAL_UNIT_UNSPECIFIED_56:
+    case NAL_UNIT_UNSPECIFIED_57:
+    case NAL_UNIT_UNSPECIFIED_58:
+    case NAL_UNIT_UNSPECIFIED_59:
+    case NAL_UNIT_UNSPECIFIED_60:
+    case NAL_UNIT_UNSPECIFIED_61:
+    case NAL_UNIT_UNSPECIFIED_62:
+    case NAL_UNIT_UNSPECIFIED_63:
     default:
       assert (1);
+      assert (0);
+  }

branches/HTM-10.0rc1-dev0/source/Lib/TLibDecoder/TDecTop.h

r833	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/AnnexBwrite.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/NALwrite.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/NALwrite.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/SEIwrite.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   if( !hrd->getSubPicCpbParamsPresentFlag() )
+  {
+    WRITE_FLAG( sei.m_rapCpbParamsPresentFlag, "rap_cpb_params_present_flag" );
+    WRITE_FLAG( sei.m_rapCpbParamsPresentFlag, "irap_cpb_params_present_flag" );
+  }
+  if( sei.m_rapCpbParamsPresentFlag )
+  {
+    WRITE_CODE( sei.m_cpbDelayOffset, hrd->getCpbRemovalDelayLengthMinus1() + 1, "cpb_delay_offset" );
+    WRITE_CODE( sei.m_dpbDelayOffset, hrd->getDpbOutputDelayLengthMinus1()  + 1, "dpb_delay_offset" );
+  }
   WRITE_FLAG( sei.m_concatenationFlag, "concatenation_flag");
   WRITE_CODE( sei.m_auCpbRemovalDelayDelta - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), "au_cpb_removal_delay_delta_minus1" );
-  if( sei.m_rapCpbParamsPresentFlag )
+  {
-    WRITE_CODE( sei.m_cpbDelayOffset, hrd->getCpbRemovalDelayLengthMinus1() + 1, "cpb_delay_offset" );
-    WRITE_CODE( sei.m_dpbDelayOffset, hrd->getDpbOutputDelayLengthMinus1()  + 1, "dpb_delay_offset" );
+  }
   for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
+  {

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/SEIwrite.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/SyntaxElementWriter.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/SyntaxElementWriter.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncAnalyze.cpp

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncAnalyze.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncBinCoder.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncBinCoderCABAC.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncBinCoderCABAC.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncBinCoderCABACCounter.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncBinCoderCABACCounter.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncCavlc.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   if( pcPPS->getScalingListPresentFlag() )
+  {
-#if SCALING_LIST_OUTPUT_RESULT
-    printf("PPS\n");
-#endif
     codeScalingList( m_pcSlice->getScalingList() );
+  }
 …
     if(pcSPS->getScalingListPresentFlag())
+    {
-#if SCALING_LIST_OUTPUT_RESULT
-    printf("SPS\n");
-#endif
       codeScalingList( m_pcSlice->getScalingList() );
+    }
 …
       TComReferencePictureSet* rps = pcSlice->getRPS();
-#if FIX1071
       // check for bitstream restriction stating that:
       // If the current picture is a BLA or CRA picture, the value of NumPocTotalCurr shall be equal to 0.
 …
+          }
+        }
-#endif
       if(pcSlice->getRPSidx() < 0)
 …
+      {
          WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "slice_sao_luma_flag" );
+         {
+           SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
+          WRITE_FLAG( saoParam->bSaoFlag[1], "slice_sao_chroma_flag" );
+         }
+         WRITE_FLAG( pcSlice->getSaoEnabledFlagChroma(), "slice_sao_chroma_flag" );
+      }
+    }
 …
   Bool scalingListPredModeFlag;
-#if SCALING_LIST_OUTPUT_RESULT
-  Int startBit;
-  Int startTotalBit;
-  startBit = m_pcBitIf->getNumberOfWrittenBits();
-  startTotalBit = m_pcBitIf->getNumberOfWrittenBits();
-#endif
     //for each size
     for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++)
 …
       for(listId = 0; listId < g_scalingListNum[sizeId]; listId++)
+      {
-#if SCALING_LIST_OUTPUT_RESULT
-        startBit = m_pcBitIf->getNumberOfWrittenBits();
-#endif
         scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId );
         WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" );
 …
           xCodeScalingList(scalingList, sizeId, listId);
+        }
+#if SCALING_LIST_OUTPUT_RESULT
+        printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit);
+#endif
+      }
+    }
+#if SCALING_LIST_OUTPUT_RESULT
+  printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit);
+#endif
+      }
+    }
   return;
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncCavlc.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Void codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList );
-  Void codeSAOSign       ( UInt code   ) { printf("Not supported\n"); assert (0); }
-  Void codeSaoMaxUvlc    ( UInt   code, UInt maxSymbol ){printf("Not supported\n"); assert (0);}
-  Void codeSaoMerge  ( UInt uiCode ){printf("Not supported\n"); assert (0);}
-  Void codeSaoTypeIdx    ( UInt uiCode ){printf("Not supported\n"); assert (0);}
-  Void codeSaoUflc       ( UInt uiLength, UInt   uiCode ){ assert(uiCode < 32); printf("Not supported\n"); assert (0);}
   Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx );
   Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncCfg.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Int       m_maxNumOffsetsPerPic;
   Bool      m_saoLcuBoundary;
-  Bool      m_saoLcuBasedOptimization;
-  //====== Lossless ========
-  Bool      m_useLossless;
   //====== Motion search ========
   Int       m_iFastSearch;                      //  0:Full search  1:Diamond  2:PMVFAST
 …
   //====== Tool list ========
-  Bool      m_bUseSBACRD;
   Bool      m_bUseASR;
   Bool      m_bUseHADME;
 …
   Int       m_TMVPModeId;
   Int       m_signHideFlag;
-#if RATE_CONTROL_LAMBDA_DOMAIN
   Bool      m_RCEnableRateControl;
   Int       m_RCTargetBitrate;
-#if M0036_RC_IMPROVEMENT
   Int       m_RCKeepHierarchicalBit;
-#else
-  Bool      m_RCKeepHierarchicalBit;
-#endif
   Bool      m_RCLCULevelRC;
   Bool      m_RCUseLCUSeparateModel;
 …
 #endif
   Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
   Bool      m_CUTransquantBypassFlagValue;                    ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
+  Bool      m_CUTransquantBypassFlagForce;                    ///< if transquant_bypass_enable_flag, then, if true, all CU transquant bypass flags will be set to true.
 #if H_MV
   TComVPS*  m_cVPS;                                           ///< pointer to VPS, same for all layers
 …
   Void      setQPAdaptationRange            ( Int   i )      { m_iQPAdaptationRange = i; }
-  //====== Lossless ========
-  Void      setUseLossless                  (Bool    b  )        { m_useLossless = b;  }
   //====== Sequence ========
   Int       getFrameRate                    ()      { return  m_iFrameRate; }
 …
   Bool      getUseAdaptiveQP                ()      { return  m_bUseAdaptiveQP; }
   Int       getQPAdaptationRange            ()      { return  m_iQPAdaptationRange; }
-  //====== Lossless ========
-  Bool      getUseLossless                  ()      { return  m_useLossless;  }
   //==== Tool list ========
-  Void      setUseSBACRD                    ( Bool  b )     { m_bUseSBACRD  = b; }
   Void      setUseASR                       ( Bool  b )     { m_bUseASR     = b; }
   Void      setUseHADME                     ( Bool  b )     { m_bUseHADME   = b; }
 …
   Void      setdQPs                         ( Int*  p )     { m_aidQP       = p; }
   Void      setDeltaQpRD                    ( UInt  u )     {m_uiDeltaQpRD  = u; }
-  Bool      getUseSBACRD                    ()      { return m_bUseSBACRD;  }
   Bool      getUseASR                       ()      { return m_bUseASR;     }
   Bool      getUseHADME                     ()      { return m_bUseHADME;   }
 …
   Void  setSaoLcuBoundary              (Bool val)      { m_saoLcuBoundary = val; }
   Bool  getSaoLcuBoundary              ()              { return m_saoLcuBoundary; }
-  Void  setSaoLcuBasedOptimization               (Bool val)            { m_saoLcuBasedOptimization = val; }
-  Bool  getSaoLcuBasedOptimization               ()                    { return m_saoLcuBasedOptimization; }
   Void  setLFCrossTileBoundaryFlag               ( Bool   val  )       { m_loopFilterAcrossTilesEnabledFlag = val; }
   Bool  getLFCrossTileBoundaryFlag               ()                    { return m_loopFilterAcrossTilesEnabledFlag;   }
 …
   Void      setSignHideFlag( Int signHideFlag ) { m_signHideFlag = signHideFlag; }
   Int       getSignHideFlag()                    { return m_signHideFlag; }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   Bool      getUseRateCtrl         ()              { return m_RCEnableRateControl;   }
   Void      setUseRateCtrl         ( Bool b )      { m_RCEnableRateControl = b;      }
   Int       getTargetBitrate       ()              { return m_RCTargetBitrate;       }
   Void      setTargetBitrate       ( Int bitrate ) { m_RCTargetBitrate  = bitrate;   }
-#if M0036_RC_IMPROVEMENT
   Int       getKeepHierBit         ()              { return m_RCKeepHierarchicalBit; }
   Void      setKeepHierBit         ( Int i )       { m_RCKeepHierarchicalBit = i;    }
-#else
-  Bool      getKeepHierBit         ()              { return m_RCKeepHierarchicalBit; }
-  Void      setKeepHierBit         ( Bool b )      { m_RCKeepHierarchicalBit = b;    }
-#endif
   Bool      getLCULevelRC          ()              { return m_RCLCULevelRC; }
   Void      setLCULevelRC          ( Bool b )      { m_RCLCULevelRC = b; }
 …
   Bool      getTransquantBypassEnableFlag()           { return m_TransquantBypassEnableFlag; }
   Void      setTransquantBypassEnableFlag(Bool flag)  { m_TransquantBypassEnableFlag = flag; }
   Bool      getCUTransquantBypassFlagValue()          { return m_CUTransquantBypassFlagValue; }
   Void      setCUTransquantBypassFlagValue(Bool flag) { m_CUTransquantBypassFlagValue = flag; }
+  Bool      getCUTransquantBypassFlagForceValue()          { return m_CUTransquantBypassFlagForce; }
+  Void      setCUTransquantBypassFlagForceValue(Bool flag) { m_CUTransquantBypassFlagForce = flag; }
 #if H_MV
   Void      setVPS           ( TComVPS *p ) { m_cVPS = p;    }

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncCu.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   m_bEncodeDQP = false;
+#if RATE_CONTROL_LAMBDA_DOMAIN
+#if !M0036_RC_IMPROVEMENT
+  m_LCUPredictionSAD = 0;
+  m_addSADDepth      = 0;
+  m_temporalSAD      = 0;
+#endif
+#if M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
+  m_LCUPredictionSAD = 0;
+  m_addSADDepth      = 0;
+  m_temporalSAD      = 0;
+  m_spatialSAD       = 0;
+#endif
+#endif
+#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
   m_LCUPredictionSAD = 0;
   m_addSADDepth      = 0;
 …
   m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
-  m_bUseSBACRD        = pcEncTop->getUseSBACRD();
   m_pcRateCtrl        = pcEncTop->getRateCtrl();
+}
 …
   m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
-#if RATE_CONTROL_LAMBDA_DOMAIN
-#if !M0036_RC_IMPROVEMENT
-  m_addSADDepth      = 0;
-  m_LCUPredictionSAD = 0;
-  m_temporalSAD      = 0;
-#endif
-#if M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
-  m_LCUPredictionSAD = 0;
-  m_addSADDepth      = 0;
-  m_temporalSAD      = 0;
-  m_spatialSAD       = 0;
-#endif
-#endif
 #if KWU_RC_MADPRED_E0227
   m_LCUPredictionSAD = 0;
 …
   Int iMaxQP;
   Bool isAddLowestQP = false;
-  Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
   if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
 …
     iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
     iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
-    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
+    {
-      isAddLowestQP = true;
-      iMinQP = iMinQP - 1;
+    }
+  }
   else
 …
+  }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_pcEncCfg->getUseRateCtrl() )
+  {
 …
     iMaxQP = m_pcRateCtrl->getRCQP();
+  }
+#else
+  if(m_pcEncCfg->getUseRateCtrl())
+  {
+    Int qp = m_pcRateCtrl->getUnitQP();
+    iMinQP  = Clip3( MIN_QP, MAX_QP, qp);
+    iMaxQP  = Clip3( MIN_QP, MAX_QP, qp);
+  }
+#endif
+  // transquant-bypass (TQB) processing loop variable initialisation ---
+  const Int lowestQP = iMinQP; // For TQB, use this QP which is the lowest non TQB QP tested (rather than QP'=0) - that way delta QPs are smaller, and TQB can be tested at all CU levels.
+  if ( (rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag()) )
+  {
+    isAddLowestQP = true; // mark that the first iteration is to cost TQB mode.
+    iMinQP = iMinQP - 1;  // increase loop variable range by 1, to allow testing of TQB mode along with other QPs
+    if ( m_pcEncCfg->getCUTransquantBypassFlagForceValue() )
+    {
+      iMaxQP = iMinQP;
+    }
+  }
 #if H_3D_IC
   Bool bICEnabled = rpcTempCU->getSlice()->getViewIndex() && ( rpcTempCU->getSlice()->getSliceType() == P_SLICE || rpcTempCU->getSlice()->getSliceType() == B_SLICE ) && !rpcTempCU->getSlice()->getIsDepth();
 …
     for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
+    {
+      if (isAddLowestQP && (iQP == iMinQP))
+      const Bool bIsLosslessMode = isAddLowestQP && (iQP == iMinQP);
+      if (bIsLosslessMode)
+      {
         iQP = lowestQP;
+      }
+      // variables for fast encoder decision
 #if H_3D_QTLPC
       bTrySplit    = true;
 #endif
       rpcTempCU->initEstData( uiDepth, iQP );
+      rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_QTLPC
       //logic for setting bTrySplit using the partition information that is stored of the texture colocated CU
 …
 #endif
 #if  H_3D_FAST_TEXTURE_ENCODING
           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP );//by Competition for inter_2Nx2N
 #else
           xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );  rpcTempCU->initEstData( uiDepth, iQP );//by Competition for inter_2Nx2N
+          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );//by Competition for inter_2Nx2N
+#else
+          xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bIsLosslessMode  );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );//by Competition for inter_2Nx2N
 #endif
 #if H_3D_VSP
 …
         bFMD = bIVFMerge && rpcBestCU->isSkipped(0);
 #endif
         rpcTempCU->initEstData( uiDepth, iQP );
+        rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
         rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
 #endif
 #if  H_3D_FAST_TEXTURE_ENCODING
             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP );
 #else
             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );  rpcTempCU->initEstData( uiDepth, iQP );
+            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFMD );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
+#else
+            xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #endif
 #if H_3D_VSP
 …
+          {
             xCheckRDCostInterDBBP( rpcBestCU, rpcTempCU, false );
             rpcTempCU->initEstData( uiDepth, iQP );
+            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode  );
 #if H_3D_VSP
             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
+      }
 #endif
       if (isAddLowestQP && (iQP == lowestQP))
+      if ( bIsLosslessMode )
+      {
         iQP = iMinQP;
 …
+    }
 #if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
+#if KWU_RC_MADPRED_E0227
     if ( uiDepth <= m_addSADDepth )
+    {
 …
+    }
 #endif
-#if RATE_CONTROL_LAMBDA_DOMAIN && M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
-    if ( uiDepth <= m_addSADDepth )
+    {
-      m_LCUPredictionSAD += m_temporalSAD;
-      m_addSADDepth = uiDepth;
+    }
-#endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_RC_MADPRED_E0227
-if ( uiDepth <= m_addSADDepth )
+{
-  m_LCUPredictionSAD += m_temporalSAD;
-  m_addSADDepth = uiDepth;
+}
-#endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_FIX_URQ
-    if(m_pcEncCfg->getUseRateCtrl())
+    {
-      Int qp = m_pcRateCtrl->getUnitQP();
-      iMinQP  = Clip3( MIN_QP, MAX_QP, qp);
-      iMaxQP  = Clip3( MIN_QP, MAX_QP, qp);
+    }
-#endif
 #if H_3D_DIM_ENC
     if( rpcBestCU->getSlice()->getIsDepth() && rpcBestCU->getSlice()->isIRAP() )
 …
       for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
+      {
+        if (isAddLowestQP && (iQP == iMinQP))
+        const Bool bIsLosslessMode = isAddLowestQP && (iQP == iMinQP);
+        if (bIsLosslessMode)
+        {
           iQP = lowestQP;
+        }
         rpcTempCU->initEstData( uiDepth, iQP );
+        rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
         // do inter modes, NxN, 2NxN, and Nx2N
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN   );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
             xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N  );
 #endif
             rpcTempCU->initEstData( uiDepth, iQP );
+            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
             xCheckRDCostInter      ( rpcBestCU, rpcTempCU, SIZE_2NxN  );
 #endif
             rpcTempCU->initEstData( uiDepth, iQP );
+            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
             rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
                 xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
 #endif
                 rpcTempCU->initEstData( uiDepth, iQP );
+                rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
                 rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
 #endif
               xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
               rpcTempCU->initEstData( uiDepth, iQP );
+              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
               rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 #endif
               xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
               rpcTempCU->initEstData( uiDepth, iQP );
+              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
               rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
 #endif
               xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
               rpcTempCU->initEstData( uiDepth, iQP );
+              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
               rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 #endif
               xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
               rpcTempCU->initEstData( uiDepth, iQP );
+              rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
 #if H_3D_VSP
               rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
 …
             xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
 #if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
             if ( uiDepth <= m_addSADDepth )
+            {
 …
+            }
 #endif
+#if RATE_CONTROL_LAMBDA_DOMAIN && M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
+            if ( uiDepth <= m_addSADDepth )
+            {
+              m_LCUPredictionSAD += m_spatialSAD;
+              m_addSADDepth = uiDepth;
+            }
+#endif
+#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_RC_MADPRED_E0227
+            if ( uiDepth <= m_addSADDepth )
+            {
+              m_LCUPredictionSAD += m_spatialSAD;
+              m_addSADDepth = uiDepth;
+            }
+#endif
+            rpcTempCU->initEstData( uiDepth, iQP );
+            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
             if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
+            {
 …
+                {
                   xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN   );
                   rpcTempCU->initEstData( uiDepth, iQP );
+                  rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
+                }
 #if H_3D_QTLPC
 …
+          {
             xCheckIntraPCM (rpcBestCU, rpcTempCU);
             rpcTempCU->initEstData( uiDepth, iQP );
+            rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
+          }
+        }
 …
+        }
 #endif
         if (isAddLowestQP && (iQP == lowestQP))
+        if (bIsLosslessMode)
+        {
           iQP = iMinQP;
 …
     m_pcEntropyCoder->encodeSplitFlag( rpcBestCU, 0, uiDepth, true );
     rpcBestCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
-    if(m_pcEncCfg->getUseSBACRD())
+    {
       rpcBestCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+    }
-#if H_3D_VSO // M8
-    if ( m_pcRdCost->getUseVSO() )
-      rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCostVSO( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
-    else
-#endif
     rpcBestCU->getTotalCost()  = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
 …
+  {
     bBoundary = true;
-#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT
-    m_addSADDepth++;
-#endif
+  }
 …
     iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
     iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
-    if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
+    {
-      isAddLowestQP = true;
-      iMinQP = iMinQP - 1;
+    }
+  }
   else if( (g_uiMaxCUWidth>>uiDepth) > rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
 …
     iMaxQP = iStartQP;
+  }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_pcEncCfg->getUseRateCtrl() )
+  {
 …
     iMaxQP = m_pcRateCtrl->getRCQP();
+  }
+#else
+  if(m_pcEncCfg->getUseRateCtrl())
+  {
+    Int qp = m_pcRateCtrl->getUnitQP();
+    iMinQP  = Clip3( MIN_QP, MAX_QP, qp);
+    iMaxQP  = Clip3( MIN_QP, MAX_QP, qp);
+  }
+#endif
+  if ( m_pcEncCfg->getCUTransquantBypassFlagForceValue() )
+  {
+    iMaxQP = iMinQP; // If all blocks are forced into using transquant bypass, do not loop here.
+  }
   for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
+  {
+    if (isAddLowestQP && (iQP == iMinQP))
+    {
+      iQP = lowestQP;
+    }
+    rpcTempCU->initEstData( uiDepth, iQP );
+    const Bool bIsLosslessMode = false; // False at this level. Next level down may set it to true.
+    rpcTempCU->initEstData( uiDepth, iQP, bIsLosslessMode );
     // further split
 …
         if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
+        {
-          if( m_bUseSBACRD )
+          {
             if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
+            {
 …
               m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
+            }
+          }
 #if AMP_ENC_SPEEDUP
 …
         rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
-        if(m_pcEncCfg->getUseSBACRD())
+        {
           rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+        }
+      }
 #if H_3D_VSO // M10
       if ( m_pcRdCost->getUseVSO() )
 …
           m_pcEntropyCoder->encodeQP( rpcTempCU, uiTargetPartIdx, false );
           rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
-          if(m_pcEncCfg->getUseSBACRD())
+          {
             rpcTempCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+          }
 #if H_3D_VSO // M11
           if ( m_pcRdCost->getUseLambdaScaleVSO())
 …
+      }
-      if( m_bUseSBACRD )
+      {
         m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
+      }
       Bool isEndOfSlice        = rpcBestCU->getSlice()->getSliceMode()==FIXED_NUMBER_OF_BYTES
                                  && (rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceArgument()<<3);
 …
       xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth);                                  // RD compare current larger prediction
     }                                                                                  // with sub partitioned prediction.
+    if (isAddLowestQP && (iQP == lowestQP))
+    {
+      iQP = iMinQP;
+    }
+  }
+    }
 #if H_3D_VSO // M12
 …
+  }
 #endif
   rpcBestCU->copyToPic(uiDepth);                                                     // Copy Best data to Picture for next partition prediction.
 …
+}
-#if RATE_CONTROL_INTRA
 Int xCalcHADs8x8_ISlice(Pel *piOrg, Int iStrideOrg)
+{
 …
   return(iSumHad);
+}
-#endif
 /** check RD costs for a CU block encoded with merge
 …
 #endif
   Int numValidMergeCand = 0;
+  const Bool bTransquantBypassFlag = rpcTempCU->getCUTransquantBypass(0);
   for( UInt ui = 0; ui < rpcTempCU->getSlice()->getMaxNumMergeCand(); ++ui )
 …
 #else
   rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
-  rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
 #endif
 …
           // set MC parameters
           rpcTempCU->setPredModeSubParts( MODE_INTER, 0, uhDepth ); // interprets depth relative to LCU level
           rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(),     0, uhDepth );
+          rpcTempCU->setCUTransquantBypassSubParts( bTransquantBypassFlag,     0, uhDepth );
           rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
 #if H_3D_IC
 …
+          }
 #endif
           rpcTempCU->initEstData( uhDepth, orgQP );
+          rpcTempCU->initEstData( uhDepth, orgQP, bTransquantBypassFlag );
       if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
 …
   rpcTempCU->setPartSizeSubParts  ( ePartSize,  0, uhDepth );
   rpcTempCU->setPredModeSubParts  ( MODE_INTER, 0, uhDepth );
-  rpcTempCU->setCUTransquantBypassSubParts  ( m_pcEncCfg->getCUTransquantBypassFlagValue(),      0, uhDepth );
 #if MTK_DDD_G0063
   rpcTempCU->setUseDDD( false, 0, uhDepth );
 …
 #endif
 #if RATE_CONTROL_LAMBDA_DOMAIN  && (!M0036_RC_IMPROVEMENT || KWU_RC_MADPRED_E0227)
+#if KWU_RC_MADPRED_E0227
   if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && ePartSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
+  {
 …
+  }
 #endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN  && KWU_RC_MADPRED_E0227
-  if ( m_pcEncCfg->getUseRateCtrl() && ePartSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
+  {
-    UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
-      m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
-      rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
-    m_temporalSAD = (Int)SAD;
+  }
-#endif
   m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
 #if NTT_STORE_SPDV_VSP_G0148 // possible bug fix
   if( rpcTempCU->getQtRootCbf(0)==0 )
 …
   rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
   rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
-  rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uiDepth );
   Bool bSeparateLumaChroma = true; // choose estimation mode
 …
   setdQPFlag( bCodeDQP );
   if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
+  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
   rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
-  if(m_pcEncCfg->getUseSBACRD())
+  {
     rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+  }
 #if H_3D_VSO // M6
   if( m_pcRdCost->getUseLambdaScaleVSO())
 …
   rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
-#if RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
-  UChar uhDepth = rpcTempCU->getDepth( 0 );
-  if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && eSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
+  {
-    UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
-      m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
-      rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
-    m_spatialSAD = (Int)SAD;
+  }
-#endif
-#if RATE_CONTROL_LAMBDA_DOMAIN && M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
-  UChar uhDepth = rpcTempCU->getDepth( 0 );
-  if ( m_pcEncCfg->getUseRateCtrl() && m_pcEncCfg->getLCULevelRC() && eSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
+  {
-    UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
-      m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
-      rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
-    m_spatialSAD = (Int)SAD;
+  }
-#endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_RC_MADPRED_E0227
-  UChar uhDepth = rpcTempCU->getDepth( 0 );
-  if ( m_pcEncCfg->getUseRateCtrl() && eSize == SIZE_2Nx2N && uhDepth <= m_addSADDepth )
+  {
-    UInt SAD = m_pcRdCost->getSADPart( g_bitDepthY, m_ppcPredYuvTemp[uhDepth]->getLumaAddr(), m_ppcPredYuvTemp[uhDepth]->getStride(),
-      m_ppcOrigYuv[uhDepth]->getLumaAddr(), m_ppcOrigYuv[uhDepth]->getStride(),
-      rpcTempCU->getWidth(0), rpcTempCU->getHeight(0) );
-    m_spatialSAD = (Int)SAD;
+  }
-#endif
   xCheckDQP( rpcTempCU );
   xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
 …
   rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
   rpcTempCU->setTrIdxSubParts ( 0, 0, uiDepth );
-  rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uiDepth );
   m_pcPredSearch->IPCMSearch( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth]);
   if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
   m_pcEntropyCoder->resetBits();
 …
   m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
   if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
+  m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
   rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
-  if(m_pcEncCfg->getUseSBACRD())
+  {
     rpcTempCU->getTotalBins() = ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+  }
 #if H_3D_VSO // M44
   if ( m_pcRdCost->getUseVSO() )
 …
     pcCU  = NULL;
     if( m_bUseSBACRD )  // store temp best CI for next CU coding
+    // store temp best CI for next CU coding
       m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]);
+  }
 …
       m_pcEntropyCoder->encodeQP( pcCU, 0, false );
       pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
-      if(m_pcEncCfg->getUseSBACRD())
+      {
         pcCU->getTotalBins() += ((TEncBinCABAC *)((TEncSbac*)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
+      }
 #if H_3D_VSO // M45
       if ( m_pcRdCost->getUseVSO() )

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncCu.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   TEncSbac***             m_pppcRDSbacCoder;
   TEncSbac*               m_pcRDGoOnSbacCoder;
-  Bool                    m_bUseSBACRD;
   TEncRateCtrl*           m_pcRateCtrl;
+#if RATE_CONTROL_LAMBDA_DOMAIN
+#if !M0036_RC_IMPROVEMENT
+  UInt                    m_LCUPredictionSAD;
+  Int                     m_addSADDepth;
+  Int                     m_temporalSAD;
+#endif
+#if M0036_RC_IMPROVEMENT && KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
   UInt                    m_LCUPredictionSAD;
   Int                     m_addSADDepth;
 …
   Int                     m_spatialSAD;
 #endif
-#endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_RC_MADPRED_E0227
-  UInt                    m_LCUPredictionSAD;
-  Int                     m_addSADDepth;
-  Int                     m_temporalSAD;
-  Int                     m_spatialSAD;
-#endif
 public:
   /// copy parameters from encoder class
 …
   Void setBitCounter        ( TComBitCounter* pcBitCounter ) { m_pcBitCounter = pcBitCounter; }
 #if (RATE_CONTROL_LAMBDA_DOMAIN && !M0036_RC_IMPROVEMENT) || KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
   UInt getLCUPredictionSAD() { return m_LCUPredictionSAD; }
 #endif
-#if RATE_CONTROL_INTRA
   Int   updateLCUDataISlice ( TComDataCU* pcCU, Int LCUIdx, Int width, Int height );
-#endif
 protected:
   Void  finishCU            ( TComDataCU*  pcCU, UInt uiAbsPartIdx,           UInt uiDepth        );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncEntropy.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 Void TEncEntropy::encodeSliceHeader ( TComSlice* pcSlice )
+{
-  if (pcSlice->getSPS()->getUseSAO())
+  {
-    SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
-    pcSlice->setSaoEnabledFlag     (saoParam->bSaoFlag[0]);
+    {
-      pcSlice->setSaoEnabledFlagChroma   (saoParam->bSaoFlag[1]);
+    }
+  }
   m_pcEntropyCoderIf->codeSliceHeader( pcSlice );
   return;
 …
+}
-/** Encode SAO Offset
- * \param  saoLcuParam SAO LCU paramters
- */
-Void TEncEntropy::encodeSaoOffset(SaoLcuParam* saoLcuParam, UInt compIdx)
+{
-  UInt uiSymbol;
-  Int i;
-  uiSymbol = saoLcuParam->typeIdx + 1;
-  if (compIdx!=2)
+  {
-    m_pcEntropyCoderIf->codeSaoTypeIdx(uiSymbol);
+  }
-  if (uiSymbol)
+  {
-    if (saoLcuParam->typeIdx < 4 && compIdx != 2)
+    {
-      saoLcuParam->subTypeIdx = saoLcuParam->typeIdx;
+    }
-    Int bitDepth = compIdx ? g_bitDepthC : g_bitDepthY;
-    Int offsetTh = 1 << min(bitDepth - 5,5);
-    if( saoLcuParam->typeIdx == SAO_BO )
+    {
-      for( i=0; i< saoLcuParam->length; i++)
+      {
-        UInt absOffset = ( (saoLcuParam->offset[i] < 0) ? -saoLcuParam->offset[i] : saoLcuParam->offset[i]);
-        m_pcEntropyCoderIf->codeSaoMaxUvlc(absOffset, offsetTh-1);
+      }
-      for( i=0; i< saoLcuParam->length; i++)
+      {
-        if (saoLcuParam->offset[i] != 0)
+        {
-          UInt sign = (saoLcuParam->offset[i] < 0) ? 1 : 0 ;
-          m_pcEntropyCoderIf->codeSAOSign(sign);
+        }
+      }
-      uiSymbol = (UInt) (saoLcuParam->subTypeIdx);
-      m_pcEntropyCoderIf->codeSaoUflc(5, uiSymbol);
+    }
-    else if( saoLcuParam->typeIdx < 4 )
+    {
-      m_pcEntropyCoderIf->codeSaoMaxUvlc( saoLcuParam->offset[0], offsetTh-1);
-      m_pcEntropyCoderIf->codeSaoMaxUvlc( saoLcuParam->offset[1], offsetTh-1);
-      m_pcEntropyCoderIf->codeSaoMaxUvlc(-saoLcuParam->offset[2], offsetTh-1);
-      m_pcEntropyCoderIf->codeSaoMaxUvlc(-saoLcuParam->offset[3], offsetTh-1);
-      if (compIdx!=2)
+      {
-        uiSymbol = (UInt) (saoLcuParam->subTypeIdx);
-        m_pcEntropyCoderIf->codeSaoUflc(2, uiSymbol);
+      }
+    }
+  }
+}
-/** Encode SAO unit interleaving
-* \param  rx
-* \param  ry
-* \param  pSaoParam
-* \param  pcCU
-* \param  iCUAddrInSlice
-* \param  iCUAddrUpInSlice
-* \param  bLFCrossSliceBoundaryFlag
- */
-Void TEncEntropy::encodeSaoUnitInterleaving(Int compIdx, Bool saoFlag, Int rx, Int ry, SaoLcuParam* saoLcuParam, Int cuAddrInSlice, Int cuAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp)
+{
-  if (saoFlag)
+  {
-    if (rx>0 && cuAddrInSlice!=0 && allowMergeLeft)
+    {
-      m_pcEntropyCoderIf->codeSaoMerge(saoLcuParam->mergeLeftFlag);
+    }
-    else
+    {
-      saoLcuParam->mergeLeftFlag = 0;
+    }
-    if (saoLcuParam->mergeLeftFlag == 0)
+    {
-      if ( (ry > 0) && (cuAddrUpInSlice>=0) && allowMergeUp )
+      {
-        m_pcEntropyCoderIf->codeSaoMerge(saoLcuParam->mergeUpFlag);
+      }
-      else
+      {
-        saoLcuParam->mergeUpFlag = 0;
+      }
-      if (!saoLcuParam->mergeUpFlag)
+      {
-        encodeSaoOffset(saoLcuParam, compIdx);
+      }
+    }
+  }
+}
 Int TEncEntropy::countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize )
+{
 …
+}
-#if H_3D_INTER_SDC
-#if QC_SDC_UNIFY_G0130
-Void TEncEntropy::encodeDeltaDC  ( TComDataCU* pcCU, UInt absPartIdx )
+{
-  m_pcEntropyCoderIf->codeDeltaDC( pcCU, absPartIdx );
+}
-Void TEncEntropy::encodeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
+{
-  if( ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) ) ||
-    ( pcCU->isIntra( uiAbsPartIdx ) && !pcCU->getSlice()->getVPS()->getVpsDepthModesFlag( pcCU->getSlice()->getLayerIdInVps() ) ) )
+  {
-    return;
+  }
-#if SEC_INTER_SDC_G0101
-  if( !pcCU->getSlice()->getIsDepth() || pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N || pcCU->isSkipped( uiAbsPartIdx ) )
-#else
-  if( !pcCU->getSlice()->getIsDepth() || ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N ) || pcCU->isSkipped( uiAbsPartIdx ) )
-#endif
+  {
-    return;
+  }
-#if SEC_INTER_SDC_G0101
-  assert( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
-#else
-  assert( ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
-#endif
-  if( bRD )
+  {
-    uiAbsPartIdx = 0;
+  }
-  m_pcEntropyCoderIf->codeSDCFlag( pcCU, uiAbsPartIdx );
+}
-#else
-Void TEncEntropy::encodeInterSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
+{
-  if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
+  {
-    return;
+  }
-  if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || pcCU->isSkipped( uiAbsPartIdx ) )
+  {
-    return;
+  }
-  if( bRD )
+  {
-    uiAbsPartIdx = 0;
+  }
-  m_pcEntropyCoderIf->codeInterSDCFlag( pcCU, uiAbsPartIdx );
+}
-Void TEncEntropy::encodeInterSDCResidualData( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
+{
-  if( !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) )
+  {
-    return;
+  }
-  if( !pcCU->getSlice()->getIsDepth() || pcCU->isIntra( uiAbsPartIdx ) || !pcCU->getInterSDCFlag( uiAbsPartIdx ) )
+  {
-    return;
+  }
-  if( bRD )
+  {
-    uiAbsPartIdx = 0;
+  }
-  // number of segments depends on prediction mode for INTRA
-  UInt uiNumSegments = ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N ) ? 1 : ( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ? 4 : 2 );
-  // encode residual data for each segment
-  for( UInt uiSeg = 0; uiSeg < uiNumSegments; uiSeg++ )
+  {
-    m_pcEntropyCoderIf->codeInterSDCResidualData( pcCU, uiAbsPartIdx, uiSeg );
+  }
+}
-#endif
-#endif
-#if H_3D_DBBP
-Void TEncEntropy::encodeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
+{
-  if( bRD )
+  {
-    uiAbsPartIdx = 0;
+  }
-  m_pcEntropyCoderIf->codeDBBPFlag( pcCU, uiAbsPartIdx );
+}
-#endif
 //! \}

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncEntropy.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   virtual Void codeCoeffNxN      ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType ) = 0;
   virtual Void codeTransformSkipFlags ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt width, UInt height, TextType eTType ) = 0;
-  virtual Void codeSAOSign          ( UInt code   ) = 0;
-  virtual Void codeSaoMaxUvlc       ( UInt code, UInt maxSymbol ) = 0;
-  virtual Void codeSaoMerge    ( UInt   uiCode  ) = 0;
-  virtual Void codeSaoTypeIdx      ( UInt   uiCode) = 0;
-  virtual Void codeSaoUflc         ( UInt uiLength, UInt   uiCode ) = 0;
   virtual Void estBit               (estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType) = 0;
 …
   Void estimateBit             ( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType);
-  Void    encodeSaoOffset(SaoLcuParam* saoLcuParam, UInt compIdx);
-  Void    encodeSaoUnitInterleaving(Int compIdx, Bool saoFlag, Int rx, Int ry, SaoLcuParam* saoLcuParam, Int cuAddrInSlice, Int cuAddrUpInSlice, Int allowMergeLeft, Int allowMergeUp);
   static Int countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncGOP.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 #endif
 #endif
+#if FIX1172
+  m_associatedIRAPType = NAL_UNIT_CODED_SLICE_IDR_N_LP;
+  m_associatedIRAPPOC  = 0;
+#endif
   return;
+}
 …
+    }
     if( getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    if( getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_W_RADL || getNalUnitType(pocCurr, m_iLastIDR, isField) == NAL_UNIT_CODED_SLICE_IDR_N_LP )
+    {
       m_iLastIDR = pocCurr;
 …
 #if H_MV
     // Set the nal unit type
     pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
+    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
     if( pcSlice->getSliceType() == B_SLICE )
+    {
 …
+      }
+    }
+// To be checked!
+    if( pcSlice->getSliceType() == B_SLICE )
+    {
+      if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'I' )
+      {
+        pcSlice->setSliceType( I_SLICE );
+      }
+    }
 #else
     if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
 …
       pcSlice->setSliceType(P_SLICE);
+    }
+    if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='I')
+    {
+      pcSlice->setSliceType(I_SLICE);
+    }
     // Set the nal unit type
     pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
+    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR, isField));
 #endif
     if(pcSlice->getTemporalLayerNonReferenceFlag())
 …
     m_pcEncTop->selectReferencePictureSet(pcSlice, pocCurr, iGOPid);
     pcSlice->getRPS()->setNumberOfLongtermPictures(0);
+#if FIX1071
+#if FIX1172
+    if ( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_LP
+      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_W_RADL
+      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_BLA_N_LP
+      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_W_RADL
+      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR_N_LP
+      || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA )  // IRAP picture
+    {
+      m_associatedIRAPType = pcSlice->getNalUnitType();
+      m_associatedIRAPPOC = pocCurr;
+    }
+    pcSlice->setAssociatedIRAPType(m_associatedIRAPType);
+    pcSlice->setAssociatedIRAPPOC(m_associatedIRAPPOC);
+#endif
     if ((pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0) || (pcSlice->isIRAP()))
+    {
       pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS(), pcSlice->isIRAP());
+    }
-#else
-    if(pcSlice->checkThatAllRefPicsAreAvailable(rcListPic, pcSlice->getRPS(), false) != 0)
+    {
-      pcSlice->createExplicitReferencePictureSetFromReference(rcListPic, pcSlice->getRPS());
+    }
-#endif
     pcSlice->applyReferencePictureSet(rcListPic, pcSlice->getRPS());
+    if(pcSlice->getTLayer() > 0)
+    if(pcSlice->getTLayer() > 0
+      &&  !( pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_N     // Check if not a leading picture
+          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RADL_R
+          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_N
+          || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_RASL_R )
+        )
+    {
       if(pcSlice->isTemporalLayerSwitchingPoint(rcListPic) || pcSlice->getSPS()->getTemporalIdNestingFlag())
 …
         else
+        {
           pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TLA_R);
+          pcSlice->setNalUnitType(NAL_UNIT_CODED_SLICE_TSA_R);
+        }
+      }
 …
     pcPic->getSlice(pcSlice->getSliceIdx())->setMvdL1ZeroFlag(pcSlice->getMvdL1ZeroFlag());
-#if RATE_CONTROL_LAMBDA_DOMAIN
     Double lambda            = 0.0;
     Int actualHeadBits       = 0;
 …
       else if ( frameLevel == 0 )   // intra case, but use the model
+      {
-#if RATE_CONTROL_INTRA
         m_pcSliceEncoder->calCostSliceI(pcPic);
-#endif
         if ( m_pcCfg->getIntraPeriod() != 1 )   // do not refine allocated bits for all intra case
+        {
           Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
-#if RATE_CONTROL_INTRA
           bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
-#else
-          bits = m_pcRateCtrl->getRCSeq()->getRefineBitsForIntra( bits );
-#endif
           if ( bits < 200 )
+          {
 …
         list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
-#if RATE_CONTROL_INTRA
         m_pcRateCtrl->getRCPic()->getLCUInitTargetBits();
         lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
-#else
-        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
-#endif
         sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
+      }
 …
 #endif
         list<TEncRCPic*> listPreviousPicture = m_pcRateCtrl->getPicList();
-#if RATE_CONTROL_INTRA
         lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture, pcSlice->getSliceType());
-#else
-        lambda  = m_pcRateCtrl->getRCPic()->estimatePicLambda( listPreviousPicture );
-#endif
         sliceQP = m_pcRateCtrl->getRCPic()->estimatePicQP( lambda, listPreviousPicture );
 #if KWU_RC_MADPRED_E0227
 …
       m_pcSliceEncoder->resetQP( pcPic, sliceQP, lambda );
+    }
-#endif
     UInt uiNumSlices = 1;
 …
     // SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
+    if( m_pcCfg->getSaoLcuBasedOptimization() && m_pcCfg->getSaoLcuBoundary() )
+    {
+      m_pcSAO->resetStats();
+      m_pcSAO->calcSaoStatsCu_BeforeDblk( pcPic );
+    if( pcSlice->getSPS()->getUseSAO() && m_pcCfg->getSaoLcuBoundary() )
+    {
+      m_pcSAO->getPreDBFStatistics(pcPic);
+    }
 …
     m_pcLoopFilter->loopFilterPic( pcPic );
-    pcSlice = pcPic->getSlice(0);
-    if(pcSlice->getSPS()->getUseSAO())
+    {
-      std::vector<Bool> LFCrossSliceBoundaryFlag;
-      for(Int s=0; s< uiNumSlices; s++)
+      {
-        LFCrossSliceBoundaryFlag.push_back(  ((uiNumSlices==1)?true:pcPic->getSlice(s)->getLFCrossSliceBoundaryFlag()) );
+      }
-      m_storedStartCUAddrForEncodingSlice.resize(uiNumSlices+1);
-      pcPic->createNonDBFilterInfo(m_storedStartCUAddrForEncodingSlice, 0, &LFCrossSliceBoundaryFlag ,pcPic->getPicSym()->getNumTiles() ,bLFCrossTileBoundary);
+    }
-    pcSlice = pcPic->getSlice(0);
-    if(pcSlice->getSPS()->getUseSAO())
+    {
-      m_pcSAO->createPicSaoInfo(pcPic);
+    }
     /////////////////////////////////////////////////////////////////////////////////////////////////// File writing
     // Set entropy coder
 …
       writeRBSPTrailingBits(nalu.m_Bitstream);
       accessUnit.push_back(new NALUnitEBSP(nalu));
-#if RATE_CONTROL_LAMBDA_DOMAIN
       actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-#endif
 #if H_MV
 …
       writeRBSPTrailingBits(nalu.m_Bitstream);
       accessUnit.push_back(new NALUnitEBSP(nalu));
-#if RATE_CONTROL_LAMBDA_DOMAIN
       actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-#endif
 #if H_MV
 …
       writeRBSPTrailingBits(nalu.m_Bitstream);
       accessUnit.push_back(new NALUnitEBSP(nalu));
-#if RATE_CONTROL_LAMBDA_DOMAIN
       actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
+#endif
 #if PPS_FIX_DEPTH
+      }
 …
+        {
           SOPcurrPOC += deltaPOC;
           SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR);
+          SOPDescriptionSEI.m_sopDescVclNaluType[i] = getNalUnitType(SOPcurrPOC, m_iLastIDR, isField);
           SOPDescriptionSEI.m_sopDescTemporalId[i] = m_pcCfg->getGOPEntry(j).m_temporalId;
           SOPDescriptionSEI.m_sopDescStRpsIdx[i] = m_pcEncTop->getReferencePictureSetIdxForSOP(pcSlice, SOPcurrPOC, j);
 …
+          }
           m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
-#if RATE_CONTROL_LAMBDA_DOMAIN
           tmpBitsBeforeWriting = m_pcEntropyCoder->getNumberOfWrittenBits();
-#endif
           m_pcEntropyCoder->encodeSliceHeader(pcSlice);
-#if RATE_CONTROL_LAMBDA_DOMAIN
           actualHeadBits += ( m_pcEntropyCoder->getNumberOfWrittenBits() - tmpBitsBeforeWriting );
-#endif
           // is it needed?
 …
           xAttachSliceDataToNalUnit(nalu, pcBitstreamRedirect);
           accessUnit.push_back(new NALUnitEBSP(nalu));
-#if RATE_CONTROL_LAMBDA_DOMAIN
           actualTotalBits += UInt(accessUnit.back()->m_nalUnitData.str().size()) * 8;
-#endif
           bNALUAlignedWrittenToList = true;
           uiOneBitstreamPerSliceLength += nalu.m_Bitstream.getNumberOfWrittenBits(); // length of bitstream after byte-alignment
 …
               m_pcEntropyCoder->resetEntropy();
               m_pcEntropyCoder->setBitstream( m_pcBitCounter );
+              m_pcSAO->startSaoEnc(pcPic, m_pcEntropyCoder, m_pcEncTop->getRDSbacCoder(), m_pcEncTop->getRDGoOnSbacCoder());
+              SAOParam& cSaoParam = *pcSlice->getPic()->getPicSym()->getSaoParam();
+#if SAO_CHROMA_LAMBDA
+#if SAO_ENCODING_CHOICE
+              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma(), pcPic->getSlice(0)->getDepth());
+#else
+              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambdaLuma(), pcPic->getSlice(0)->getLambdaChroma());
+#endif
+#else
+              m_pcSAO->SAOProcess(&cSaoParam, pcPic->getSlice(0)->getLambda());
+#endif
+              m_pcSAO->endSaoEnc();
+            Bool sliceEnabled[NUM_SAO_COMPONENTS];
+            m_pcSAO->initRDOCabacCoder(m_pcEncTop->getRDGoOnSbacCoder(), pcSlice);
+            m_pcSAO->SAOProcess(pcPic
+              , sliceEnabled
+              , pcPic->getSlice(0)->getLambdas()
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+              , m_pcCfg->getSaoLcuBoundary()
+#endif
+              );
               m_pcSAO->PCMLFDisableProcess(pcPic);
+            }
+#if SAO_RDO
+            m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
+#endif
+            processingState = ENCODE_SLICE;
+            //assign SAO slice header
             for(Int s=0; s< uiNumSlices; s++)
+            {
               if (pcSlice->getSPS()->getUseSAO())
+              {
                 pcPic->getSlice(s)->setSaoEnabledFlag((pcSlice->getPic()->getPicSym()->getSaoParam()->bSaoFlag[0]==1)?true:false);
+              pcPic->getSlice(s)->setSaoEnabledFlag(sliceEnabled[SAO_Y]);
+              assert(sliceEnabled[SAO_Cb] == sliceEnabled[SAO_Cr]);
+              pcPic->getSlice(s)->setSaoEnabledFlagChroma(sliceEnabled[SAO_Cb]);
+              }
+            }
+          processingState = ENCODE_SLICE;
+          }
           break;
 …
+        }
       } // end iteration over slices
-      if(pcSlice->getSPS()->getUseSAO())
+      {
-        if(pcSlice->getSPS()->getUseSAO())
+        {
-          m_pcSAO->destroyPicSaoInfo();
+        }
-        pcPic->destroyNonDBFilterInfo();
+      }
 #if H_3D
       pcPic->compressMotion(2);
 …
     //In case of field coding, compute the interlaced PSNR for both fields
     if (isField && ((!pcPic->isTopField() && isTff) || (pcPic->isTopField() && !isTff)))
+    if (isField && ((!pcPic->isTopField() && isTff) || (pcPic->isTopField() && !isTff)) && (pcPic->getPOC()%m_iGopSize != 1))
+    {
       //get complementary top field
 …
       xCalculateInterlacedAddPSNR(pcPicTop, pcPic, pcPicTop->getPicYuvRec(), pcPic->getPicYuvRec(), accessUnit, dEncTime );
+    }
+    else if (isField && pcPic->getPOC()!= 0 && (pcPic->getPOC()%m_iGopSize == 0))
+    {
+      //get complementary bottom field
+      TComPic* pcPicBottom;
+      TComList<TComPic*>::iterator   iterPic = rcListPic.begin();
+      while ((*iterPic)->getPOC() != pcPic->getPOC()+1)
+      {
+        iterPic ++;
+      }
+      pcPicBottom = *(iterPic);
+      xCalculateInterlacedAddPSNR(pcPic, pcPicBottom, pcPic->getPicYuvRec(), pcPicBottom->getPicYuvRec(), accessUnit, dEncTime );
+    }
       if (digestStr)
 …
+        }
+      }
-#if RATE_CONTROL_LAMBDA_DOMAIN
       if ( m_pcCfg->getUseRateCtrl() )
+      {
-#if !M0036_RC_IMPROVEMENT
-        Double effectivePercentage = m_pcRateCtrl->getRCPic()->getEffectivePercentage();
-#endif
         Double avgQP     = m_pcRateCtrl->getRCPic()->calAverageQP();
         Double avgLambda = m_pcRateCtrl->getRCPic()->calAverageLambda();
 …
           avgLambda = lambda;
+        }
-#if M0036_RC_IMPROVEMENT
-#if RATE_CONTROL_INTRA
         m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, pcSlice->getSliceType());
-#else
-        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda );
-#endif
-#else
-        m_pcRateCtrl->getRCPic()->updateAfterPicture( actualHeadBits, actualTotalBits, avgQP, avgLambda, effectivePercentage );
-#endif
         m_pcRateCtrl->getRCPic()->addToPictureLsit( m_pcRateCtrl->getPicList() );
 …
+        }
+      }
-#else
-      if(m_pcCfg->getUseRateCtrl())
+      {
-        UInt  frameBits = m_vRVM_RP[m_vRVM_RP.size()-1];
-        m_pcRateCtrl->updataRCFrameStatus((Int)frameBits, pcSlice->getSliceType());
+      }
-#endif
       if( ( m_pcCfg->getPictureTimingSEIEnabled() || m_pcCfg->getDecodingUnitInfoSEIEnabled() ) &&
 …
       delete[] pcSubstreamsOut;
+  }
-#if !KWU_FIX_URQ && !RATE_CONTROL_LAMBDA_DOMAIN
-  if(m_pcCfg->getUseRateCtrl())
+  {
-    m_pcRateCtrl->updateRCGOPStatus();
+  }
-#endif
   delete pcBitstreamRedirect;
 …
   m_pcEntropyCoder->resetEntropy    ();
   m_pcEntropyCoder->setBitstream    ( m_pcBitCounter );
-  pcSlice = pcPic->getSlice(0);
-  if(pcSlice->getSPS()->getUseSAO())
+  {
-    std::vector<Bool> LFCrossSliceBoundaryFlag(1, true);
-    std::vector<Int>  sliceStartAddress;
-    sliceStartAddress.push_back(0);
-    sliceStartAddress.push_back(pcPic->getNumCUsInFrame()* pcPic->getNumPartInCU());
-    pcPic->createNonDBFilterInfo(sliceStartAddress, 0, &LFCrossSliceBoundaryFlag);
+  }
-  if( pcSlice->getSPS()->getUseSAO())
+  {
-    pcPic->destroyNonDBFilterInfo();
+  }
   m_pcEntropyCoder->resetEntropy    ();
   ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
 …
     case NAL_UNIT_CODED_SLICE_TRAIL_R: return "TRAIL_R";
     case NAL_UNIT_CODED_SLICE_TRAIL_N: return "TRAIL_N";
     case NAL_UNIT_CODED_SLICE_TLA_R:      return "TLA_R";
+    case NAL_UNIT_CODED_SLICE_TSA_R:      return "TSA_R";
     case NAL_UNIT_CODED_SLICE_TSA_N: return "TSA_N";
     case NAL_UNIT_CODED_SLICE_STSA_R: return "STSA_R";
 …
     for (Int x = 0; x < width; x++)
+    {
       dst[x] = isTff ? (UChar) top[x] : (UChar) bottom[x];
       dst[stride+x] = isTff ? (UChar) bottom[x] : (UChar) top[x];
+      dst[x] = isTff ? top[x] : bottom[x];
+      dst[stride+x] = isTff ? bottom[x] : top[x];
+    }
     top += stride;
 …
  * This function checks the configuration and returns the appropriate nal_unit_type for the picture.
  */
 NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR)
+NalUnitType TEncGOP::getNalUnitType(Int pocCurr, Int lastIDR, Bool isField)
+{
   if (pocCurr == 0)
 …
     return NAL_UNIT_CODED_SLICE_IDR_W_RADL;
+  }
   if (pocCurr % m_pcCfg->getIntraPeriod() == 0)
+  if ((pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0)
+  {
     if (m_pcCfg->getDecodingRefreshType() == 1)

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncGOP.h

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   std::vector<Int>        m_storedStartCUAddrForEncodingSlice;
   std::vector<Int>        m_storedStartCUAddrForEncodingSliceSegment;
+#if FIX1172
+  NalUnitType             m_associatedIRAPType;
+  Int                     m_associatedIRAPPOC;
+#endif
   std::vector<Int> m_vRVM_RP;
 …
   TEncSlice*  getSliceEncoder()   { return m_pcSliceEncoder; }
   NalUnitType getNalUnitType( Int pocCurr, Int lastIdr );
+  NalUnitType getNalUnitType( Int pocCurr, Int lastIdr, Bool isField );
   Void arrangeLongtermPicturesInRPS(TComSlice *, TComList<TComPic*>& );
 protected:
 …
 protected:
   Void xInitGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, bool isField );
   Void  xInitGOP          ( Int iPOC, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut );
   Void  xGetBuffer        ( TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, Int iNumPicRcvd, Int iTimeOffset, TComPic*& rpcPic, TComPicYuv*& rpcPicYuvRecOut, Int pocCurr, bool isField );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncPic.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncPic.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncPreanalyzer.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncPreanalyzer.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncRateCtrl.cpp

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 using namespace std;
-#if RATE_CONTROL_LAMBDA_DOMAIN
 //sequence level
 TEncRCSeq::TEncRCSeq()
 …
   m_bitsLeft            = 0;
   m_useLCUSeparateModel = false;
-#if M0036_RC_IMPROVEMENT
   m_adaptiveBit         = 0;
   m_lastLambda          = 0.0;
-#endif
+}
 …
+}
-#if M0036_RC_IMPROVEMENT
 Void TEncRCSeq::create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel, Int adaptiveBit )
-#else
-Void TEncRCSeq::create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel )
-#endif
+{
   destroy();
 …
     m_betaUpdate  = 0.025;
+  }
-#if M0036_RC_IMPROVEMENT
   else if ( m_seqTargetBpp < 0.2 )
+  {
 …
     m_betaUpdate  = 0.2;
+  }
-#else
-  else
+  {
-    m_alphaUpdate = 0.1;
-    m_betaUpdate  = 0.05;
+  }
-#endif
   m_averageBits     = (Int)(m_targetBits / totalFrames);
   Int picWidthInBU  = ( m_picWidth  % m_LCUWidth  ) == 0 ? m_picWidth  / m_LCUWidth  : m_picWidth  / m_LCUWidth  + 1;
 …
   m_framesLeft = m_totalFrames;
   m_bitsLeft   = m_targetBits;
-#if M0036_RC_IMPROVEMENT
   m_adaptiveBit = adaptiveBit;
   m_lastLambda = 0.0;
-#endif
+}
 …
     for ( Int i=0; i<m_numberOfLevel; i++ )
+    {
-#if RATE_CONTROL_INTRA
       if (i>0)
+      {
 …
         m_picPara[i].m_beta  = BETA2;
+      }
-#else
-      m_picPara[i].m_alpha = 3.2003;
-      m_picPara[i].m_beta  = -1.367;
-#endif
+    }
+  }
 …
       for ( Int j=0; j<m_numberOfLCU; j++)
+      {
-#if RATE_CONTROL_INTRA
         m_LCUPara[i][j].m_alpha = m_picPara[i].m_alpha;
         m_LCUPara[i][j].m_beta  = m_picPara[i].m_beta;
-#else
-        m_LCUPara[i][j].m_alpha = 3.2003;
-        m_LCUPara[i][j].m_beta  = -1.367;
-#endif
+      }
+    }
 …
+}
-#if !RATE_CONTROL_INTRA
-Int TEncRCSeq::getRefineBitsForIntra( Int orgBits )
+{
-  Double bpp = ( (Double)orgBits ) / m_picHeight / m_picHeight;
-  if ( bpp > 0.2 )
+  {
-    return orgBits * 5;
+  }
-  if ( bpp > 0.1 )
+  {
-    return orgBits * 7;
+  }
-  return orgBits * 10;
+}
-#endif
-#if M0036_RC_IMPROVEMENT
 Void TEncRCSeq::setAllBitRatio( Double basicLambda, Double* equaCoeffA, Double* equaCoeffB )
+{
 …
   delete[] bitsRatio;
+}
-#endif
 //GOP level
 …
   Int targetBits = xEstGOPTargetBits( encRCSeq, numPic );
-#if M0036_RC_IMPROVEMENT
   if ( encRCSeq->getAdaptiveBits() > 0 && encRCSeq->getLastLambda() > 0.1 )
+  {
 …
     delete []equaCoeffB;
+  }
-#endif
   m_picTargetBitInGOP = new Int[numPic];
 …
+  {
     currPicRatio = encRCSeq->getBitRatio( i );
-#if M0036_RC_IMPROVEMENT
     m_picTargetBitInGOP[i] = (Int)( ((Double)targetBits) * currPicRatio / totalPicRatio );
-#else
-    m_picTargetBitInGOP[i] = targetBits * currPicRatio / totalPicRatio;
-#endif
+  }
 …
+}
-#if M0036_RC_IMPROVEMENT
 Void TEncRCGOP::xCalEquaCoeff( TEncRCSeq* encRCSeq, Double* lambdaRatio, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize )
+{
 …
   return solution;
+}
-#endif
 Void TEncRCGOP::destroy()
 …
   m_LCUs         = NULL;
-#if !M0036_RC_IMPROVEMENT
-  m_lastPicture  = NULL;
-#endif
 #if KWU_RC_MADPRED_E0227
   m_lastIVPicture = NULL;
 …
   m_picActualHeaderBits = 0;
-#if !M0036_RC_IMPROVEMENT
-  m_totalMAD            = 0.0;
-#endif
   m_picActualBits       = 0;
   m_picQP               = 0;
 …
+  }
-#if M0036_RC_IMPROVEMENT
   targetBits  = Int( ((Double)GOPbitsLeft) * currPicRatio / totalPicRatio );
-#else
-  targetBits  = Int( GOPbitsLeft * currPicRatio / totalPicRatio );
-#endif
   if ( targetBits < 100 )
 …
       m_LCUs[LCUIdx].m_lambda     = 0.0;
       m_LCUs[LCUIdx].m_targetBits = 0;
-#if M0036_RC_IMPROVEMENT
       m_LCUs[LCUIdx].m_bitWeight  = 1.0;
-#else
-      m_LCUs[LCUIdx].m_MAD        = 0.0;
-#endif
       Int currWidth  = ( (i == picWidthInLCU -1) ? picWidth  - LCUWidth *(picWidthInLCU -1) : LCUWidth  );
       Int currHeight = ( (j == picHeightInLCU-1) ? picHeight - LCUHeight*(picHeightInLCU-1) : LCUHeight );
 …
+  }
   m_picActualHeaderBits = 0;
-#if !M0036_RC_IMPROVEMENT
-  m_totalMAD            = 0.0;
-#endif
   m_picActualBits       = 0;
   m_picQP               = 0;
 …
-#if !M0036_RC_IMPROVEMENT
-  m_lastPicture = NULL;
-  list<TEncRCPic*>::reverse_iterator it;
-  for ( it = listPreviousPictures.rbegin(); it != listPreviousPictures.rend(); it++ )
+  {
-    if ( (*it)->getFrameLevel() == m_frameLevel )
+    {
-      m_lastPicture = (*it);
-      break;
+    }
+  }
-#endif
 #if KWU_RC_MADPRED_E0227
   list<TEncRCPic*>::reverse_iterator it;
 …
-#if RATE_CONTROL_INTRA
 Double TEncRCPic::estimatePicLambda( list<TEncRCPic*>& listPreviousPictures, SliceType eSliceType)
-#else
-Double TEncRCPic::estimatePicLambda( list<TEncRCPic*>& listPreviousPictures )
-#endif
+{
   Double alpha         = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
   Double beta          = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
   Double bpp       = (Double)m_targetBits/(Double)m_numberOfPixel;
-#if RATE_CONTROL_INTRA
   Double estLambda;
   if (eSliceType == I_SLICE)
 …
     estLambda = alpha * pow( bpp, beta );
+  }
-#else
-  Double estLambda = alpha * pow( bpp, beta );
-#endif
   Double lastLevelLambda = -1.0;
 …
   m_estPicLambda = estLambda;
-#if M0036_RC_IMPROVEMENT
   Double totalWeight = 0.0;
   // initial BU bit allocation weight
   for ( Int i=0; i<m_numberOfLCU; i++ )
+  {
-#if RC_FIX
     Double alphaLCU, betaLCU;
     if ( m_encRCSeq->getUseLCUSeparateModel() )
 …
       betaLCU  = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
+    }
-#else
-    Double alphaLCU = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_alpha;
-    Double betaLCU  = m_encRCSeq->getLCUPara( m_frameLevel, i ).m_beta;
-#endif
     m_LCUs[i].m_bitWeight =  m_LCUs[i].m_numberOfPixel * pow( estLambda/alphaLCU, 1.0/betaLCU );
 …
     m_LCUs[i].m_bitWeight = BUTargetBits;
+  }
-#endif
   return estLambda;
 …
-#if RATE_CONTROL_INTRA
 Double TEncRCPic::getLCUTargetBpp(SliceType eSliceType)
+#else
+Double TEncRCPic::getLCUTargetBpp()
+#endif
+{
+  Int   LCUIdx    = getLCUCoded();
+  Double bpp      = -1.0;
+  Int avgBits     = 0;
+  if (eSliceType == I_SLICE)
+  {
+    Int noOfLCUsLeft = m_numberOfLCU - LCUIdx + 1;
+    Int bitrateWindow = min(4,noOfLCUsLeft);
+    Double MAD      = getLCU(LCUIdx).m_costIntra;
+    if (m_remainingCostIntra > 0.1 )
+    {
+      Double weightedBitsLeft = (m_bitsLeft*bitrateWindow+(m_bitsLeft-getLCU(LCUIdx).m_targetBitsLeft)*noOfLCUsLeft)/(Double)bitrateWindow;
+      avgBits = Int( MAD*weightedBitsLeft/m_remainingCostIntra );
+    }
+    else
+    {
+      avgBits = Int( m_bitsLeft / m_LCULeft );
+    }
+    m_remainingCostIntra -= MAD;
+  }
+  else
+  {
+  Double totalWeight = 0;
+  for ( Int i=LCUIdx; i<m_numberOfLCU; i++ )
+  {
+    totalWeight += m_LCUs[i].m_bitWeight;
+  }
+  Int realInfluenceLCU = min( g_RCLCUSmoothWindowSize, getLCULeft() );
+  avgBits = (Int)( m_LCUs[LCUIdx].m_bitWeight - ( totalWeight - m_bitsLeft ) / realInfluenceLCU + 0.5 );
+  }
+  if ( avgBits < 1 )
+  {
+    avgBits = 1;
+  }
+  bpp = ( Double )avgBits/( Double )m_LCUs[ LCUIdx ].m_numberOfPixel;
+  m_LCUs[ LCUIdx ].m_targetBits = avgBits;
+  return bpp;
+}
+#if KWU_RC_MADPRED_E0227
+Double TEncRCPic::getLCUTargetBppforInterView( list<TEncRCPic*>& listPreviousPictures, TComDataCU* pcCU, Double basePos, Double curPos, Double focalLen, Double znear, Double zfar, Int direction, Int* disparity )
+{
   Int   LCUIdx    = getLCUCoded();
 …
 #endif
-#if RATE_CONTROL_INTRA
-  if (eSliceType == I_SLICE){
-    Int noOfLCUsLeft = m_numberOfLCU - LCUIdx + 1;
-    Int bitrateWindow = min(4,noOfLCUsLeft);
-    Double MAD      = getLCU(LCUIdx).m_costIntra;
-    if (m_remainingCostIntra > 0.1 )
+    {
-      Double weightedBitsLeft = (m_bitsLeft*bitrateWindow+(m_bitsLeft-getLCU(LCUIdx).m_targetBitsLeft)*noOfLCUsLeft)/(Double)bitrateWindow;
-      avgBits = Int( MAD*weightedBitsLeft/m_remainingCostIntra );
+    }
-    else
+    {
-      avgBits = Int( m_bitsLeft / m_LCULeft );
+    }
-    m_remainingCostIntra -= MAD;
+  }
-  else
+  {
-#endif
-#if M0036_RC_IMPROVEMENT
-  Double totalWeight = 0;
-  for ( Int i=LCUIdx; i<m_numberOfLCU; i++ )
+  {
-    totalWeight += m_LCUs[i].m_bitWeight;
+  }
-  Int realInfluenceLCU = min( g_RCLCUSmoothWindowSize, getLCULeft() );
-  avgBits = (Int)( m_LCUs[LCUIdx].m_bitWeight - ( totalWeight - m_bitsLeft ) / realInfluenceLCU + 0.5 );
-#else
-  if ( m_lastPicture == NULL )
+  {
-    avgBits = Int( m_bitsLeft / m_LCULeft );
+  }
-  else
+  {
-    MAD = m_lastPicture->getLCU(LCUIdx).m_MAD;
-    totalMAD = m_lastPicture->getTotalMAD();
-    for ( Int i=0; i<LCUIdx; i++ )
+    {
-      totalMAD -= m_lastPicture->getLCU(i).m_MAD;
+    }
-    if ( totalMAD > 0.1 )
+    {
-      avgBits = Int( m_bitsLeft * MAD / totalMAD );
+    }
-    else
+    {
-      avgBits = Int( m_bitsLeft / m_LCULeft );
+    }
+  }
-#endif
-#if RATE_CONTROL_INTRA
+  }
-#endif
-  if ( avgBits < 1 )
+  {
-    avgBits = 1;
+  }
-  bpp = ( Double )avgBits/( Double )m_LCUs[ LCUIdx ].m_numberOfPixel;
-  m_LCUs[ LCUIdx ].m_targetBits = avgBits;
-  return bpp;
+}
-#if KWU_RC_MADPRED_E0227
-Double TEncRCPic::getLCUTargetBppforInterView( list<TEncRCPic*>& listPreviousPictures, TComDataCU* pcCU, Double basePos, Double curPos, Double focalLen, Double znear, Double zfar, Int direction, Int* disparity )
+{
-  Int   LCUIdx    = getLCUCoded();
-  Double bpp      = -1.0;
-  Int avgBits     = 0;
-#if !M0036_RC_IMPROVEMENT
-  Double totalMAD = -1.0;
-  Double MAD      = -1.0;
-#endif
   Double totalMAD = -1.0;
   Double MAD      = -1.0;
 …
     beta  *= ( 1.0 - m_encRCSeq->getBetaUpdate() / 2.0 );
-#if M0036_RC_IMPROVEMENT
     alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
-#else
-    alpha = Clip3( 0.05, 20.0, alpha );
-    beta  = Clip3( -3.0, -0.1, beta  );
-#endif
     TRCParameter rcPara;
 …
   alpha += m_encRCSeq->getAlphaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * alpha;
   double lnbpp = log( bpp );
-#if M0036_RC_IMPROVEMENT
   lnbpp = Clip3( -5.0, -0.1, lnbpp );
-#else
-  lnbpp = Clip3( -5.0, 1.0, lnbpp );
-#endif
   beta  += m_encRCSeq->getBetaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * lnbpp;
-#if M0036_RC_IMPROVEMENT
   alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
   beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
-#else
-  alpha = Clip3( 0.05, 20.0, alpha );
-  beta  = Clip3( -3.0, -0.1, beta  );
-#endif
   TRCParameter rcPara;
   rcPara.m_alpha = alpha;
 …
+}
-#if !M0036_RC_IMPROVEMENT
-Double TEncRCPic::getEffectivePercentage()
+{
-  Int effectivePiexels = 0;
-  Int totalPixels = 0;
-  for ( Int i=0; i<m_numberOfLCU; i++ )
+  {
-    totalPixels += m_LCUs[i].m_numberOfPixel;
-    if ( m_LCUs[i].m_QP > 0 )
+    {
-      effectivePiexels += m_LCUs[i].m_numberOfPixel;
+    }
+  }
-  Double effectivePixelPercentage = (Double)effectivePiexels/(Double)totalPixels;
-  return effectivePixelPercentage;
+}
-#endif
 Double TEncRCPic::calAverageQP()
+{
 …
+}
-#if M0036_RC_IMPROVEMENT
-#if RATE_CONTROL_INTRA
 Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, SliceType eSliceType)
-#else
-Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda )
-#endif
-#else
-Void TEncRCPic::updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, Double effectivePercentage )
-#endif
+{
   m_picActualHeaderBits = actualHeaderBits;
 …
+  }
   m_picLambda           = averageLambda;
-#if !M0036_RC_IMPROVEMENT || KWU_RC_MADPRED_E0227
 #if KWU_RC_MADPRED_E0227
   m_totalMAD = 0;
-#endif
   for ( Int i=0; i<m_numberOfLCU; i++ )
+  {
 …
   Double alpha = m_encRCSeq->getPicPara( m_frameLevel ).m_alpha;
   Double beta  = m_encRCSeq->getPicPara( m_frameLevel ).m_beta;
-#if RATE_CONTROL_INTRA
   if (eSliceType == I_SLICE)
+  {
 …
   else
+  {
-#endif
   // update parameters
   Double picActualBits = ( Double )m_picActualBits;
 …
   Double inputLambda   = m_picLambda;
-#if M0036_RC_IMPROVEMENT
   if ( inputLambda < 0.01 || calLambda < 0.01 || picActualBpp < 0.0001 )
-#else
-  if ( inputLambda < 0.01 || calLambda < 0.01 || picActualBpp < 0.0001 || effectivePercentage < 0.05 )
-#endif
+  {
     alpha *= ( 1.0 - m_encRCSeq->getAlphaUpdate() / 2.0 );
     beta  *= ( 1.0 - m_encRCSeq->getBetaUpdate() / 2.0 );
-#if M0036_RC_IMPROVEMENT
     alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
     beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
-#else
-    alpha = Clip3( 0.05, 20.0, alpha );
-    beta  = Clip3( -3.0, -0.1, beta  );
-#endif
     TRCParameter rcPara;
     rcPara.m_alpha = alpha;
 …
   alpha += m_encRCSeq->getAlphaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * alpha;
   double lnbpp = log( picActualBpp );
-#if M0036_RC_IMPROVEMENT
   lnbpp = Clip3( -5.0, -0.1, lnbpp );
-#else
-  lnbpp = Clip3( -5.0, 1.0, lnbpp );
-#endif
   beta  += m_encRCSeq->getBetaUpdate() * ( log( inputLambda ) - log( calLambda ) ) * lnbpp;
-#if M0036_RC_IMPROVEMENT
   alpha = Clip3( g_RCAlphaMinValue, g_RCAlphaMaxValue, alpha );
   beta  = Clip3( g_RCBetaMinValue,  g_RCBetaMaxValue,  beta  );
+#else
+  alpha = Clip3( 0.05, 20.0, alpha );
+  beta  = Clip3( -3.0, -0.1, beta  );
+#endif
+#if RATE_CONTROL_INTRA
+  }
+#endif
+  }
   TRCParameter rcPara;
 …
   m_encRCSeq->setPicPara( m_frameLevel, rcPara );
-#if M0036_RC_IMPROVEMENT
   if ( m_frameLevel == 1 )
+  {
 …
     m_encRCSeq->setLastLambda( updateLastLambda );
+  }
+#endif
+}
+#if RATE_CONTROL_INTRA
+}
 Int TEncRCPic::getRefineBitsForIntra( Int orgBits )
+{
 …
   return estLambda;
+}
-#endif
 TEncRateCtrl::TEncRateCtrl()
 …
+}
-#if M0036_RC_IMPROVEMENT
 #if KWU_RC_MADPRED_E0227
 Void TEncRateCtrl::init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP], Int layerID )
 …
 Void TEncRateCtrl::init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int keepHierBits, Bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP] )
 #endif
-#else
-Void TEncRateCtrl::init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry  GOPList[MAX_GOP] )
-#endif
+{
   destroy();
 …
   Int numberOfLevel = 1;
-#if M0036_RC_IMPROVEMENT
   Int adaptiveBit = 0;
   if ( keepHierBits > 0 )
-#else
-  if ( keepHierBits )
-#endif
+  {
     numberOfLevel = Int( log((Double)GOPSize)/log(2.0) + 0.5 ) + 1;
 …
+  }
-#if M0036_RC_IMPROVEMENT
   if ( keepHierBits > 0 )
-#else
-  if ( keepHierBits )
-#endif
+  {
     Double bpp = (Double)( targetBitrate / (Double)( frameRate*picWidth*picHeight ) );
 …
         bitsRatio[3] = 14;
+      }
-#if M0036_RC_IMPROVEMENT
       if ( keepHierBits == 2 )
+      {
         adaptiveBit = 1;
+      }
-#endif
+    }
     else if ( GOPSize == 8 && !isLowdelay )
 …
         bitsRatio[7] = 1;
+      }
-#if M0036_RC_IMPROVEMENT
       if ( keepHierBits == 2 )
+      {
         adaptiveBit = 2;
+      }
-#endif
+    }
     else
+    {
-#if M0036_RC_IMPROVEMENT
       printf( "\n hierarchical bit allocation is not support for the specified coding structure currently.\n" );
-#else
-      printf( "\n hierarchical bit allocation is not support for the specified coding structure currently." );
-#endif
+    }
+  }
 …
+    }
+  }
-#if M0036_RC_IMPROVEMENT
   if ( keepHierBits > 0 )
-#else
-  if ( keepHierBits )
-#endif
+  {
     if ( GOPSize == 4 && isLowdelay )
 …
   m_encRCSeq = new TEncRCSeq;
-#if M0036_RC_IMPROVEMENT
   m_encRCSeq->create( totalFrames, targetBitrate, frameRate, GOPSize, picWidth, picHeight, LCUWidth, LCUHeight, numberOfLevel, useLCUSeparateModel, adaptiveBit );
-#else
-  m_encRCSeq->create( totalFrames, targetBitrate, frameRate, GOPSize, picWidth, picHeight, LCUWidth, LCUHeight, numberOfLevel, useLCUSeparateModel );
-#endif
   m_encRCSeq->initBitsRatio( bitsRatio );
   m_encRCSeq->initGOPID2Level( GOPID2Level );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncRateCtrl.h

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 //! \{
-#if RATE_CONTROL_LAMBDA_DOMAIN
 #include "../TLibEncoder/TEncCfg.h"
 #include <list>
 …
 const Double g_RCWeightPicTargetBitInGOP    = 0.9;
 const Double g_RCWeightPicRargetBitInBuffer = 1.0 - g_RCWeightPicTargetBitInGOP;
-#if M0036_RC_IMPROVEMENT
 const Int g_RCIterationNum = 20;
 const Double g_RCWeightHistoryLambda = 0.5;
 …
 const Double g_RCBetaMinValue  = -3.0;
 const Double g_RCBetaMaxValue  = -0.1;
+#endif
+#if RATE_CONTROL_INTRA
 #define ALPHA     6.7542;
 #define BETA1     1.2517
 #define BETA2     1.7860
-#endif
 struct TRCLCU
 …
   Int m_targetBits;
   Double m_lambda;
-#if M0036_RC_IMPROVEMENT
   Double m_bitWeight;
-#else
-  Double m_MAD;
-#endif
   Int m_numberOfPixel;
-#if RATE_CONTROL_INTRA
   Double m_costIntra;
   Int m_targetBitsLeft;
-#endif
 #if KWU_RC_MADPRED_E0227
   Double m_MAD;
   Int m_CUWidth;
   Int m_CUHeight;
 …
 public:
-#if M0036_RC_IMPROVEMENT
   Void create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel, Int adaptiveBit );
-#else
-  Void create( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int numberOfLevel, Bool useLCUSeparateModel );
-#endif
   Void destroy();
   Void initBitsRatio( Int bitsRatio[] );
 …
   Void initLCUPara( TRCParameter** LCUPara = NULL );    // NULL to initial with default value
   Void updateAfterPic ( Int bits );
-#if !RATE_CONTROL_INTRA
-  Int  getRefineBitsForIntra( Int orgBits );
-#endif
-#if M0036_RC_IMPROVEMENT
   Void setAllBitRatio( Double basicLambda, Double* equaCoeffA, Double* equaCoeffB );
-#endif
 public:
 …
   Double getBetaUpdate()                { return m_betaUpdate; }
-#if M0036_RC_IMPROVEMENT
   Int    getAdaptiveBits()              { return m_adaptiveBit;  }
   Double getLastLambda()                { return m_lastLambda;   }
   Void   setLastLambda( Double lamdba ) { m_lastLambda = lamdba; }
-#endif
 private:
 …
   Bool m_useLCUSeparateModel;
-#if M0036_RC_IMPROVEMENT
   Int m_adaptiveBit;
   Double m_lastLambda;
-#endif
 };
 …
 private:
   Int  xEstGOPTargetBits( TEncRCSeq* encRCSeq, Int GOPSize );
-#if M0036_RC_IMPROVEMENT
   Void   xCalEquaCoeff( TEncRCSeq* encRCSeq, Double* lambdaRatio, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize );
   Double xSolveEqua( Double targetBpp, Double* equaCoeffA, Double* equaCoeffB, Int GOPSize );
-#endif
 public:
 …
   Double estimatePicLambdaIV( list<TEncRCPic*>& listPreviousPictures, Int curPOC );
 #endif
-#if !RATE_CONTROL_INTRA
-  Double estimatePicLambda( list<TEncRCPic*>& listPreviousPictures );
-#endif
   Int    estimatePicQP    ( Double lambda, list<TEncRCPic*>& listPreviousPictures );
-#if RATE_CONTROL_INTRA
   Int    getRefineBitsForIntra(Int orgBits);
   Double calculateLambdaIntra(double alpha, double beta, double MADPerPixel, double bitsPerPixel);
 …
   Double getLCUTargetBpp(SliceType eSliceType);
   Double getLCUEstLambdaAndQP(Double bpp, Int clipPicQP, Int *estQP);
-#else
-  Double getLCUTargetBpp();
-#endif
 #if KWU_RC_MADPRED_E0227
   Double getLCUTargetBppforInterView( list<TEncRCPic*>& listPreviousPictures, TComDataCU* pcCU, Double basePos, Double curPos, Double focalLen, Double znear, Double zfar, Int direction, Int* disparity );
 #endif
   Double getLCUEstLambda( Double bpp );
   Int    getLCUEstQP( Double lambda, Int clipPicQP );
   Void updateAfterLCU( Int LCUIdx, Int bits, Int QP, Double lambda, Bool updateLCUParameter = true );
-#if M0036_RC_IMPROVEMENT
-#if RATE_CONTROL_INTRA
   Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, SliceType eSliceType);
-#else
-  Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda );
-#endif
-#else
-  Void updateAfterPicture( Int actualHeaderBits, Int actualTotalBits, Double averageQP, Double averageLambda, Double effectivePercentage );
-#endif
   Void addToPictureLsit( list<TEncRCPic*>& listPreviousPictures );
 #if KWU_RC_MADPRED_E0227
   Void addToPictureLsitIV( list<TEncRCPic*>& listPreviousPictures );
   Void setIVPic( TEncRCPic* baseRCPic );
-#endif
-#if !M0036_RC_IMPROVEMENT
-  Double getEffectivePercentage();
 #endif
   Double calAverageQP();
 …
   Int  getNumberOfLCU()                                   { return m_numberOfLCU; }
   Int  getTargetBits()                                    { return m_targetBits; }
-#if !RATE_CONTROL_INTRA
-  Void setTargetBits( Int bits )                          { m_targetBits = bits; }
-#endif
   Int  getEstHeaderBits()                                 { return m_estHeaderBits; }
   Int  getLCULeft()                                       { return m_LCULeft; }
 …
   TRCLCU& getLCU( Int LCUIdx )                            { return m_LCUs[LCUIdx]; }
   Int  getPicActualHeaderBits()                           { return m_picActualHeaderBits; }
-#if !M0036_RC_IMPROVEMENT
-  Double getTotalMAD()                                    { return m_totalMAD; }
-  Void   setTotalMAD( Double MAD )                        { m_totalMAD = MAD; }
-#endif
-#if RATE_CONTROL_INTRA
   Void setTargetBits( Int bits )                          { m_targetBits = bits; m_bitsLeft = bits;}
   Void setTotalIntraCost(Double cost)                     { m_totalCostIntra = cost; }
   Void getLCUInitTargetBits();
-#endif
 #if KWU_RC_MADPRED_E0227
   Double getTotalMAD()                                    { return m_totalMAD; }
 …
   Void setLayerID(Int layerid)                              { m_LayerID = layerid; }
 #endif
 private:
   TEncRCSeq* m_encRCSeq;
 …
   Double m_totalMAD;
 #endif
-#if RATE_CONTROL_INTRA
   Double m_totalCostIntra;
   Double m_remainingCostIntra;
-#endif
   Int m_picActualBits;          // the whole picture, including header
   Int m_picQP;                  // in integer form
   Double m_picLambda;
-#if !M0036_RC_IMPROVEMENT
-  TEncRCPic* m_lastPicture;
-#endif
 #if KWU_RC_MADPRED_E0227
   Double m_totalMAD;
 …
 public:
-#if M0036_RC_IMPROVEMENT
 #if KWU_RC_MADPRED_E0227
   Void init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry GOPList[MAX_GOP], Int layerID );
 #else
   Void init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Int keepHierBits, Bool useLCUSeparateModel, GOPEntry GOPList[MAX_GOP] );
-#endif
-#else
-  Void init( Int totalFrames, Int targetBitrate, Int frameRate, Int GOPSize, Int picWidth, Int picHeight, Int LCUWidth, Int LCUHeight, Bool keepHierBits, Bool useLCUSeparateModel, GOPEntry GOPList[MAX_GOP] );
 #endif
   Void destroy();
 …
   Void setLayerID(Int layerid)     { m_LayerID = layerid; }
 #endif
 private:
   TEncRCSeq* m_encRCSeq;
 …
   list<TEncRCPic*> m_listRCPictures;
   Int        m_RCQP;
 #if KWU_RC_MADPRED_E0227
   Int m_LayerID;
 …
 };
+#else
+// ====================================================================================================================
+// Class definition
+// ====================================================================================================================
+#define MAX_DELTA_QP    2
+#define MAX_CUDQP_DEPTH 0
+typedef struct FrameData
+{
+  Bool       m_isReferenced;
+  Int        m_qp;
+  Int        m_bits;
+  Double     m_costMAD;
+}FrameData;
+typedef struct LCUData
+{
+  Int     m_qp;                ///<  coded QP
+  Int     m_bits;              ///<  actually generated bits
+  Int     m_pixels;            ///<  number of pixels for a unit
+  Int     m_widthInPixel;      ///<  number of pixels for width
+  Int     m_heightInPixel;     ///<  number of pixels for height
+  Double  m_costMAD;           ///<  texture complexity for a unit
+}LCUData;
+class MADLinearModel
+{
+private:
+  Bool   m_activeOn;
+  Double m_paramY1;
+  Double m_paramY2;
+  Double m_costMADs[3];
+public:
+  MADLinearModel ()   {};
+  ~MADLinearModel()   {};
+  Void    initMADLinearModel      ();
+  Double  getMAD                  ();
+  Void    updateMADLiearModel     ();
+  Void    updateMADHistory        (Double costMAD);
+  Bool    IsUpdateAvailable       ()              { return m_activeOn; }
+};
+class PixelBaseURQQuadraticModel
+{
+private:
+  Double m_paramHighX1;
+  Double m_paramHighX2;
+  Double m_paramLowX1;
+  Double m_paramLowX2;
+public:
+  PixelBaseURQQuadraticModel () {};
+  ~PixelBaseURQQuadraticModel() {};
+  Void    initPixelBaseQuadraticModel       ();
+  Int     getQP                             (Int qp, Int targetBits, Int numberOfPixels, Double costPredMAD);
+  Void    updatePixelBasedURQQuadraticModel (Int qp, Int bits, Int numberOfPixels, Double costMAD);
+  Bool    checkUpdateAvailable              (Int qpReference );
+  Double  xConvertQP2QStep                  (Int qp );
+  Int     xConvertQStep2QP                  (Double qStep );
+};
+class TEncRateCtrl
+{
+private:
+  Bool            m_isLowdelay;
+  Int             m_prevBitrate;
+  Int             m_currBitrate;
+  Int             m_frameRate;
+  Int             m_refFrameNum;
+  Int             m_nonRefFrameNum;
+  Int             m_numOfPixels;
+  Int             m_sourceWidthInLCU;
+  Int             m_sourceHeightInLCU;
+  Int             m_sizeGOP;
+  Int             m_indexGOP;
+  Int             m_indexFrame;
+  Int             m_indexLCU;
+  Int             m_indexUnit;
+  Int             m_indexRefFrame;
+  Int             m_indexNonRefFrame;
+  Int             m_indexPOCInGOP;
+  Int             m_indexPrevPOCInGOP;
+  Int             m_occupancyVB;
+  Int             m_initialOVB;
+  Int             m_targetBufLevel;
+  Int             m_initialTBL;
+  Int             m_remainingBitsInGOP;
+  Int             m_remainingBitsInFrame;
+  Int             m_occupancyVBInFrame;
+  Int             m_targetBits;
+  Int             m_numUnitInFrame;
+  Int             m_codedPixels;
+  Bool            m_activeUnitLevelOn;
+  Double          m_costNonRefAvgWeighting;
+  Double          m_costRefAvgWeighting;
+  Double          m_costAvgbpp;
+  FrameData*      m_pcFrameData;
+  LCUData*        m_pcLCUData;
+  MADLinearModel              m_cMADLinearModel;
+  PixelBaseURQQuadraticModel  m_cPixelURQQuadraticModel;
+public:
+  TEncRateCtrl         () {};
+  virtual ~TEncRateCtrl() {};
+  Void          create                (Int sizeIntraPeriod, Int sizeGOP, Int frameRate, Int targetKbps, Int qp, Int numLCUInBasicUnit, Int sourceWidth, Int sourceHeight, Int maxCUWidth, Int maxCUHeight);
+  Void          destroy               ();
+  Void          initFrameData         (Int qp = 0);
+  Void          initUnitData          (Int qp = 0);
+  Int           getFrameQP            (Bool isReferenced, Int POC);
+  Bool          calculateUnitQP       ();
+  Int           getUnitQP             ()                                          { return m_pcLCUData[m_indexLCU].m_qp;  }
+  Void          updateRCGOPStatus     ();
+  Void          updataRCFrameStatus   (Int frameBits, SliceType eSliceType);
+  Void          updataRCUnitStatus    ();
+  Void          updateLCUData         (TComDataCU* pcCU, UInt64 actualLCUBits, Int qp);
+#if KWU_RC_MADPRED_E0227
+  Void          updateLCUDataEnhancedView(TComDataCU* pcCU, UInt64 uiBits, Int qp, Double basePos, Double curPos, Double focalLen, Double znear, Double zfar, Int direction);
+#endif
+  Void          updateFrameData       (UInt64 actualFrameBits);
+  Double        xAdjustmentBits       (Int& reductionBits, Int& compensationBits);
+  Int           getGOPId              ()                                          { return m_indexFrame; }
+};
+#endif
+#endif
+#endif

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+ * Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 //! \{
-TEncSampleAdaptiveOffset::TEncSampleAdaptiveOffset()
+{
-  m_pcEntropyCoder = NULL;
-  m_pppcRDSbacCoder = NULL;
-  m_pcRDGoOnSbacCoder = NULL;
-  m_pppcBinCoderCABAC = NULL;
-  m_iCount = NULL;
-  m_iOffset = NULL;
-  m_iOffsetOrg = NULL;
-  m_iRate = NULL;
-  m_iDist = NULL;
-  m_dCost = NULL;
-  m_dCostPartBest = NULL;
-  m_iDistOrg = NULL;
-  m_iTypePartBest = NULL;
-#if SAO_ENCODING_CHOICE_CHROMA
-  m_depthSaoRate[0][0] = 0;
-  m_depthSaoRate[0][1] = 0;
-  m_depthSaoRate[0][2] = 0;
-  m_depthSaoRate[0][3] = 0;
-  m_depthSaoRate[1][0] = 0;
-  m_depthSaoRate[1][1] = 0;
-  m_depthSaoRate[1][2] = 0;
-  m_depthSaoRate[1][3] = 0;
-#endif
+}
-TEncSampleAdaptiveOffset::~TEncSampleAdaptiveOffset()
+{
+}
-// ====================================================================================================================
-// Constants
-// ====================================================================================================================
-// ====================================================================================================================
-// Tables
-// ====================================================================================================================
-inline Double xRoundIbdi2(Int bitDepth, Double x)
+{
-  return ((x)>0) ? (Int)(((Int)(x)+(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))) : ((Int)(((Int)(x)-(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))));
+}
 /** rounding with IBDI
  * \param  x
  */
+inline Double xRoundIbdi2(Int bitDepth, Double x)
+{
+  return ((x)>0) ? (Int)(((Int)(x)+(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))) : ((Int)(((Int)(x)-(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))));
+}
 inline Double xRoundIbdi(Int bitDepth, Double x)
+{
 …
+/** process SAO for one partition
+ * \param  *psQTPart, iPartIdx, dLambda
+ */
+Void TEncSampleAdaptiveOffset::rdoSaoOnePart(SAOQTPart *psQTPart, Int iPartIdx, Double dLambda, Int yCbCr)
+{
+  Int iTypeIdx;
+  Int iNumTotalType = MAX_NUM_SAO_TYPE;
+  SAOQTPart*  pOnePart = &(psQTPart[iPartIdx]);
+  Int64 iEstDist;
+  Int iClassIdx;
+  Int uiShift = 2 * DISTORTION_PRECISION_ADJUSTMENT((yCbCr == 0 ? g_bitDepthY : g_bitDepthC)-8);
+  UInt uiDepth = pOnePart->PartLevel;
+  m_iDistOrg [iPartIdx] =  0;
+  Double  bestRDCostTableBo = MAX_DOUBLE;
+  Int     bestClassTableBo    = 0;
+  Int     currentDistortionTableBo[MAX_NUM_SAO_CLASS];
+  Double  currentRdCostTableBo[MAX_NUM_SAO_CLASS];
+  Int addr;
+  Int allowMergeLeft;
+  Int allowMergeUp;
+  Int frameWidthInCU = m_pcPic->getFrameWidthInCU();
+  SaoLcuParam  saoLcuParamRdo;
+  for (iTypeIdx=-1; iTypeIdx<iNumTotalType; iTypeIdx++)
+  {
+    if( m_bUseSBACRD )
+    {
+      m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
+      m_pcRDGoOnSbacCoder->resetBits();
+    }
+    else
+    {
+      m_pcEntropyCoder->resetEntropy();
+      m_pcEntropyCoder->resetBits();
+    }
+    iEstDist = 0;
+    if (iTypeIdx == -1)
+    {
+      for (Int ry = pOnePart->StartCUY; ry<= pOnePart->EndCUY; ry++)
+      {
+        for (Int rx = pOnePart->StartCUX; rx <= pOnePart->EndCUX; rx++)
+        {
+          addr = ry * frameWidthInCU + rx;
+          // get bits for iTypeIdx = -1
+          allowMergeLeft = 1;
+          allowMergeUp   = 1;
+          if (rx != 0)
+          {
+            // check tile id and slice id
+            if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-1) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-1)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+            {
+              allowMergeLeft = 0;
+            }
+          }
+          if (ry!=0)
+          {
+            if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-m_iNumCuInWidth) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-m_iNumCuInWidth)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+            {
+              allowMergeUp = 0;
+            }
+          }
+          // reset
+          resetSaoUnit(&saoLcuParamRdo);
+          // set merge flag
+          saoLcuParamRdo.mergeUpFlag   = 1;
+          saoLcuParamRdo.mergeLeftFlag = 1;
+          if (ry == pOnePart->StartCUY)
+          {
+            saoLcuParamRdo.mergeUpFlag = 0;
+          }
+          if (rx == pOnePart->StartCUX)
+          {
+            saoLcuParamRdo.mergeLeftFlag = 0;
+          }
+          m_pcEntropyCoder->encodeSaoUnitInterleaving(yCbCr, 1, rx, ry,  &saoLcuParamRdo, 1,  1,  allowMergeLeft, allowMergeUp);
+        }
+      }
+    }
+    if (iTypeIdx>=0)
+    {
+      iEstDist = estSaoTypeDist(iPartIdx, iTypeIdx, uiShift, dLambda, currentDistortionTableBo, currentRdCostTableBo);
+      if( iTypeIdx == SAO_BO )
+      {
+        // Estimate Best Position
+        Double currentRDCost = 0.0;
+        for(Int i=0; i< SAO_MAX_BO_CLASSES -SAO_BO_LEN +1; i++)
+        {
+          currentRDCost = 0.0;
+          for(UInt uj = i; uj < i+SAO_BO_LEN; uj++)
+          {
+            currentRDCost += currentRdCostTableBo[uj];
+          }
+          if( currentRDCost < bestRDCostTableBo)
+          {
+            bestRDCostTableBo = currentRDCost;
+            bestClassTableBo  = i;
+          }
+        }
+        // Re code all Offsets
+        // Code Center
+        for(iClassIdx = bestClassTableBo; iClassIdx < bestClassTableBo+SAO_BO_LEN; iClassIdx++)
+        {
+          iEstDist += currentDistortionTableBo[iClassIdx];
+        }
+      }
+      for (Int ry = pOnePart->StartCUY; ry<= pOnePart->EndCUY; ry++)
+      {
+        for (Int rx = pOnePart->StartCUX; rx <= pOnePart->EndCUX; rx++)
+        {
+          addr = ry * frameWidthInCU + rx;
+          // get bits for iTypeIdx = -1
+          allowMergeLeft = 1;
+          allowMergeUp   = 1;
+          if (rx != 0)
+          {
+            // check tile id and slice id
+            if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-1) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-1)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+            {
+              allowMergeLeft = 0;
+            }
+          }
+          if (ry!=0)
+          {
+            if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-m_iNumCuInWidth) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-m_iNumCuInWidth)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+            {
+              allowMergeUp = 0;
+            }
+          }
+          // reset
+          resetSaoUnit(&saoLcuParamRdo);
+          // set merge flag
+          saoLcuParamRdo.mergeUpFlag   = 1;
+          saoLcuParamRdo.mergeLeftFlag = 1;
+          if (ry == pOnePart->StartCUY)
+          {
+            saoLcuParamRdo.mergeUpFlag = 0;
+          }
+          if (rx == pOnePart->StartCUX)
+          {
+            saoLcuParamRdo.mergeLeftFlag = 0;
+          }
+          // set type and offsets
+          saoLcuParamRdo.typeIdx = iTypeIdx;
+          saoLcuParamRdo.subTypeIdx = (iTypeIdx==SAO_BO)?bestClassTableBo:0;
+          saoLcuParamRdo.length = m_iNumClass[iTypeIdx];
+          for (iClassIdx = 0; iClassIdx < saoLcuParamRdo.length; iClassIdx++)
+          {
+            saoLcuParamRdo.offset[iClassIdx] = (Int)m_iOffset[iPartIdx][iTypeIdx][iClassIdx+saoLcuParamRdo.subTypeIdx+1];
+          }
+          m_pcEntropyCoder->encodeSaoUnitInterleaving(yCbCr, 1, rx, ry,  &saoLcuParamRdo, 1,  1,  allowMergeLeft, allowMergeUp);
+        }
+      }
+      m_iDist[iPartIdx][iTypeIdx] = iEstDist;
+      m_iRate[iPartIdx][iTypeIdx] = m_pcEntropyCoder->getNumberOfWrittenBits();
+      m_dCost[iPartIdx][iTypeIdx] = (Double)((Double)m_iDist[iPartIdx][iTypeIdx] + dLambda * (Double) m_iRate[iPartIdx][iTypeIdx]);
+      if(m_dCost[iPartIdx][iTypeIdx] < m_dCostPartBest[iPartIdx])
+      {
+        m_iDistOrg [iPartIdx] = 0;
+        m_dCostPartBest[iPartIdx] = m_dCost[iPartIdx][iTypeIdx];
+        m_iTypePartBest[iPartIdx] = iTypeIdx;
+        if( m_bUseSBACRD )
+          m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[pOnePart->PartLevel][CI_TEMP_BEST] );
+      }
+    }
+    else
+    {
+      if(m_iDistOrg[iPartIdx] < m_dCostPartBest[iPartIdx] )
+      {
+        m_dCostPartBest[iPartIdx] = (Double) m_iDistOrg[iPartIdx] + m_pcEntropyCoder->getNumberOfWrittenBits()*dLambda ;
+        m_iTypePartBest[iPartIdx] = -1;
+        if( m_bUseSBACRD )
+        {
+          m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[pOnePart->PartLevel][CI_TEMP_BEST] );
+        }
+      }
+    }
+  }
+  pOnePart->bProcessed = true;
+  pOnePart->bSplit     = false;
+  pOnePart->iMinDist   =        m_iTypePartBest[iPartIdx] >= 0 ? m_iDist[iPartIdx][m_iTypePartBest[iPartIdx]] : m_iDistOrg[iPartIdx];
+  pOnePart->iMinRate   = (Int) (m_iTypePartBest[iPartIdx] >= 0 ? m_iRate[iPartIdx][m_iTypePartBest[iPartIdx]] : 0);
+  pOnePart->dMinCost   = pOnePart->iMinDist + dLambda * pOnePart->iMinRate;
+  pOnePart->iBestType  = m_iTypePartBest[iPartIdx];
+  if (pOnePart->iBestType != -1)
+  {
+    //     pOnePart->bEnableFlag =  1;
+    pOnePart->iLength = m_iNumClass[pOnePart->iBestType];
+    Int minIndex = 0;
+    if( pOnePart->iBestType == SAO_BO )
+    {
+      pOnePart->subTypeIdx = bestClassTableBo;
+      minIndex = pOnePart->subTypeIdx;
+    }
+    for (Int i=0; i< pOnePart->iLength ; i++)
+    {
+      pOnePart->iOffset[i] = (Int) m_iOffset[iPartIdx][pOnePart->iBestType][minIndex+i+1];
+    }
+  }
+  else
+  {
+    //     pOnePart->bEnableFlag = 0;
+    pOnePart->iLength     = 0;
+  }
+}
+/** Run partition tree disable
+ */
+Void TEncSampleAdaptiveOffset::disablePartTree(SAOQTPart *psQTPart, Int iPartIdx)
+{
+  SAOQTPart*  pOnePart= &(psQTPart[iPartIdx]);
+  pOnePart->bSplit      = false;
+  pOnePart->iLength     =  0;
+  pOnePart->iBestType   = -1;
+  if (pOnePart->PartLevel < m_uiMaxSplitLevel)
+  {
+    for (Int i=0; i<NUM_DOWN_PART; i++)
+    {
+      disablePartTree(psQTPart, pOnePart->DownPartsIdx[i]);
+    }
+  }
+}
+/** Run quadtree decision function
+ * \param  iPartIdx, pcPicOrg, pcPicDec, pcPicRest, &dCostFinal
+ */
+Void TEncSampleAdaptiveOffset::runQuadTreeDecision(SAOQTPart *psQTPart, Int iPartIdx, Double &dCostFinal, Int iMaxLevel, Double dLambda, Int yCbCr)
+{
+  SAOQTPart*  pOnePart = &(psQTPart[iPartIdx]);
+  UInt uiDepth = pOnePart->PartLevel;
+  UInt uhNextDepth = uiDepth+1;
+  if (iPartIdx == 0)
+  {
+    dCostFinal = 0;
+  }
+  //SAO for this part
+  if(!pOnePart->bProcessed)
+  {
+    rdoSaoOnePart (psQTPart, iPartIdx, dLambda, yCbCr);
+  }
+  //SAO for sub 4 parts
+  if (pOnePart->PartLevel < iMaxLevel)
+  {
+    Double      dCostNotSplit = dLambda + pOnePart->dMinCost;
+    Double      dCostSplit    = dLambda;
+    for (Int i=0; i< NUM_DOWN_PART ;i++)
+    {
+      if( m_bUseSBACRD )
+      {
+        if ( 0 == i) //initialize RD with previous depth buffer
+        {
+          m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
+        }
+        else
+        {
+          m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
+        }
+      }
+      runQuadTreeDecision(psQTPart, pOnePart->DownPartsIdx[i], dCostFinal, iMaxLevel, dLambda, yCbCr);
+      dCostSplit += dCostFinal;
+      if( m_bUseSBACRD )
+      {
+        m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_TEMP_BEST]);
+      }
+    }
+    if(dCostSplit < dCostNotSplit)
+    {
+      dCostFinal = dCostSplit;
+      pOnePart->bSplit      = true;
+      pOnePart->iLength     =  0;
+      pOnePart->iBestType   = -1;
+      if( m_bUseSBACRD )
+      {
+        m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
+      }
+    }
+    else
+    {
+      dCostFinal = dCostNotSplit;
+      pOnePart->bSplit = false;
+      for (Int i=0; i<NUM_DOWN_PART; i++)
+      {
+        disablePartTree(psQTPart, pOnePart->DownPartsIdx[i]);
+      }
+      if( m_bUseSBACRD )
+      {
+        m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
+      }
+    }
+  }
+  else
+  {
+    dCostFinal = pOnePart->dMinCost;
+  }
+}
+/** delete allocated memory of TEncSampleAdaptiveOffset class.
+ */
+Void TEncSampleAdaptiveOffset::destroyEncBuffer()
+{
+  for (Int i=0;i<m_iNumTotalParts;i++)
+  {
+    for (Int j=0;j<MAX_NUM_SAO_TYPE;j++)
+    {
+      if (m_iCount [i][j])
+      {
+        delete [] m_iCount [i][j];
+      }
+      if (m_iOffset[i][j])
+      {
+        delete [] m_iOffset[i][j];
+      }
+      if (m_iOffsetOrg[i][j])
+      {
+        delete [] m_iOffsetOrg[i][j];
+      }
+    }
+    if (m_iRate[i])
+    {
+      delete [] m_iRate[i];
+    }
+    if (m_iDist[i])
+    {
+      delete [] m_iDist[i];
+    }
+    if (m_dCost[i])
+    {
+      delete [] m_dCost[i];
+    }
+    if (m_iCount [i])
+    {
+      delete [] m_iCount [i];
+    }
+    if (m_iOffset[i])
+    {
+      delete [] m_iOffset[i];
+    }
+    if (m_iOffsetOrg[i])
+    {
+      delete [] m_iOffsetOrg[i];
+    }
+  }
+  if (m_iDistOrg)
+  {
+    delete [] m_iDistOrg ; m_iDistOrg = NULL;
+  }
+  if (m_dCostPartBest)
+  {
+    delete [] m_dCostPartBest ; m_dCostPartBest = NULL;
+  }
+  if (m_iTypePartBest)
+  {
+    delete [] m_iTypePartBest ; m_iTypePartBest = NULL;
+  }
+  if (m_iRate)
+  {
+    delete [] m_iRate ; m_iRate = NULL;
+  }
+  if (m_iDist)
+  {
+    delete [] m_iDist ; m_iDist = NULL;
+  }
+  if (m_dCost)
+  {
+    delete [] m_dCost ; m_dCost = NULL;
+  }
+  if (m_iCount)
+  {
+    delete [] m_iCount  ; m_iCount = NULL;
+  }
+  if (m_iOffset)
+  {
+    delete [] m_iOffset ; m_iOffset = NULL;
+  }
+  if (m_iOffsetOrg)
+  {
+    delete [] m_iOffsetOrg ; m_iOffsetOrg = NULL;
+  }
+  Int numLcu = m_iNumCuInWidth * m_iNumCuInHeight;
+  for (Int i=0;i<numLcu;i++)
+  {
+    for (Int j=0;j<3;j++)
+    {
+      for (Int k=0;k<MAX_NUM_SAO_TYPE;k++)
+      {
+        if (m_count_PreDblk [i][j][k])
+        {
+          delete [] m_count_PreDblk [i][j][k];
+        }
+        if (m_offsetOrg_PreDblk[i][j][k])
+        {
+          delete [] m_offsetOrg_PreDblk[i][j][k];
+        }
+      }
+      if (m_count_PreDblk [i][j])
+      {
+        delete [] m_count_PreDblk [i][j];
+      }
+      if (m_offsetOrg_PreDblk[i][j])
+      {
+        delete [] m_offsetOrg_PreDblk[i][j];
+      }
+    }
+    if (m_count_PreDblk [i])
+    {
+      delete [] m_count_PreDblk [i];
+    }
+    if (m_offsetOrg_PreDblk[i])
+    {
+      delete [] m_offsetOrg_PreDblk[i];
+    }
+  }
+  if (m_count_PreDblk)
+  {
+    delete [] m_count_PreDblk  ; m_count_PreDblk = NULL;
+  }
+  if (m_offsetOrg_PreDblk)
+  {
+    delete [] m_offsetOrg_PreDblk ; m_offsetOrg_PreDblk = NULL;
+  }
+  Int iMaxDepth = 4;
+  Int iDepth;
+  for ( iDepth = 0; iDepth < iMaxDepth+1; iDepth++ )
+  {
+    for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
+    {
+      delete m_pppcRDSbacCoder[iDepth][iCIIdx];
+      delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
+    }
+  }
+  for ( iDepth = 0; iDepth < iMaxDepth+1; iDepth++ )
+  {
+    delete [] m_pppcRDSbacCoder[iDepth];
+    delete [] m_pppcBinCoderCABAC[iDepth];
+  }
+  delete [] m_pppcRDSbacCoder;
+  delete [] m_pppcBinCoderCABAC;
+}
+/** create Encoder Buffer for SAO
+ * \param
+ */
+Void TEncSampleAdaptiveOffset::createEncBuffer()
+{
+  m_iDistOrg = new Int64 [m_iNumTotalParts];
+  m_dCostPartBest = new Double [m_iNumTotalParts];
+  m_iTypePartBest = new Int [m_iNumTotalParts];
+  m_iRate = new Int64* [m_iNumTotalParts];
+  m_iDist = new Int64* [m_iNumTotalParts];
+  m_dCost = new Double*[m_iNumTotalParts];
+  m_iCount  = new Int64 **[m_iNumTotalParts];
+  m_iOffset = new Int64 **[m_iNumTotalParts];
+  m_iOffsetOrg = new Int64 **[m_iNumTotalParts];
+  for (Int i=0;i<m_iNumTotalParts;i++)
+  {
+    m_iRate[i] = new Int64  [MAX_NUM_SAO_TYPE];
+    m_iDist[i] = new Int64  [MAX_NUM_SAO_TYPE];
+    m_dCost[i] = new Double [MAX_NUM_SAO_TYPE];
+    m_iCount [i] = new Int64 *[MAX_NUM_SAO_TYPE];
+    m_iOffset[i] = new Int64 *[MAX_NUM_SAO_TYPE];
+    m_iOffsetOrg[i] = new Int64 *[MAX_NUM_SAO_TYPE];
+    for (Int j=0;j<MAX_NUM_SAO_TYPE;j++)
+    {
+      m_iCount [i][j]   = new Int64 [MAX_NUM_SAO_CLASS];
+      m_iOffset[i][j]   = new Int64 [MAX_NUM_SAO_CLASS];
+      m_iOffsetOrg[i][j]= new Int64 [MAX_NUM_SAO_CLASS];
+    }
+  }
+  Int numLcu = m_iNumCuInWidth * m_iNumCuInHeight;
+  m_count_PreDblk  = new Int64 ***[numLcu];
+  m_offsetOrg_PreDblk = new Int64 ***[numLcu];
+  for (Int i=0; i<numLcu; i++)
+  {
+    m_count_PreDblk[i]  = new Int64 **[3];
+    m_offsetOrg_PreDblk[i] = new Int64 **[3];
+    for (Int j=0;j<3;j++)
+    {
+      m_count_PreDblk [i][j] = new Int64 *[MAX_NUM_SAO_TYPE];
+      m_offsetOrg_PreDblk[i][j] = new Int64 *[MAX_NUM_SAO_TYPE];
+      for (Int k=0;k<MAX_NUM_SAO_TYPE;k++)
+      {
+        m_count_PreDblk [i][j][k]   = new Int64 [MAX_NUM_SAO_CLASS];
+        m_offsetOrg_PreDblk[i][j][k]= new Int64 [MAX_NUM_SAO_CLASS];
+      }
+    }
+  }
+  Int iMaxDepth = 4;
+  m_pppcRDSbacCoder = new TEncSbac** [iMaxDepth+1];
+#if FAST_BIT_EST
+  m_pppcBinCoderCABAC = new TEncBinCABACCounter** [iMaxDepth+1];
+#else
+  m_pppcBinCoderCABAC = new TEncBinCABAC** [iMaxDepth+1];
+#endif
+  for ( Int iDepth = 0; iDepth < iMaxDepth+1; iDepth++ )
+  {
+    m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
+#if FAST_BIT_EST
+    m_pppcBinCoderCABAC[iDepth] = new TEncBinCABACCounter* [CI_NUM];
+#else
+    m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
+#endif
+    for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
+    {
+      m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
+#if FAST_BIT_EST
+      m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABACCounter;
+#else
+      m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
+#endif
+      m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
+    }
+  }
+}
+/** Start SAO encoder
+ * \param pcPic, pcEntropyCoder, pppcRDSbacCoder, pcRDGoOnSbacCoder
+ */
+Void TEncSampleAdaptiveOffset::startSaoEnc( TComPic* pcPic, TEncEntropy* pcEntropyCoder, TEncSbac*** pppcRDSbacCoder, TEncSbac* pcRDGoOnSbacCoder)
+{
+    m_bUseSBACRD = true;
+  m_pcPic = pcPic;
+  m_pcEntropyCoder = pcEntropyCoder;
+TEncSampleAdaptiveOffset::TEncSampleAdaptiveOffset()
+{
+  m_pppcRDSbacCoder = NULL;
+  m_pcRDGoOnSbacCoder = NULL;
+  m_pppcBinCoderCABAC = NULL;
+  m_statData = NULL;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  m_preDBFstatData = NULL;
+#endif
+}
+TEncSampleAdaptiveOffset::~TEncSampleAdaptiveOffset()
+{
+  destroyEncData();
+}
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+Void TEncSampleAdaptiveOffset::createEncData(Bool isPreDBFSamplesUsed)
+#else
+Void TEncSampleAdaptiveOffset::createEncData()
+#endif
+{
+  //cabac coder for RDO
+  m_pppcRDSbacCoder = new TEncSbac* [NUM_SAO_CABACSTATE_LABELS];
+  m_pppcBinCoderCABAC = new TEncBinCABACCounter* [NUM_SAO_CABACSTATE_LABELS];
+  for(Int cs=0; cs < NUM_SAO_CABACSTATE_LABELS; cs++)
+  {
+    m_pppcRDSbacCoder[cs] = new TEncSbac;
+    m_pppcBinCoderCABAC[cs] = new TEncBinCABACCounter;
+    m_pppcRDSbacCoder   [cs]->init( m_pppcBinCoderCABAC [cs] );
+  }
+  //statistics
+  m_statData = new SAOStatData**[m_numCTUsPic];
+  for(Int i=0; i< m_numCTUsPic; i++)
+  {
+    m_statData[i] = new SAOStatData*[NUM_SAO_COMPONENTS];
+    for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+    {
+      m_statData[i][compIdx] = new SAOStatData[NUM_SAO_NEW_TYPES];
+    }
+  }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  if(isPreDBFSamplesUsed)
+  {
+    m_preDBFstatData = new SAOStatData**[m_numCTUsPic];
+    for(Int i=0; i< m_numCTUsPic; i++)
+    {
+      m_preDBFstatData[i] = new SAOStatData*[NUM_SAO_COMPONENTS];
+      for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+      {
+        m_preDBFstatData[i][compIdx] = new SAOStatData[NUM_SAO_NEW_TYPES];
+      }
+    }
+  }
+#endif
+#if SAO_ENCODING_CHOICE
+  ::memset(m_saoDisabledRate, 0, sizeof(m_saoDisabledRate));
+#endif
+  for(Int typeIdc=0; typeIdc < NUM_SAO_NEW_TYPES; typeIdc++)
+  {
+    m_skipLinesR[SAO_Y ][typeIdc]= 5;
+    m_skipLinesR[SAO_Cb][typeIdc]= m_skipLinesR[SAO_Cr][typeIdc]= 3;
+    m_skipLinesB[SAO_Y ][typeIdc]= 4;
+    m_skipLinesB[SAO_Cb][typeIdc]= m_skipLinesB[SAO_Cr][typeIdc]= 2;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+    if(isPreDBFSamplesUsed)
+    {
+      switch(typeIdc)
+      {
+      case SAO_TYPE_EO_0:
+        {
+          m_skipLinesR[SAO_Y ][typeIdc]= 5;
+          m_skipLinesR[SAO_Cb][typeIdc]= m_skipLinesR[SAO_Cr][typeIdc]= 3;
+          m_skipLinesB[SAO_Y ][typeIdc]= 3;
+          m_skipLinesB[SAO_Cb][typeIdc]= m_skipLinesB[SAO_Cr][typeIdc]= 1;
+        }
+        break;
+      case SAO_TYPE_EO_90:
+        {
+          m_skipLinesR[SAO_Y ][typeIdc]= 4;
+          m_skipLinesR[SAO_Cb][typeIdc]= m_skipLinesR[SAO_Cr][typeIdc]= 2;
+          m_skipLinesB[SAO_Y ][typeIdc]= 4;
+          m_skipLinesB[SAO_Cb][typeIdc]= m_skipLinesB[SAO_Cr][typeIdc]= 2;
+        }
+        break;
+      case SAO_TYPE_EO_135:
+      case SAO_TYPE_EO_45:
+        {
+          m_skipLinesR[SAO_Y ][typeIdc]= 5;
+          m_skipLinesR[SAO_Cb][typeIdc]= m_skipLinesR[SAO_Cr][typeIdc]= 3;
+          m_skipLinesB[SAO_Y ][typeIdc]= 4;
+          m_skipLinesB[SAO_Cb][typeIdc]= m_skipLinesB[SAO_Cr][typeIdc]= 2;
+        }
+        break;
+      case SAO_TYPE_BO:
+        {
+          m_skipLinesR[SAO_Y ][typeIdc]= 4;
+          m_skipLinesR[SAO_Cb][typeIdc]= m_skipLinesR[SAO_Cr][typeIdc]= 2;
+          m_skipLinesB[SAO_Y ][typeIdc]= 3;
+          m_skipLinesB[SAO_Cb][typeIdc]= m_skipLinesB[SAO_Cr][typeIdc]= 1;
+        }
+        break;
+      default:
+        {
+          printf("Not a supported type");
+          assert(0);
+          exit(-1);
+        }
+      }
+    }
+#endif
+  }
+}
+Void TEncSampleAdaptiveOffset::destroyEncData()
+{
+  if(m_pppcRDSbacCoder != NULL)
+  {
+    for (Int cs = 0; cs < NUM_SAO_CABACSTATE_LABELS; cs ++ )
+    {
+      delete m_pppcRDSbacCoder[cs];
+    }
+    delete[] m_pppcRDSbacCoder; m_pppcRDSbacCoder = NULL;
+  }
+  if(m_pppcBinCoderCABAC != NULL)
+  {
+    for (Int cs = 0; cs < NUM_SAO_CABACSTATE_LABELS; cs ++ )
+    {
+      delete m_pppcBinCoderCABAC[cs];
+    }
+    delete[] m_pppcBinCoderCABAC; m_pppcBinCoderCABAC = NULL;
+  }
+  if(m_statData != NULL)
+  {
+    for(Int i=0; i< m_numCTUsPic; i++)
+    {
+      for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+      {
+        delete[] m_statData[i][compIdx];
+      }
+      delete[] m_statData[i];
+    }
+    delete[] m_statData; m_statData = NULL;
+  }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  if(m_preDBFstatData != NULL)
+  {
+    for(Int i=0; i< m_numCTUsPic; i++)
+    {
+      for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+      {
+        delete[] m_preDBFstatData[i][compIdx];
+      }
+      delete[] m_preDBFstatData[i];
+    }
+    delete[] m_preDBFstatData; m_preDBFstatData = NULL;
+  }
+#endif
+}
+Void TEncSampleAdaptiveOffset::initRDOCabacCoder(TEncSbac* pcRDGoOnSbacCoder, TComSlice* pcSlice)
+{
   m_pcRDGoOnSbacCoder = pcRDGoOnSbacCoder;
+  m_pcEntropyCoder->setEntropyCoder(m_pcRDGoOnSbacCoder, pcPic->getSlice(0));
+  m_pcEntropyCoder->resetEntropy();
+  m_pcEntropyCoder->resetBits();
+  if( m_bUseSBACRD )
+  {
+    m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[0][CI_NEXT_BEST]);
+    m_pppcRDSbacCoder[0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_NEXT_BEST]);
+  }
+}
+/** End SAO encoder
+ */
+Void TEncSampleAdaptiveOffset::endSaoEnc()
+{
+  m_pcPic = NULL;
+  m_pcEntropyCoder = NULL;
+}
+inline Int xSign(Int x)
+{
+  return ((x >> 31) | ((Int)( (((UInt) -x)) >> 31)));
+}
+/** Calculate SAO statistics for non-cross-slice or non-cross-tile processing
+ * \param  pRecStart to-be-filtered block buffer pointer
+ * \param  pOrgStart original block buffer pointer
+ * \param  stride picture buffer stride
+ * \param  ppStat statistics buffer
+ * \param  ppCount counter buffer
+ * \param  width block width
+ * \param  height block height
+ * \param  pbBorderAvail availabilities of block border pixels
+ */
+Void TEncSampleAdaptiveOffset::calcSaoStatsBlock( Pel* pRecStart, Pel* pOrgStart, Int stride, Int64** ppStats, Int64** ppCount, UInt width, UInt height, Bool* pbBorderAvail, Int iYCbCr)
+{
+  Int64 *stats, *count;
+  Int classIdx, posShift, startX, endX, startY, endY, signLeft,signRight,signDown,signDown1;
+  Pel *pOrg, *pRec;
+  UInt edgeType;
+  Int x, y;
+  Pel *pTableBo = (iYCbCr==0)?m_lumaTableBo:m_chromaTableBo;
+  //--------- Band offset-----------//
+  stats = ppStats[SAO_BO];
+  count = ppCount[SAO_BO];
+  pOrg   = pOrgStart;
+  pRec   = pRecStart;
+  for (y=0; y< height; y++)
+  {
+    for (x=0; x< width; x++)
+    {
+      classIdx = pTableBo[pRec[x]];
+      if (classIdx)
+      {
+        stats[classIdx] += (pOrg[x] - pRec[x]);
+        count[classIdx] ++;
+      }
+    }
+    pOrg += stride;
+    pRec += stride;
+  }
+  //---------- Edge offset 0--------------//
+  stats = ppStats[SAO_EO_0];
+  count = ppCount[SAO_EO_0];
+  pOrg   = pOrgStart;
+  pRec   = pRecStart;
+  startX = (pbBorderAvail[SGU_L]) ? 0 : 1;
+  endX   = (pbBorderAvail[SGU_R]) ? width : (width -1);
+  for (y=0; y< height; y++)
+  {
+    signLeft = xSign(pRec[startX] - pRec[startX-1]);
+    for (x=startX; x< endX; x++)
+    {
+      signRight =  xSign(pRec[x] - pRec[x+1]);
+      edgeType =  signRight + signLeft + 2;
+      signLeft  = -signRight;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+    pRec  += stride;
+    pOrg += stride;
+  }
+  //---------- Edge offset 1--------------//
+  stats = ppStats[SAO_EO_1];
+  count = ppCount[SAO_EO_1];
+  pOrg   = pOrgStart;
+  pRec   = pRecStart;
+  startY = (pbBorderAvail[SGU_T]) ? 0 : 1;
+  endY   = (pbBorderAvail[SGU_B]) ? height : height-1;
+  if (!pbBorderAvail[SGU_T])
+  {
+    pRec  += stride;
+    pOrg  += stride;
+  }
+  for (x=0; x< width; x++)
+  {
+    m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-stride]);
+  }
+  for (y=startY; y<endY; y++)
+  {
+    for (x=0; x< width; x++)
+    {
+      signDown     =  xSign(pRec[x] - pRec[x+stride]);
+      edgeType    =  signDown + m_iUpBuff1[x] + 2;
+      m_iUpBuff1[x] = -signDown;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+    pOrg += stride;
+    pRec += stride;
+  }
+  //---------- Edge offset 2--------------//
+  stats = ppStats[SAO_EO_2];
+  count = ppCount[SAO_EO_2];
+  pOrg   = pOrgStart;
+  pRec   = pRecStart;
+  posShift= stride + 1;
+  startX = (pbBorderAvail[SGU_L]) ? 0 : 1 ;
+  endX   = (pbBorderAvail[SGU_R]) ? width : (width-1);
+  //prepare 2nd line upper sign
+  pRec += stride;
+  for (x=startX; x< endX+1; x++)
+  {
+    m_iUpBuff1[x] = xSign(pRec[x] - pRec[x- posShift]);
+  }
+  //1st line
+  pRec -= stride;
+  if(pbBorderAvail[SGU_TL])
+  {
+    x= 0;
+    edgeType      =  xSign(pRec[x] - pRec[x- posShift]) - m_iUpBuff1[x+1] + 2;
+    stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+    count[m_auiEoTable[edgeType]] ++;
+  }
+  if(pbBorderAvail[SGU_T])
+  {
+    for(x= 1; x< endX; x++)
+    {
+      edgeType      =  xSign(pRec[x] - pRec[x- posShift]) - m_iUpBuff1[x+1] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+  }
+  pRec   += stride;
+  pOrg   += stride;
+  //middle lines
+  for (y= 1; y< height-1; y++)
+  {
+    for (x=startX; x<endX; x++)
+    {
+      signDown1      =  xSign(pRec[x] - pRec[x+ posShift]) ;
+      edgeType      =  signDown1 + m_iUpBuff1[x] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+      m_iUpBufft[x+1] = -signDown1;
+    }
+    m_iUpBufft[startX] = xSign(pRec[stride+startX] - pRec[startX-1]);
+    ipSwap     = m_iUpBuff1;
+    m_iUpBuff1 = m_iUpBufft;
+    m_iUpBufft = ipSwap;
+    pRec  += stride;
+    pOrg  += stride;
+  }
+  //last line
+  if(pbBorderAvail[SGU_B])
+  {
+    for(x= startX; x< width-1; x++)
+    {
+      edgeType =  xSign(pRec[x] - pRec[x+ posShift]) + m_iUpBuff1[x] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+  }
+  if(pbBorderAvail[SGU_BR])
+  {
+    x= width -1;
+    edgeType =  xSign(pRec[x] - pRec[x+ posShift]) + m_iUpBuff1[x] + 2;
+    stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+    count[m_auiEoTable[edgeType]] ++;
+  }
+  //---------- Edge offset 3--------------//
+  stats = ppStats[SAO_EO_3];
+  count = ppCount[SAO_EO_3];
+  pOrg   = pOrgStart;
+  pRec   = pRecStart;
+  posShift     = stride - 1;
+  startX = (pbBorderAvail[SGU_L]) ? 0 : 1;
+  endX   = (pbBorderAvail[SGU_R]) ? width : (width -1);
+  //prepare 2nd line upper sign
+  pRec += stride;
+  for (x=startX-1; x< endX; x++)
+  {
+    m_iUpBuff1[x] = xSign(pRec[x] - pRec[x- posShift]);
+  }
+  //first line
+  pRec -= stride;
+  if(pbBorderAvail[SGU_T])
+  {
+    for(x= startX; x< width -1; x++)
+    {
+      edgeType = xSign(pRec[x] - pRec[x- posShift]) -m_iUpBuff1[x-1] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+  }
+  if(pbBorderAvail[SGU_TR])
+  {
+    x= width-1;
+    edgeType = xSign(pRec[x] - pRec[x- posShift]) -m_iUpBuff1[x-1] + 2;
+    stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+    count[m_auiEoTable[edgeType]] ++;
+  }
+  pRec  += stride;
+  pOrg  += stride;
+  //middle lines
+  for (y= 1; y< height-1; y++)
+  {
+    for(x= startX; x< endX; x++)
+    {
+      signDown1      =  xSign(pRec[x] - pRec[x+ posShift]) ;
+      edgeType      =  signDown1 + m_iUpBuff1[x] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+      m_iUpBuff1[x-1] = -signDown1;
+    }
+    m_iUpBuff1[endX-1] = xSign(pRec[endX-1 + stride] - pRec[endX]);
+    pRec  += stride;
+    pOrg  += stride;
+  }
+  //last line
+  if(pbBorderAvail[SGU_BL])
+  {
+    x= 0;
+    edgeType = xSign(pRec[x] - pRec[x+ posShift]) + m_iUpBuff1[x] + 2;
+    stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+    count[m_auiEoTable[edgeType]] ++;
+  }
+  if(pbBorderAvail[SGU_B])
+  {
+    for(x= 1; x< endX; x++)
+    {
+      edgeType = xSign(pRec[x] - pRec[x+ posShift]) + m_iUpBuff1[x] + 2;
+      stats[m_auiEoTable[edgeType]] += (pOrg[x] - pRec[x]);
+      count[m_auiEoTable[edgeType]] ++;
+    }
+  }
+}
+/** Calculate SAO statistics for current LCU
+ * \param  iAddr,  iPartIdx,  iYCbCr
+ */
+Void TEncSampleAdaptiveOffset::calcSaoStatsCu(Int iAddr, Int iPartIdx, Int iYCbCr)
+{
+  if(!m_bUseNIF)
+  {
+    calcSaoStatsCuOrg( iAddr, iPartIdx, iYCbCr);
+  }
+  else
+  {
+    Int64** ppStats = m_iOffsetOrg[iPartIdx];
+    Int64** ppCount = m_iCount    [iPartIdx];
+    //parameters
+    Int  isChroma = (iYCbCr != 0)? 1:0;
+    Int  stride   = (iYCbCr != 0)?(m_pcPic->getCStride()):(m_pcPic->getStride());
+    Pel* pPicOrg = getPicYuvAddr (m_pcPic->getPicYuvOrg(), iYCbCr);
+    Pel* pPicRec  = getPicYuvAddr(m_pcYuvTmp, iYCbCr);
+    std::vector<NDBFBlockInfo>& vFilterBlocks = *(m_pcPic->getCU(iAddr)->getNDBFilterBlocks());
+    //variables
+    UInt  xPos, yPos, width, height;
+    Bool* pbBorderAvail;
+    UInt  posOffset;
+    for(Int i=0; i< vFilterBlocks.size(); i++)
+    {
+      xPos        = vFilterBlocks[i].posX   >> isChroma;
+      yPos        = vFilterBlocks[i].posY   >> isChroma;
+      width       = vFilterBlocks[i].width  >> isChroma;
+      height      = vFilterBlocks[i].height >> isChroma;
+      pbBorderAvail = vFilterBlocks[i].isBorderAvailable;
+      posOffset = (yPos* stride) + xPos;
+      calcSaoStatsBlock(pPicRec+ posOffset, pPicOrg+ posOffset, stride, ppStats, ppCount,width, height, pbBorderAvail, iYCbCr);
+    }
+  }
+}
+/** Calculate SAO statistics for current LCU without non-crossing slice
+ * \param  iAddr,  iPartIdx,  iYCbCr
+ */
+Void TEncSampleAdaptiveOffset::calcSaoStatsCuOrg(Int iAddr, Int iPartIdx, Int iYCbCr)
+{
+  Int x,y;
+  TComDataCU *pTmpCu = m_pcPic->getCU(iAddr);
+  TComSPS *pTmpSPS =  m_pcPic->getSlice(0)->getSPS();
+  Pel* pOrg;
+  Pel* pRec;
+  Int iStride;
+  Int iLcuHeight = pTmpSPS->getMaxCUHeight();
+  Int iLcuWidth  = pTmpSPS->getMaxCUWidth();
+  UInt uiLPelX   = pTmpCu->getCUPelX();
+  UInt uiTPelY   = pTmpCu->getCUPelY();
+  UInt uiRPelX;
+  UInt uiBPelY;
+  Int64* iStats;
+  Int64* iCount;
+  Int iClassIdx;
+  Int iPicWidthTmp;
+  Int iPicHeightTmp;
+  Int iStartX;
+  Int iStartY;
+  Int iEndX;
+  Int iEndY;
+  Pel* pTableBo = (iYCbCr==0)?m_lumaTableBo:m_chromaTableBo;
+  Int iIsChroma = (iYCbCr!=0)? 1:0;
+  Int numSkipLine = iIsChroma? 2:4;
+  if (m_saoLcuBasedOptimization == 0)
+  {
+    numSkipLine = 0;
+  }
+  Int numSkipLineRight = iIsChroma? 3:5;
+  if (m_saoLcuBasedOptimization == 0)
+  {
+    numSkipLineRight = 0;
+  }
+  iPicWidthTmp  = m_iPicWidth  >> iIsChroma;
+  iPicHeightTmp = m_iPicHeight >> iIsChroma;
+  iLcuWidth     = iLcuWidth    >> iIsChroma;
+  iLcuHeight    = iLcuHeight   >> iIsChroma;
+  uiLPelX       = uiLPelX      >> iIsChroma;
+  uiTPelY       = uiTPelY      >> iIsChroma;
+  uiRPelX       = uiLPelX + iLcuWidth  ;
+  uiBPelY       = uiTPelY + iLcuHeight ;
+  uiRPelX       = uiRPelX > iPicWidthTmp  ? iPicWidthTmp  : uiRPelX;
+  uiBPelY       = uiBPelY > iPicHeightTmp ? iPicHeightTmp : uiBPelY;
+  iLcuWidth     = uiRPelX - uiLPelX;
+  iLcuHeight    = uiBPelY - uiTPelY;
+  iStride    =  (iYCbCr == 0)? m_pcPic->getStride(): m_pcPic->getCStride();
+//if(iSaoType == BO_0 || iSaoType == BO_1)
+  {
+    if( m_saoLcuBasedOptimization && m_saoLcuBoundary )
+    {
+      numSkipLine = iIsChroma? 1:3;
+      numSkipLineRight = iIsChroma? 2:4;
+    }
+    iStats = m_iOffsetOrg[iPartIdx][SAO_BO];
+    iCount = m_iCount    [iPartIdx][SAO_BO];
+    pOrg = getPicYuvAddr(m_pcPic->getPicYuvOrg(), iYCbCr, iAddr);
+    pRec = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr, iAddr);
+    iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth : iLcuWidth-numSkipLineRight;
+    iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight : iLcuHeight-numSkipLine;
+    for (y=0; y<iEndY; y++)
+    {
+      for (x=0; x<iEndX; x++)
+      {
+        iClassIdx = pTableBo[pRec[x]];
+        if (iClassIdx)
+        {
+          iStats[iClassIdx] += (pOrg[x] - pRec[x]);
+          iCount[iClassIdx] ++;
+        }
+      }
+      pOrg += iStride;
+      pRec += iStride;
+    }
+  }
+  Int iSignLeft;
+  Int iSignRight;
+  Int iSignDown;
+  Int iSignDown1;
+  Int iSignDown2;
+  UInt uiEdgeType;
+//if (iSaoType == EO_0  || iSaoType == EO_1 || iSaoType == EO_2 || iSaoType == EO_3)
+  {
+  //if (iSaoType == EO_0)
+    {
+      if( m_saoLcuBasedOptimization && m_saoLcuBoundary )
+      {
+        numSkipLine = iIsChroma? 1:3;
+        numSkipLineRight = iIsChroma? 3:5;
+      }
+      iStats = m_iOffsetOrg[iPartIdx][SAO_EO_0];
+      iCount = m_iCount    [iPartIdx][SAO_EO_0];
+      pOrg = getPicYuvAddr(m_pcPic->getPicYuvOrg(), iYCbCr, iAddr);
+      pRec = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr, iAddr);
+      iStartX = (uiLPelX == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth-numSkipLineRight;
+      for (y=0; y<iLcuHeight-numSkipLine; y++)
+      {
+        iSignLeft = xSign(pRec[iStartX] - pRec[iStartX-1]);
+        for (x=iStartX; x< iEndX; x++)
+        {
+          iSignRight =  xSign(pRec[x] - pRec[x+1]);
+          uiEdgeType =  iSignRight + iSignLeft + 2;
+          iSignLeft  = -iSignRight;
+          iStats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+          iCount[m_auiEoTable[uiEdgeType]] ++;
+        }
+        pOrg += iStride;
+        pRec += iStride;
+      }
+    }
+  //if (iSaoType == EO_1)
+    {
+      if( m_saoLcuBasedOptimization && m_saoLcuBoundary )
+      {
+        numSkipLine = iIsChroma? 2:4;
+        numSkipLineRight = iIsChroma? 2:4;
+      }
+      iStats = m_iOffsetOrg[iPartIdx][SAO_EO_1];
+      iCount = m_iCount    [iPartIdx][SAO_EO_1];
+      pOrg = getPicYuvAddr(m_pcPic->getPicYuvOrg(), iYCbCr, iAddr);
+      pRec = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr, iAddr);
+      iStartY = (uiTPelY == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth : iLcuWidth-numSkipLineRight;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight-numSkipLine;
+      if (uiTPelY == 0)
+      {
+        pOrg += iStride;
+        pRec += iStride;
+      }
+      for (x=0; x< iLcuWidth; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-iStride]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        for (x=0; x<iEndX; x++)
+        {
+          iSignDown     =  xSign(pRec[x] - pRec[x+iStride]);
+          uiEdgeType    =  iSignDown + m_iUpBuff1[x] + 2;
+          m_iUpBuff1[x] = -iSignDown;
+          iStats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+          iCount[m_auiEoTable[uiEdgeType]] ++;
+        }
+        pOrg += iStride;
+        pRec += iStride;
+      }
+    }
+  //if (iSaoType == EO_2)
+    {
+      if( m_saoLcuBasedOptimization && m_saoLcuBoundary )
+      {
+        numSkipLine = iIsChroma? 2:4;
+        numSkipLineRight = iIsChroma? 3:5;
+      }
+      iStats = m_iOffsetOrg[iPartIdx][SAO_EO_2];
+      iCount = m_iCount    [iPartIdx][SAO_EO_2];
+      pOrg = getPicYuvAddr(m_pcPic->getPicYuvOrg(), iYCbCr, iAddr);
+      pRec = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr, iAddr);
+      iStartX = (uiLPelX == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth-numSkipLineRight;
+      iStartY = (uiTPelY == 0) ? 1 : 0;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight-numSkipLine;
+      if (uiTPelY == 0)
+      {
+        pOrg += iStride;
+        pRec += iStride;
+      }
+      for (x=iStartX; x<iEndX; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-iStride-1]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        iSignDown2 = xSign(pRec[iStride+iStartX] - pRec[iStartX-1]);
+        for (x=iStartX; x<iEndX; x++)
+        {
+          iSignDown1      =  xSign(pRec[x] - pRec[x+iStride+1]) ;
+          uiEdgeType      =  iSignDown1 + m_iUpBuff1[x] + 2;
+          m_iUpBufft[x+1] = -iSignDown1;
+          iStats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+          iCount[m_auiEoTable[uiEdgeType]] ++;
+        }
+        m_iUpBufft[iStartX] = iSignDown2;
+        ipSwap     = m_iUpBuff1;
+        m_iUpBuff1 = m_iUpBufft;
+        m_iUpBufft = ipSwap;
+        pRec += iStride;
+        pOrg += iStride;
+      }
+    }
+  //if (iSaoType == EO_3  )
+    {
+      if( m_saoLcuBasedOptimization && m_saoLcuBoundary )
+      {
+        numSkipLine = iIsChroma? 2:4;
+        numSkipLineRight = iIsChroma? 3:5;
+      }
+      iStats = m_iOffsetOrg[iPartIdx][SAO_EO_3];
+      iCount = m_iCount    [iPartIdx][SAO_EO_3];
+      pOrg = getPicYuvAddr(m_pcPic->getPicYuvOrg(), iYCbCr, iAddr);
+      pRec = getPicYuvAddr(m_pcPic->getPicYuvRec(), iYCbCr, iAddr);
+      iStartX = (uiLPelX == 0) ? 1 : 0;
+      iEndX   = (uiRPelX == iPicWidthTmp) ? iLcuWidth-1 : iLcuWidth-numSkipLineRight;
+      iStartY = (uiTPelY == 0) ? 1 : 0;
+      iEndY   = (uiBPelY == iPicHeightTmp) ? iLcuHeight-1 : iLcuHeight-numSkipLine;
+      if (iStartY == 1)
+      {
+        pOrg += iStride;
+        pRec += iStride;
+      }
+      for (x=iStartX-1; x<iEndX; x++)
+      {
+        m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-iStride+1]);
+      }
+      for (y=iStartY; y<iEndY; y++)
+      {
+        for (x=iStartX; x<iEndX; x++)
+        {
+          iSignDown1      =  xSign(pRec[x] - pRec[x+iStride-1]) ;
+          uiEdgeType      =  iSignDown1 + m_iUpBuff1[x] + 2;
+          m_iUpBuff1[x-1] = -iSignDown1;
+          iStats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+          iCount[m_auiEoTable[uiEdgeType]] ++;
+        }
+        m_iUpBuff1[iEndX-1] = xSign(pRec[iEndX-1 + iStride] - pRec[iEndX]);
+        pRec += iStride;
+        pOrg += iStride;
+      }
+    }
+  }
+}
+Void TEncSampleAdaptiveOffset::calcSaoStatsCu_BeforeDblk( TComPic* pcPic )
+{
+  Int addr, yCbCr;
+  Int x,y;
+  TComSPS *pTmpSPS =  pcPic->getSlice(0)->getSPS();
+  Pel* pOrg;
+  Pel* pRec;
+  Int stride;
+  Int lcuHeight = pTmpSPS->getMaxCUHeight();
+  Int lcuWidth  = pTmpSPS->getMaxCUWidth();
+  UInt rPelX;
+  UInt bPelY;
+  Int64* stats;
+  Int64* count;
+  Int classIdx;
+  Int picWidthTmp = 0;
+  Int picHeightTmp = 0;
+  Int startX;
+  Int startY;
+  Int endX;
+  Int endY;
+  Int firstX, firstY;
+  Int idxY;
+  Int idxX;
+  Int frameHeightInCU = m_iNumCuInHeight;
+  Int frameWidthInCU  = m_iNumCuInWidth;
+  Int j, k;
+  Int isChroma;
+  Int numSkipLine, numSkipLineRight;
+  UInt lPelX, tPelY;
+  TComDataCU *pTmpCu;
+  Pel* pTableBo;
+  for (idxY = 0; idxY< frameHeightInCU; idxY++)
+  {
+    for (idxX = 0; idxX< frameWidthInCU; idxX++)
+    {
+      lcuHeight = pTmpSPS->getMaxCUHeight();
+      lcuWidth  = pTmpSPS->getMaxCUWidth();
+      addr     = idxX  + frameWidthInCU*idxY;
+      pTmpCu = pcPic->getCU(addr);
+      lPelX   = pTmpCu->getCUPelX();
+      tPelY   = pTmpCu->getCUPelY();
+      for( yCbCr = 0; yCbCr < 3; yCbCr++ )
+      {
+        isChroma = (yCbCr!=0)? 1:0;
+        for ( j=0;j<MAX_NUM_SAO_TYPE;j++)
+        {
+          for ( k=0;k< MAX_NUM_SAO_CLASS;k++)
+          {
+            m_count_PreDblk    [addr][yCbCr][j][k] = 0;
+            m_offsetOrg_PreDblk[addr][yCbCr][j][k] = 0;
+          }
+        }
+        if( yCbCr == 0 )
+        {
+          picWidthTmp  = m_iPicWidth;
+          picHeightTmp = m_iPicHeight;
+        }
+        else if( yCbCr == 1 )
+        {
+          picWidthTmp  = m_iPicWidth  >> isChroma;
+          picHeightTmp = m_iPicHeight >> isChroma;
+          lcuWidth     = lcuWidth    >> isChroma;
+          lcuHeight    = lcuHeight   >> isChroma;
+          lPelX       = lPelX      >> isChroma;
+          tPelY       = tPelY      >> isChroma;
+        }
+        rPelX       = lPelX + lcuWidth  ;
+        bPelY       = tPelY + lcuHeight ;
+        rPelX       = rPelX > picWidthTmp  ? picWidthTmp  : rPelX;
+        bPelY       = bPelY > picHeightTmp ? picHeightTmp : bPelY;
+        lcuWidth     = rPelX - lPelX;
+        lcuHeight    = bPelY - tPelY;
+        stride    =  (yCbCr == 0)? pcPic->getStride(): pcPic->getCStride();
+        pTableBo = (yCbCr==0)?m_lumaTableBo:m_chromaTableBo;
+        //if(iSaoType == BO)
+        numSkipLine = isChroma? 1:3;
+        numSkipLineRight = isChroma? 2:4;
+        stats = m_offsetOrg_PreDblk[addr][yCbCr][SAO_BO];
+        count = m_count_PreDblk[addr][yCbCr][SAO_BO];
+        pOrg = getPicYuvAddr(pcPic->getPicYuvOrg(), yCbCr, addr);
+        pRec = getPicYuvAddr(pcPic->getPicYuvRec(), yCbCr, addr);
+        startX   = (rPelX == picWidthTmp) ? lcuWidth : lcuWidth-numSkipLineRight;
+        startY   = (bPelY == picHeightTmp) ? lcuHeight : lcuHeight-numSkipLine;
+        for (y=0; y<lcuHeight; y++)
+        {
+          for (x=0; x<lcuWidth; x++)
+          {
+            if( x < startX && y < startY )
+              continue;
+            classIdx = pTableBo[pRec[x]];
+            if (classIdx)
+            {
+              stats[classIdx] += (pOrg[x] - pRec[x]);
+              count[classIdx] ++;
+            }
+          }
+          pOrg += stride;
+          pRec += stride;
+        }
+        Int signLeft;
+        Int signRight;
+        Int signDown;
+        Int signDown1;
+        Int signDown2;
+        UInt uiEdgeType;
+        //if (iSaoType == EO_0)
+        numSkipLine = isChroma? 1:3;
+        numSkipLineRight = isChroma? 3:5;
+        stats = m_offsetOrg_PreDblk[addr][yCbCr][SAO_EO_0];
+        count = m_count_PreDblk[addr][yCbCr][SAO_EO_0];
+        pOrg = getPicYuvAddr(pcPic->getPicYuvOrg(), yCbCr, addr);
+        pRec = getPicYuvAddr(pcPic->getPicYuvRec(), yCbCr, addr);
+        startX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth-numSkipLineRight;
+        startY   = (bPelY == picHeightTmp) ? lcuHeight : lcuHeight-numSkipLine;
+        firstX   = (lPelX == 0) ? 1 : 0;
+        endX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth;
+        for (y=0; y<lcuHeight; y++)
+        {
+          signLeft = xSign(pRec[firstX] - pRec[firstX-1]);
+          for (x=firstX; x< endX; x++)
+          {
+            signRight =  xSign(pRec[x] - pRec[x+1]);
+            uiEdgeType =  signRight + signLeft + 2;
+            signLeft  = -signRight;
+            if( x < startX && y < startY )
+              continue;
+            stats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+            count[m_auiEoTable[uiEdgeType]] ++;
+          }
+          pOrg += stride;
+          pRec += stride;
+        }
+        //if (iSaoType == EO_1)
+        numSkipLine = isChroma? 2:4;
+        numSkipLineRight = isChroma? 2:4;
+        stats = m_offsetOrg_PreDblk[addr][yCbCr][SAO_EO_1];
+        count = m_count_PreDblk[addr][yCbCr][SAO_EO_1];
+        pOrg = getPicYuvAddr(pcPic->getPicYuvOrg(), yCbCr, addr);
+        pRec = getPicYuvAddr(pcPic->getPicYuvRec(), yCbCr, addr);
+        startX   = (rPelX == picWidthTmp) ? lcuWidth : lcuWidth-numSkipLineRight;
+        startY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight-numSkipLine;
+        firstY = (tPelY == 0) ? 1 : 0;
+        endY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight;
+        if (firstY == 1)
+        {
+          pOrg += stride;
+          pRec += stride;
+        }
+        for (x=0; x< lcuWidth; x++)
+        {
+          m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-stride]);
+        }
+        for (y=firstY; y<endY; y++)
+        {
+          for (x=0; x<lcuWidth; x++)
+          {
+            signDown     =  xSign(pRec[x] - pRec[x+stride]);
+            uiEdgeType    =  signDown + m_iUpBuff1[x] + 2;
+            m_iUpBuff1[x] = -signDown;
+            if( x < startX && y < startY )
+              continue;
+            stats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+            count[m_auiEoTable[uiEdgeType]] ++;
+          }
+          pOrg += stride;
+          pRec += stride;
+        }
+        //if (iSaoType == EO_2)
+        numSkipLine = isChroma? 2:4;
+        numSkipLineRight = isChroma? 3:5;
+        stats = m_offsetOrg_PreDblk[addr][yCbCr][SAO_EO_2];
+        count = m_count_PreDblk[addr][yCbCr][SAO_EO_2];
+        pOrg = getPicYuvAddr(pcPic->getPicYuvOrg(), yCbCr, addr);
+        pRec = getPicYuvAddr(pcPic->getPicYuvRec(), yCbCr, addr);
+        startX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth-numSkipLineRight;
+        startY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight-numSkipLine;
+        firstX   = (lPelX == 0) ? 1 : 0;
+        firstY = (tPelY == 0) ? 1 : 0;
+        endX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth;
+        endY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight;
+        if (firstY == 1)
+        {
+          pOrg += stride;
+          pRec += stride;
+        }
+        for (x=firstX; x<endX; x++)
+        {
+          m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-stride-1]);
+        }
+        for (y=firstY; y<endY; y++)
+        {
+          signDown2 = xSign(pRec[stride+startX] - pRec[startX-1]);
+          for (x=firstX; x<endX; x++)
+          {
+            signDown1      =  xSign(pRec[x] - pRec[x+stride+1]) ;
+            uiEdgeType      =  signDown1 + m_iUpBuff1[x] + 2;
+            m_iUpBufft[x+1] = -signDown1;
+            if( x < startX && y < startY )
+              continue;
+            stats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+            count[m_auiEoTable[uiEdgeType]] ++;
+          }
+          m_iUpBufft[firstX] = signDown2;
+          ipSwap     = m_iUpBuff1;
+          m_iUpBuff1 = m_iUpBufft;
+          m_iUpBufft = ipSwap;
+          pRec += stride;
+          pOrg += stride;
+        }
+        //if (iSaoType == EO_3)
+        numSkipLine = isChroma? 2:4;
+        numSkipLineRight = isChroma? 3:5;
+        stats = m_offsetOrg_PreDblk[addr][yCbCr][SAO_EO_3];
+        count = m_count_PreDblk[addr][yCbCr][SAO_EO_3];
+        pOrg = getPicYuvAddr(pcPic->getPicYuvOrg(), yCbCr, addr);
+        pRec = getPicYuvAddr(pcPic->getPicYuvRec(), yCbCr, addr);
+        startX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth-numSkipLineRight;
+        startY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight-numSkipLine;
+        firstX   = (lPelX == 0) ? 1 : 0;
+        firstY = (tPelY == 0) ? 1 : 0;
+        endX   = (rPelX == picWidthTmp) ? lcuWidth-1 : lcuWidth;
+        endY   = (bPelY == picHeightTmp) ? lcuHeight-1 : lcuHeight;
+        if (firstY == 1)
+        {
+          pOrg += stride;
+          pRec += stride;
+        }
+        for (x=firstX-1; x<endX; x++)
+        {
+          m_iUpBuff1[x] = xSign(pRec[x] - pRec[x-stride+1]);
+        }
+        for (y=firstY; y<endY; y++)
+        {
+          for (x=firstX; x<endX; x++)
+          {
+            signDown1      =  xSign(pRec[x] - pRec[x+stride-1]) ;
+            uiEdgeType      =  signDown1 + m_iUpBuff1[x] + 2;
+            m_iUpBuff1[x-1] = -signDown1;
+            if( x < startX && y < startY )
+              continue;
+            stats[m_auiEoTable[uiEdgeType]] += (pOrg[x] - pRec[x]);
+            count[m_auiEoTable[uiEdgeType]] ++;
+          }
+          m_iUpBuff1[endX-1] = xSign(pRec[endX-1 + stride] - pRec[endX]);
+          pRec += stride;
+          pOrg += stride;
+        }
+      }
+    }
+  }
+}
+/** get SAO statistics
+ * \param  *psQTPart,  iYCbCr
+ */
+Void TEncSampleAdaptiveOffset::getSaoStats(SAOQTPart *psQTPart, Int iYCbCr)
+{
+  Int iLevelIdx, iPartIdx, iTypeIdx, iClassIdx;
+  Int i;
+  Int iNumTotalType = MAX_NUM_SAO_TYPE;
+  Int LcuIdxX;
+  Int LcuIdxY;
+  Int iAddr;
+  Int iFrameWidthInCU = m_pcPic->getFrameWidthInCU();
+  Int iDownPartIdx;
+  Int iPartStart;
+  Int iPartEnd;
+  SAOQTPart*  pOnePart;
+  if (m_uiMaxSplitLevel == 0)
+  {
+    iPartIdx = 0;
+    pOnePart = &(psQTPart[iPartIdx]);
+    for (LcuIdxY = pOnePart->StartCUY; LcuIdxY<= pOnePart->EndCUY; LcuIdxY++)
+    {
+      for (LcuIdxX = pOnePart->StartCUX; LcuIdxX<= pOnePart->EndCUX; LcuIdxX++)
+      {
+        iAddr = LcuIdxY*iFrameWidthInCU + LcuIdxX;
+        calcSaoStatsCu(iAddr, iPartIdx, iYCbCr);
+      }
+    }
+  }
+  else
+  {
+    for(iPartIdx=m_aiNumCulPartsLevel[m_uiMaxSplitLevel-1]; iPartIdx<m_aiNumCulPartsLevel[m_uiMaxSplitLevel]; iPartIdx++)
+    {
+      pOnePart = &(psQTPart[iPartIdx]);
+      for (LcuIdxY = pOnePart->StartCUY; LcuIdxY<= pOnePart->EndCUY; LcuIdxY++)
+      {
+        for (LcuIdxX = pOnePart->StartCUX; LcuIdxX<= pOnePart->EndCUX; LcuIdxX++)
+        {
+          iAddr = LcuIdxY*iFrameWidthInCU + LcuIdxX;
+          calcSaoStatsCu(iAddr, iPartIdx, iYCbCr);
+        }
+      }
+    }
+    for (iLevelIdx = m_uiMaxSplitLevel-1; iLevelIdx>=0; iLevelIdx-- )
+    {
+      iPartStart = (iLevelIdx > 0) ? m_aiNumCulPartsLevel[iLevelIdx-1] : 0;
+      iPartEnd   = m_aiNumCulPartsLevel[iLevelIdx];
+      for(iPartIdx = iPartStart; iPartIdx < iPartEnd; iPartIdx++)
+      {
+        pOnePart = &(psQTPart[iPartIdx]);
+        for (i=0; i< NUM_DOWN_PART; i++)
+        {
+          iDownPartIdx = pOnePart->DownPartsIdx[i];
+          for (iTypeIdx=0; iTypeIdx<iNumTotalType; iTypeIdx++)
+          {
+            for (iClassIdx=0; iClassIdx< (iTypeIdx < SAO_BO ? m_iNumClass[iTypeIdx] : SAO_MAX_BO_CLASSES) +1; iClassIdx++)
+            {
+              m_iOffsetOrg[iPartIdx][iTypeIdx][iClassIdx] += m_iOffsetOrg[iDownPartIdx][iTypeIdx][iClassIdx];
+              m_iCount [iPartIdx][iTypeIdx][iClassIdx]    += m_iCount [iDownPartIdx][iTypeIdx][iClassIdx];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+/** reset offset statistics
+ * \param
+ */
+Void TEncSampleAdaptiveOffset::resetStats()
+{
+  for (Int i=0;i<m_iNumTotalParts;i++)
+  {
+    m_dCostPartBest[i] = MAX_DOUBLE;
+    m_iTypePartBest[i] = -1;
+    m_iDistOrg[i] = 0;
+    for (Int j=0;j<MAX_NUM_SAO_TYPE;j++)
+    {
+      m_iDist[i][j] = 0;
+      m_iRate[i][j] = 0;
+      m_dCost[i][j] = 0;
+      for (Int k=0;k<MAX_NUM_SAO_CLASS;k++)
+      {
+        m_iCount [i][j][k] = 0;
+        m_iOffset[i][j][k] = 0;
+        m_iOffsetOrg[i][j][k] = 0;
+      }
+    }
+  }
+}
+#if SAO_CHROMA_LAMBDA
+/** Sample adaptive offset process
+ * \param pcSaoParam
+ * \param dLambdaLuma
+ * \param dLambdaChroma
+ */
+#if SAO_ENCODING_CHOICE
+Void TEncSampleAdaptiveOffset::SAOProcess(SAOParam *pcSaoParam, Double dLambdaLuma, Double dLambdaChroma, Int depth)
+#else
+Void TEncSampleAdaptiveOffset::SAOProcess(SAOParam *pcSaoParam, Double dLambdaLuma, Double dLambdaChroma)
+#endif
+#else
+/** Sample adaptive offset process
+ * \param dLambda
+ */
+Void TEncSampleAdaptiveOffset::SAOProcess(SAOParam *pcSaoParam, Double dLambda)
+#endif
+{
+  if(m_bUseNIF)
+  {
+    m_pcPic->getPicYuvRec()->copyToPic(m_pcYuvTmp);
+  }
+  m_uiSaoBitIncreaseY = max(g_bitDepthY - 10, 0);
+  m_uiSaoBitIncreaseC = max(g_bitDepthC - 10, 0);
+  m_iOffsetThY = 1 << min(g_bitDepthY - 5, 5);
+  m_iOffsetThC = 1 << min(g_bitDepthC - 5, 5);
+  resetSAOParam(pcSaoParam);
+  if( !m_saoLcuBasedOptimization || !m_saoLcuBoundary )
+  {
+    resetStats();
+  }
+  Double dCostFinal = 0;
+  if ( m_saoLcuBasedOptimization)
+  {
+#if SAO_ENCODING_CHOICE
+    rdoSaoUnitAll(pcSaoParam, dLambdaLuma, dLambdaChroma, depth);
+#else
+    rdoSaoUnitAll(pcSaoParam, dLambdaLuma, dLambdaChroma);
+#endif
+  }
+  else
+  {
+    pcSaoParam->bSaoFlag[0] = 1;
+    pcSaoParam->bSaoFlag[1] = 0;
+    dCostFinal = 0;
+    Double lambdaRdo =  dLambdaLuma;
+    resetStats();
+    getSaoStats(pcSaoParam->psSaoPart[0], 0);
+    runQuadTreeDecision(pcSaoParam->psSaoPart[0], 0, dCostFinal, m_uiMaxSplitLevel, lambdaRdo, 0);
+    pcSaoParam->bSaoFlag[0] = dCostFinal < 0 ? 1:0;
+    if(pcSaoParam->bSaoFlag[0])
+    {
+      convertQT2SaoUnit(pcSaoParam, 0, 0);
+      assignSaoUnitSyntax(pcSaoParam->saoLcuParam[0],  pcSaoParam->psSaoPart[0], pcSaoParam->oneUnitFlag[0], 0);
+    }
+  }
+  if (pcSaoParam->bSaoFlag[0])
+  {
+    processSaoUnitAll( pcSaoParam->saoLcuParam[0], pcSaoParam->oneUnitFlag[0], 0);
+  }
+  if (pcSaoParam->bSaoFlag[1])
+  {
+    processSaoUnitAll( pcSaoParam->saoLcuParam[1], pcSaoParam->oneUnitFlag[1], 1);
+    processSaoUnitAll( pcSaoParam->saoLcuParam[2], pcSaoParam->oneUnitFlag[2], 2);
+  }
+}
+/** Check merge SAO unit
+ * \param saoUnitCurr current SAO unit
+ * \param saoUnitCheck SAO unit tobe check
+ * \param dir direction
+ */
+Void TEncSampleAdaptiveOffset::checkMerge(SaoLcuParam * saoUnitCurr, SaoLcuParam * saoUnitCheck, Int dir)
+{
+  Int i ;
+  Int countDiff = 0;
+  if (saoUnitCurr->partIdx != saoUnitCheck->partIdx)
+  {
+    if (saoUnitCurr->typeIdx !=-1)
+    {
+      if (saoUnitCurr->typeIdx == saoUnitCheck->typeIdx)
+      {
+        for (i=0;i<saoUnitCurr->length;i++)
+        {
+          countDiff += (saoUnitCurr->offset[i] != saoUnitCheck->offset[i]);
+        }
+        countDiff += (saoUnitCurr->subTypeIdx != saoUnitCheck->subTypeIdx);
+        if (countDiff ==0)
+        {
+          saoUnitCurr->partIdx = saoUnitCheck->partIdx;
+          if (dir == 1)
+          {
+            saoUnitCurr->mergeUpFlag = 1;
+            saoUnitCurr->mergeLeftFlag = 0;
+          }
+          else
+          {
+            saoUnitCurr->mergeUpFlag = 0;
+            saoUnitCurr->mergeLeftFlag = 1;
+          }
+        }
+      }
+    }
+    else
+    {
+      if (saoUnitCurr->typeIdx == saoUnitCheck->typeIdx)
+      {
+        saoUnitCurr->partIdx = saoUnitCheck->partIdx;
+        if (dir == 1)
+        {
+          saoUnitCurr->mergeUpFlag = 1;
+          saoUnitCurr->mergeLeftFlag = 0;
+        }
+        else
+        {
+          saoUnitCurr->mergeUpFlag = 0;
+          saoUnitCurr->mergeLeftFlag = 1;
+        }
+      }
+    }
+  }
+}
+/** Assign SAO unit syntax from picture-based algorithm
+ * \param saoLcuParam SAO LCU parameters
+ * \param saoPart SAO part
+ * \param oneUnitFlag SAO one unit flag
+ * \param iYCbCr color component Index
+ */
+Void TEncSampleAdaptiveOffset::assignSaoUnitSyntax(SaoLcuParam* saoLcuParam,  SAOQTPart* saoPart, Bool &oneUnitFlag, Int yCbCr)
+{
+  if (saoPart->bSplit == 0)
+  {
+    oneUnitFlag = 1;
+  }
+  else
+  {
+    Int i,j, addr, addrUp, addrLeft,  idx, idxUp, idxLeft,  idxCount;
+    oneUnitFlag = 0;
+    idxCount = -1;
+    saoLcuParam[0].mergeUpFlag = 0;
+    saoLcuParam[0].mergeLeftFlag = 0;
+    for (j=0;j<m_iNumCuInHeight;j++)
+    {
+      for (i=0;i<m_iNumCuInWidth;i++)
+      {
+        addr     = i + j*m_iNumCuInWidth;
+        addrLeft = (addr%m_iNumCuInWidth == 0) ? -1 : addr - 1;
+        addrUp   = (addr<m_iNumCuInWidth)      ? -1 : addr - m_iNumCuInWidth;
+        idx      = saoLcuParam[addr].partIdxTmp;
+        idxLeft  = (addrLeft == -1) ? -1 : saoLcuParam[addrLeft].partIdxTmp;
+        idxUp    = (addrUp == -1)   ? -1 : saoLcuParam[addrUp].partIdxTmp;
+        if(idx!=idxLeft && idx!=idxUp)
+        {
+          saoLcuParam[addr].mergeUpFlag   = 0; idxCount++;
+          saoLcuParam[addr].mergeLeftFlag = 0;
+          saoLcuParam[addr].partIdx = idxCount;
+        }
+        else if (idx==idxLeft)
+        {
+          saoLcuParam[addr].mergeUpFlag   = 1;
+          saoLcuParam[addr].mergeLeftFlag = 1;
+          saoLcuParam[addr].partIdx = saoLcuParam[addrLeft].partIdx;
+        }
+        else if (idx==idxUp)
+        {
+          saoLcuParam[addr].mergeUpFlag   = 1;
+          saoLcuParam[addr].mergeLeftFlag = 0;
+          saoLcuParam[addr].partIdx = saoLcuParam[addrUp].partIdx;
+        }
+        if (addrUp != -1)
+        {
+          checkMerge(&saoLcuParam[addr], &saoLcuParam[addrUp], 1);
+        }
+        if (addrLeft != -1)
+        {
+          checkMerge(&saoLcuParam[addr], &saoLcuParam[addrLeft], 0);
+        }
+      }
+    }
+  }
+}
+/** rate distortion optimization of all SAO units
+ * \param saoParam SAO parameters
+ * \param lambda
+ * \param lambdaChroma
+ */
+#if SAO_ENCODING_CHOICE
+Void TEncSampleAdaptiveOffset::rdoSaoUnitAll(SAOParam *saoParam, Double lambda, Double lambdaChroma, Int depth)
+#else
+Void TEncSampleAdaptiveOffset::rdoSaoUnitAll(SAOParam *saoParam, Double lambda, Double lambdaChroma)
+#endif
+{
+  Int idxY;
+  Int idxX;
+  Int frameHeightInCU = saoParam->numCuInHeight;
+  Int frameWidthInCU  = saoParam->numCuInWidth;
+  Int j, k;
+  Int addr = 0;
+  Int addrUp = -1;
+  Int addrLeft = -1;
+  Int compIdx = 0;
+  SaoLcuParam mergeSaoParam[3][2];
+  Double compDistortion[3];
+  saoParam->bSaoFlag[0] = true;
+  saoParam->bSaoFlag[1] = true;
+  saoParam->oneUnitFlag[0] = false;
+  saoParam->oneUnitFlag[1] = false;
+  saoParam->oneUnitFlag[2] = false;
+  m_pcRDGoOnSbacCoder->setSlice(pcSlice);
+  m_pcRDGoOnSbacCoder->resetEntropy();
+  m_pcRDGoOnSbacCoder->resetBits();
+  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[SAO_CABACSTATE_PIC_INIT]);
+}
+Void TEncSampleAdaptiveOffset::SAOProcess(TComPic* pPic, Bool* sliceEnabled, const Double *lambdas
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                                         , Bool isPreDBFSamplesUsed
+#endif
+                                          )
+{
+  TComPicYuv* orgYuv= pPic->getPicYuvOrg();
+  TComPicYuv* resYuv= pPic->getPicYuvRec();
+  m_lambda[SAO_Y]= lambdas[0]; m_lambda[SAO_Cb]= lambdas[1]; m_lambda[SAO_Cr]= lambdas[2];
+  TComPicYuv* srcYuv = m_tempPicYuv;
+  resYuv->copyToPic(srcYuv);
+  srcYuv->setBorderExtension(false);
+  srcYuv->extendPicBorder();
+  //collect statistics
+  getStatistics(m_statData, orgYuv, srcYuv, pPic);
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  if(isPreDBFSamplesUsed)
+  {
+    addPreDBFStatistics(m_statData);
+  }
+#endif
+  //slice on/off
+  decidePicParams(sliceEnabled, pPic->getSlice(0)->getDepth());
+  //block on/off
+  SAOBlkParam* reconParams = new SAOBlkParam[m_numCTUsPic]; //temporary parameter buffer for storing reconstructed SAO parameters
+  decideBlkParams(pPic, sliceEnabled, m_statData, srcYuv, resYuv, reconParams, pPic->getPicSym()->getSAOBlkParam());
+  delete[] reconParams;
+}
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+Void TEncSampleAdaptiveOffset::getPreDBFStatistics(TComPic* pPic)
+{
+  getStatistics(m_preDBFstatData, pPic->getPicYuvOrg(), pPic->getPicYuvRec(), pPic, true);
+}
+Void TEncSampleAdaptiveOffset::addPreDBFStatistics(SAOStatData*** blkStats)
+{
+  for(Int n=0; n< m_numCTUsPic; n++)
+  {
+    for(Int compIdx=0; compIdx < NUM_SAO_COMPONENTS; compIdx++)
+    {
+      for(Int typeIdc=0; typeIdc < NUM_SAO_NEW_TYPES; typeIdc++)
+      {
+        blkStats[n][compIdx][typeIdc] += m_preDBFstatData[n][compIdx][typeIdc];
+      }
+    }
+  }
+}
+#endif
+Void TEncSampleAdaptiveOffset::getStatistics(SAOStatData*** blkStats, TComPicYuv* orgYuv, TComPicYuv* srcYuv, TComPic* pPic
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                          , Bool isCalculatePreDeblockSamples
+#endif
+                          )
+{
+  Bool isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail;
+  for(Int ctu= 0; ctu < m_numCTUsPic; ctu++)
+  {
+    Int yPos   = (ctu / m_numCTUInWidth)*m_maxCUHeight;
+    Int xPos   = (ctu % m_numCTUInWidth)*m_maxCUWidth;
+    Int height = (yPos + m_maxCUHeight > m_picHeight)?(m_picHeight- yPos):m_maxCUHeight;
+    Int width  = (xPos + m_maxCUWidth  > m_picWidth )?(m_picWidth - xPos):m_maxCUWidth;
+    pPic->getPicSym()->deriveLoopFilterBoundaryAvailibility(ctu, isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail);
+    //NOTE: The number of skipped lines during gathering CTU statistics depends on the slice boundary availabilities.
+    //For simplicity, here only picture boundaries are considered.
+    isRightAvail      = (xPos + m_maxCUWidth  < m_picWidth );
+    isBelowAvail      = (yPos + m_maxCUHeight < m_picHeight);
+    isBelowRightAvail = (isRightAvail && isBelowAvail);
+    isBelowLeftAvail  = ((xPos > 0) && (isBelowAvail));
+    isAboveRightAvail = ((yPos > 0) && (isRightAvail));
+    for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+    {
+      Bool isLuma     = (compIdx == SAO_Y);
+      Int  formatShift= isLuma?0:1;
+      Int  srcStride = isLuma?srcYuv->getStride():srcYuv->getCStride();
+      Pel* srcBlk    = getPicBuf(srcYuv, compIdx)+ (yPos >> formatShift)*srcStride+ (xPos >> formatShift);
+      Int  orgStride  = isLuma?orgYuv->getStride():orgYuv->getCStride();
+      Pel* orgBlk     = getPicBuf(orgYuv, compIdx)+ (yPos >> formatShift)*orgStride+ (xPos >> formatShift);
+      getBlkStats(compIdx, blkStats[ctu][compIdx]
+                , srcBlk, orgBlk, srcStride, orgStride, (width  >> formatShift), (height >> formatShift)
+                , isLeftAvail,  isRightAvail, isAboveAvail, isBelowAvail, isAboveLeftAvail, isAboveRightAvail, isBelowLeftAvail, isBelowRightAvail
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                , isCalculatePreDeblockSamples
+#endif
+                );
+    }
+  }
+}
+Void TEncSampleAdaptiveOffset::decidePicParams(Bool* sliceEnabled, Int picTempLayer)
+{
+  //decide sliceEnabled[compIdx]
+  for (Int compIdx=0; compIdx<NUM_SAO_COMPONENTS; compIdx++)
+  {
+    // reset flags & counters
+    sliceEnabled[compIdx] = true;
 #if SAO_ENCODING_CHOICE
 #if SAO_ENCODING_CHOICE_CHROMA
+  Int numNoSao[2];
+  numNoSao[0] = 0;// Luma
+  numNoSao[1] = 0;// Chroma
+  if( depth > 0 && m_depthSaoRate[0][depth-1] > SAO_ENCODING_RATE )
+  {
+    saoParam->bSaoFlag[0] = false;
+  }
+  if( depth > 0 && m_depthSaoRate[1][depth-1] > SAO_ENCODING_RATE_CHROMA )
+  {
+    saoParam->bSaoFlag[1] = false;
+  }
+#else
+  Int numNoSao = 0;
+  if( depth > 0 && m_depth0SaoRate > SAO_ENCODING_RATE )
+  {
+    saoParam->bSaoFlag[0] = false;
+    saoParam->bSaoFlag[1] = false;
+  }
+#endif
+#endif
+  for (idxY = 0; idxY< frameHeightInCU; idxY++)
+  {
+    for (idxX = 0; idxX< frameWidthInCU; idxX++)
+    {
+      addr     = idxX  + frameWidthInCU*idxY;
+      addrUp   = addr < frameWidthInCU ? -1:idxX   + frameWidthInCU*(idxY-1);
+      addrLeft = idxX == 0               ? -1:idxX-1 + frameWidthInCU*idxY;
+      Int allowMergeLeft = 1;
+      Int allowMergeUp   = 1;
+      UInt rate;
+      Double bestCost, mergeCost;
+      if (idxX!=0)
+      {
+        // check tile id and slice id
+        if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-1) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-1)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+        {
+          allowMergeLeft = 0;
+        }
+      }
+      else
+      {
+        allowMergeLeft = 0;
+      }
+      if (idxY!=0)
+      {
+        if ( (m_pcPic->getPicSym()->getTileIdxMap(addr-m_iNumCuInWidth) != m_pcPic->getPicSym()->getTileIdxMap(addr)) || (m_pcPic->getCU(addr-m_iNumCuInWidth)->getSlice()->getSliceIdx() != m_pcPic->getCU(addr)->getSlice()->getSliceIdx()))
+        {
+          allowMergeUp = 0;
+        }
+      }
+      else
+      {
+        allowMergeUp = 0;
+      }
+      compDistortion[0] = 0;
+      compDistortion[1] = 0;
+      compDistortion[2] = 0;
+      m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
+      if (allowMergeLeft)
+      {
+        m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(0);
+      }
+      if (allowMergeUp)
+      {
+        m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(0);
+      }
+      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[0][CI_TEMP_BEST] );
+      // reset stats Y, Cb, Cr
+      for ( compIdx=0;compIdx<3;compIdx++)
+      {
+        for ( j=0;j<MAX_NUM_SAO_TYPE;j++)
+        {
+          for ( k=0;k< MAX_NUM_SAO_CLASS;k++)
+          {
+            m_iOffset   [compIdx][j][k] = 0;
+            if( m_saoLcuBasedOptimization && m_saoLcuBoundary ){
+              m_iCount    [compIdx][j][k] = m_count_PreDblk    [addr][compIdx][j][k];
+              m_iOffsetOrg[compIdx][j][k] = m_offsetOrg_PreDblk[addr][compIdx][j][k];
+            }
+            else
+            {
+              m_iCount    [compIdx][j][k] = 0;
+              m_iOffsetOrg[compIdx][j][k] = 0;
+            }
+          }
+        }
+        saoParam->saoLcuParam[compIdx][addr].typeIdx       =  -1;
+        saoParam->saoLcuParam[compIdx][addr].mergeUpFlag   = 0;
+        saoParam->saoLcuParam[compIdx][addr].mergeLeftFlag = 0;
+        saoParam->saoLcuParam[compIdx][addr].subTypeIdx    = 0;
+#if SAO_ENCODING_CHOICE
+  if( (compIdx ==0 && saoParam->bSaoFlag[0])|| (compIdx >0 && saoParam->bSaoFlag[1]) )
+#endif
+        {
+          calcSaoStatsCu(addr, compIdx,  compIdx);
+       }
+      }
+      saoComponentParamDist(allowMergeLeft, allowMergeUp, saoParam, addr, addrUp, addrLeft, 0,  lambda, &mergeSaoParam[0][0], &compDistortion[0]);
+      sao2ChromaParamDist(allowMergeLeft, allowMergeUp, saoParam, addr, addrUp, addrLeft, lambdaChroma, &mergeSaoParam[1][0], &mergeSaoParam[2][0], &compDistortion[0]);
+     if( saoParam->bSaoFlag[0] || saoParam->bSaoFlag[1] )
+      {
+        // Cost of new SAO_params
+        m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
+        m_pcRDGoOnSbacCoder->resetBits();
+        if (allowMergeLeft)
+        {
+          m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(0);
+        }
+        if (allowMergeUp)
+        {
+          m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(0);
+        }
+        for ( compIdx=0;compIdx<3;compIdx++)
+        {
+        if( (compIdx ==0 && saoParam->bSaoFlag[0]) || (compIdx >0 && saoParam->bSaoFlag[1]))
+          {
+           m_pcEntropyCoder->encodeSaoOffset(&saoParam->saoLcuParam[compIdx][addr], compIdx);
+          }
+        }
+        rate = m_pcEntropyCoder->getNumberOfWrittenBits();
+        bestCost = compDistortion[0] + (Double)rate;
+        m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+        // Cost of Merge
+        for(Int mergeUp=0; mergeUp<2; ++mergeUp)
+        {
+          if ( (allowMergeLeft && (mergeUp==0)) || (allowMergeUp && (mergeUp==1)) )
+          {
+            m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
+            m_pcRDGoOnSbacCoder->resetBits();
+            if (allowMergeLeft)
+            {
+              m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(1-mergeUp);
+            }
+            if ( allowMergeUp && (mergeUp==1) )
+            {
+              m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(1);
+            }
+            rate = m_pcEntropyCoder->getNumberOfWrittenBits();
+            mergeCost = compDistortion[mergeUp+1] + (Double)rate;
+            if (mergeCost < bestCost)
+            {
+              bestCost = mergeCost;
+              m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+              for ( compIdx=0;compIdx<3;compIdx++)
+              {
+                mergeSaoParam[compIdx][mergeUp].mergeLeftFlag = 1-mergeUp;
+                mergeSaoParam[compIdx][mergeUp].mergeUpFlag = mergeUp;
+                if( (compIdx==0 && saoParam->bSaoFlag[0]) || (compIdx>0 && saoParam->bSaoFlag[1]))
+                {
+                  copySaoUnit(&saoParam->saoLcuParam[compIdx][addr], &mergeSaoParam[compIdx][mergeUp] );
+                }
+              }
+            }
+          }
+        }
+#if SAO_ENCODING_CHOICE
+#if SAO_ENCODING_CHOICE_CHROMA
+if( saoParam->saoLcuParam[0][addr].typeIdx == -1)
+{
+  numNoSao[0]++;
+}
+if( saoParam->saoLcuParam[1][addr].typeIdx == -1)
+{
+  numNoSao[1]+=2;
+}
+#else
+        for ( compIdx=0;compIdx<3;compIdx++)
+        {
+          if( depth == 0 && saoParam->saoLcuParam[compIdx][addr].typeIdx == -1)
+          {
+            numNoSao++;
+          }
+        }
+#endif
+#endif
+        m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+        m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
+      }
+    }
+  }
+#if SAO_ENCODING_CHOICE
+#if SAO_ENCODING_CHOICE_CHROMA
+  if( !saoParam->bSaoFlag[0])
+  {
+    m_depthSaoRate[0][depth] = 1.0;
+  }
+  else
+  {
+    m_depthSaoRate[0][depth] = numNoSao[0]/((Double) frameHeightInCU*frameWidthInCU);
+  }
+  if( !saoParam->bSaoFlag[1])
+  {
+    m_depthSaoRate[1][depth] = 1.0;
+  }
+  else
+  {
+    m_depthSaoRate[1][depth] = numNoSao[1]/((Double) frameHeightInCU*frameWidthInCU*2);
+  }
+#else
+  if( depth == 0)
+  {
+    // update SAO Rate
+    m_depth0SaoRate = numNoSao/((Double) frameHeightInCU*frameWidthInCU*3);
+  }
+#endif
+#endif
+}
+/** rate distortion optimization of SAO unit
+ * \param saoParam SAO parameters
+ * \param addr address
+ * \param addrUp above address
+ * \param addrLeft left address
+ * \param yCbCr color component index
+ * \param lambda
+ */
+inline Int64 TEncSampleAdaptiveOffset::estSaoTypeDist(Int compIdx, Int typeIdx, Int shift, Double lambda, Int *currentDistortionTableBo, Double *currentRdCostTableBo)
+{
+  Int64 estDist = 0;
+  Int classIdx;
+  Int bitDepth = (compIdx==0) ? g_bitDepthY : g_bitDepthC;
+  Int saoBitIncrease = (compIdx==0) ? m_uiSaoBitIncreaseY : m_uiSaoBitIncreaseC;
+  Int saoOffsetTh = (compIdx==0) ? m_iOffsetThY : m_iOffsetThC;
+  for(classIdx=1; classIdx < ( (typeIdx < SAO_BO) ?  m_iNumClass[typeIdx]+1 : SAO_MAX_BO_CLASSES+1); classIdx++)
+  {
+    if( typeIdx == SAO_BO)
+    {
+      currentDistortionTableBo[classIdx-1] = 0;
+      currentRdCostTableBo[classIdx-1] = lambda;
+    }
+    if(m_iCount [compIdx][typeIdx][classIdx])
+    {
+      m_iOffset[compIdx][typeIdx][classIdx] = (Int64) xRoundIbdi(bitDepth, (Double)(m_iOffsetOrg[compIdx][typeIdx][classIdx]<<(bitDepth-8)) / (Double)(m_iCount [compIdx][typeIdx][classIdx]<<saoBitIncrease));
+      m_iOffset[compIdx][typeIdx][classIdx] = Clip3(-saoOffsetTh+1, saoOffsetTh-1, (Int)m_iOffset[compIdx][typeIdx][classIdx]);
+      if (typeIdx < 4)
+      {
+        if ( m_iOffset[compIdx][typeIdx][classIdx]<0 && classIdx<3 )
+        {
+          m_iOffset[compIdx][typeIdx][classIdx] = 0;
+        }
+        if ( m_iOffset[compIdx][typeIdx][classIdx]>0 && classIdx>=3)
+        {
+          m_iOffset[compIdx][typeIdx][classIdx] = 0;
+        }
+      }
+      m_iOffset[compIdx][typeIdx][classIdx] = estIterOffset( typeIdx, classIdx, lambda, m_iOffset[compIdx][typeIdx][classIdx], m_iCount [compIdx][typeIdx][classIdx], m_iOffsetOrg[compIdx][typeIdx][classIdx], shift, saoBitIncrease, currentDistortionTableBo, currentRdCostTableBo, saoOffsetTh );
+    }
+    else
+    {
+      m_iOffsetOrg[compIdx][typeIdx][classIdx] = 0;
+      m_iOffset[compIdx][typeIdx][classIdx] = 0;
+    }
+    if( typeIdx != SAO_BO )
+    {
+      estDist   += estSaoDist( m_iCount [compIdx][typeIdx][classIdx], m_iOffset[compIdx][typeIdx][classIdx] << saoBitIncrease, m_iOffsetOrg[compIdx][typeIdx][classIdx], shift);
+    }
+  }
+  return estDist;
+}
+inline Int64 TEncSampleAdaptiveOffset::estSaoDist(Int64 count, Int64 offset, Int64 offsetOrg, Int shift)
+{
+  return (( count*offset*offset-offsetOrg*offset*2 ) >> shift);
+}
+inline Int64 TEncSampleAdaptiveOffset::estIterOffset(Int typeIdx, Int classIdx, Double lambda, Int64 offsetInput, Int64 count, Int64 offsetOrg, Int shift, Int bitIncrease, Int *currentDistortionTableBo, Double *currentRdCostTableBo, Int offsetTh )
+{
+  //Clean up, best_q_offset.
+  Int64 iterOffset, tempOffset;
+    // decide slice-level on/off based on previous results
+    if( (picTempLayer > 0)
+      && (m_saoDisabledRate[compIdx][picTempLayer-1] > ((compIdx==SAO_Y) ? SAO_ENCODING_RATE : SAO_ENCODING_RATE_CHROMA)) )
+    {
+      sliceEnabled[compIdx] = false;
+    }
+#else
+    // decide slice-level on/off based on previous results
+    if( (picTempLayer > 0)
+      && (m_saoDisabledRate[SAO_Y][0] > SAO_ENCODING_RATE) )
+    {
+      sliceEnabled[compIdx] = false;
+    }
+#endif
+#endif
+  }
+}
+Int64 TEncSampleAdaptiveOffset::getDistortion(Int ctu, Int compIdx, Int typeIdc, Int typeAuxInfo, Int* invQuantOffset, SAOStatData& statData)
+{
+  Int64 dist=0;
+  Int inputBitDepth    = (compIdx == SAO_Y) ? g_bitDepthY : g_bitDepthC ;
+  Int shift = 2 * DISTORTION_PRECISION_ADJUSTMENT(inputBitDepth-8);
+  switch(typeIdc)
+  {
+    case SAO_TYPE_EO_0:
+    case SAO_TYPE_EO_90:
+    case SAO_TYPE_EO_135:
+    case SAO_TYPE_EO_45:
+      {
+        for (Int offsetIdx=0; offsetIdx<NUM_SAO_EO_CLASSES; offsetIdx++)
+        {
+          dist += estSaoDist( statData.count[offsetIdx], invQuantOffset[offsetIdx], statData.diff[offsetIdx], shift);
+        }
+      }
+      break;
+    case SAO_TYPE_BO:
+      {
+        for (Int offsetIdx=typeAuxInfo; offsetIdx<typeAuxInfo+4; offsetIdx++)
+        {
+          Int bandIdx = offsetIdx % NUM_SAO_BO_CLASSES ;
+          dist += estSaoDist( statData.count[bandIdx], invQuantOffset[bandIdx], statData.diff[bandIdx], shift);
+        }
+      }
+      break;
+    default:
+      {
+        printf("Not a supported type");
+        assert(0);
+        exit(-1);
+      }
+  }
+  return dist;
+}
+inline Int64 TEncSampleAdaptiveOffset::estSaoDist(Int64 count, Int64 offset, Int64 diffSum, Int shift)
+{
+  return (( count*offset*offset-diffSum*offset*2 ) >> shift);
+}
+inline Int TEncSampleAdaptiveOffset::estIterOffset(Int typeIdx, Int classIdx, Double lambda, Int offsetInput, Int64 count, Int64 diffSum, Int shift, Int bitIncrease, Int64& bestDist, Double& bestCost, Int offsetTh )
+{
+  Int iterOffset, tempOffset;
   Int64 tempDist, tempRate;
   Double tempCost, tempMinCost;
   Int64 offsetOutput = 0;
+  Int offsetOutput = 0;
   iterOffset = offsetInput;
   // Assuming sending quantized value 0 results in zero offset and sending the value zero needs 1 bit. entropy coder can be used to measure the exact rate here.
 …
   while (iterOffset != 0)
+  {
     // Calculate the bits required for signalling the offset
     tempRate = (typeIdx == SAO_BO) ? (abs((Int)iterOffset)+2) : (abs((Int)iterOffset)+1);
     if (abs((Int)iterOffset)==offsetTh-1)
+    // Calculate the bits required for signaling the offset
+    tempRate = (typeIdx == SAO_TYPE_BO) ? (abs((Int)iterOffset)+2) : (abs((Int)iterOffset)+1);
+    if (abs((Int)iterOffset)==offsetTh) //inclusive
+    {
       tempRate --;
+    }
     // Do the dequntization before distorion calculation
+    // Do the dequantization before distortion calculation
     tempOffset  = iterOffset << bitIncrease;
     tempDist    = estSaoDist( count, tempOffset, offsetOrg, shift);
+    tempDist    = estSaoDist( count, tempOffset, diffSum, shift);
     tempCost    = ((Double)tempDist + lambda * (Double) tempRate);
     if(tempCost < tempMinCost)
 …
       tempMinCost = tempCost;
       offsetOutput = iterOffset;
+      if(typeIdx == SAO_BO)
+      {
+        currentDistortionTableBo[classIdx-1] = (Int) tempDist;
+        currentRdCostTableBo[classIdx-1] = tempCost;
+      }
+      bestDist = tempDist;
+      bestCost = tempCost;
+    }
     iterOffset = (iterOffset > 0) ? (iterOffset-1):(iterOffset+1);
 …
+Void TEncSampleAdaptiveOffset::saoComponentParamDist(Int allowMergeLeft, Int allowMergeUp, SAOParam *saoParam, Int addr, Int addrUp, Int addrLeft, Int yCbCr, Double lambda, SaoLcuParam *compSaoParam, Double *compDistortion)
+{
+  Int typeIdx;
+  Int64 estDist;
+  Int classIdx;
+  Int shift = 2 * DISTORTION_PRECISION_ADJUSTMENT(((yCbCr==0)?g_bitDepthY:g_bitDepthC)-8);
+  Int64 bestDist;
+  SaoLcuParam*  saoLcuParam = &(saoParam->saoLcuParam[yCbCr][addr]);
+  SaoLcuParam*  saoLcuParamNeighbor = NULL;
+  resetSaoUnit(saoLcuParam);
+  resetSaoUnit(&compSaoParam[0]);
+  resetSaoUnit(&compSaoParam[1]);
+  Double dCostPartBest = MAX_DOUBLE;
+  Double  bestRDCostTableBo = MAX_DOUBLE;
+  Int     bestClassTableBo    = 0;
+  Int     currentDistortionTableBo[MAX_NUM_SAO_CLASS];
+  Double  currentRdCostTableBo[MAX_NUM_SAO_CLASS];
+  SaoLcuParam   saoLcuParamRdo;
+  Double   estRate = 0;
+  resetSaoUnit(&saoLcuParamRdo);
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+Void TEncSampleAdaptiveOffset::deriveOffsets(Int ctu, Int compIdx, Int typeIdc, SAOStatData& statData, Int* quantOffsets, Int& typeAuxInfo)
+{
+  Int bitDepth = (compIdx== SAO_Y) ? g_bitDepthY : g_bitDepthC;
+  Int shift = 2 * DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8);
+  Int offsetTh = g_saoMaxOffsetQVal[compIdx];  //inclusive
+  ::memset(quantOffsets, 0, sizeof(Int)*MAX_NUM_SAO_CLASSES);
+  //derive initial offsets
+  Int numClasses = (typeIdc == SAO_TYPE_BO)?((Int)NUM_SAO_BO_CLASSES):((Int)NUM_SAO_EO_CLASSES);
+  for(Int classIdx=0; classIdx< numClasses; classIdx++)
+  {
+    if( (typeIdc != SAO_TYPE_BO) && (classIdx==SAO_CLASS_EO_PLAIN)  )
+    {
+      continue; //offset will be zero
+    }
+    if(statData.count[classIdx] == 0)
+    {
+      continue; //offset will be zero
+    }
+    quantOffsets[classIdx] = (Int) xRoundIbdi(bitDepth, (Double)( statData.diff[classIdx]<<(bitDepth-8))
+                                                                  /
+                                                          (Double)( statData.count[classIdx]<< m_offsetStepLog2[compIdx])
+                                               );
+    quantOffsets[classIdx] = Clip3(-offsetTh, offsetTh, quantOffsets[classIdx]);
+  }
+  // adjust offsets
+  switch(typeIdc)
+  {
+    case SAO_TYPE_EO_0:
+    case SAO_TYPE_EO_90:
+    case SAO_TYPE_EO_135:
+    case SAO_TYPE_EO_45:
+      {
+        Int64 classDist;
+        Double classCost;
+        for(Int classIdx=0; classIdx<NUM_SAO_EO_CLASSES; classIdx++)
+        {
+          if(classIdx==SAO_CLASS_EO_FULL_VALLEY && quantOffsets[classIdx] < 0) quantOffsets[classIdx] =0;
+          if(classIdx==SAO_CLASS_EO_HALF_VALLEY && quantOffsets[classIdx] < 0) quantOffsets[classIdx] =0;
+          if(classIdx==SAO_CLASS_EO_HALF_PEAK   && quantOffsets[classIdx] > 0) quantOffsets[classIdx] =0;
+          if(classIdx==SAO_CLASS_EO_FULL_PEAK   && quantOffsets[classIdx] > 0) quantOffsets[classIdx] =0;
+          if( quantOffsets[classIdx] != 0 ) //iterative adjustment only when derived offset is not zero
+          {
+            quantOffsets[classIdx] = estIterOffset( typeIdc, classIdx, m_lambda[compIdx], quantOffsets[classIdx], statData.count[classIdx], statData.diff[classIdx], shift, m_offsetStepLog2[compIdx], classDist , classCost , offsetTh );
+          }
+        }
+        typeAuxInfo =0;
+      }
+      break;
+    case SAO_TYPE_BO:
+      {
+        Int64  distBOClasses[NUM_SAO_BO_CLASSES];
+        Double costBOClasses[NUM_SAO_BO_CLASSES];
+        ::memset(distBOClasses, 0, sizeof(Int64)*NUM_SAO_BO_CLASSES);
+        for(Int classIdx=0; classIdx< NUM_SAO_BO_CLASSES; classIdx++)
+        {
+          costBOClasses[classIdx]= m_lambda[compIdx];
+          if( quantOffsets[classIdx] != 0 ) //iterative adjustment only when derived offset is not zero
+          {
+            quantOffsets[classIdx] = estIterOffset( typeIdc, classIdx, m_lambda[compIdx], quantOffsets[classIdx], statData.count[classIdx], statData.diff[classIdx], shift, m_offsetStepLog2[compIdx], distBOClasses[classIdx], costBOClasses[classIdx], offsetTh );
+          }
+        }
+        //decide the starting band index
+        Double minCost = MAX_DOUBLE, cost;
+        for(Int band=0; band< NUM_SAO_BO_CLASSES- 4+ 1; band++)
+        {
+          cost  = costBOClasses[band  ];
+          cost += costBOClasses[band+1];
+          cost += costBOClasses[band+2];
+          cost += costBOClasses[band+3];
+          if(cost < minCost)
+          {
+            minCost = cost;
+            typeAuxInfo = band;
+          }
+        }
+        //clear those unused classes
+        Int clearQuantOffset[NUM_SAO_BO_CLASSES];
+        ::memset(clearQuantOffset, 0, sizeof(Int)*NUM_SAO_BO_CLASSES);
+        for(Int i=0; i< 4; i++)
+        {
+          Int band = (typeAuxInfo+i)%NUM_SAO_BO_CLASSES;
+          clearQuantOffset[band] = quantOffsets[band];
+        }
+        ::memcpy(quantOffsets, clearQuantOffset, sizeof(Int)*NUM_SAO_BO_CLASSES);
+      }
+      break;
+    default:
+      {
+        printf("Not a supported type");
+        assert(0);
+        exit(-1);
+      }
+  }
+}
+Void TEncSampleAdaptiveOffset::deriveModeNewRDO(Int ctu, std::vector<SAOBlkParam*>& mergeList, Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel)
+{
+  Double minCost, cost;
+  Int rate;
+  UInt previousWrittenBits;
+  Int64 dist[NUM_SAO_COMPONENTS], modeDist[NUM_SAO_COMPONENTS];
+  SAOOffset testOffset[NUM_SAO_COMPONENTS];
+  Int compIdx;
+  Int invQuantOffset[MAX_NUM_SAO_CLASSES];
+  modeDist[SAO_Y]= modeDist[SAO_Cb] = modeDist[SAO_Cr] = 0;
+  //pre-encode merge flags
+  modeParam[SAO_Y ].modeIdc = SAO_MODE_OFF;
+  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
+  m_pcRDGoOnSbacCoder->codeSAOBlkParam(modeParam, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), true);
+  m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
+  //------ luma --------//
+  compIdx = SAO_Y;
+  //"off" case as initial cost
+  modeParam[compIdx].modeIdc = SAO_MODE_OFF;
   m_pcRDGoOnSbacCoder->resetBits();
+ m_pcEntropyCoder->encodeSaoOffset(&saoLcuParamRdo, yCbCr);
+  dCostPartBest = m_pcEntropyCoder->getNumberOfWrittenBits()*lambda ;
+  copySaoUnit(saoLcuParam, &saoLcuParamRdo );
+  bestDist = 0;
+  for (typeIdx=0; typeIdx<MAX_NUM_SAO_TYPE; typeIdx++)
+  {
+    estDist = estSaoTypeDist(yCbCr, typeIdx, shift, lambda, currentDistortionTableBo, currentRdCostTableBo);
+    if( typeIdx == SAO_BO )
+    {
+      // Estimate Best Position
+      Double currentRDCost = 0.0;
+      for(Int i=0; i< SAO_MAX_BO_CLASSES -SAO_BO_LEN +1; i++)
+      {
+        currentRDCost = 0.0;
+        for(UInt uj = i; uj < i+SAO_BO_LEN; uj++)
+        {
+          currentRDCost += currentRdCostTableBo[uj];
+        }
+        if( currentRDCost < bestRDCostTableBo)
+        {
+          bestRDCostTableBo = currentRDCost;
+          bestClassTableBo  = i;
+        }
+      }
+      // Re code all Offsets
+      // Code Center
+      estDist = 0;
+      for(classIdx = bestClassTableBo; classIdx < bestClassTableBo+SAO_BO_LEN; classIdx++)
+      {
+        estDist += currentDistortionTableBo[classIdx];
+      }
+    }
+    resetSaoUnit(&saoLcuParamRdo);
+    saoLcuParamRdo.length = m_iNumClass[typeIdx];
+    saoLcuParamRdo.typeIdx = typeIdx;
+    saoLcuParamRdo.mergeLeftFlag = 0;
+    saoLcuParamRdo.mergeUpFlag   = 0;
+    saoLcuParamRdo.subTypeIdx = (typeIdx == SAO_BO) ? bestClassTableBo : 0;
+    for (classIdx = 0; classIdx < saoLcuParamRdo.length; classIdx++)
+    {
+      saoLcuParamRdo.offset[classIdx] = (Int)m_iOffset[yCbCr][typeIdx][classIdx+saoLcuParamRdo.subTypeIdx+1];
+    }
+    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+  m_pcRDGoOnSbacCoder->codeSAOOffsetParam(compIdx, modeParam[compIdx], sliceEnabled[compIdx]);
+  modeDist[compIdx] = 0;
+  minCost= m_lambda[compIdx]*((Double)m_pcRDGoOnSbacCoder->getNumberOfWrittenBits());
+  m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
+  if(sliceEnabled[compIdx])
+  {
+    for(Int typeIdc=0; typeIdc< NUM_SAO_NEW_TYPES; typeIdc++)
+    {
+      testOffset[compIdx].modeIdc = SAO_MODE_NEW;
+      testOffset[compIdx].typeIdc = typeIdc;
+      //derive coded offset
+      deriveOffsets(ctu, compIdx, typeIdc, blkStats[ctu][compIdx][typeIdc], testOffset[compIdx].offset, testOffset[compIdx].typeAuxInfo);
+      //inversed quantized offsets
+      invertQuantOffsets(compIdx, typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, testOffset[compIdx].offset);
+      //get distortion
+      dist[compIdx] = getDistortion(ctu, compIdx, testOffset[compIdx].typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, blkStats[ctu][compIdx][typeIdc]);
+      //get rate
+      m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
+      m_pcRDGoOnSbacCoder->resetBits();
+      m_pcRDGoOnSbacCoder->codeSAOOffsetParam(compIdx, testOffset[compIdx], sliceEnabled[compIdx]);
+      rate = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
+      cost = (Double)dist[compIdx] + m_lambda[compIdx]*((Double)rate);
+      if(cost < minCost)
+      {
+        minCost = cost;
+        modeDist[compIdx] = dist[compIdx];
+        modeParam[compIdx]= testOffset[compIdx];
+        m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
+      }
+    }
+  }
+  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
+  m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
+  //------ chroma --------//
+  //"off" case as initial cost
+  cost = 0;
+  previousWrittenBits = 0;
+  m_pcRDGoOnSbacCoder->resetBits();
+  for (Int component = SAO_Cb; component < NUM_SAO_COMPONENTS; component++)
+  {
+    modeParam[component].modeIdc = SAO_MODE_OFF;
+    modeDist [component] = 0;
+    m_pcRDGoOnSbacCoder->codeSAOOffsetParam(component, modeParam[component], sliceEnabled[component]);
+    const UInt currentWrittenBits = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
+    cost += m_lambda[component] * (currentWrittenBits - previousWrittenBits);
+    previousWrittenBits = currentWrittenBits;
+  }
+  minCost = cost;
+  //doesn't need to store cabac status here since the whole CTU parameters will be re-encoded at the end of this function
+  for(Int typeIdc=0; typeIdc< NUM_SAO_NEW_TYPES; typeIdc++)
+  {
+    m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
     m_pcRDGoOnSbacCoder->resetBits();
+    m_pcEntropyCoder->encodeSaoOffset(&saoLcuParamRdo, yCbCr);
+    estRate = m_pcEntropyCoder->getNumberOfWrittenBits();
+    m_dCost[yCbCr][typeIdx] = (Double)((Double)estDist + lambda * (Double) estRate);
+    if(m_dCost[yCbCr][typeIdx] < dCostPartBest)
+    {
+      dCostPartBest = m_dCost[yCbCr][typeIdx];
+      copySaoUnit(saoLcuParam, &saoLcuParamRdo );
+      bestDist = estDist;
+    }
+  }
+  compDistortion[0] += ((Double)bestDist/lambda);
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+ m_pcEntropyCoder->encodeSaoOffset(saoLcuParam, yCbCr);
+  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[0][CI_TEMP_BEST] );
+  // merge left or merge up
+  for (Int idxNeighbor=0;idxNeighbor<2;idxNeighbor++)
+  {
+    saoLcuParamNeighbor = NULL;
+    if (allowMergeLeft && addrLeft>=0 && idxNeighbor ==0)
+    {
+      saoLcuParamNeighbor = &(saoParam->saoLcuParam[yCbCr][addrLeft]);
+    }
+    else if (allowMergeUp && addrUp>=0 && idxNeighbor ==1)
+    {
+      saoLcuParamNeighbor = &(saoParam->saoLcuParam[yCbCr][addrUp]);
+    }
+    if (saoLcuParamNeighbor!=NULL)
+    {
+      estDist = 0;
+      typeIdx = saoLcuParamNeighbor->typeIdx;
+      if (typeIdx>=0)
+      {
+        Int mergeBandPosition = (typeIdx == SAO_BO)?saoLcuParamNeighbor->subTypeIdx:0;
+        Int   merge_iOffset;
+        for(classIdx = 0; classIdx < m_iNumClass[typeIdx]; classIdx++)
+        {
+          merge_iOffset = saoLcuParamNeighbor->offset[classIdx];
+          estDist   += estSaoDist(m_iCount [yCbCr][typeIdx][classIdx+mergeBandPosition+1], merge_iOffset, m_iOffsetOrg[yCbCr][typeIdx][classIdx+mergeBandPosition+1],  shift);
+        }
+      }
+      else
+      {
+        estDist = 0;
+      }
+      copySaoUnit(&compSaoParam[idxNeighbor], saoLcuParamNeighbor );
+      compSaoParam[idxNeighbor].mergeUpFlag   = idxNeighbor;
+      compSaoParam[idxNeighbor].mergeLeftFlag = !idxNeighbor;
+      compDistortion[idxNeighbor+1] += ((Double)estDist/lambda);
+    }
+  }
+}
+Void TEncSampleAdaptiveOffset::sao2ChromaParamDist(Int allowMergeLeft, Int allowMergeUp, SAOParam *saoParam, Int addr, Int addrUp, Int addrLeft, Double lambda, SaoLcuParam *crSaoParam, SaoLcuParam *cbSaoParam, Double *distortion)
+{
+  Int typeIdx;
+  Int64 estDist[2];
+  Int classIdx;
+  Int shift = 2 * DISTORTION_PRECISION_ADJUSTMENT(g_bitDepthC-8);
+  Int64 bestDist = 0;
+  SaoLcuParam*  saoLcuParam[2] = {&(saoParam->saoLcuParam[1][addr]), &(saoParam->saoLcuParam[2][addr])};
+  SaoLcuParam*  saoLcuParamNeighbor[2] = {NULL, NULL};
+  SaoLcuParam*  saoMergeParam[2][2];
+  saoMergeParam[0][0] = &crSaoParam[0];
+  saoMergeParam[0][1] = &crSaoParam[1];
+  saoMergeParam[1][0] = &cbSaoParam[0];
+  saoMergeParam[1][1] = &cbSaoParam[1];
+  resetSaoUnit(saoLcuParam[0]);
+  resetSaoUnit(saoLcuParam[1]);
+  resetSaoUnit(saoMergeParam[0][0]);
+  resetSaoUnit(saoMergeParam[0][1]);
+  resetSaoUnit(saoMergeParam[1][0]);
+  resetSaoUnit(saoMergeParam[1][1]);
+  Double costPartBest = MAX_DOUBLE;
+  Double  bestRDCostTableBo;
+  Int     bestClassTableBo[2]    = {0, 0};
+  Int     currentDistortionTableBo[MAX_NUM_SAO_CLASS];
+  Double  currentRdCostTableBo[MAX_NUM_SAO_CLASS];
+  SaoLcuParam   saoLcuParamRdo[2];
+  Double   estRate = 0;
+  resetSaoUnit(&saoLcuParamRdo[0]);
+  resetSaoUnit(&saoLcuParamRdo[1]);
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+    previousWrittenBits = 0;
+    cost = 0;
+    for(compIdx= SAO_Cb; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+    {
+      if(!sliceEnabled[compIdx])
+      {
+        testOffset[compIdx].modeIdc = SAO_MODE_OFF;
+        dist[compIdx]= 0;
+        continue;
+      }
+      testOffset[compIdx].modeIdc = SAO_MODE_NEW;
+      testOffset[compIdx].typeIdc = typeIdc;
+      //derive offset & get distortion
+      deriveOffsets(ctu, compIdx, typeIdc, blkStats[ctu][compIdx][typeIdc], testOffset[compIdx].offset, testOffset[compIdx].typeAuxInfo);
+      invertQuantOffsets(compIdx, typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, testOffset[compIdx].offset);
+      dist[compIdx]= getDistortion(ctu, compIdx, typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, blkStats[ctu][compIdx][typeIdc]);
+      m_pcRDGoOnSbacCoder->codeSAOOffsetParam(compIdx, testOffset[compIdx], sliceEnabled[compIdx]);
+      const UInt currentWrittenBits = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
+      cost += dist[compIdx] + (m_lambda[compIdx] * (currentWrittenBits - previousWrittenBits));
+      previousWrittenBits = currentWrittenBits;
+    }
+    if(cost < minCost)
+    {
+      minCost = cost;
+      for(compIdx= SAO_Cb; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+      {
+        modeDist [compIdx] = dist      [compIdx];
+        modeParam[compIdx] = testOffset[compIdx];
+      }
+    }
+  }
+  //----- re-gen rate & normalized cost----//
+  modeNormCost = 0;
+  for(UInt component = SAO_Y; component < NUM_SAO_COMPONENTS; component++)
+  {
+    modeNormCost += (Double)modeDist[component] / m_lambda[component];
+  }
+  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
   m_pcRDGoOnSbacCoder->resetBits();
+  m_pcEntropyCoder->encodeSaoOffset(&saoLcuParamRdo[0], 1);
+  m_pcEntropyCoder->encodeSaoOffset(&saoLcuParamRdo[1], 2);
+  costPartBest = m_pcEntropyCoder->getNumberOfWrittenBits()*lambda ;
+  copySaoUnit(saoLcuParam[0], &saoLcuParamRdo[0] );
+  copySaoUnit(saoLcuParam[1], &saoLcuParamRdo[1] );
+  for (typeIdx=0; typeIdx<MAX_NUM_SAO_TYPE; typeIdx++)
+  {
+    if( typeIdx == SAO_BO )
+    {
+      // Estimate Best Position
+      for(Int compIdx = 0; compIdx < 2; compIdx++)
+      {
+        Double currentRDCost = 0.0;
+        bestRDCostTableBo = MAX_DOUBLE;
+        estDist[compIdx] = estSaoTypeDist(compIdx+1, typeIdx, shift, lambda, currentDistortionTableBo, currentRdCostTableBo);
+        for(Int i=0; i< SAO_MAX_BO_CLASSES -SAO_BO_LEN +1; i++)
+        {
+          currentRDCost = 0.0;
+          for(UInt uj = i; uj < i+SAO_BO_LEN; uj++)
+  m_pcRDGoOnSbacCoder->codeSAOBlkParam(modeParam, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), false);
+  modeNormCost += (Double)m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
+}
+Void TEncSampleAdaptiveOffset::deriveModeMergeRDO(Int ctu, std::vector<SAOBlkParam*>& mergeList, Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel)
+{
+  Int mergeListSize = (Int)mergeList.size();
+  modeNormCost = MAX_DOUBLE;
+  Double cost;
+  SAOBlkParam testBlkParam;
+  for(Int mergeType=0; mergeType< mergeListSize; mergeType++)
+  {
+    if(mergeList[mergeType] == NULL)
+    {
+      continue;
+    }
+    testBlkParam = *(mergeList[mergeType]);
+    //normalized distortion
+    Double normDist=0;
+    for(Int compIdx=0; compIdx< NUM_SAO_COMPONENTS; compIdx++)
+    {
+      testBlkParam[compIdx].modeIdc = SAO_MODE_MERGE;
+      testBlkParam[compIdx].typeIdc = mergeType;
+      SAOOffset& mergedOffsetParam = (*(mergeList[mergeType]))[compIdx];
+      if( mergedOffsetParam.modeIdc != SAO_MODE_OFF)
+      {
+        //offsets have been reconstructed. Don't call inversed quantization function.
+        normDist += (((Double)getDistortion(ctu, compIdx, mergedOffsetParam.typeIdc, mergedOffsetParam.typeAuxInfo, mergedOffsetParam.offset, blkStats[ctu][compIdx][mergedOffsetParam.typeIdc]))
+                       /m_lambda[compIdx]
+                    );
+      }
+    }
+    //rate
+    m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
+    m_pcRDGoOnSbacCoder->resetBits();
+    m_pcRDGoOnSbacCoder->codeSAOBlkParam(testBlkParam, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), false);
+    Int rate = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
+    cost = normDist+(Double)rate;
+    if(cost < modeNormCost)
+    {
+      modeNormCost = cost;
+      modeParam    = testBlkParam;
+      m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
+    }
+  }
+  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
+}
+Void TEncSampleAdaptiveOffset::decideBlkParams(TComPic* pic, Bool* sliceEnabled, SAOStatData*** blkStats, TComPicYuv* srcYuv, TComPicYuv* resYuv, SAOBlkParam* reconParams, SAOBlkParam* codedParams)
+{
+  Bool isAllBlksDisabled = false;
+  if(!sliceEnabled[SAO_Y] && !sliceEnabled[SAO_Cb] && !sliceEnabled[SAO_Cr])
+  {
+    isAllBlksDisabled = true;
+  }
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[ SAO_CABACSTATE_PIC_INIT ]);
+  SAOBlkParam modeParam;
+  Double minCost, modeCost;
+  for(Int ctu=0; ctu< m_numCTUsPic; ctu++)
+  {
+    if(isAllBlksDisabled)
+    {
+      codedParams[ctu].reset();
+      continue;
+    }
+    m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_CUR ]);
+    //get merge list
+    std::vector<SAOBlkParam*> mergeList;
+    getMergeList(pic, ctu, reconParams, mergeList);
+    minCost = MAX_DOUBLE;
+    for(Int mode=0; mode < NUM_SAO_MODES; mode++)
+    {
+      switch(mode)
+      {
+      case SAO_MODE_OFF:
+        {
+          continue; //not necessary, since all-off case will be tested in SAO_MODE_NEW case.
+        }
+        break;
+      case SAO_MODE_NEW:
+        {
+          deriveModeNewRDO(ctu, mergeList, sliceEnabled, blkStats, modeParam, modeCost, m_pppcRDSbacCoder, SAO_CABACSTATE_BLK_CUR);
+        }
+        break;
+      case SAO_MODE_MERGE:
+        {
+          deriveModeMergeRDO(ctu, mergeList, sliceEnabled, blkStats , modeParam, modeCost, m_pppcRDSbacCoder, SAO_CABACSTATE_BLK_CUR);
+        }
+        break;
+      default:
+        {
+          printf("Not a supported SAO mode\n");
+          assert(0);
+          exit(-1);
+        }
+      }
+      if(modeCost < minCost)
+      {
+        minCost = modeCost;
+        codedParams[ctu] = modeParam;
+        m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_NEXT ]);
+      }
+    } //mode
+    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_NEXT ]);
+    //apply reconstructed offsets
+    reconParams[ctu] = codedParams[ctu];
+    reconstructBlkSAOParam(reconParams[ctu], mergeList);
+    offsetCTU(ctu, srcYuv, resYuv, reconParams[ctu], pic);
+  } //ctu
+#if SAO_ENCODING_CHOICE
+  Int picTempLayer = pic->getSlice(0)->getDepth();
+  Int numLcusForSAOOff[NUM_SAO_COMPONENTS];
+  numLcusForSAOOff[SAO_Y ] = numLcusForSAOOff[SAO_Cb]= numLcusForSAOOff[SAO_Cr]= 0;
+  for (Int compIdx=0; compIdx<NUM_SAO_COMPONENTS; compIdx++)
+  {
+    for(Int ctu=0; ctu< m_numCTUsPic; ctu++)
+    {
+      if( reconParams[ctu][compIdx].modeIdc == SAO_MODE_OFF)
+      {
+        numLcusForSAOOff[compIdx]++;
+      }
+    }
+  }
+#if SAO_ENCODING_CHOICE_CHROMA
+  for (Int compIdx=0; compIdx<NUM_SAO_COMPONENTS; compIdx++)
+  {
+    m_saoDisabledRate[compIdx][picTempLayer] = (Double)numLcusForSAOOff[compIdx]/(Double)m_numCTUsPic;
+  }
+#else
+  if (picTempLayer == 0)
+  {
+    m_saoDisabledRate[SAO_Y][0] = (Double)(numLcusForSAOOff[SAO_Y]+numLcusForSAOOff[SAO_Cb]+numLcusForSAOOff[SAO_Cr])/(Double)(m_numCTUsPic*3);
+  }
+#endif
+#endif
+}
+Void TEncSampleAdaptiveOffset::getBlkStats(Int compIdx, SAOStatData* statsDataTypes
+                        , Pel* srcBlk, Pel* orgBlk, Int srcStride, Int orgStride, Int width, Int height
+                        , Bool isLeftAvail,  Bool isRightAvail, Bool isAboveAvail, Bool isBelowAvail, Bool isAboveLeftAvail, Bool isAboveRightAvail, Bool isBelowLeftAvail, Bool isBelowRightAvail
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                        , Bool isCalculatePreDeblockSamples
+#endif
+                        )
+{
+  if(m_lineBufWidth != m_maxCUWidth)
+  {
+    m_lineBufWidth = m_maxCUWidth;
+    if (m_signLineBuf1) delete[] m_signLineBuf1; m_signLineBuf1 = NULL;
+    m_signLineBuf1 = new Char[m_lineBufWidth+1];
+    if (m_signLineBuf2) delete[] m_signLineBuf2; m_signLineBuf2 = NULL;
+    m_signLineBuf2 = new Char[m_lineBufWidth+1];
+  }
+  Int x,y, startX, startY, endX, endY, edgeType, firstLineStartX, firstLineEndX;
+  Char signLeft, signRight, signDown;
+  Int64 *diff, *count;
+  Pel *srcLine, *orgLine;
+  Int* skipLinesR = m_skipLinesR[compIdx];
+  Int* skipLinesB = m_skipLinesB[compIdx];
+  for(Int typeIdx=0; typeIdx< NUM_SAO_NEW_TYPES; typeIdx++)
+  {
+    SAOStatData& statsData= statsDataTypes[typeIdx];
+    statsData.reset();
+    srcLine = srcBlk;
+    orgLine = orgBlk;
+    diff    = statsData.diff;
+    count   = statsData.count;
+    switch(typeIdx)
+    {
+    case SAO_TYPE_EO_0:
+      {
+        diff +=2;
+        count+=2;
+        endY   = (isBelowAvail) ? (height - skipLinesB[typeIdx]) : height;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
+                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
+                                                 ;
+#else
+        startX = isLeftAvail ? 0 : 1;
+#endif
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
+                                                 : (isRightAvail ? width : (width - 1))
+                                                 ;
+#else
+        endX   = isRightAvail ? (width - skipLinesR[typeIdx]): (width - 1);
+#endif
+        for (y=0; y<endY; y++)
+        {
+          signLeft = (Char)m_sign[srcLine[startX] - srcLine[startX-1]];
+          for (x=startX; x<endX; x++)
+          {
+            currentRDCost += currentRdCostTableBo[uj];
+            signRight =  (Char)m_sign[srcLine[x] - srcLine[x+1]];
+            edgeType  =  signRight + signLeft;
+            signLeft  = -signRight;
+            diff [edgeType] += (orgLine[x] - srcLine[x]);
+            count[edgeType] ++;
+          }
+          if( currentRDCost < bestRDCostTableBo)
+          srcLine  += srcStride;
+          orgLine  += orgStride;
+        }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        if(isCalculatePreDeblockSamples)
+        {
+          if(isBelowAvail)
+          {
+            bestRDCostTableBo = currentRDCost;
+            bestClassTableBo[compIdx]  = i;
+            startX = isLeftAvail  ? 0 : 1;
+            endX   = isRightAvail ? width : (width -1);
+            for(y=0; y<skipLinesB[typeIdx]; y++)
+            {
+              signLeft = (Char)m_sign[srcLine[startX] - srcLine[startX-1]];
+              for (x=startX; x<endX; x++)
+              {
+                signRight =  (Char)m_sign[srcLine[x] - srcLine[x+1]];
+                edgeType  =  signRight + signLeft;
+                signLeft  = -signRight;
+                diff [edgeType] += (orgLine[x] - srcLine[x]);
+                count[edgeType] ++;
+              }
+              srcLine  += srcStride;
+              orgLine  += orgStride;
+            }
+          }
+        }
+        // Re code all Offsets
+        // Code Center
+        estDist[compIdx] = 0;
+        for(classIdx = bestClassTableBo[compIdx]; classIdx < bestClassTableBo[compIdx]+SAO_BO_LEN; classIdx++)
+        {
+          estDist[compIdx] += currentDistortionTableBo[classIdx];
+        }
+      }
+    }
+    else
+    {
+      estDist[0] = estSaoTypeDist(1, typeIdx, shift, lambda, currentDistortionTableBo, currentRdCostTableBo);
+      estDist[1] = estSaoTypeDist(2, typeIdx, shift, lambda, currentDistortionTableBo, currentRdCostTableBo);
+    }
+    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+    m_pcRDGoOnSbacCoder->resetBits();
+    for(Int compIdx = 0; compIdx < 2; compIdx++)
+    {
+      resetSaoUnit(&saoLcuParamRdo[compIdx]);
+      saoLcuParamRdo[compIdx].length = m_iNumClass[typeIdx];
+      saoLcuParamRdo[compIdx].typeIdx = typeIdx;
+      saoLcuParamRdo[compIdx].mergeLeftFlag = 0;
+      saoLcuParamRdo[compIdx].mergeUpFlag   = 0;
+      saoLcuParamRdo[compIdx].subTypeIdx = (typeIdx == SAO_BO) ? bestClassTableBo[compIdx] : 0;
+      for (classIdx = 0; classIdx < saoLcuParamRdo[compIdx].length; classIdx++)
+      {
+        saoLcuParamRdo[compIdx].offset[classIdx] = (Int)m_iOffset[compIdx+1][typeIdx][classIdx+saoLcuParamRdo[compIdx].subTypeIdx+1];
+      }
+      m_pcEntropyCoder->encodeSaoOffset(&saoLcuParamRdo[compIdx], compIdx+1);
+    }
+    estRate = m_pcEntropyCoder->getNumberOfWrittenBits();
+    m_dCost[1][typeIdx] = (Double)((Double)(estDist[0] + estDist[1])  + lambda * (Double) estRate);
+    if(m_dCost[1][typeIdx] < costPartBest)
+    {
+      costPartBest = m_dCost[1][typeIdx];
+      copySaoUnit(saoLcuParam[0], &saoLcuParamRdo[0] );
+      copySaoUnit(saoLcuParam[1], &saoLcuParamRdo[1] );
+      bestDist = (estDist[0]+estDist[1]);
+    }
+  }
+  distortion[0] += ((Double)bestDist/lambda);
+  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[0][CI_TEMP_BEST]);
+  m_pcEntropyCoder->encodeSaoOffset(saoLcuParam[0], 1);
+  m_pcEntropyCoder->encodeSaoOffset(saoLcuParam[1], 2);
+  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[0][CI_TEMP_BEST] );
+  // merge left or merge up
+  for (Int idxNeighbor=0;idxNeighbor<2;idxNeighbor++)
+  {
+    for(Int compIdx = 0; compIdx < 2; compIdx++)
+    {
+      saoLcuParamNeighbor[compIdx] = NULL;
+      if (allowMergeLeft && addrLeft>=0 && idxNeighbor ==0)
+      {
+        saoLcuParamNeighbor[compIdx] = &(saoParam->saoLcuParam[compIdx+1][addrLeft]);
+      }
+      else if (allowMergeUp && addrUp>=0 && idxNeighbor ==1)
+      {
+        saoLcuParamNeighbor[compIdx] = &(saoParam->saoLcuParam[compIdx+1][addrUp]);
+      }
+      if (saoLcuParamNeighbor[compIdx]!=NULL)
+      {
+        estDist[compIdx] = 0;
+        typeIdx = saoLcuParamNeighbor[compIdx]->typeIdx;
+        if (typeIdx>=0)
+        {
+          Int mergeBandPosition = (typeIdx == SAO_BO)?saoLcuParamNeighbor[compIdx]->subTypeIdx:0;
+          Int   merge_iOffset;
+          for(classIdx = 0; classIdx < m_iNumClass[typeIdx]; classIdx++)
+#endif
+      }
+      break;
+    case SAO_TYPE_EO_90:
+      {
+        diff +=2;
+        count+=2;
+        Char *signUpLine = m_signLineBuf1;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        startX = (!isCalculatePreDeblockSamples) ? 0
+                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : width)
+                                                 ;
+#endif
+        startY = isAboveAvail ? 0 : 1;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : width)
+                                                 : width
+                                                 ;
+#else
+        endX   = isRightAvail ? (width - skipLinesR[typeIdx]) : width ;
+#endif
+        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
+        if (!isAboveAvail)
+        {
+          srcLine += srcStride;
+          orgLine += orgStride;
+        }
+        Pel* srcLineAbove = srcLine - srcStride;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        for (x=startX; x<endX; x++)
+#else
+        for (x=0; x< endX; x++)
+#endif
+        {
+          signUpLine[x] = (Char)m_sign[srcLine[x] - srcLineAbove[x]];
+        }
+        Pel* srcLineBelow;
+        for (y=startY; y<endY; y++)
+        {
+          srcLineBelow = srcLine + srcStride;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+          for (x=startX; x<endX; x++)
+#else
+          for (x=0; x<endX; x++)
+#endif
+          {
+            merge_iOffset = saoLcuParamNeighbor[compIdx]->offset[classIdx];
+            estDist[compIdx]   += estSaoDist(m_iCount [compIdx+1][typeIdx][classIdx+mergeBandPosition+1], merge_iOffset, m_iOffsetOrg[compIdx+1][typeIdx][classIdx+mergeBandPosition+1],  shift);
+            signDown  = (Char)m_sign[srcLine[x] - srcLineBelow[x]];
+            edgeType  = signDown + signUpLine[x];
+            signUpLine[x]= -signDown;
+            diff [edgeType] += (orgLine[x] - srcLine[x]);
+            count[edgeType] ++;
+          }
+        }
+        else
+        {
+          estDist[compIdx] = 0;
+        }
+        copySaoUnit(saoMergeParam[compIdx][idxNeighbor], saoLcuParamNeighbor[compIdx] );
+        saoMergeParam[compIdx][idxNeighbor]->mergeUpFlag   = idxNeighbor;
+        saoMergeParam[compIdx][idxNeighbor]->mergeLeftFlag = !idxNeighbor;
+        distortion[idxNeighbor+1] += ((Double)estDist[compIdx]/lambda);
+      }
+    }
+  }
+          srcLine += srcStride;
+          orgLine += orgStride;
+        }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        if(isCalculatePreDeblockSamples)
+        {
+          if(isBelowAvail)
+          {
+            startX = 0;
+            endX   = width;
+            for(y=0; y<skipLinesB[typeIdx]; y++)
+            {
+              srcLineBelow = srcLine + srcStride;
+              srcLineAbove = srcLine - srcStride;
+              for (x=startX; x<endX; x++)
+              {
+                edgeType = m_sign[srcLine[x] - srcLineBelow[x]] + m_sign[srcLine[x] - srcLineAbove[x]];
+                diff [edgeType] += (orgLine[x] - srcLine[x]);
+                count[edgeType] ++;
+              }
+              srcLine  += srcStride;
+              orgLine  += orgStride;
+            }
+          }
+        }
+#endif
+      }
+      break;
+    case SAO_TYPE_EO_135:
+      {
+        diff +=2;
+        count+=2;
+        Char *signUpLine, *signDownLine, *signTmpLine;
+        signUpLine  = m_signLineBuf1;
+        signDownLine= m_signLineBuf2;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
+                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
+                                                 ;
+#else
+        startX = isLeftAvail ? 0 : 1 ;
+#endif
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]): (width - 1))
+                                                 : (isRightAvail ? width : (width - 1))
+                                                 ;
+#else
+        endX   = isRightAvail ? (width - skipLinesR[typeIdx]): (width - 1);
+#endif
+        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
+        //prepare 2nd line's upper sign
+        Pel* srcLineBelow = srcLine + srcStride;
+        for (x=startX; x<endX+1; x++)
+        {
+          signUpLine[x] = (Char)m_sign[srcLineBelow[x] - srcLine[x-1]];
+        }
+        //1st line
+        Pel* srcLineAbove = srcLine - srcStride;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        firstLineStartX = (!isCalculatePreDeblockSamples) ? (isAboveLeftAvail ? 0    : 1) : startX;
+        firstLineEndX   = (!isCalculatePreDeblockSamples) ? (isAboveAvail     ? endX : 1) : endX;
+#else
+        firstLineStartX = isAboveLeftAvail ? 0    : 1;
+        firstLineEndX   = isAboveAvail     ? endX : 1;
+#endif
+        for(x=firstLineStartX; x<firstLineEndX; x++)
+        {
+          edgeType = m_sign[srcLine[x] - srcLineAbove[x-1]] - signUpLine[x+1];
+          diff [edgeType] += (orgLine[x] - srcLine[x]);
+          count[edgeType] ++;
+        }
+        srcLine  += srcStride;
+        orgLine  += orgStride;
+        //middle lines
+        for (y=1; y<endY; y++)
+        {
+          srcLineBelow = srcLine + srcStride;
+          for (x=startX; x<endX; x++)
+          {
+            signDown = (Char)m_sign[srcLine[x] - srcLineBelow[x+1]] ;
+            edgeType = signDown + signUpLine[x];
+            diff [edgeType] += (orgLine[x] - srcLine[x]);
+            count[edgeType] ++;
+            signDownLine[x+1] = -signDown;
+          }
+          signDownLine[startX] = (Char)m_sign[srcLineBelow[startX] - srcLine[startX-1]];
+          signTmpLine  = signUpLine;
+          signUpLine   = signDownLine;
+          signDownLine = signTmpLine;
+          srcLine += srcStride;
+          orgLine += orgStride;
+        }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        if(isCalculatePreDeblockSamples)
+        {
+          if(isBelowAvail)
+          {
+            startX = isLeftAvail  ? 0     : 1 ;
+            endX   = isRightAvail ? width : (width -1);
+            for(y=0; y<skipLinesB[typeIdx]; y++)
+            {
+              srcLineBelow = srcLine + srcStride;
+              srcLineAbove = srcLine - srcStride;
+              for (x=startX; x< endX; x++)
+              {
+                edgeType = m_sign[srcLine[x] - srcLineBelow[x+1]] + m_sign[srcLine[x] - srcLineAbove[x-1]];
+                diff [edgeType] += (orgLine[x] - srcLine[x]);
+                count[edgeType] ++;
+              }
+              srcLine  += srcStride;
+              orgLine  += orgStride;
+            }
+          }
+        }
+#endif
+      }
+      break;
+    case SAO_TYPE_EO_45:
+      {
+        diff +=2;
+        count+=2;
+        Char *signUpLine = m_signLineBuf1+1;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
+                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
+                                                 ;
+#else
+        startX = isLeftAvail ? 0 : 1;
+#endif
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
+                                                 : (isRightAvail ? width : (width - 1))
+                                                 ;
+#else
+        endX   = isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1);
+#endif
+        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
+        //prepare 2nd line upper sign
+        Pel* srcLineBelow = srcLine + srcStride;
+        for (x=startX-1; x<endX; x++)
+        {
+          signUpLine[x] = (Char)m_sign[srcLineBelow[x] - srcLine[x+1]];
+        }
+        //first line
+        Pel* srcLineAbove = srcLine - srcStride;
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        firstLineStartX = (!isCalculatePreDeblockSamples) ? (isAboveAvail ? startX : endX)
+                                                          : startX
+                                                          ;
+        firstLineEndX   = (!isCalculatePreDeblockSamples) ? ((!isRightAvail && isAboveRightAvail) ? width : endX)
+                                                          : endX
+                                                          ;
+#else
+        firstLineStartX = isAboveAvail ? startX : endX;
+        firstLineEndX   = (!isRightAvail && isAboveRightAvail) ? width : endX;
+#endif
+        for(x=firstLineStartX; x<firstLineEndX; x++)
+        {
+          edgeType = m_sign[srcLine[x] - srcLineAbove[x+1]] - signUpLine[x-1];
+          diff [edgeType] += (orgLine[x] - srcLine[x]);
+          count[edgeType] ++;
+        }
+        srcLine += srcStride;
+        orgLine += orgStride;
+        //middle lines
+        for (y=1; y<endY; y++)
+        {
+          srcLineBelow = srcLine + srcStride;
+          for(x=startX; x<endX; x++)
+          {
+            signDown = (Char)m_sign[srcLine[x] - srcLineBelow[x-1]] ;
+            edgeType = signDown + signUpLine[x];
+            diff [edgeType] += (orgLine[x] - srcLine[x]);
+            count[edgeType] ++;
+            signUpLine[x-1] = -signDown;
+          }
+          signUpLine[endX-1] = (Char)m_sign[srcLineBelow[endX-1] - srcLine[endX]];
+          srcLine  += srcStride;
+          orgLine  += orgStride;
+        }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        if(isCalculatePreDeblockSamples)
+        {
+          if(isBelowAvail)
+          {
+            startX = isLeftAvail  ? 0     : 1 ;
+            endX   = isRightAvail ? width : (width -1);
+            for(y=0; y<skipLinesB[typeIdx]; y++)
+            {
+              srcLineBelow = srcLine + srcStride;
+              srcLineAbove = srcLine - srcStride;
+              for (x=startX; x<endX; x++)
+              {
+                edgeType = m_sign[srcLine[x] - srcLineBelow[x-1]] + m_sign[srcLine[x] - srcLineAbove[x+1]];
+                diff [edgeType] += (orgLine[x] - srcLine[x]);
+                count[edgeType] ++;
+              }
+              srcLine  += srcStride;
+              orgLine  += orgStride;
+            }
+          }
+        }
+#endif
+      }
+      break;
+    case SAO_TYPE_BO:
+      {
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        startX = (!isCalculatePreDeblockSamples)?0
+                                                :( isRightAvail?(width- skipLinesR[typeIdx]):width)
+                                                ;
+        endX   = (!isCalculatePreDeblockSamples)?(isRightAvail ? (width - skipLinesR[typeIdx]) : width )
+                                                :width
+                                                ;
+#else
+        endX = isRightAvail ? (width- skipLinesR[typeIdx]) : width;
+#endif
+        endY = isBelowAvail ? (height- skipLinesB[typeIdx]) : height;
+        Int shiftBits = ((compIdx == SAO_Y)?g_bitDepthY:g_bitDepthC)- NUM_SAO_BO_CLASSES_LOG2;
+        for (y=0; y< endY; y++)
+        {
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+          for (x=startX; x< endX; x++)
+#else
+          for (x=0; x< endX; x++)
+#endif
+          {
+            Int bandIdx= srcLine[x] >> shiftBits;
+            diff [bandIdx] += (orgLine[x] - srcLine[x]);
+            count[bandIdx] ++;
+          }
+          srcLine += srcStride;
+          orgLine += orgStride;
+        }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+        if(isCalculatePreDeblockSamples)
+        {
+          if(isBelowAvail)
+          {
+            startX = 0;
+            endX   = width;
+            for(y= 0; y< skipLinesB[typeIdx]; y++)
+            {
+              for (x=startX; x< endX; x++)
+              {
+                Int bandIdx= srcLine[x] >> shiftBits;
+                diff [bandIdx] += (orgLine[x] - srcLine[x]);
+                count[bandIdx] ++;
+              }
+              srcLine  += srcStride;
+              orgLine  += orgStride;
+            }
+          }
+        }
+#endif
+      }
+      break;
+    default:
+      {
+        printf("Not a supported SAO types\n");
+        assert(0);
+        exit(-1);
+      }
+    }
+  }
+}

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.h

-                      r608
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+ * Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 // ====================================================================================================================
+enum SAOCabacStateLablesRDO //CABAC state labels
+{
+  SAO_CABACSTATE_PIC_INIT =0,
+  SAO_CABACSTATE_BLK_CUR,
+  SAO_CABACSTATE_BLK_NEXT,
+  SAO_CABACSTATE_BLK_MID,
+  SAO_CABACSTATE_BLK_TEMP,
+  NUM_SAO_CABACSTATE_LABELS
+};
+struct SAOStatData //data structure for SAO statistics
+{
+  Int64 diff[MAX_NUM_SAO_CLASSES];
+  Int64 count[MAX_NUM_SAO_CLASSES];
+  SAOStatData(){}
+  ~SAOStatData(){}
+  Void reset()
+  {
+    ::memset(diff, 0, sizeof(Int64)*MAX_NUM_SAO_CLASSES);
+    ::memset(count, 0, sizeof(Int64)*MAX_NUM_SAO_CLASSES);
+  }
+  const SAOStatData& operator=(const SAOStatData& src)
+  {
+    ::memcpy(diff, src.diff, sizeof(Int64)*MAX_NUM_SAO_CLASSES);
+    ::memcpy(count, src.count, sizeof(Int64)*MAX_NUM_SAO_CLASSES);
+    return *this;
+  }
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  const SAOStatData& operator+= (const SAOStatData& src)
+  {
+    for(Int i=0; i< MAX_NUM_SAO_CLASSES; i++)
+    {
+      diff[i] += src.diff[i];
+      count[i] += src.count[i];
+    }
+    return *this;
+  }
+#endif
+};
 class TEncSampleAdaptiveOffset : public TComSampleAdaptiveOffset
+{
-private:
-  TEncEntropy*      m_pcEntropyCoder;
-  TEncSbac***       m_pppcRDSbacCoder;              ///< for CABAC
-  TEncSbac*         m_pcRDGoOnSbacCoder;
-#if FAST_BIT_EST
-  TEncBinCABACCounter*** m_pppcBinCoderCABAC;            ///< temporal CABAC state storage for RD computation
-#else
-  TEncBinCABAC***   m_pppcBinCoderCABAC;            ///< temporal CABAC state storage for RD computation
-#endif
-  Int64  ***m_iCount;      //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE][MAX_NUM_SAO_CLASS];
-  Int64  ***m_iOffset;     //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE][MAX_NUM_SAO_CLASS];
-  Int64  ***m_iOffsetOrg;  //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE];
-  Int64  ****m_count_PreDblk;      //[LCU][YCbCr][MAX_NUM_SAO_TYPE][MAX_NUM_SAO_CLASS];
-  Int64  ****m_offsetOrg_PreDblk;  //[LCU][YCbCr][MAX_NUM_SAO_TYPE][MAX_NUM_SAO_CLASS];
-  Int64  **m_iRate;        //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE];
-  Int64  **m_iDist;        //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE];
-  Double **m_dCost;        //[MAX_NUM_SAO_PART][MAX_NUM_SAO_TYPE];
-  Double *m_dCostPartBest; //[MAX_NUM_SAO_PART];
-  Int64  *m_iDistOrg;      //[MAX_NUM_SAO_PART];
-  Int    *m_iTypePartBest; //[MAX_NUM_SAO_PART];
-  Int     m_iOffsetThY;
-  Int     m_iOffsetThC;
-  Bool    m_bUseSBACRD;
-#if SAO_ENCODING_CHOICE
-#if SAO_ENCODING_CHOICE_CHROMA
-  Double  m_depthSaoRate[2][4];
-#else
-  Double  m_depth0SaoRate;
-#endif
-#endif
 public:
   TEncSampleAdaptiveOffset         ();
+  TEncSampleAdaptiveOffset();
   virtual ~TEncSampleAdaptiveOffset();
+  Void startSaoEnc( TComPic* pcPic, TEncEntropy* pcEntropyCoder, TEncSbac*** pppcRDSbacCoder, TEncSbac* pcRDGoOnSbacCoder);
+  Void endSaoEnc();
+  Void resetStats();
+#if SAO_CHROMA_LAMBDA
+  //interface
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  Void createEncData(Bool isPreDBFSamplesUsed);
+#else
+  Void createEncData();
+#endif
+  Void destroyEncData();
+  Void initRDOCabacCoder(TEncSbac* pcRDGoOnSbacCoder, TComSlice* pcSlice) ;
+  Void SAOProcess(TComPic* pPic, Bool* sliceEnabled, const Double *lambdas
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                , Bool isPreDBFSamplesUsed
+#endif
+                );
+public: //methods
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  Void getPreDBFStatistics(TComPic* pPic);
+#endif
+private: //methods
+  Void getStatistics(SAOStatData*** blkStats, TComPicYuv* orgYuv, TComPicYuv* srcYuv,TComPic* pPic
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                   , Bool isCalculatePreDeblockSamples = false
+#endif
+                   );
+  Void decidePicParams(Bool* sliceEnabled, Int picTempLayer);
+  Void decideBlkParams(TComPic* pic, Bool* sliceEnabled, SAOStatData*** blkStats, TComPicYuv* srcYuv, TComPicYuv* resYuv, SAOBlkParam* reconParams, SAOBlkParam* codedParams);
+  Void getBlkStats(Int compIdx, SAOStatData* statsDataTypes, Pel* srcBlk, Pel* orgBlk, Int srcStride, Int orgStride, Int width, Int height, Bool isLeftAvail,  Bool isRightAvail, Bool isAboveAvail, Bool isBelowAvail, Bool isAboveLeftAvail, Bool isAboveRightAvail, Bool isBelowLeftAvail, Bool isBelowRightAvail
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+                  , Bool isCalculatePreDeblockSamples
+#endif
+                  );
+  Void deriveModeNewRDO(Int ctu, std::vector<SAOBlkParam*>& mergeList, Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel);
+  Void deriveModeMergeRDO(Int ctu, std::vector<SAOBlkParam*>& mergeList, Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel);
+  Int64 getDistortion(Int ctu, Int compIdx, Int typeIdc, Int typeAuxInfo, Int* offsetVal, SAOStatData& statData);
+  Void deriveOffsets(Int ctu, Int compIdx, Int typeIdc, SAOStatData& statData, Int* quantOffsets, Int& typeAuxInfo);
+  inline Int64 estSaoDist(Int64 count, Int64 offset, Int64 diffSum, Int shift);
+  inline Int estIterOffset(Int typeIdx, Int classIdx, Double lambda, Int offsetInput, Int64 count, Int64 diffSum, Int shift, Int bitIncrease, Int64& bestDist, Double& bestCost, Int offsetTh );
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  Void addPreDBFStatistics(SAOStatData*** blkStats);
+#endif
+private: //members
+  //for RDO
+  TEncSbac**             m_pppcRDSbacCoder;
+  TEncSbac*              m_pcRDGoOnSbacCoder;
+  TEncBinCABACCounter**  m_pppcBinCoderCABAC;
+  Double                 m_lambda[NUM_SAO_COMPONENTS];
+  //statistics
+  SAOStatData***         m_statData; //[ctu][comp][classes]
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+  SAOStatData***         m_preDBFstatData;
+#endif
 #if SAO_ENCODING_CHOICE
+  Void SAOProcess(SAOParam *pcSaoParam, Double dLambda, Double dLambdaChroma, Int depth);
+#else
+  Void SAOProcess(SAOParam *pcSaoParam, Double dLambda, Double dLambdaChroma);
+  Double                 m_saoDisabledRate[NUM_SAO_COMPONENTS][MAX_TLAYER];
 #endif
+#else
+  Void SAOProcess(SAOParam *pcSaoParam, Double dLambda);
+#endif
+  Void runQuadTreeDecision(SAOQTPart *psQTPart, Int iPartIdx, Double &dCostFinal, Int iMaxLevel, Double dLambda, Int yCbCr);
+  Void rdoSaoOnePart(SAOQTPart *psQTPart, Int iPartIdx, Double dLambda, Int yCbCr);
+  Void disablePartTree(SAOQTPart *psQTPart, Int iPartIdx);
+  Void getSaoStats(SAOQTPart *psQTPart, Int iYCbCr);
+  Void calcSaoStatsCu(Int iAddr, Int iPartIdx, Int iYCbCr);
+  Void calcSaoStatsBlock( Pel* pRecStart, Pel* pOrgStart, Int stride, Int64** ppStats, Int64** ppCount, UInt width, UInt height, Bool* pbBorderAvail, Int iYCbCr);
+  Void calcSaoStatsCuOrg(Int iAddr, Int iPartIdx, Int iYCbCr);
+  Void calcSaoStatsCu_BeforeDblk( TComPic* pcPic );
+  Void destroyEncBuffer();
+  Void createEncBuffer();
+  Void assignSaoUnitSyntax(SaoLcuParam* saoLcuParam,  SAOQTPart* saoPart, Bool &oneUnitFlag, Int yCbCr);
+  Void checkMerge(SaoLcuParam * lcuParamCurr,SaoLcuParam * lcuParamCheck, Int dir);
+#if SAO_ENCODING_CHOICE
+  Void rdoSaoUnitAll(SAOParam *saoParam, Double lambda, Double lambdaChroma, Int depth);
+#else
+  Void rdoSaoUnitAll(SAOParam *saoParam, Double lambda, Double lambdaChroma);
+#endif
+  Void saoComponentParamDist(Int allowMergeLeft, Int allowMergeUp, SAOParam *saoParam, Int addr, Int addrUp, Int addrLeft, Int yCbCr, Double lambda, SaoLcuParam *compSaoParam, Double *distortion);
+  Void sao2ChromaParamDist(Int allowMergeLeft, Int allowMergeUp, SAOParam *saoParam, Int addr, Int addrUp, Int addrLeft, Double lambda, SaoLcuParam *crSaoParam, SaoLcuParam *cbSaoParam, Double *distortion);
+  inline Int64 estSaoDist(Int64 count, Int64 offset, Int64 offsetOrg, Int shift);
+  inline Int64 estIterOffset(Int typeIdx, Int classIdx, Double lambda, Int64 offsetInput, Int64 count, Int64 offsetOrg, Int shift, Int bitIncrease, Int *currentDistortionTableBo, Double *currentRdCostTableBo, Int offsetTh );
+  inline Int64 estSaoTypeDist(Int compIdx, Int typeIdx, Int shift, Double lambda, Int *currentDistortionTableBo, Double *currentRdCostTableBo);
+  Void setMaxNumOffsetsPerPic(Int iVal) {m_maxNumOffsetsPerPic = iVal; }
+  Int  getMaxNumOffsetsPerPic() {return m_maxNumOffsetsPerPic; }
+  Int                    m_skipLinesR[NUM_SAO_COMPONENTS][NUM_SAO_NEW_TYPES];
+  Int                    m_skipLinesB[NUM_SAO_COMPONENTS][NUM_SAO_NEW_TYPES];
 };
 //! \}

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSbac.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
 , m_cCUAbsSCModel             ( 1,             1,               NUM_ABS_FLAG_CTX              , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cMVPIdxSCModel            ( 1,             1,               NUM_MVP_IDX_CTX               , m_contextModels + m_numContextModels, m_numContextModels)
-, m_cCUAMPSCModel             ( 1,             1,               NUM_CU_AMP_CTX                , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoMergeSCModel          ( 1,             1,               NUM_SAO_MERGE_FLAG_CTX   , m_contextModels + m_numContextModels, m_numContextModels)
 , m_cSaoTypeIdxSCModel        ( 1,             1,               NUM_SAO_TYPE_IDX_CTX          , m_contextModels + m_numContextModels, m_numContextModels)
 …
 #endif
   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
-  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
 …
 #endif
       curCost += m_cCUPartSizeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PART_SIZE );
-      curCost += m_cCUAMPSCModel.calcCost             ( curSliceType, qp, (UChar*)INIT_CU_AMP_POS );
       curCost += m_cCUPredModeSCModel.calcCost        ( curSliceType, qp, (UChar*)INIT_PRED_MODE );
       curCost += m_cCUIntraPredSCModel.calcCost       ( curSliceType, qp, (UChar*)INIT_INTRA_PRED_MODE );
 …
 #endif
   m_cCUPartSizeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PART_SIZE );
-  m_cCUAMPSCModel.initBuffer             ( eSliceType, iQp, (UChar*)INIT_CU_AMP_POS );
   m_cCUPredModeSCModel.initBuffer        ( eSliceType, iQp, (UChar*)INIT_PRED_MODE );
   m_cCUIntraPredSCModel.initBuffer       ( eSliceType, iQp, (UChar*)INIT_INTRA_PRED_MODE );
 …
   m_cTransformSkipSCModel.initBuffer     ( eSliceType, iQp, (UChar*)INIT_TRANSFORMSKIP_FLAG );
   m_CUTransquantBypassFlagSCModel.initBuffer( eSliceType, iQp, (UChar*)INIT_CU_TRANSQUANT_BYPASS_FLAG );
 #if H_3D_DIM
   m_cDepthIntraModeSCModel.initBuffer    ( eSliceType, iQp, (UChar*)INIT_DEPTH_INTRA_MODE );
 …
         if (eSize == SIZE_2NxN)
+        {
           m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
+          m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
+        }
         else
+        {
           m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
+          m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
           m_pcBinIf->encodeBinEP((eSize == SIZE_2NxnU? 0: 1));
+        }
 …
         if (eSize == SIZE_Nx2N)
+        {
           m_pcBinIf->encodeBin(1, m_cCUAMPSCModel.get( 0, 0, 0 ));
+          m_pcBinIf->encodeBin(1, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
+        }
         else
+        {
           m_pcBinIf->encodeBin(0, m_cCUAMPSCModel.get( 0, 0, 0 ));
+          m_pcBinIf->encodeBin(0, m_cCUPartSizeSCModel.get( 0, 0, 3 ));
           m_pcBinIf->encodeBinEP((eSize == SIZE_nLx2N? 0: 1));
+        }

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSbac.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   Void  codeScalingList      ( TComScalingList* /*scalingList*/     ){ assert (0);  return;};
+  Void codeSAOOffsetParam(Int compIdx, SAOOffset& ctbParam, Bool sliceEnabled);
+  Void codeSAOBlkParam(SAOBlkParam& saoBlkParam
+                    , Bool* sliceEnabled
+                    , Bool leftMergeAvail
+                    , Bool aboveMergeAvail
+                    , Bool onlyEstMergeInfo = false
+                    );
 private:
   Void  xWriteUnarySymbol    ( UInt uiSymbol, ContextModel* pcSCModel, Int iOffset );
 …
   ContextModel3DBuffer m_cMVPIdxSCModel;
-  ContextModel3DBuffer m_cCUAMPSCModel;
   ContextModel3DBuffer m_cSaoMergeSCModel;
   ContextModel3DBuffer m_cSaoTypeIdxSCModel;
   ContextModel3DBuffer m_cTransformSkipSCModel;
   ContextModel3DBuffer m_CUTransquantBypassFlagSCModel;
-#if H_3D_DIM
-  ContextModel3DBuffer m_cDepthIntraModeSCModel;
-  ContextModel3DBuffer m_cDdcFlagSCModel;
-  ContextModel3DBuffer m_cDdcDataSCModel;
-#if QC_GENERIC_SDC_G0122
-  ContextModel3DBuffer m_cAngleFlagSCModel;
-#if !QC_SDC_UNIFY_G0130
-  ContextModel3DBuffer m_cIntraSdcFlagSCModel;
-#endif
-#endif
-#if H_3D_DIM_DMM
-  ContextModel3DBuffer m_cDmm1DataSCModel;
-#endif
-#if H_3D_DIM_SDC
-  ContextModel3DBuffer m_cSDCResidualFlagSCModel;
-  ContextModel3DBuffer m_cSDCResidualSCModel;
-#endif
-#endif
-#if H_3D_INTER_SDC && !QC_SDC_UNIFY_G0130
-  ContextModel3DBuffer m_cInterSDCFlagSCModel;
-  ContextModel3DBuffer m_cInterSDCResidualSCModel;
-  ContextModel3DBuffer m_cInterSDCResidualSignFlagSCModel;
-#endif
-#if QC_SDC_UNIFY_G0130
-  ContextModel3DBuffer m_cSDCFlagSCModel;
-#endif
-#if H_3D_DBBP
-  ContextModel3DBuffer m_cDBBPFlagSCModel;
-#endif
 };

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSearch.cpp

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   m_pppcRDSbacCoder     = pppcRDSbacCoder;
   m_pcRDGoOnSbacCoder   = pcRDGoOnSbacCoder;
-  m_bUseSBACRD          = pppcRDSbacCoder ? true : false;
   for (Int iDir = 0; iDir < 2; iDir++)
 …
     piRefPos = m_filteredBlock[ verVal & 3 ][ horVal & 3 ].getLumaAddr();
     if ( horVal == 2 && ( verVal & 1 ) == 0 )
+    {
       piRefPos += 1;
+    }
     if ( ( horVal & 1 ) == 0 && verVal == 2 )
+    {
       piRefPos += iRefStride;
+    }
     cMvTest = pcMvRefine[i];
     cMvTest += rcMvFrac;
 …
   UInt  uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()] + 2 - uiFullDepth;
+  {
     if( pcCU->getPredictionMode(0) == MODE_INTRA && pcCU->getPartitionSize(0) == SIZE_NxN && uiTrDepth == 0 )
+    {
 …
+      }
+    }
+  }
   if ( bChroma )
 …
+    {
       if( uiTrDepth==0 || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth-1 ) )
+      {
         m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepth );
+      }
       if( uiTrDepth==0 || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth-1 ) )
+      {
         m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepth );
+    }
+  }
+  }
 …
+  }
+  {
     //===== Cbfs =====
     if( bLuma )
 …
+    }
+  }
+}
 Void
 …
+  {
     Int scalingListType = 0 + g_eTTable[(Int)TEXT_LUMA];
     assert(scalingListType < 6);
+    assert(scalingListType < SCALING_LIST_NUM);
     m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkip );
+  }
 …
 #if RDOQ_CHROMA_LAMBDA
     m_pcTrQuant->selectLambda      (TEXT_CHROMA);
+    m_pcTrQuant->selectLambda(eText);
 #endif
     m_pcTrQuant->transformNxN      ( pcCU, piResi, uiStride, pcCoeff,
 …
+    {
       Int scalingListType = 0 + g_eTTable[(Int)eText];
       assert(scalingListType < 6);
+      assert(scalingListType < SCALING_LIST_NUM);
       m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA, REG_DCT, piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkipChroma );
+    }
 …
   //===== update distortion =====
-#if WEIGHTED_CHROMA_DISTORTION
   ruiDist += m_pcRdCost->getDistPart(g_bitDepthC, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, eText );
-#else
-  ruiDist += m_pcRdCost->getDistPart(g_bitDepthC, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight );
-#endif
+}
 …
   checkTransformSkip         &= (widthTransformSkip == 4 && heightTransformSkip == 4);
   checkTransformSkip         &= (!pcCU->getCUTransquantBypass(0));
-  checkTransformSkip         &= (!((pcCU->getQP( 0 ) == 0) && (pcCU->getSlice()->getSPS()->getUseLossless())));
   if ( m_pcEncCfg->getUseTransformSkipFast() )
+  {
 …
+    {
       //----- store original entropy coding status -----
-      if( m_bUseSBACRD)
+      {
         m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
+      }
 #if H_3D_VSO
       Dist   singleDistYTmp     = 0;
 …
+          {
             xStoreIntraResultQT(pcCU, uiTrDepth, uiAbsPartIdx,bLumaOnly );
-            if( m_bUseSBACRD)
+            {
               m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
+            }
+          }
+        }
         if(modeId == firstCheckId)
+        {
 …
+          }
+        }
-        if(m_bUseSBACRD)
+        {
           m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
+        }
+      }
       if( !bLumaOnly )
 …
       pcCU ->setTransformSkipSubParts ( 0, TEXT_LUMA, uiAbsPartIdx, uiFullDepth );
       //----- store original entropy coding status -----
       if( m_bUseSBACRD && bCheckSplit )
+      if( bCheckSplit )
+      {
         m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
 …
+  {
     //----- store full entropy coding status, load original entropy coding status -----
-    if( m_bUseSBACRD )
+    {
       if( bCheckFull )
+      {
 …
         m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
+      }
+    }
     //----- code splitted block -----
     Double  dSplitCost      = 0.0;
 …
+    }
     //----- restore context states -----
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
+    }
     //----- determine rate and r-d cost -----
     UInt uiSplitBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
 …
+    }
     //----- set entropy coding status -----
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_TEST ] );
+    }
     //--- set transform index and Cbf values ---
 …
+    {
         //use RDO to decide whether Cr/Cb takes TS
-        if( m_bUseSBACRD )
+        {
           m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );
+        }
         for(Int chromaId = 0; chromaId < 2; chromaId ++)
 …
+              {
                 xStoreIntraResultChromaQT(pcCU, uiTrDepth, uiAbsPartIdx,chromaId);
-                if( m_bUseSBACRD)
+                {
                   m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
+                }
+              }
+            }
             if(chromaModeId == firstCheckId)
+            {
 …
             xLoadIntraResultChromaQT(pcCU, uiTrDepth, uiAbsPartIdx,chromaId);
             pcCU->setCbfSubParts ( singleCbfC << uiTrDepth, (TextType)(chromaId + 2), uiAbsPartIdx, pcCU->getDepth(0) + actualTrDepth );
-            if(m_bUseSBACRD)
+            {
               m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
+            }
+          }
           pcCU ->setTransformSkipSubParts( bestModeId, (TextType)(chromaId + 2), uiAbsPartIdx, pcCU->getDepth( 0 ) +  actualTrDepth );
           ruiDist += singleDistC;
 …
           if(chromaId == 0)
+          {
-            if( m_bUseSBACRD )
+            {
               m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );
+            }
+          }
+        }
+    }
     else
+    {
 …
 #endif
       // set context models
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
+      }
       // determine residual for partition
 …
       // set context models
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
+      }
       // determine residual for partition
 …
   //===== reset context models =====
-  if(m_bUseSBACRD)
+  {
     m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
+  }
   //===== set distortion (rate and r-d costs are determined later) =====
 …
+  {
     //----- restore context models -----
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
+    }
     //----- chroma coding -----
 …
     pcCU->setChromIntraDirSubParts  ( uiModeList[uiMode], 0, uiDepth );
     xRecurIntraChromaCodingQT       ( pcCU,   0, 0, pcOrgYuv, pcPredYuv, pcResiYuv, uiDist );
     if( m_bUseSBACRD && pcCU->getSlice()->getPPS()->getUseTransformSkip() )
+    if( pcCU->getSlice()->getPPS()->getUseTransformSkip() )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
 …
   //----- restore context models -----
-  if( m_bUseSBACRD )
+  {
     m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
+  }
+}
 /** Function for encoding and reconstructing luma/chroma samples of a PCM mode CU.
 …
   dCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
-  if(m_bUseSBACRD)
+  {
     m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
+  }
   pcCU->getTotalBits()       = uiBits;
 …
                             pcYuvOrg->getLumaAddr( uiAbsPartIdx ), pcYuvOrg->getStride(),
                             m_tmpYuvPred .getLumaAddr( uiAbsPartIdx ), m_tmpYuvPred .getStride(),
-#if NS_HAD
-                            iWidth, iHeight, m_pcEncCfg->getUseHADME(), m_pcEncCfg->getUseNSQT() );
-#else
                             iWidth, iHeight, m_pcEncCfg->getUseHADME() );
-#endif
 #if H_3D_IC
   cDistParam.bUseIC = false;
 …
   for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
+  {
+    {
       UInt uiCostCand = MAX_UINT;
       UInt uiBitsCand = 0;
 …
+    }
+  }
+}
 /** convert bi-pred merge candidates to uni-pred
 …
     UInt          uiCostTempL0[MAX_NUM_REF];
+    for (Int iNumRef=0; iNumRef < MAX_NUM_REF; iNumRef++) uiCostTempL0[iNumRef] = MAX_UINT;
+    for (Int iNumRef=0; iNumRef < MAX_NUM_REF; iNumRef++)
+    {
+      uiCostTempL0[iNumRef] = MAX_UINT;
+    }
     UInt          uiBitsTempL0[MAX_NUM_REF];
 …
+    {
       uiLastMode = 2;
+      {
             pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMvBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
             pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdxBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
             pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMvBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
             pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdxBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
+      }
+      {
         TempMv = cMvBi[0] - cMvPredBi[0][iRefIdxBi[0]];
             pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
+      }
+      {
         TempMv = cMvBi[1] - cMvPredBi[1][iRefIdxBi[1]];
             pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
+      }
       pcCU->setInterDirSubParts( 3, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
 …
           pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMv[0], ePartSize, uiPartAddr, 0, iPartIdx );
           pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdx[0], ePartSize, uiPartAddr, 0, iPartIdx );
+      {
         TempMv = cMv[0] - cMvPred[0][iRefIdx[0]];
             pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
+      }
       pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
 …
           pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMv[1], ePartSize, uiPartAddr, 0, iPartIdx );
           pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdx[1], ePartSize, uiPartAddr, 0, iPartIdx );
+      {
         TempMv = cMv[1] - cMvPred[1][iRefIdx[1]];
             pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd    ( TempMv,                 ePartSize, uiPartAddr, 0, iPartIdx );
+      }
       pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
 …
         pcCU->setDvInfoSubParts(inheritedVSPDisInfo[uiMRGIndex].m_acDvInfo, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
 #endif
 #if MTK_DDD_G0063
         if( uiMRGIndex == pcCU->getUseDDDCandIdx() )
 …
+        }
 #endif
 #if H_3D_SPIVMP
         pcCU->setSPIVMPFlagSubParts(bSPIVMPFlag[uiMRGIndex], uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
 …
+        {
           UInt uiSPAddr;
           Int iNumSPInOneLine, iNumSP, iSPWidth, iSPHeight;
           pcCU->getSPPara(iRoiWidth, iRoiHeight, iNumSP, iNumSPInOneLine, iSPWidth, iSPHeight);
           for (Int iPartitionIdx = 0; iPartitionIdx < iNumSP; iPartitionIdx++)
+          {
 …
             pcCU->getCUMvField( REF_PIC_LIST_1 )->setMvFieldSP(pcCU, uiSPAddr, pcMvFieldSP[2*iPartitionIdx + 1], iSPWidth, iSPHeight);
+          }
           if ( pcCU->getInterDir(uiPartAddr) == 3 && pcCU->isBipredRestriction(iPartIdx) )
+          {
 …
             pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ));
+          }
+        }
         else
 …
           Int width, height;
           pcCU->getPartIndexAndSize( iPartIdx, partAddrTemp, width, height ); // true or pcCU->getTotalNumPart()==256
           if( uiMRGInterDir & 0x01 )
+          {
 …
         else
 #endif
+        {
           pcCU->setInterDirSubParts  ( uiMRGInterDir, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
+          {
             pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMRGMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
             pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMRGMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
+          }
+        }
         pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd    ( cMvZero,            ePartSize, uiPartAddr, 0, iPartIdx );
 …
         pcCU->setSPIVMPFlagSubParts(0, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
 #endif
 #if MTK_DDD_G0063
         pcCU->setUseDDD( false, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
 …
         pcCU->setDvInfoSubParts(OriginalDvInfo, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
 #endif
+        {
           pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMEMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
           pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMEMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
+        }
+      }
 #if H_3D_SPIVMP
       delete[] pcMvFieldSP;
 …
   if (iNum == 1)
+  {
     return 0;
+  }
   UInt uiLength = 1;
 …
                             pcOrgYuv->getLumaAddr(uiPartAddr), pcOrgYuv->getStride(),
                             pcTemplateCand->getLumaAddr(uiPartAddr), pcTemplateCand->getStride(),
-#if NS_HAD
-                            iSizeX, iSizeY, m_pcEncCfg->getUseHADME(), m_pcEncCfg->getUseNSQT() );
-#else
                             iSizeX, iSizeY, m_pcEncCfg->getUseHADME() );
-#endif
   ruiDist = cDistParam.DistFunc( &cDistParam );
   uiCost = ruiDist + m_pcRdCost->getCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum] );
 #else
-#if WEIGHTED_CHROMA_DISTORTION
   uiCost = m_pcRdCost->getDistPart(g_bitDepthY, pcTemplateCand->getLumaAddr(uiPartAddr), pcTemplateCand->getStride(), pcOrgYuv->getLumaAddr(uiPartAddr), pcOrgYuv->getStride(), iSizeX, iSizeY, TEXT_LUMA, DF_SAD );
-#else
-  uiCost = m_pcRdCost->getDistPart(g_bitDepthY, pcTemplateCand->getLumaAddr(uiPartAddr), pcTemplateCand->getStride(), pcOrgYuv->getLumaAddr(uiPartAddr), pcOrgYuv->getStride(), iSizeX, iSizeY, DF_SAD );
-#endif
   uiCost = (UInt) m_pcRdCost->calcRdCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum], uiCost, false, DF_SAD );
 #endif
 …
   m_pcRdCost->setCostScale ( 1 );
+  {
+    xPatternSearchFracDIF( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost
+                          ,bBi
+                          );
+  }
+    xPatternSearchFracDIF( pcCU, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost,bBi );
 …
 #endif
-    if( m_bUseSBACRD )
       m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST]);
 …
     pcCU->getTotalCost() = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
-    if( m_bUseSBACRD )
       m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_TEMP_BEST]);
 …
     uiBits = 0;
     uiDistortion = 0;
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_CURR_BEST ] );
+    }
 #if H_3D_VSO // M16 // M18
 …
+    }
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST] );
+    }
 #if 0 // check
+    {
 …
       m_pcEntropyCoder->encodeCoeff( pcCU, 0, pcCU->getDepth(0), pcCU->getWidth(0), pcCU->getHeight(0) );
       const UInt uiBitsForCoeff = m_pcEntropyCoder->getNumberOfWrittenBits();
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST] );
+      }
       if( uiBitsForCoeff != uiBits )
         assert( 0 );
 …
       dCostBest        = dCost;
       qpBest           = qp;
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
+      }
 …
+    }
 #endif
+  }
   assert ( dCostBest != MAX_DOUBLE );
 …
   if( qpMin != qpMax && qpBest != qpMax )
+  {
-    if( m_bUseSBACRD )
+    {
       assert( 0 ); // check
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
+    }
     // copy best cbf and trIdx to pcCU
     const UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> (pcCU->getDepth(0) << 1);
 …
 #endif
   // update with clipped distortion and cost (qp estimation loop uses unclipped values)
-#if WEIGHTED_CHROMA_DISTORTION
     uiDistortionBest = m_pcRdCost->getDistPart(g_bitDepthY, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight      )
     + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCbAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCbAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_U )
     + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCrAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCrAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1, TEXT_CHROMA_V );
-#else
-  uiDistortionBest = m_pcRdCost->getDistPart(g_bitDepthY, rpcYuvRec->getLumaAddr(), rpcYuvRec->getStride(),  pcYuvOrg->getLumaAddr(), pcYuvOrg->getStride(),  uiWidth,      uiHeight      )
-  + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCbAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCbAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1 )
-  + m_pcRdCost->getDistPart(g_bitDepthC, rpcYuvRec->getCrAddr(),   rpcYuvRec->getCStride(), pcYuvOrg->getCrAddr(),   pcYuvOrg->getCStride(), uiWidth >> 1, uiHeight >> 1 );
-#endif
 #if H_3D_VSO // M23
+  }
 …
   pcCU->setQPSubParts( qpBest, 0, pcCU->getDepth(0) );
 #if H_3D_VSO // M24 // necessary??
   if( m_pcRdCost->getUseRenModel() && !m_pcRdCost->getUseEstimatedVSD() )
 …
   Bool bCheckFull;
   if ( SplitFlag && uiDepth == pcCU->getDepth(uiAbsPartIdx) && ( uiLog2TrSize >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) ) )
+  {
      bCheckFull = false;
+  }
   else
+  {
      bCheckFull =  ( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
+  }
   const Bool bCheckSplit  = ( uiLog2TrSize >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
 …
   UInt uiBestTransformMode[3] = {0};
-  if( m_bUseSBACRD )
+  {
     m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+  }
   if( bCheckFull )
 …
 #if RDOQ_CHROMA_LAMBDA
       m_pcTrQuant->selectLambda(TEXT_CHROMA);
+      m_pcTrQuant->selectLambda(TEXT_CHROMA_U);
 #endif
 …
       curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
       m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
+#if RDOQ_CHROMA_LAMBDA
+      m_pcTrQuant->selectLambda(TEXT_CHROMA_V);
+#endif
       m_pcTrQuant->transformNxN( pcCU, pcResi->getCrAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrV,
 #if ADAPTIVE_QP_SELECTION
 …
     m_pcEntropyCoder->resetBits();
+    {
       m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
+    }
     m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx,  trWidth,  trHeight,    uiDepth, TEXT_LUMA );
 …
     if( bCodeChroma )
+    {
+      {
         m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrMode );
+      }
       m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrU, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_U );
       uiSingleBitsU = m_pcEntropyCoder->getNumberOfWrittenBits() - uiSingleBitsY;
+      {
         m_pcEntropyCoder->encodeQtCbf   ( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrMode );
+      }
       m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrV, uiAbsPartIdx, trWidthC, trHeightC, uiDepth, TEXT_CHROMA_V );
       uiSingleBitsV = m_pcEntropyCoder->getNumberOfWrittenBits() - ( uiSingleBitsY + uiSingleBitsU );
 …
       Int scalingListType = 3 + g_eTTable[(Int)TEXT_LUMA];
       assert(scalingListType < 6);
+      assert(scalingListType < SCALING_LIST_NUM);
       m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType );//this is for inter mode only
 …
+      }
 #else
+      const UInt uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
+      const UInt uiNonzeroDistY = m_pcRdCost->getDistPart(g_bitDepthY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getLumaAddr( absTUPartIdx ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),
+      pcResi->getLumaAddr( absTUPartIdx ), pcResi->getStride(), trWidth,trHeight );
 #endif
       if (pcCU->isLosslessCoded(0))
 …
+    {
       uiDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pTempPel, trWidthC, pcResi->getCbAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                         , TEXT_CHROMA_U
-#endif
                                         ); // initialized with zero residual destortion
       if ( puiZeroDist )
 …
         Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_U];
         assert(scalingListType < 6);
+        assert(scalingListType < SCALING_LIST_NUM);
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrU, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrU, trWidthC, trHeightC, scalingListType  );
         const UInt uiNonzeroDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
                                                             pcResi->getCbAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                                             , TEXT_CHROMA_U
-#endif
                                                             );
 …
+      {
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U, uiTrModeC );
+        m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_U, uiTrMode );
         const UInt uiNullBitsU = m_pcEntropyCoder->getNumberOfWrittenBits();
         minCostU = m_pcRdCost->calcRdCost( uiNullBitsU, uiDistU );
 …
       uiDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pTempPel, trWidthC, pcResi->getCrAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                         , TEXT_CHROMA_V
-#endif
                                         ); // initialized with zero residual destortion
       if ( puiZeroDist )
 …
         Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_V];
         assert(scalingListType < 6);
+        assert(scalingListType < SCALING_LIST_NUM);
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrV, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrV, trWidthC, trHeightC, scalingListType );
         const UInt uiNonzeroDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
                                                             pcResi->getCrAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                                             , TEXT_CHROMA_V
-#endif
                                                             );
         if (pcCU->isLosslessCoded(0))
 …
+      {
         m_pcEntropyCoder->resetBits();
         m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V, uiTrModeC );
+        m_pcEntropyCoder->encodeQtCbfZero( pcCU, TEXT_CHROMA_V, uiTrMode );
         const UInt uiNullBitsV = m_pcEntropyCoder->getNumberOfWrittenBits();
         minCostV = m_pcRdCost->calcRdCost( uiNullBitsV, uiDistV );
 …
+      }
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+      }
       pcCU->setTransformSkipSubParts ( 1, TEXT_LUMA, uiAbsPartIdx, uiDepth );
 …
         Int scalingListType = 3 + g_eTTable[(Int)TEXT_LUMA];
         assert(scalingListType < 6);
+        assert(scalingListType < SCALING_LIST_NUM);
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,REG_DCT, pcResiCurrY, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(),  pcCoeffCurrY, trWidth, trHeight, scalingListType, true );
 …
+      }
-      if( m_bUseSBACRD )
+      {
         m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+      }
       pcCU->setTransformSkipSubParts ( 1, TEXT_CHROMA_U, uiAbsPartIdx, pcCU->getDepth(0)+uiTrModeC );
 …
 #if RDOQ_CHROMA_LAMBDA
       m_pcTrQuant->selectLambda(TEXT_CHROMA);
+      m_pcTrQuant->selectLambda(TEXT_CHROMA_U);
 #endif
 …
       curChromaQpOffset = pcCU->getSlice()->getPPS()->getChromaCrQpOffset() + pcCU->getSlice()->getSliceQpDeltaCr();
       m_pcTrQuant->setQPforQuant( pcCU->getQP( 0 ), TEXT_CHROMA, pcCU->getSlice()->getSPS()->getQpBDOffsetC(), curChromaQpOffset );
+#if RDOQ_CHROMA_LAMBDA
+      m_pcTrQuant->selectLambda(TEXT_CHROMA_V);
+#endif
       m_pcTrQuant->transformNxN( pcCU, pcResi->getCrAddr(absTUPartIdxC), pcResi->getCStride(), pcCoeffCurrV,
 #if ADAPTIVE_QP_SELECTION
 …
         Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_U];
         assert(scalingListType < 6);
+        assert(scalingListType < SCALING_LIST_NUM);
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrU, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrU, trWidthC, trHeightC, scalingListType, true  );
 …
         uiNonzeroDistU = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCbAddr( absTUPartIdxC), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
                                                  pcResi->getCbAddr( absTUPartIdxC), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                                  , TEXT_CHROMA_U
-#endif
                                                  );
 …
         Int scalingListType = 3 + g_eTTable[(Int)TEXT_CHROMA_V];
         assert(scalingListType < 6);
+        assert(scalingListType < SCALING_LIST_NUM);
         m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_CHROMA,REG_DCT, pcResiCurrV, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(), pcCoeffCurrV, trWidthC, trHeightC, scalingListType, true );
 …
         uiNonzeroDistV = m_pcRdCost->getDistPart(g_bitDepthC, m_pcQTTempTComYuv[uiQTTempAccessLayer].getCrAddr( absTUPartIdxC ), m_pcQTTempTComYuv[uiQTTempAccessLayer].getCStride(),
                                                  pcResi->getCrAddr( absTUPartIdxC ), pcResi->getCStride(), trWidthC, trHeightC
-#if WEIGHTED_CHROMA_DISTORTION
                                                  , TEXT_CHROMA_V
-#endif
                                                  );
 …
+    }
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+    }
     m_pcEntropyCoder->resetBits();
+    {
       if( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
+      {
         m_pcEntropyCoder->encodeTransformSubdivFlag( 0, 5 - uiLog2TrSize );
+      }
+    }
+    {
       if( bCodeChroma )
+      {
 …
       m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
+    }
     m_pcEntropyCoder->encodeCoeffNxN( pcCU, pcCoeffCurrY, uiAbsPartIdx, trWidth, trHeight,    uiDepth, TEXT_LUMA );
 …
   if( bCheckSplit )
+  {
     if( m_bUseSBACRD && bCheckFull )
+    if( bCheckFull )
+    {
       m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
 …
+    }
-    if( m_bUseSBACRD )
+    {
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
+    }
     m_pcEntropyCoder->resetBits();
+    {
       xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, true,  TEXT_LUMA );
       xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_LUMA );
       xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_CHROMA_U );
       xEncodeResidualQT( pcCU, uiAbsPartIdx, uiDepth, false, TEXT_CHROMA_V );
+    }
     uiSubdivBits = m_pcEntropyCoder->getNumberOfWrittenBits();
 …
+    }
     assert( bCheckFull );
+    if( m_bUseSBACRD )
+    {
+      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
+    }
+  }
+    m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
+  }
 #if H_3D_VSO // M33
   if( m_pcRdCost->getUseRenModel() && !m_pcRdCost->getUseEstimatedVSD() )
 …
     UInt  uiWidth     = 1<< uiLog2TrSize;
     UInt  uiHeight    = 1<< uiLog2TrSize;
     Pel*  piSrc;
     UInt  uiSrcStride;
     if ( uiAbsSumY )
+    {
 …
       uiSrcStride = pcPred->getStride  ();
+    }
     m_pcRdCost->setRenModelData( pcCU, uiAbsPartIdx, piSrc, (Int) uiSrcStride, (Int) uiWidth, (Int) uiHeight );
+  }
 #endif
   rdCost += dSingleCost;
   ruiBits += uiSingleBits;
 …
   const UInt uiLog2TrSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiDepth]+2;
+  {
     if( bSubdivAndCbf && uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() && uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
+    {
       m_pcEntropyCoder->encodeTransformSubdivFlag( bSubdiv, 5 - uiLog2TrSize );
+    }
+  }
+  {
     assert( pcCU->getPredictionMode(uiAbsPartIdx) != MODE_INTRA );
     if( bSubdivAndCbf )
 …
+      }
+    }
+  }
   if( !bSubdiv )
 …
     if( bSubdivAndCbf )
+    {
+      {
         m_pcEntropyCoder->encodeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA,     uiTrMode );
+      }
+    }
     else
+    {
 …
       if( bCodeChroma )
+      {
+        {
           m_pcQTTempTComYuv[uiQTTempAccessLayer].copyPartToPartChroma( pcResi, uiAbsPartIdx, 1 << uiLog2TrSizeC, 1 << uiLog2TrSizeC );
+        }
+      }
+    }
     else
+    {
 …
 UInt TEncSearch::xModeBitsIntra( TComDataCU* pcCU, UInt uiMode, UInt uiPU, UInt uiPartOffset, UInt uiDepth, UInt uiInitTrDepth )
+{
-  if( m_bUseSBACRD )
+  {
     // Reload only contexts required for coding intra mode information
     m_pcRDGoOnSbacCoder->loadIntraDirModeLuma( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
 …
     m_pcRDGoOnSbacCoder->loadIntraDepthMode( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
 #endif
+  }
   pcCU->setLumaIntraDirSubParts ( uiMode, uiPartOffset, uiDepth + uiInitTrDepth );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSearch.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   TEncSbac***     m_pppcRDSbacCoder;
   TEncSbac*       m_pcRDGoOnSbacCoder;
-  Bool            m_bUseSBACRD;
   DistParam       m_cDistParam;

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSlice.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   eSliceType=B_SLICE;
   eSliceType = (pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
+  eSliceType = (pocLast == 0 || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
   rpcSlice->setSliceType    ( eSliceType );
 …
   if(eSliceType!=I_SLICE)
+  {
     if (!(( m_pcCfg->getMaxDeltaQP() == 0 ) && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() ) && (rpcSlice->getSPS()->getUseLossless())))
+    if (!(( m_pcCfg->getMaxDeltaQP() == 0 ) && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() ) && (rpcSlice->getPPS()->getTransquantBypassEnableFlag())))
+    {
 #if H_MV
 …
     dQP += pdQPs[ rpcSlice->getPOC() ];
+  }
-#if !RATE_CONTROL_LAMBDA_DOMAIN
-  if ( m_pcCfg->getUseRateCtrl())
+  {
-    dQP = m_pcRateCtrl->getFrameQP(rpcSlice->isReferenced(), rpcSlice->getPOC());
+  }
-#endif
   // ------------------------------------------------------------------------------------------------------------------
   // Lambda computation
 …
   // store lambda
   m_pcRdCost ->setLambda( dLambda );
-#if H_3D_VSO
-  m_pcRdCost->setUseLambdaScaleVSO  ( (m_pcCfg->getUseVSO() ||  m_pcCfg->getForceLambdaScaleVSO()) && m_pcCfg->getIsDepth() );
-  m_pcRdCost->setLambdaVSO          ( dLambda * m_pcCfg->getLambdaScaleVSO() );
-  // Should be moved to TEncTop
-  // SAIT_VSO_EST_A0033
-  m_pcRdCost->setDisparityCoeff( m_pcCfg->getDispCoeff() );
-  // LGE_WVSO_A0119
-  if( m_pcCfg->getUseWVSO() && m_pcCfg->getIsDepth() )
+  {
-    m_pcRdCost->setDWeight  ( m_pcCfg->getDWeight()   );
-    m_pcRdCost->setVSOWeight( m_pcCfg->getVSOWeight() );
-    m_pcRdCost->setVSDWeight( m_pcCfg->getVSDWeight() );
+  }
-#endif
-#if WEIGHTED_CHROMA_DISTORTION
 // for RDO
   // in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
   Double weight = 1.0;
+  Double weight[2] = { 1.0, 1.0 };
   Int qpc;
   Int chromaQPOffset;
 …
   chromaQPOffset = rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb();
   qpc = Clip3( 0, 57, iQP + chromaQPOffset);
   weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
   m_pcRdCost->setCbDistortionWeight(weight);
+  weight[0] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCbDistortionWeight(weight[0]);
   chromaQPOffset = rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr();
   qpc = Clip3( 0, 57, iQP + chromaQPOffset);
+  weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCrDistortionWeight(weight);
+#endif
+  weight[1] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCrDistortionWeight(weight[1]);
+  const Double lambdaArray[3] = {dLambda, (dLambda / weight[0]), (dLambda / weight[1])};
 #if RDOQ_CHROMA_LAMBDA
 // for RDOQ
   m_pcTrQuant->setLambda( dLambda, dLambda / weight );
+  m_pcTrQuant->setLambdas( lambdaArray );
 #else
   m_pcTrQuant->setLambda( dLambda );
 #endif
-#if SAO_CHROMA_LAMBDA
 // For SAO
+  rpcSlice   ->setLambda( dLambda, dLambda / weight );
+#else
+  rpcSlice   ->setLambda( dLambda );
+#endif
+  rpcSlice->setLambdas( lambdaArray );
 #if HB_LAMBDA_FOR_LDC
 …
+  }
 #else
   eSliceType = (pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
+eSliceType = (pocLast == 0 || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
 #endif
 …
+}
-#if RATE_CONTROL_LAMBDA_DOMAIN
 Void TEncSlice::resetQP( TComPic* pic, Int sliceQP, Double lambda )
+{
 …
   slice->setSliceQpBase ( sliceQP );
   m_pcRdCost ->setLambda( lambda );
-#if WEIGHTED_CHROMA_DISTORTION
   // for RDO
   // in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
   Double weight;
+  Double weight[2] = { 1.0, 1.0 };
   Int qpc;
   Int chromaQPOffset;
 …
   chromaQPOffset = slice->getPPS()->getChromaCbQpOffset() + slice->getSliceQpDeltaCb();
   qpc = Clip3( 0, 57, sliceQP + chromaQPOffset);
   weight = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
   m_pcRdCost->setCbDistortionWeight(weight);
+  weight[0] = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCbDistortionWeight(weight[0]);
   chromaQPOffset = slice->getPPS()->getChromaCrQpOffset() + slice->getSliceQpDeltaCr();
   qpc = Clip3( 0, 57, sliceQP + chromaQPOffset);
   weight = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
   m_pcRdCost->setCrDistortionWeight(weight);
+#endif
+  weight[1] = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCrDistortionWeight(weight[1]);
 #if RDOQ_CHROMA_LAMBDA
   // for RDOQ
   m_pcTrQuant->setLambda( lambda, lambda / weight );
+  m_pcTrQuant->setLambdas( lambdaArray );
 #else
   m_pcTrQuant->setLambda( lambda );
 #endif
-#if SAO_CHROMA_LAMBDA
   // For SAO
+  slice   ->setLambda( lambda, lambda / weight );
+#else
+  slice   ->setLambda( lambda );
+#endif
+  slice->setLambdas( lambdaArray );
+}
-#else
-/**
- - lambda re-computation based on rate control QP
- */
-Void TEncSlice::xLamdaRecalculation(Int changeQP, Int idGOP, Int depth, SliceType eSliceType, TComSPS* pcSPS, TComSlice* pcSlice)
+{
-  Int qp;
-  Double recalQP= (Double)changeQP;
-  Double origQP = (Double)recalQP;
-  Double lambda;
-  // pre-compute lambda and QP values for all possible QP candidates
-  for ( Int deltqQpIdx = 0; deltqQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; deltqQpIdx++ )
+  {
-    // compute QP value
-    recalQP = origQP + ((deltqQpIdx+1)>>1)*(deltqQpIdx%2 ? -1 : 1);
-    // compute lambda value
-    Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
-    Int    SHIFT_QP = 12;
-    Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
-#if FULL_NBIT
-    Int    bitdepth_luma_qp_scale = 6 * (g_bitDepth - 8);
-#else
-    Int    bitdepth_luma_qp_scale = 0;
-#endif
-    Double qp_temp = (Double) recalQP + bitdepth_luma_qp_scale - SHIFT_QP;
-#if FULL_NBIT
-    Double qp_temp_orig = (Double) recalQP - SHIFT_QP;
-#endif
-    // Case #1: I or P-slices (key-frame)
-    Double dQPFactor = m_pcCfg->getGOPEntry(idGOP).m_QPFactor;
-    if ( eSliceType==I_SLICE )
+    {
-      dQPFactor=0.57*dLambda_scale;
+    }
-    lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
-    if ( depth>0 )
+    {
-#if FULL_NBIT
-      lambda *= Clip3( 2.00, 4.00, (qp_temp_orig / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
-#else
-      lambda *= Clip3( 2.00, 4.00, (qp_temp / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
-#endif
+    }
-    // if hadamard is used in ME process
-    if ( !m_pcCfg->getUseHADME() )
+    {
-      lambda *= 0.95;
+    }
-    qp = max( -pcSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( recalQP + 0.5 ) ) );
-    m_pdRdPicLambda[deltqQpIdx] = lambda;
-    m_pdRdPicQp    [deltqQpIdx] = recalQP;
-    m_piRdPicQp    [deltqQpIdx] = qp;
+  }
-  // obtain dQP = 0 case
-  lambda  = m_pdRdPicLambda[0];
-  recalQP = m_pdRdPicQp    [0];
-  qp      = m_piRdPicQp    [0];
-  if( pcSlice->getSliceType( ) != I_SLICE )
+  {
-    lambda *= m_pcCfg->getLambdaModifier( depth );
+  }
-  // store lambda
-  m_pcRdCost ->setLambda( lambda );
-#if WEIGHTED_CHROMA_DISTORTION
-  // for RDO
-  // in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
-  Double weight = 1.0;
-  Int qpc;
-  Int chromaQPOffset;
-  chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
-  qpc = Clip3( 0, 57, qp + chromaQPOffset);
-  weight = pow( 2.0, (qp-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
-  m_pcRdCost->setCbDistortionWeight(weight);
-  chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
-  qpc = Clip3( 0, 57, qp + chromaQPOffset);
-  weight = pow( 2.0, (qp-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
-  m_pcRdCost->setCrDistortionWeight(weight);
-#endif
-#if RDOQ_CHROMA_LAMBDA
-  // for RDOQ
-  m_pcTrQuant->setLambda( lambda, lambda / weight );
-#else
-  m_pcTrQuant->setLambda( lambda );
-#endif
-#if SAO_CHROMA_LAMBDA
-  // For SAO
-  pcSlice   ->setLambda( lambda, lambda / weight );
-#else
-  pcSlice   ->setLambda( lambda );
-#endif
+}
-#endif
 // ====================================================================================================================
 // Public member functions
 …
+  }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_pcCfg->getUseRateCtrl() )
+  {
 …
     assert(0);
+  }
-#endif
   TComSlice* pcSlice        = rpcPic->getSlice(getSliceIdx());
 …
 #endif
     m_pcRdCost    ->setLambda              ( m_pdRdPicLambda[uiQpIdx] );
-#if WEIGHTED_CHROMA_DISTORTION
     // for RDO
     // in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
     Int iQP = m_piRdPicQp    [uiQpIdx];
     Double weight = 1.0;
+    Double weight[2] = { 1.0, 1.0 };
     Int qpc;
     Int chromaQPOffset;
 …
     chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
     qpc = Clip3( 0, 57, iQP + chromaQPOffset);
     weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
     m_pcRdCost->setCbDistortionWeight(weight);
+    weight[0] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+    m_pcRdCost->setCbDistortionWeight(weight[0]);
     chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
     qpc = Clip3( 0, 57, iQP + chromaQPOffset);
     weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
     m_pcRdCost->setCrDistortionWeight(weight);
+#endif
+    weight[1] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+    m_pcRdCost->setCrDistortionWeight(weight[1]);
+    const Double lambdaArray[3] = {m_pdRdPicLambda[uiQpIdx], (m_pdRdPicLambda[uiQpIdx] / weight[0]), (m_pdRdPicLambda[uiQpIdx] / weight[1])};
 #if RDOQ_CHROMA_LAMBDA
     // for RDOQ
     m_pcTrQuant   ->setLambda( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
+    m_pcTrQuant->setLambdas( lambdaArray );
 #else
     m_pcTrQuant   ->setLambda              ( m_pdRdPicLambda[uiQpIdx] );
 #endif
-#if SAO_CHROMA_LAMBDA
     // For SAO
+    pcSlice       ->setLambda              ( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
+#else
+    pcSlice       ->setLambda              ( m_pdRdPicLambda[uiQpIdx] );
+#endif
+    pcSlice->setLambdas( lambdaArray );
     // try compress
 …
 #endif
   m_pcRdCost    ->setLambda              ( m_pdRdPicLambda[uiQpIdxBest] );
-#if WEIGHTED_CHROMA_DISTORTION
   // in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
   Int iQP = m_piRdPicQp    [uiQpIdxBest];
   Double weight = 1.0;
+  Double weight[2] = { 1.0, 1.0 };
   Int qpc;
   Int chromaQPOffset;
 …
   chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
   qpc = Clip3( 0, 57, iQP + chromaQPOffset);
   weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
   m_pcRdCost->setCbDistortionWeight(weight);
+  weight[0] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCbDistortionWeight(weight[0]);
   chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
   qpc = Clip3( 0, 57, iQP + chromaQPOffset);
   weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
   m_pcRdCost->setCrDistortionWeight(weight);
+#endif
+  weight[1] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset
+  m_pcRdCost->setCrDistortionWeight(weight[1]);
+  const Double lambdaArray[3] = {m_pdRdPicLambda[uiQpIdxBest], (m_pdRdPicLambda[uiQpIdxBest] / weight[0]), (m_pdRdPicLambda[uiQpIdxBest] / weight[1])};
 #if RDOQ_CHROMA_LAMBDA
   // for RDOQ
   m_pcTrQuant   ->setLambda( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
+  m_pcTrQuant->setLambdas( lambdaArray );
 #else
   m_pcTrQuant   ->setLambda              ( m_pdRdPicLambda[uiQpIdxBest] );
 #endif
-#if SAO_CHROMA_LAMBDA
   // For SAO
+  pcSlice       ->setLambda              ( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
+#else
+  pcSlice       ->setLambda              ( m_pdRdPicLambda[uiQpIdxBest] );
+#endif
+  pcSlice->setLambdas( lambdaArray );
+}
 /** \param rpcPic   picture class
  */
-#if RATE_CONTROL_INTRA
 Void TEncSlice::calCostSliceI(TComPic*& rpcPic)
+{
 …
   m_pcRateCtrl->getRCPic()->setTotalIntraCost(iSumHadSlice);
+}
-#endif
 Void TEncSlice::compressSlice( TComPic*& rpcPic )
 …
   // set entropy coder
-  if( m_pcCfg->getUseSBACRD() )
+  {
     m_pcSbacCoder->init( m_pcBinCABAC );
     m_pcEntropyCoder->setEntropyCoder   ( m_pcSbacCoder, pcSlice );
 …
     pppcRDSbacCoder->setBinCountingEnableFlag( false );
     pppcRDSbacCoder->setBinsCoded( 0 );
+  }
-  else
+  {
-    m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
-    m_pcEntropyCoder->resetEntropy      ();
-    m_pcEntropyCoder->setBitstream    ( m_pcBitCounter );
+  }
   //------------------------------------------------------------------------------
 …
+  }
 #endif
-  if( m_pcCfg->getUseSBACRD() )
+  {
     iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
     uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
 …
       ppppcRDSbacCoders[ui][0][CI_CURR_BEST]->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
+    }
+  }
-  //if( m_pcCfg->getUseSBACRD() )
+  {
     delete[] m_pcBufferLowLatSbacCoders;
     delete[] m_pcBufferLowLatBinCoderCABACs;
 …
     for (UInt ui = 0; ui < uiTilesAcross; ui++)
       m_pcBufferLowLatSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);  //init. state
+  }
   UInt uiWidthInLCUs  = rpcPic->getPicSym()->getFrameWidthInCU();
   //UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
 …
+    }
 #endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN
-    if(m_pcCfg->getUseRateCtrl())
+    {
-#if KWU_RC_MADPRED_E0227
-      if(pcSlice->getLayerId() != 0 && m_pcCfg->getUseDepthMADPred() && !pcSlice->getIsDepth())
+      {
-        Double zn, zf, focallength, position, camshift;
-        Double basepos;
-        Bool bInterpolated;
-        Int direction = pcSlice->getViewId() - pcCU->getSlice()->getIvPic(false, 0)->getViewId();
-        pcEncTop->getCamParam()->xGetZNearZFar(pcEncTop->getCamParam()->getBaseViewNumbers()[pcSlice->getViewIndex()], pcSlice->getPOC(), zn, zf);
-        pcEncTop->getCamParam()->xGetGeometryData(pcEncTop->getCamParam()->getBaseViewNumbers()[0], pcSlice->getPOC(), focallength, basepos, camshift, bInterpolated);
-        pcEncTop->getCamParam()->xGetGeometryData(pcEncTop->getCamParam()->getBaseViewNumbers()[pcSlice->getViewIndex()], pcSlice->getPOC(), focallength, position, camshift, bInterpolated);
-        m_pcRateCtrl->updateLCUDataEnhancedView(pcCU, pcCU->getTotalBits(), pcCU->getQP(0), basepos, position, focallength, zn, zf, (direction > 0 ? 1 : -1));
+      }
-#endif
-      if(m_pcRateCtrl->calculateUnitQP())
+      {
-        xLamdaRecalculation(m_pcRateCtrl->getUnitQP(), m_pcRateCtrl->getGOPId(), pcSlice->getDepth(), pcSlice->getSliceType(), pcSlice->getSPS(), pcSlice );
+      }
+    }
-#endif
     // inherit from TR if necessary, select substream to use.
-    if( m_pcCfg->getUseSBACRD() )
+    {
       uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
       uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
 …
+      }
       m_pppcRDSbacCoder[0][CI_CURR_BEST]->load( ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST] ); //this load is used to simplify the code
+    }
     // reset the entropy coder
 …
       m_pcEntropyCoder->setEntropyCoder     ( m_pcSbacCoder, pcSlice );
+    }
+    // if RD based on SBAC is used
+    if( m_pcCfg->getUseSBACRD() )
+    {
       // set go-on entropy coder
       m_pcEntropyCoder->setEntropyCoder ( m_pcRDGoOnSbacCoder, pcSlice );
 …
       ((TEncBinCABAC*)m_pcRDGoOnSbacCoder->getEncBinIf())->setBinCountingEnableFlag(true);
-#if RATE_CONTROL_LAMBDA_DOMAIN
       Double oldLambda = m_pcRdCost->getLambda();
       if ( m_pcCfg->getUseRateCtrl() )
 …
         Double bpp       = -1.0;
-#if M0036_RC_IMPROVEMENT
         if ( ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE && m_pcCfg->getForceIntraQP() ) || !m_pcCfg->getLCULevelRC() )
-#else
-        if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE || !m_pcCfg->getLCULevelRC() )
-#endif
+        {
           estQP = pcSlice->getSliceQp();
 …
+          {
 #endif
-#if RATE_CONTROL_INTRA
           bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp(pcSlice->getSliceType());
           if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE)
 …
             estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );
+          }
-#else
-          bpp       = m_pcRateCtrl->getRCPic()->getLCUTargetBpp();
-          estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
-          estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );
-#endif
-#if KWU_RC_MADPRED_E0227
+          }
-#endif
 #if KWU_RC_MADPRED_E0227
           estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
 …
           m_pcRdCost->setLambda(estLambda);
-#if M0036_RC_IMPROVEMENT
 #if RDOQ_CHROMA_LAMBDA
           // set lambda for RDOQ
           Double weight=m_pcRdCost->getChromaWeight();
+          m_pcTrQuant->setLambda( estLambda, estLambda / weight );
+        const Double lambdaArray[3] = { estLambda, (estLambda / weight), (estLambda / weight) };
+        m_pcTrQuant->setLambdas( lambdaArray );
 #else
           m_pcTrQuant->setLambda( estLambda );
-#endif
 #endif
+        }
 …
         pcCU->getSlice()->setSliceQpBase( estQP );
+      }
-#endif
       // run CU encoder
       m_pcCuEncoder->compressCU( pcCU );
-#if !TICKET_1090_FIX
-#if RATE_CONTROL_LAMBDA_DOMAIN
-      if ( m_pcCfg->getUseRateCtrl() )
+      {
-#if !M0036_RC_IMPROVEMENT
-        UInt SAD    = m_pcCuEncoder->getLCUPredictionSAD();
-        Int height  = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
-        Int width   = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
-        Double MAD = (Double)SAD / (Double)(height * width);
-        MAD = MAD * MAD;
-        ( m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr) ).m_MAD = MAD;
-#endif
-        Int actualQP        = g_RCInvalidQPValue;
-        Double actualLambda = m_pcRdCost->getLambda();
-        Int actualBits      = pcCU->getTotalBits();
-        Int numberOfEffectivePixels    = 0;
-        for ( Int idx = 0; idx < rpcPic->getNumPartInCU(); idx++ )
+        {
-          if ( pcCU->getPredictionMode( idx ) != MODE_NONE && ( !pcCU->isSkipped( idx ) ) )
+          {
-            numberOfEffectivePixels = numberOfEffectivePixels + 16;
-            break;
+          }
+        }
-        if ( numberOfEffectivePixels == 0 )
+        {
-          actualQP = g_RCInvalidQPValue;
+        }
-        else
+        {
-          actualQP = pcCU->getQP( 0 );
+        }
-        m_pcRdCost->setLambda(oldLambda);
-#if RATE_CONTROL_INTRA
-        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
-          pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
-#else
-        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
-#endif
+      }
-#endif
-#endif
       // restore entropy coder to an initial stage
       m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
 …
         break;
+      }
-      if( m_pcCfg->getUseSBACRD() )
+      {
-         ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
+    ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
          //Store probabilties of second LCU in line into buffer
          if ( ( uiCol == uiTileLCUX+1) && (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && m_pcCfg->getWaveFrontsynchro())
 …
           m_pcBufferSbacCoders[uiTileCol].loadContexts(ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]);
+        }
+      }
+#if TICKET_1090_FIX
+#if RATE_CONTROL_LAMBDA_DOMAIN
       if ( m_pcCfg->getUseRateCtrl() )
+      {
 #if !M0036_RC_IMPROVEMENT || KWU_RC_MADPRED_E0227
+#if KWU_RC_MADPRED_E0227
         UInt SAD    = m_pcCuEncoder->getLCUPredictionSAD();
         Int height  = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
 …
         m_pcRdCost->setLambda(oldLambda);
-#if RATE_CONTROL_INTRA
         m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
           pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
-#else
-        m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
-#endif
+      }
-#endif
-#endif
+    }
-    // other case: encodeCU is not called
-    else
+    {
-      m_pcCuEncoder->compressCU( pcCU );
-      m_pcCuEncoder->encodeCU( pcCU );
-      if (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES && ( ( pcSlice->getSliceBits()+ m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)
+      {
-        pcSlice->setNextSlice( true );
-        break;
+      }
-      if (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceSegmentBits()+ m_pcEntropyCoder->getNumberOfWrittenBits()> m_pcCfg->getSliceSegmentArgument()<<3 &&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getSliceSegmentCurEndCUAddr())
+      {
-        pcSlice->setNextSliceSegment( true );
-        break;
+      }
+    }
 …
     m_dPicRdCost     += pcCU->getTotalCost();
     m_uiPicDist      += pcCU->getTotalDistortion();
-#if !RATE_CONTROL_LAMBDA_DOMAIN
-    if(m_pcCfg->getUseRateCtrl())
+    {
-      m_pcRateCtrl->updateLCUData(pcCU, pcCU->getTotalBits(), pcCU->getQP(0));
-      m_pcRateCtrl->updataRCUnitStatus();
+    }
-#endif
+  }
   if ((pcSlice->getPPS()->getNumSubstreams() > 1) && !depSliceSegmentsEnabled)
 …
     pcSlice->setNextSlice( true );
+  }
+  if(m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES || m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES)
+  {
+    if(pcSlice->getSliceCurEndCUAddr()<=pcSlice->getSliceSegmentCurEndCUAddr())
+    {
+       pcSlice->setNextSlice( true );
+    }
+    else
+    {
+       pcSlice->setNextSliceSegment( true );
+    }
+  }
   if( depSliceSegmentsEnabled )
+  {
 …
+  }
   xRestoreWPparam( pcSlice );
-#if !RATE_CONTROL_LAMBDA_DOMAIN
-  if(m_pcCfg->getUseRateCtrl())
+  {
-    m_pcRateCtrl->updateFrameData(m_uiPicTotalBits);
+  }
-#endif
+}
 …
        uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
+  {
-    if( m_pcCfg->getUseSBACRD() )
+    {
       uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
       uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
 …
+      }
       m_pcSbacCoder->load(&pcSbacCoders[uiSubStrm]);  //this load is used to simplify the code (avoid to change all the call to m_pcSbacCoder)
+    }
     // reset the entropy coder
     if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() &&                                   // must be first CU of tile
 …
 #endif
     TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
+    if ( pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma()) )
+    {
+      SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
+      Int iNumCuInWidth     = saoParam->numCuInWidth;
+      Int iCUAddrInSlice    = uiCUAddr - rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU());
+      Int iCUAddrUpInSlice  = iCUAddrInSlice - iNumCuInWidth;
+      Int rx = uiCUAddr % iNumCuInWidth;
+      Int ry = uiCUAddr / iNumCuInWidth;
+      Int allowMergeLeft = 1;
+      Int allowMergeUp   = 1;
+      if (rx!=0)
+      {
+        if (rpcPic->getPicSym()->getTileIdxMap(uiCUAddr-1) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))
+        {
+          allowMergeLeft = 0;
+        }
+      }
+      if (ry!=0)
+      {
+        if (rpcPic->getPicSym()->getTileIdxMap(uiCUAddr-iNumCuInWidth) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))
+        {
+          allowMergeUp = 0;
+        }
+      }
+      Int addr = pcCU->getAddr();
+      allowMergeLeft = allowMergeLeft && (rx>0) && (iCUAddrInSlice!=0);
+      allowMergeUp = allowMergeUp && (ry>0) && (iCUAddrUpInSlice>=0);
+      if( saoParam->bSaoFlag[0] || saoParam->bSaoFlag[1] )
+      {
+        Int mergeLeft = saoParam->saoLcuParam[0][addr].mergeLeftFlag;
+        Int mergeUp = saoParam->saoLcuParam[0][addr].mergeUpFlag;
+        if (allowMergeLeft)
+        {
+          m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(mergeLeft);
+        }
+        else
+        {
+          mergeLeft = 0;
+        }
+        if(mergeLeft == 0)
+        {
+          if (allowMergeUp)
+          {
+            m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(mergeUp);
+          }
+          else
+          {
+            mergeUp = 0;
+          }
+          if(mergeUp == 0)
+          {
+            for (Int compIdx=0;compIdx<3;compIdx++)
+            {
+            if( (compIdx == 0 && saoParam->bSaoFlag[0]) || (compIdx > 0 && saoParam->bSaoFlag[1]))
+              {
+                m_pcEntropyCoder->encodeSaoOffset(&saoParam->saoLcuParam[compIdx][addr], compIdx);
+              }
+            }
+          }
+        }
+      }
+    }
+    else if (pcSlice->getSPS()->getUseSAO())
+    {
+      Int addr = pcCU->getAddr();
+      SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
+      for (Int cIdx=0; cIdx<3; cIdx++)
+      {
+        SaoLcuParam *saoLcuParam = &(saoParam->saoLcuParam[cIdx][addr]);
+        if ( ((cIdx == 0) && !pcSlice->getSaoEnabledFlag()) || ((cIdx == 1 || cIdx == 2) && !pcSlice->getSaoEnabledFlagChroma()))
+        {
+          saoLcuParam->mergeUpFlag   = 0;
+          saoLcuParam->mergeLeftFlag = 0;
+          saoLcuParam->subTypeIdx    = 0;
+          saoLcuParam->typeIdx       = -1;
+          saoLcuParam->offset[0]     = 0;
+          saoLcuParam->offset[1]     = 0;
+          saoLcuParam->offset[2]     = 0;
+          saoLcuParam->offset[3]     = 0;
+        }
+    if ( pcSlice->getSPS()->getUseSAO() )
+    {
+      if (pcSlice->getSaoEnabledFlag()||pcSlice->getSaoEnabledFlagChroma())
+      {
+        SAOBlkParam& saoblkParam = (rpcPic->getPicSym()->getSAOBlkParam())[uiCUAddr];
+        Bool sliceEnabled[NUM_SAO_COMPONENTS];
+        sliceEnabled[SAO_Y] = pcSlice->getSaoEnabledFlag();
+        sliceEnabled[SAO_Cb]= sliceEnabled[SAO_Cr]= pcSlice->getSaoEnabledFlagChroma();
+        Bool leftMergeAvail = false;
+        Bool aboveMergeAvail= false;
+        //merge left condition
+        Int rx = (uiCUAddr % uiWidthInLCUs);
+        if(rx > 0)
+        {
+          leftMergeAvail = rpcPic->getSAOMergeAvailability(uiCUAddr, uiCUAddr-1);
+        }
+        //merge up condition
+        Int ry = (uiCUAddr / uiWidthInLCUs);
+        if(ry > 0)
+      {
+          aboveMergeAvail = rpcPic->getSAOMergeAvailability(uiCUAddr, uiCUAddr-uiWidthInLCUs);
+        }
+        m_pcEntropyCoder->encodeSAOBlkParam(saoblkParam,sliceEnabled, leftMergeAvail, aboveMergeAvail);
+      }
+    }
 …
     g_bJustDoIt = g_bEncDecTraceDisable;
 #endif
-    if( m_pcCfg->getUseSBACRD() )
+    {
        pcSbacCoders[uiSubStrm].load(m_pcSbacCoder);   //load back status of the entropy coder after encoding the LCU into relevant bitstream entropy coder
 …
+      }
+    }
-#if H_3D_QTLPC
-    rpcPic->setReduceBitsFlag(false);
-#endif
+  }
   if( depSliceSegmentsEnabled )
+  {

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncSlice.h

-                      r833
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   UInt                    m_uiSliceIdx;
   std::vector<TEncSbac*> CTXMem;
 #if MTK_DDD_G0063
   Int          m_iDDDScale;
 …
                                 Int iGOPid,   TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS, bool isField  );
 #endif
-#if RATE_CONTROL_LAMBDA_DOMAIN
   Void    resetQP             ( TComPic* pic, Int sliceQP, Double lambda );
-#else
-  Void    xLamdaRecalculation ( Int changeQP, Int idGOP, Int depth, SliceType eSliceType, TComSPS* pcSPS, TComSlice* pcSlice);
-#endif
   // compress and encode slice
   Void    precompressSlice    ( TComPic*& rpcPic                                );      ///< precompress slice for multi-loop opt.
   Void    compressSlice       ( TComPic*& rpcPic                                );      ///< analysis stage of slice
-#if RATE_CONTROL_INTRA
   Void    calCostSliceI       ( TComPic*& rpcPic );
-#endif
   Void    encodeSlice         ( TComPic*& rpcPic, TComOutputBitstream* pcSubstreams  );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncTop.cpp

-                      r773
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   if (m_bUseSAO)
+  {
+    m_cEncSAO.setSaoLcuBoundary(getSaoLcuBoundary());
+    m_cEncSAO.setSaoLcuBasedOptimization(getSaoLcuBasedOptimization());
+    m_cEncSAO.setMaxNumOffsetsPerPic(getMaxNumOffsetsPerPic());
+    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight );
+    m_cEncSAO.createEncBuffer();
+    m_cEncSAO.create( getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+#if SAO_ENCODE_ALLOW_USE_PREDEBLOCK
+    m_cEncSAO.createEncData(getSaoLcuBoundary());
+#else
+    m_cEncSAO.createEncData();
+#endif
+  }
 #if ADAPTIVE_QP_SELECTION
 …
   m_cLoopFilter.        create( g_uiMaxCUDepth );
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_RCEnableRateControl )
+  {
 …
 #endif
+  }
-#else
-#if KWU_FIX_URQ
-  if(m_enableRateCtrl)
-#endif
-    m_cRateCtrl.create(getIntraPeriod(), getGOPSize(), getFrameRate(), getTargetBitrate(), getQP(), getNumLCUInUnit(), getSourceWidth(), getSourceHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight);
-#endif
-  // if SBAC-based RD optimization is used
-  if( m_bUseSBACRD )
+  {
     m_pppcRDSbacCoder = new TEncSbac** [g_uiMaxCUDepth+1];
 #if FAST_BIT_EST
 …
+    }
+  }
+}
 /**
 …
     m_pcSbacCoders[ui].init( &m_pcBinCoderCABACs[ui] );
+  }
+  if( m_bUseSBACRD )
+  {
     m_ppppcRDSbacCoders      = new TEncSbac***    [iNumSubstreams];
     m_ppppcBinCodersCABAC    = new TEncBinCABAC***[iNumSubstreams];
 …
+    }
+  }
+}
 Void TEncTop::destroy ()
 …
   if (m_cSPS.getUseSAO())
+  {
+    m_cEncSAO.destroyEncData();
     m_cEncSAO.destroy();
-    m_cEncSAO.destroyEncBuffer();
+  }
   m_cLoopFilter.        destroy();
   m_cRateCtrl.          destroy();
+  // SBAC RD
+  if( m_bUseSBACRD )
+  {
     Int iDepth;
     for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
 …
     delete[] m_ppppcRDSbacCoders;
     delete[] m_ppppcBinCodersCABAC;
+  }
   delete[] m_pcSbacCoders;
   delete[] m_pcBinCoderCABACs;
 …
 #endif
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_RCEnableRateControl )
+  {
     m_cRateCtrl.initRCGOP( m_iNumPicRcvd );
+  }
-#endif
 #if H_MV
+  }
 …
 #endif
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_RCEnableRateControl )
+  {
     m_cRateCtrl.destroyRCGOP();
+  }
-#endif
   iNumEncoded         = m_iNumPicRcvd;
 …
     TComPic *pcTopField;
     xGetNewPicBuffer( pcTopField );
-    pcTopField->getPicSym()->allocSaoParam(&m_cEncSAO);
     pcTopField->setReconMark (false);
 …
     Pel * pcTopFieldV =  pcTopField->getPicYuvOrg()->getCrAddr();
-    // compute image characteristics
-    if ( getUseAdaptiveQP() )
+    {
-      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcTopField ) );
+    }
     /* -- Defield -- */
 …
     separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcTopFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
+    // compute image characteristics
+    if ( getUseAdaptiveQP() )
+    {
+      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcTopField ) );
+    }
+  }
 …
     TComPic* pcBottomField;
     xGetNewPicBuffer( pcBottomField );
-    pcBottomField->getPicSym()->allocSaoParam(&m_cEncSAO);
     pcBottomField->setReconMark (false);
     TComPicYuv* rpcPicYuvRec = new TComPicYuv;
+    TComPicYuv* rpcPicYuvRec;
     if ( rcListPicYuvRecOut.size() == (UInt)m_iGOPSize )
+    {
 …
     else
+    {
+      rpcPicYuvRec = new TComPicYuv;
       rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
+    }
 …
     Pel * pcBottomFieldV =  pcBottomField->getPicYuvOrg()->getCrAddr();
-    // Compute image characteristics
-    if ( getUseAdaptiveQP() )
+    {
-      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcBottomField ) );
+    }
     /* -- Defield -- */
 …
     separateFields(PicBufV + nPadChroma + (nStride >> 1)*nPadChroma, pcBottomFieldV, nStride >> 1, nWidth >> 1, nHeight >> 1, isTop);
+    // Compute image characteristics
+    if ( getUseAdaptiveQP() )
+    {
+      m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcBottomField ) );
+    }
+  }
 …
   m_uiNumAllPicCoded += iNumEncoded;
+}
-#endif
 // ====================================================================================================================
 …
       rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth,
                       m_conformanceWindow, m_defaultDisplayWindow, m_numReorderPics);
+    }
-    if (getUseSAO())
+    {
-      rpcPic->getPicSym()->allocSaoParam(&m_cEncSAO);
+    }
     m_cListPic.pushBack( rpcPic );
 …
   m_cSPS.setTMVPFlagsPresent(false);
-  m_cSPS.setUseLossless   ( m_useLossless  );
   m_cSPS.setMaxTrSize   ( 1 << m_uiQuadtreeTULog2MaxSize );
 …
   m_cSPS.setMaxTLayers( m_maxTempLayer );
   m_cSPS.setTemporalIdNestingFlag( ( m_maxTempLayer == 1 ) ? true : false );
   for ( i = 0; i < m_cSPS.getMaxTLayers(); i++ )
+  for ( i = 0; i < min(m_cSPS.getMaxTLayers(),(UInt) MAX_TLAYER); i++ )
+  {
     m_cSPS.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
 …
   m_cPPS.setSPSId( getLayerIdInVps() );
 #endif
 #if H_3D
   m_cPPS.setDLT( getDLT() );
 #endif
   m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
   Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
-  Int lowestQP = - m_cSPS.getQpBDOffsetY();
-  if(getUseLossless())
+  {
-    if ((getMaxCuDQPDepth() == 0) && (getMaxDeltaQP() == 0 ) && (getQP() == lowestQP) )
+    {
-      bUseDQP = false;
+    }
-    else
+    {
-      bUseDQP = true;
+    }
+  }
-  else
+  {
-    if(bUseDQP == false)
+    {
       if((getMaxDeltaQP() != 0 )|| getUseAdaptiveQP())
+      {
         bUseDQP = true;
+      }
+    }
+  }
   if(bUseDQP)
 …
+  }
-#if RATE_CONTROL_LAMBDA_DOMAIN
   if ( m_RCEnableRateControl )
+  {
 …
     m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
+  }
-#endif
-#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_FIX_URQ
-  if ( m_enableRateCtrl )
+  {
-    m_cPPS.setUseDQP(true);
-    m_cPPS.setMaxCuDQPDepth( 0 );
-    m_cPPS.setMinCuDQPSize( m_cPPS.getSPS()->getMaxCUWidth() >> ( m_cPPS.getMaxCuDQPDepth()) );
+  }
-#endif
   m_cPPS.setChromaCbQpOffset( m_chromaCbQpOffset );

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/TEncTop.h

-                      r655
+                      r837
  * granted under this license.
+ *
  * Copyright (c) 2010-2013, ITU/ISO/IEC
+* Copyright (c) 2010-2014, ITU/ISO/IEC
  * All rights reserved.
+ *
 …
   // encoder search
   TEncSearch              m_cSearch;                      ///< encoder search class
   TEncEntropy*            m_pcEntropyCoder;                     ///< entropy encoder
+  //TEncEntropy*            m_pcEntropyCoder;                     ///< entropy encoder
   TEncCavlc*              m_pcCavlcCoder;                       ///< CAVLC encoder
   // coding tool

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/WeightPredAnalysis.cpp

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibEncoder/WeightPredAnalysis.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibVideoIO/TVideoIOYuv.cpp

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/TLibVideoIO/TVideoIOYuv.h

r655	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/libmd5/MD5.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

branches/HTM-10.0rc1-dev0/source/Lib/libmd5/libmd5.h

r608	r837
4	4	* granted under this license.
5	5	*
6		* Copyright (c) 2010-2013, ITU/ISO/IEC
	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
7	7	* All rights reserved.
8	8	*

Context navigation

Changeset 837 in 3DVCSoftware

Legend: