Changeset 5 in 3DVCSoftware for trunk/source/Lib


Ignore:
Timestamp:
12 Dec 2011, 18:35:44 (13 years ago)
Author:
hhi
Message:

Clean version with cfg-files

Location:
trunk/source/Lib
Files:
124 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/Lib/TLibCommon/CommonDef.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    1548#include "TComRom.h"
    1649
    17 // SB
    1850#include <string>
    1951#include <assert.h>
     
    2658
    2759#define HM_VERSION        "3.0rc2"                 ///< Current software version
    28 #define NV_VERSION        "0.31r4"                   ///< Current software version
     60#define NV_VERSION        "0.37"                   ///< Current software version
    2961
    3062// ====================================================================================================================
     
    70102
    71103
    72 #define SEBASTIAN                   1
    73 #if     SEBASTIAN
    74 #define SB_INTERVIEW_SKIP           1
    75 #define SB_INTERVIEW_SKIP_LAMBDA_SCALE 1
    76 #define SB_MEM_FIX                  1
    77 #define SB_NO_LowDelayCoding        0   // noch offen in motionestimation
    78 #endif
    79 
    80 #define GERHARD                     1
    81 #if     GERHARD
    82 #define GERHARD_VQM_XCHECK          0
    83 #define GERHARD_RM_DEBUG_MM         0
    84 #define GERHARD_RM_HOLE_EXT         0
    85 #define GERHARD_RM_COLOR_PLANES     1
    86 #define GERHARD_RM_SPLAT            1
    87 #endif
    88 
    89 
    90104// ====================================================================================================================
    91105// Common constants
     
    116130#define STD_CAM_PARAMETERS_PRECISION 5        ///< quarter luma sample accuarcy for derived disparities (as default)
    117131
    118 // SB
    119132#define MAX_INPUT_VIEW_NUM                                      10                              ///< max. number of input view for multiview coding
    120133
    121 // GT
     134#if HHI_VSO
    122135#define MAX_ERREF_VIEW_NUM                                      15                              ///< max. number of virtual external reference views
     136#endif
    123137#define LOG2_DISP_PREC_LUT                              2                               ///< log2 of disparity precision used in integer disparity LUTs
    124138
     139
     140#if ( HHI_INTER_VIEW_MOTION_PRED || HHI_INTER_VIEW_RESIDUAL_PRED )
     141#define DEPTH_MAP_GENERATION        1
     142#else
     143#define DEPTH_MAP_GENERATION        0
     144#endif
    125145
    126146//>>>>> generation and usage of virtual prediction depth maps >>>>>
     
    151171#define OUTPUT_RESIDUAL_PICTURES          0         // output residual pictures (for debugging)
    152172
    153 #define MVI_MERGE_POS                     0         // position of mvi in merge list (0..5)
     173#define HHI_MPI_MERGE_POS                     0         // position of mvi in merge list (0..5)
    154174
    155175
     
    298318#endif
    299319
    300 // SB from ViCo for formatted string parsing
    301320
    302321class VideoCodecException
  • trunk/source/Lib/TLibCommon/ContextModel.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/ContextModel.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/ContextModel3DBuffer.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/ContextModel3DBuffer.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/ContextTables.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    1447
    1548#define NUM_SPLIT_FLAG_CTX            3       ///< number of context models for split flag
    16 #if MW_MVI_SIGNALLING_MODE == 0
    17 #define NUM_MVI_FLAG_CTX              3       ///< number of context models for motion inheritance flag
    18 #endif
    1949#define NUM_SKIP_FLAG_CTX             3       ///< number of context models for skip flag
    2050
     
    72102#define NUM_VIEW_IDX_CTX              6
    73103
    74 #if HHI_DMM_INTRA
     104#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    75105#define NUM_DMM_CTX                   2
    76106#define NUM_WEDGE_CTX                 4
     
    120150  }
    121151};
    122 
    123 #if MW_MVI_SIGNALLING_MODE == 0
    124 // initial probability for skip flag
    125 static const Short
    126 INIT_MVI_FLAG[3][NUM_MVI_FLAG_CTX][2] =
    127 {
    128   {
    129     {    0,   64 }, {    0,   64 }, {    0,   64 }
    130   },
    131   {
    132     {    0,   64 }, {    0,   64 }, {    0,   64 }
    133   },
    134   {
    135     {    0,   64 }, {    0,   64 }, {    0,   64 }
    136   }
    137 };
    138 #endif
    139152
    140153// initial probability for skip flag
     
    13241337};
    13251338
    1326 #if HHI_DMM_INTRA
     1339#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    13271340static const Short
    13281341INIT_INTRA_DMM[3][NUM_DMM_CTX][2] =
  • trunk/source/Lib/TLibCommon/SEI.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComAdaptiveLoopFilter.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    278311  m_bUseNonCrossALF = false;
    279312#endif
    280 #if SB_MEM_FIX
    281313  m_bIsCreated = false;
    282 #endif
    283314}
    284315
     
    471502Void TComAdaptiveLoopFilter::create( Int iPicWidth, Int iPicHeight, UInt uiMaxCUWidth, UInt uiMaxCUHeight, UInt uiMaxCUDepth )
    472503{
    473 #if SB_MEM_FIX
    474504  m_bIsCreated = true;
    475 #endif
    476505  if ( !m_pcTempPicYuv )
    477506  {
     
    514543Void TComAdaptiveLoopFilter::destroy()
    515544{
    516 #if SB_MEM_FIX
    517545  m_bIsCreated = false ;
    518 #endif
    519546  if ( m_pcTempPicYuv )
    520547  {
  • trunk/source/Lib/TLibCommon/TComAdaptiveLoopFilter.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    336369  Bool        m_bIsFirstDecodedSlice;
    337370
    338 #if SB_MEM_FIX
    339371  Bool        m_bIsCreated;
    340 #endif
    341372  Void xFilterOneSlice            (CAlfSlice* pSlice, imgpel* pDec, imgpel* pRest, Int iStride, ALFParam* pcAlfParam);
    342373  Void calcVarforOneSlice         (CAlfSlice* pSlice, imgpel **imgY_var, imgpel *imgY_pad, Int pad_size, Int fl, Int img_stride);
     
    408439  Void destroy ();
    409440 
    410 #if SB_MEM_FIX
    411441  Bool isCreated() { return m_bIsCreated;}
    412 #endif
    413442  // alloc & free & set functions
    414443  Void allocALFParam  ( ALFParam* pAlfParam );
  • trunk/source/Lib/TLibCommon/TComBitCounter.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComBitStream.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComBitStream.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComCABACTables.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComCABACTables.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComDataCU.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    2053  m_pcSlice            = NULL;
    2154  m_puhDepth           = NULL;
     55#if HHI_MPI
    2256  m_piTextureModeDepth = NULL;
     57#endif
    2358 
    2459  m_pePartSize         = NULL;
     
    3166  m_pbMergeFlag        = NULL;
    3267  m_puhMergeIndex      = NULL;
     68#if HHI_INTER_VIEW_RESIDUAL_PRED
    3369  m_pbResPredAvailable = NULL;
    3470  m_pbResPredFlag      = NULL;
     71#endif
    3572  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    3673  {
     
    71108#endif//SNY_DQP
    72109
    73 #if HHI_DMM_INTRA
     110#if HHI_DMM_WEDGE_INTRA
    74111  m_puiWedgeFullTabIdx  = NULL;
    75112  m_piWedgeFullDeltaDC1       = NULL;
     
    80117  m_piWedgePredDirDeltaDC2   = NULL;
    81118  m_piWedgePredDirDeltaEnd   = NULL;
    82 
     119#endif
     120#if HHI_DMM_PRED_TEX
    83121  m_puiWedgePredTexTabIdx     = NULL;
    84122  m_piWedgePredTexDeltaDC1    = NULL;
     
    87125  m_piContourPredTexDeltaDC1  = NULL;
    88126  m_piContourPredTexDeltaDC2  = NULL;
    89 
    90   m_pbTextureModesAllowed     = NULL;
    91127#endif
    92128}
     
    108144    m_phQP               = (UChar*    )xMalloc(UChar,    uiNumPartition);
    109145    m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
     146#if HHI_MPI
    110147    m_piTextureModeDepth = (Int*      )xMalloc(Int,      uiNumPartition);
     148#endif
    111149    m_puhWidth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
    112150    m_puhHeight          = (UChar*    )xMalloc(UChar,    uiNumPartition);
     
    118156    m_pbMergeFlag        = (Bool*  )xMalloc(Bool,   uiNumPartition);
    119157    m_puhMergeIndex      = (UChar* )xMalloc(UChar,  uiNumPartition);
     158#if HHI_INTER_VIEW_RESIDUAL_PRED
    120159    m_pbResPredAvailable = (Bool*  )xMalloc(Bool,   uiNumPartition);
    121160    m_pbResPredFlag      = (Bool*  )xMalloc(Bool,   uiNumPartition);
     161#endif
    122162    for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    123163    {
     
    147187    m_acCUMvField[1].create( uiNumPartition );
    148188   
    149 #if HHI_DMM_INTRA
    150     m_puiWedgeFullTabIdx  = (UInt*   )xMalloc(UInt,    uiNumPartition);
     189#if HHI_DMM_WEDGE_INTRA
     190    m_puiWedgeFullTabIdx       = (UInt*)xMalloc(UInt, uiNumPartition);
    151191    m_piWedgeFullDeltaDC1       = (Int* )xMalloc(Int,  uiNumPartition);
    152192    m_piWedgeFullDeltaDC2       = (Int* )xMalloc(Int,  uiNumPartition);
     
    156196    m_piWedgePredDirDeltaDC2   = (Int* )xMalloc(Int,  uiNumPartition);
    157197    m_piWedgePredDirDeltaEnd   = (Int* )xMalloc(Int,  uiNumPartition);
    158 
     198#endif
     199#if HHI_DMM_PRED_TEX
    159200    m_puiWedgePredTexTabIdx     = (UInt*)xMalloc(UInt, uiNumPartition);
    160201    m_piWedgePredTexDeltaDC1    = (Int* )xMalloc(Int,  uiNumPartition);
     
    163204    m_piContourPredTexDeltaDC1  = (Int* )xMalloc(Int,  uiNumPartition);
    164205    m_piContourPredTexDeltaDC2  = (Int* )xMalloc(Int,  uiNumPartition);
    165 
    166     m_pbTextureModesAllowed     = (Bool*)xMalloc(Bool, uiNumPartition);
    167206#endif
    168207  }
     
    203242    if ( m_phQP               ) { xFree(m_phQP);                m_phQP              = NULL; }
    204243    if ( m_puhDepth           ) { xFree(m_puhDepth);            m_puhDepth          = NULL; }
     244#if HHI_MPI
    205245    if ( m_piTextureModeDepth ) { xFree(m_piTextureModeDepth);  m_piTextureModeDepth= NULL; }
     246#endif
    206247    if ( m_puhWidth           ) { xFree(m_puhWidth);            m_puhWidth          = NULL; }
    207248    if ( m_puhHeight          ) { xFree(m_puhHeight);           m_puhHeight         = NULL; }
     
    215256    if ( m_pbMergeFlag        ) { xFree(m_pbMergeFlag);         m_pbMergeFlag       = NULL; }
    216257    if ( m_puhMergeIndex      ) { xFree(m_puhMergeIndex);       m_puhMergeIndex     = NULL; }
     258#if HHI_INTER_VIEW_RESIDUAL_PRED
    217259    if ( m_pbResPredAvailable ) { xFree(m_pbResPredAvailable);  m_pbResPredAvailable= NULL; }
    218260    if ( m_pbResPredFlag      ) { xFree(m_pbResPredFlag);       m_pbResPredFlag     = NULL; }
     261#endif
    219262    for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    220263    {
     
    235278    m_acCUMvField[1].destroy();
    236279   
    237 #if HHI_DMM_INTRA
     280#if HHI_DMM_WEDGE_INTRA
    238281    if ( m_puiWedgeFullTabIdx  ) { xFree(m_puiWedgeFullTabIdx);   m_puiWedgeFullTabIdx  = NULL; }
    239282    if ( m_piWedgeFullDeltaDC1  ) { xFree(m_piWedgeFullDeltaDC1);   m_piWedgeFullDeltaDC1  = NULL; }
     
    244287    if ( m_piWedgePredDirDeltaDC1 ) { xFree(m_piWedgePredDirDeltaDC1); m_piWedgePredDirDeltaDC1 = NULL; }
    245288    if ( m_piWedgePredDirDeltaDC2 ) { xFree(m_piWedgePredDirDeltaDC2); m_piWedgePredDirDeltaDC2 = NULL; }
    246 
     289#endif
     290#if HHI_DMM_PRED_TEX
    247291    if ( m_puiWedgePredTexTabIdx     ) { xFree(m_puiWedgePredTexTabIdx);     m_puiWedgePredTexTabIdx     = NULL; }
    248292    if ( m_piWedgePredTexDeltaDC1    ) { xFree(m_piWedgePredTexDeltaDC1);    m_piWedgePredTexDeltaDC1    = NULL; }
     
    251295    if ( m_piContourPredTexDeltaDC1  ) { xFree(m_piContourPredTexDeltaDC1);  m_piContourPredTexDeltaDC1  = NULL; }
    252296    if ( m_piContourPredTexDeltaDC2  ) { xFree(m_piContourPredTexDeltaDC2);  m_piContourPredTexDeltaDC2  = NULL; }
    253 
    254     if ( m_pbTextureModesAllowed     ) { xFree(m_pbTextureModesAllowed   );  m_pbTextureModesAllowed     = NULL; }
    255297#endif   
    256298  }
     
    308350  memset( m_pbMergeFlag,        0, iSizeInBool  );
    309351  memset( m_puhMergeIndex,      0, iSizeInUchar );
     352#if HHI_INTER_VIEW_RESIDUAL_PRED
    310353  memset( m_pbResPredAvailable, 0, iSizeInBool  );
    311354  memset( m_pbResPredFlag,      0, iSizeInBool  );
     355#endif
    312356  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    313357  {
     
    322366  memset( m_puhCbf[2],          0, iSizeInUchar );
    323367  memset( m_puhDepth,           0, iSizeInUchar );
     368#if HHI_MPI
    324369  memset( m_piTextureModeDepth,-1, iSizeInInt );
     370#endif
    325371 
    326372  UChar uhWidth  = g_uiMaxCUWidth;
     
    390436  }
    391437
    392 #if HHI_DMM_INTRA
     438#if HHI_DMM_WEDGE_INTRA
    393439  memset( m_puiWedgeFullTabIdx,  0, iSizeInUInt   );
    394440  memset( m_piWedgeFullDeltaDC1,       0, iSizeInInt  );
     
    399445  memset( m_piWedgePredDirDeltaDC2,   0, iSizeInInt  );
    400446  memset( m_piWedgePredDirDeltaEnd,   0, iSizeInInt  );
    401 
     447#endif
     448#if HHI_DMM_PRED_TEX
    402449  memset( m_puiWedgePredTexTabIdx,     0, iSizeInUInt );
    403450  memset( m_piWedgePredTexDeltaDC1,    0, iSizeInInt  );
     
    406453  memset( m_piContourPredTexDeltaDC1,  0, iSizeInInt  );
    407454  memset( m_piContourPredTexDeltaDC2,  0, iSizeInInt  );
    408 
    409   memset( m_pbTextureModesAllowed,  false, iSizeInBool );
    410455#endif   
    411456}
     
    426471  memset( m_pbMergeFlag,        0, iSizeInBool  );
    427472  memset( m_puhMergeIndex,      0, iSizeInUchar );
     473#if HHI_INTER_VIEW_RESIDUAL_PRED
    428474  memset( m_pbResPredAvailable, 0, iSizeInBool  );
    429475  memset( m_pbResPredFlag,      0, iSizeInBool  );
     476#endif
    430477  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    431478  {
     
    461508  m_acCUMvField[1].clearMvField();
    462509
    463 #if HHI_DMM_INTRA
     510#if HHI_DMM_WEDGE_INTRA
    464511  memset( m_puiWedgeFullTabIdx,  0, iSizeInUInt   );
    465512  memset( m_piWedgeFullDeltaDC1,       0, iSizeInInt  );
     
    470517  memset( m_piWedgePredDirDeltaDC2,   0, iSizeInInt  );
    471518  memset( m_piWedgePredDirDeltaEnd,   0, iSizeInInt  );
    472 
     519#endif
     520#if HHI_DMM_PRED_TEX
    473521  memset( m_puiWedgePredTexTabIdx,     0, iSizeInUInt );
    474522  memset( m_piWedgePredTexDeltaDC1,    0, iSizeInInt  );
     
    477525  memset( m_piContourPredTexDeltaDC1,  0, iSizeInInt  );
    478526  memset( m_piContourPredTexDeltaDC2,  0, iSizeInInt  );
    479 
    480   memset( m_pbTextureModesAllowed,  false, iSizeInBool );
    481527#endif   
    482528
     529#if HHI_MPI
    483530  memset( m_piTextureModeDepth, -1, iSizeInInt );
     531#endif
    484532}
    485533
     
    513561  memset( m_pbMergeFlag,        0, iSizeInBool  );
    514562  memset( m_puhMergeIndex,      0, iSizeInUchar );
     563#if HHI_INTER_VIEW_RESIDUAL_PRED
    515564  memset( m_pbResPredAvailable, 0, iSizeInBool  );
    516565  memset( m_pbResPredFlag,      0, iSizeInBool  );
     566#endif
    517567  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    518568  {
     
    527577  memset( m_puhCbf[2],          0, iSizeInUchar );
    528578  memset( m_puhDepth,     uiDepth, iSizeInUchar );
     579#if HHI_MPI
    529580  memset( m_piTextureModeDepth, -1, iSizeInInt );
     581#endif
    530582 
    531583  UChar uhWidth  = g_uiMaxCUWidth  >> uiDepth;
     
    565617  m_uiEntropySliceStartCU   = pcCU->getEntropySliceStartCU();
    566618
    567 #if HHI_DMM_INTRA
     619#if HHI_DMM_WEDGE_INTRA
    568620  memset( m_puiWedgeFullTabIdx,  0, iSizeInUInt   );
    569621  memset( m_piWedgeFullDeltaDC1,       0, iSizeInInt  );
     
    574626  memset( m_piWedgePredDirDeltaDC2,   0, iSizeInInt  );
    575627  memset( m_piWedgePredDirDeltaEnd,   0, iSizeInInt  );
    576 
     628#endif
     629#if HHI_DMM_PRED_TEX
    577630  memset( m_puiWedgePredTexTabIdx,     0, iSizeInUInt );
    578631  memset( m_piWedgePredTexDeltaDC1,    0, iSizeInInt  );
     
    581634  memset( m_piContourPredTexDeltaDC1,  0, iSizeInInt  );
    582635  memset( m_piContourPredTexDeltaDC2,  0, iSizeInInt  );
    583 
    584   memset( m_pbTextureModesAllowed,  false, iSizeInBool );
    585636#endif
    586637}
     
    611662  m_pbMergeFlag         = pcCU->getMergeFlag()        + uiPart;
    612663  m_puhMergeIndex       = pcCU->getMergeIndex()       + uiPart;
     664#if HHI_INTER_VIEW_RESIDUAL_PRED
    613665  m_pbResPredAvailable  = pcCU->getResPredAvail()     + uiPart;
    614666  m_pbResPredFlag       = pcCU->getResPredFlag ()     + uiPart;
     667#endif
    615668  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    616669  {
     
    630683  m_puhWidth=pcCU->getWidth()                     + uiPart;
    631684  m_puhHeight=pcCU->getHeight()                   + uiPart;
     685#if HHI_MPI
    632686  m_piTextureModeDepth=pcCU->getTextureModeDepth()+ uiPart;
     687#endif
    633688 
    634689  m_apiMVPIdx[0]=pcCU->getMVPIdx(REF_PIC_LIST_0)  + uiPart;
     
    667722  m_uiEntropySliceStartCU = pcCU->getEntropySliceStartCU();
    668723
    669 #if HHI_DMM_INTRA
     724#if HHI_DMM_WEDGE_INTRA
    670725  m_puiWedgeFullTabIdx  = pcCU->getWedgeFullTabIdx()  + uiPart;   
    671726  m_piWedgeFullDeltaDC1       = pcCU->getWedgeFullDeltaDC1()      + uiPart;   
     
    676731  m_piWedgePredDirDeltaDC2   = pcCU->getWedgePredDirDeltaDC2()   + uiPart;   
    677732  m_piWedgePredDirDeltaEnd   = pcCU->getWedgePredDirDeltaEnd()   + uiPart;
    678 
     733#endif
     734#if HHI_DMM_PRED_TEX
    679735  m_puiWedgePredTexTabIdx     = pcCU->getWedgePredTexTabIdx()     + uiPart;   
    680736  m_piWedgePredTexDeltaDC1    = pcCU->getWedgePredTexDeltaDC1()   + uiPart;   
     
    683739  m_piContourPredTexDeltaDC1  = pcCU->getContourPredTexDeltaDC1() + uiPart;   
    684740  m_piContourPredTexDeltaDC2  = pcCU->getContourPredTexDeltaDC2() + uiPart;   
    685 
    686   m_pbTextureModesAllowed     = pcCU->getTextureModeAllowance()   + uiPart;   
    687741#endif
    688742}
     
    718772  m_pbMergeFlag        = pcCU->getMergeFlag()             + uiAbsPartIdx;
    719773  m_puhMergeIndex      = pcCU->getMergeIndex()            + uiAbsPartIdx;
     774#if HHI_INTER_VIEW_RESIDUAL_PRED
    720775  m_pbResPredAvailable = pcCU->getResPredAvail()          + uiAbsPartIdx;
    721776  m_pbResPredFlag      = pcCU->getResPredFlag ()          + uiAbsPartIdx;
     777#endif
    722778  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui ++ )
    723779  {
     
    731787  m_acCUMvField[eRefPicList].setMvdPtr(pcCU->getCUMvField(eRefPicList)->getMvd()    + uiAbsPartIdx);
    732788  m_acCUMvField[eRefPicList].setRefIdxPtr(pcCU->getCUMvField(eRefPicList)->getRefIdx() + uiAbsPartIdx);
     789#if HHI_MPI
    733790  m_piTextureModeDepth = pcCU->getTextureModeDepth() + uiAbsPartIdx;
     791#endif
    734792
    735793  m_uiSliceStartCU        = pcCU->getSliceStartCU();
     
    762820  memcpy( m_pbMergeFlag         + uiOffset, pcCU->getMergeFlag(),         iSizeInBool  );
    763821  memcpy( m_puhMergeIndex       + uiOffset, pcCU->getMergeIndex(),        iSizeInUchar );
     822#if HHI_INTER_VIEW_RESIDUAL_PRED
    764823  memcpy( m_pbResPredAvailable  + uiOffset, pcCU->getResPredAvail(),      iSizeInBool  );
    765824  memcpy( m_pbResPredFlag       + uiOffset, pcCU->getResPredFlag(),       iSizeInBool  );
     825#endif
    766826  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    767827  {
     
    807867  m_uiEntropySliceStartCU = pcCU->getEntropySliceStartCU();
    808868
    809 #if HHI_DMM_INTRA
     869#if HHI_DMM_WEDGE_INTRA
    810870  memcpy( m_puiWedgeFullTabIdx   + uiOffset, pcCU->getWedgeFullTabIdx(),    iSizeInUInt    );
    811871  memcpy( m_piWedgeFullDeltaDC1       + uiOffset, pcCU->getWedgeFullDeltaDC1(),      iSizeInInt  );
     
    816876  memcpy( m_piWedgePredDirDeltaDC2   + uiOffset, pcCU->getWedgePredDirDeltaDC2(),   iSizeInInt  );
    817877  memcpy( m_piWedgePredDirDeltaEnd   + uiOffset, pcCU->getWedgePredDirDeltaEnd(),   iSizeInInt  );
    818 
     878#endif
     879#if HHI_DMM_PRED_TEX
    819880  memcpy( m_puiWedgePredTexTabIdx     + uiOffset, pcCU->getWedgePredTexTabIdx(),     iSizeInUInt );
    820881  memcpy( m_piWedgePredTexDeltaDC1    + uiOffset, pcCU->getWedgePredTexDeltaDC1(),   iSizeInInt  );
     
    823884  memcpy( m_piContourPredTexDeltaDC1  + uiOffset, pcCU->getContourPredTexDeltaDC1(), iSizeInInt  );
    824885  memcpy( m_piContourPredTexDeltaDC2  + uiOffset, pcCU->getContourPredTexDeltaDC2(), iSizeInInt  );
    825 
    826   memcpy( m_pbTextureModesAllowed     + uiOffset, pcCU->getTextureModeAllowance(),   iSizeInBool );
    827 #endif
    828 
     886#endif
     887
     888#if HHI_MPI
    829889  memcpy( m_piTextureModeDepth + uiOffset, pcCU->getTextureModeDepth(), iSizeInInt );
     890#endif
    830891}
    831892
     
    854915  memcpy( rpcCU->getMergeFlag()         + m_uiAbsIdxInLCU, m_pbMergeFlag,         iSizeInBool  );
    855916  memcpy( rpcCU->getMergeIndex()        + m_uiAbsIdxInLCU, m_puhMergeIndex,       iSizeInUchar );
     917#if HHI_INTER_VIEW_RESIDUAL_PRED
    856918  memcpy( rpcCU->getResPredAvail()      + m_uiAbsIdxInLCU, m_pbResPredAvailable,  iSizeInBool  );
    857919  memcpy( rpcCU->getResPredFlag()       + m_uiAbsIdxInLCU, m_pbResPredFlag,       iSizeInBool  );
     920#endif
    858921  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    859922  {
     
    891954  rpcCU->setEntropySliceStartCU( m_uiEntropySliceStartCU );
    892955
    893 #if HHI_DMM_INTRA
     956#if HHI_DMM_WEDGE_INTRA
    894957  memcpy( rpcCU->getWedgeFullTabIdx()  + m_uiAbsIdxInLCU, m_puiWedgeFullTabIdx,  iSizeInUInt   );
    895958  memcpy( rpcCU->getWedgeFullDeltaDC1()      + m_uiAbsIdxInLCU, m_piWedgeFullDeltaDC1,       iSizeInInt  );
     
    900963  memcpy( rpcCU->getWedgePredDirDeltaDC2()   + m_uiAbsIdxInLCU, m_piWedgePredDirDeltaDC2,   iSizeInInt  );
    901964  memcpy( rpcCU->getWedgePredDirDeltaEnd()   + m_uiAbsIdxInLCU, m_piWedgePredDirDeltaEnd,   iSizeInInt  );
    902 
     965#endif
     966#if HHI_DMM_PRED_TEX
    903967  memcpy( rpcCU->getWedgePredTexTabIdx()     + m_uiAbsIdxInLCU, m_puiWedgePredTexTabIdx,     iSizeInUInt );
    904968  memcpy( rpcCU->getWedgePredTexDeltaDC1()   + m_uiAbsIdxInLCU, m_piWedgePredTexDeltaDC1,    iSizeInInt  );
     
    907971  memcpy( rpcCU->getContourPredTexDeltaDC1() + m_uiAbsIdxInLCU, m_piContourPredTexDeltaDC1,  iSizeInInt  );
    908972  memcpy( rpcCU->getContourPredTexDeltaDC2() + m_uiAbsIdxInLCU, m_piContourPredTexDeltaDC2,  iSizeInInt  );
    909 
    910   memcpy( rpcCU->getTextureModeAllowance()   + m_uiAbsIdxInLCU, m_pbTextureModesAllowed,     iSizeInBool  );
    911 #endif
    912 
     973#endif
     974
     975#if HHI_MPI
    913976  memcpy( rpcCU->getTextureModeDepth() + m_uiAbsIdxInLCU, m_piTextureModeDepth, iSizeInInt );
     977#endif
    914978}
    915979
     
    9391003  memcpy( rpcCU->getMergeFlag()         + uiPartOffset, m_pbMergeFlag,         iSizeInBool  );
    9401004  memcpy( rpcCU->getMergeIndex()        + uiPartOffset, m_puhMergeIndex,       iSizeInUchar );
     1005#if HHI_INTER_VIEW_RESIDUAL_PRED
    9411006  memcpy( rpcCU->getResPredAvail()      + uiPartOffset, m_pbResPredAvailable,  iSizeInBool  );
    9421007  memcpy( rpcCU->getResPredFlag()       + uiPartOffset, m_pbResPredFlag,       iSizeInBool  );
     1008#endif
    9431009  for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ui++ )
    9441010  {
     
    9751041  rpcCU->setEntropySliceStartCU( m_uiEntropySliceStartCU );
    9761042
    977 #if HHI_DMM_INTRA
     1043#if HHI_DMM_WEDGE_INTRA
    9781044  memcpy( rpcCU->getWedgeFullTabIdx()  + uiPartOffset, m_puiWedgeFullTabIdx,  iSizeInUInt   );
    9791045  memcpy( rpcCU->getWedgeFullDeltaDC1()      + uiPartOffset, m_piWedgeFullDeltaDC1,       iSizeInInt  );
     
    9841050  memcpy( rpcCU->getWedgePredDirDeltaDC2()   + uiPartOffset, m_piWedgePredDirDeltaDC2,   iSizeInInt  );
    9851051  memcpy( rpcCU->getWedgePredDirDeltaEnd()   + uiPartOffset, m_piWedgePredDirDeltaEnd,   iSizeInInt  );
    986 
     1052#endif
     1053#if HHI_DMM_PRED_TEX
    9871054  memcpy( rpcCU->getWedgePredTexTabIdx()     + uiPartOffset, m_puiWedgePredTexTabIdx,     iSizeInUInt );
    9881055  memcpy( rpcCU->getWedgePredTexDeltaDC1()   + uiPartOffset, m_piWedgePredTexDeltaDC1,    iSizeInInt  );
     
    9911058  memcpy( rpcCU->getContourPredTexDeltaDC1() + uiPartOffset, m_piContourPredTexDeltaDC1,  iSizeInInt  );
    9921059  memcpy( rpcCU->getContourPredTexDeltaDC2() + uiPartOffset, m_piContourPredTexDeltaDC2,  iSizeInInt  );
    993 
    994   memcpy( rpcCU->getTextureModeAllowance()   + uiPartOffset, m_pbTextureModesAllowed,     iSizeInBool  );
    995 #endif
    996 
     1060#endif
     1061
     1062#if HHI_MPI
    9971063  memcpy( rpcCU->getTextureModeDepth() + uiPartOffset, m_piTextureModeDepth, iSizeInInt );
     1064#endif
    9981065}
    9991066
     
    13561423}
    13571424
    1358 
    1359 #if HHI_DMM_INTRA
     1425#if HHI_DMM_WEDGE_INTRA
    13601426Void TComDataCU::setWedgeFullTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
    13611427{
     
    14271493  }
    14281494}
    1429 
     1495#endif
     1496#if HHI_DMM_PRED_TEX
    14301497Void TComDataCU::setWedgePredTexTabIdxSubParts( UInt uiTIdx, UInt uiAbsPartIdx, UInt uiDepth )
    14311498{
     
    14771544  }
    14781545}
    1479 
    1480 Void TComDataCU::setTextureModeAllowanceSubParts ( Bool bTMAllowed, UInt uiAbsPartIdx, UInt uiDepth )
    1481 {
    1482   UInt uiCurrPartNumb = m_pcPic->getNumPartInCU() >> (uiDepth << 1);
    1483 
    1484   memset( m_pbTextureModesAllowed + uiAbsPartIdx, bTMAllowed, sizeof(Bool)*uiCurrPartNumb );
    1485 }
    1486 #endif
    1487 
     1546#endif
     1547
     1548#if HHI_INTER_VIEW_MOTION_PRED
    14881549Int
    14891550TComDataCU::getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
     
    15111572  return pcDepthMapGenerator->getIViewOrgDepthMvPred( this, uiPartIdx, eRefPicList, iRefIdx, rcMv );
    15121573}
    1513 
     1574#endif
     1575
     1576
     1577#if HHI_INTER_VIEW_RESIDUAL_PRED
    15141578Bool
    15151579TComDataCU::getResidualSamples( UInt uiPartIdx, TComYuv* pcYuv )
     
    15191583  return pcResidualGenerator->getResidualSamples( this, uiPartIdx, pcYuv );
    15201584}
     1585#endif
    15211586
    15221587
     
    15331598  mapPlanartoDC( iLeftIntraDir );
    15341599#endif
    1535 #if HHI_DMM_INTRA
     1600#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    15361601  mapDMMtoDC( iLeftIntraDir );
    15371602#endif
     
    15431608  mapPlanartoDC( iAboveIntraDir );
    15441609#endif
    1545 #if HHI_DMM_INTRA
     1610#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    15461611  mapDMMtoDC( iAboveIntraDir );
    15471612#endif
     
    15781643  mapPlanartoDC( iLeftIntraDir );
    15791644#endif
    1580 #if HHI_DMM_INTRA
     1645#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    15811646  mapDMMtoDC( iLeftIntraDir );
    15821647#endif
     
    15881653  mapPlanartoDC( iAboveIntraDir );
    15891654#endif
    1590 #if HHI_DMM_INTRA
     1655#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    15911656  mapDMMtoDC( iAboveIntraDir );
    15921657#endif
     
    16931758}
    16941759
    1695 #if MW_MVI_SIGNALLING_MODE == 0
    1696 UInt TComDataCU::getCtxMvInheritanceFlag( UInt uiAbsPartIdx, UInt uiDepth )
    1697 {
    1698 //  return 0; // MW
    1699   TComDataCU* pcTempCU;
    1700   UInt        uiTempPartIdx;
    1701   UInt        uiCtx;
    1702   // Get left split flag
    1703   pcTempCU = getPULeft( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
    1704   uiCtx  = ( pcTempCU ) ? ( ( pcTempCU->getTextureModeDepth( uiTempPartIdx ) == uiDepth ) ? 1 : 0 ) : 0;
    1705 
    1706   // Get above split flag
    1707   pcTempCU = getPUAbove( uiTempPartIdx, m_uiAbsIdxInLCU + uiAbsPartIdx );
    1708   uiCtx += ( pcTempCU ) ? ( ( pcTempCU->getTextureModeDepth( uiTempPartIdx ) == uiDepth ) ? 1 : 0 ) : 0;
    1709 
    1710   return uiCtx;
    1711 }
    1712 #endif
    1713 
    17141760UInt TComDataCU::getCtxIntraDirChroma( UInt uiAbsPartIdx )
    17151761{
     
    21482194}
    21492195
     2196#if HHI_INTER_VIEW_RESIDUAL_PRED
    21502197Void TComDataCU::setResPredAvailSubParts( Bool bResPredAvailable, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    21512198{
     
    21572204  setSubPartBool( bResPredFlag, m_pbResPredFlag, uiAbsPartIdx, uiDepth, uiPartIdx );
    21582205}
     2206#endif
    21592207
    21602208Void TComDataCU::setChromIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth )
     
    26322680{
    26332681  UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx;
     2682#if HHI_INTER_VIEW_MOTION_PRED
    26342683  Bool bNoPdmMerge   = ( m_pcSlice->getSPS()->getViewId() == 0 || ( m_pcSlice->getSPS()->getMultiviewMvPredMode() & PDM_USE_FOR_MERGE ) != PDM_USE_FOR_MERGE );
    26352684  UInt uiPdmMergePos = ( bNoPdmMerge ? 5 : PDM_MERGE_POS );
     
    26402689  UInt uiCorBLAddr   = ( uiPdmMergePos < 5 ? 5 : 4 );
    26412690  UInt uiPdmAddr     =   uiPdmMergePos;
     2691#else
     2692  UInt uiLeftAddr    = 0;
     2693  UInt uiAboveAddr   = 1;
     2694  UInt uiColocAddr   = 2;
     2695  UInt uiCorRTAddr   = 3;
     2696  UInt uiCorBLAddr   = 4;
     2697#endif
    26422698 
    26432699  bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
     
    30993155
    31003156
     3157#if HHI_INTER_VIEW_MOTION_PRED
    31013158  //===== add merge with predicted depth maps =====
    31023159  TComMv  acPdmMv       [2];
     
    31243181    }
    31253182  }
     3183#endif
    31263184
    31273185
     
    33203378  Int iLeftIdx = -1;
    33213379
     3380#if HHI_INTER_VIEW_MOTION_PRED
    33223381#if ( PDM_AMVP_POS == 0 )
    33233382  // get inter-view mv predictor (at position 0)
     
    33283387    pInfo->m_acMvCand[ pInfo->iN++ ] = cPdmMvPred;
    33293388  }
     3389#endif
    33303390#endif
    33313391
     
    33883448
    33893449
     3450#if HHI_INTER_VIEW_MOTION_PRED
    33903451#if ( PDM_AMVP_POS == 1 )
    33913452  // get inter-view mv predictor (at position 1)
     
    33973458  }
    33983459#endif
    3399 
     3460#endif
    34003461
    34013462 
     
    35953656
    35963657
     3658#if HHI_INTER_VIEW_MOTION_PRED
    35973659#if ( PDM_AMVP_POS == 2 )
    35983660  // get inter-view mv predictor (at position 2)
     
    36043666  }
    36053667#endif
    3606 
     3668#endif
    36073669
    36083670  // Get Temporal Motion Predictor
     
    37543816
    37553817
     3818#if HHI_INTER_VIEW_MOTION_PRED
    37563819#if ( PDM_AMVP_POS == 3 )
    37573820  // get inter-view mv predictor (at position 3)
     
    37633826  }
    37643827#endif
    3765 
     3828#endif
    37663829
    37673830  // Check No MV Candidate
     
    38543917{
    38553918  Int  iMvShift = 2;
    3856 #if MW_DEPTH_MAP_INTERP_FILTER == 2 && MW_FULL_PEL_DEPTH_MAP_MV_SIGNALLING
     3919#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
    38573920  if( getSlice()->getSPS()->isDepth() )
    38583921    iMvShift = 0;
     
    46764739#endif
    46774740
     4741#if HHI_MPI
    46784742Void TComDataCU::setTextureModeDepthSubParts( Int iTextureModeDepth, UInt uiAbsPartIdx, UInt uiDepth )
    46794743{
     
    46924756  Int iSizeInUchar  = sizeof( UChar ) * uiNumPartition;
    46934757  Int iSizeInInt    = sizeof( Int   ) * uiNumPartition;
    4694 //#if HHI_MRG
    4695 //  Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
    4696 //#endif
    4697 
    4698 //  memcpy( m_pePartSize + uiAbsPartIdxDst,  pcCU->getPartitionSize() + uiAbsPartIdxSrc,  sizeof( PartSize ) * uiNumPartition );
     4758
    46994759  memcpy( m_pePredMode + uiAbsPartIdxDst,  pcCU->getPredictionMode() + uiAbsPartIdxSrc, sizeof( PredMode ) * uiNumPartition );
    47004760  memcpy( m_puhInterDir + uiAbsPartIdxDst, pcCU->getInterDir() + uiAbsPartIdxSrc,       iSizeInUchar );
    4701 
    4702 //#if HHI_MRG
    4703 //  m_pbMergeFlag        = pcCU->getMergeFlag()             + uiAbsPartIdx;
    4704 //  m_puhMergeIndex      = pcCU->getMergeIndex()            + uiAbsPartIdx;
    4705 //  for( UInt ui = 0; ui < HHI_NUM_MRG_CAND; ui ++ )
    4706 //  {
    4707 //    m_apuhNeighbourCandIdx[ui] = pcCU->getNeighbourCandIdx( ui ) + uiAbsPartIdx;
    4708 //  }
    4709 //#endif
    47104761
    47114762  memcpy( m_apiMVPIdx[0] + uiAbsPartIdxDst, pcCU->getMVPIdx(REF_PIC_LIST_0) + uiAbsPartIdxSrc, iSizeInInt );
     
    47144765  memcpy( m_apiMVPNum[1] + uiAbsPartIdxDst, pcCU->getMVPNum(REF_PIC_LIST_1) + uiAbsPartIdxSrc, iSizeInInt );
    47154766
    4716 //  m_acCUMvField[0].copyFrom( pcCU->getCUMvField( REF_PIC_LIST_0 ), pcCU->getTotalNumPart(), 0 );
    4717 //  m_acCUMvField[1].copyFrom( pcCU->getCUMvField( REF_PIC_LIST_1 ), pcCU->getTotalNumPart(), 0 );
    4718 
    47194767  pcCU->getCUMvField( REF_PIC_LIST_0 )->copyTo( &m_acCUMvField[0], -Int(uiAbsPartIdxSrc) + uiAbsPartIdxDst, uiAbsPartIdxSrc, uiNumPartition );
    47204768  pcCU->getCUMvField( REF_PIC_LIST_1 )->copyTo( &m_acCUMvField[1], -Int(uiAbsPartIdxSrc) + uiAbsPartIdxDst, uiAbsPartIdxSrc, uiNumPartition );
    4721 #if MW_DEPTH_MAP_INTERP_FILTER == 2 && MW_FULL_PEL_DEPTH_MAP_MV_SIGNALLING
     4769#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
    47224770  for( UInt ui = 0; ui < uiNumPartition; ui++ )
    47234771  {
     
    47364784#endif
    47374785}
     4786#endif
    47384787
    47394788Void TComDataCU::getPosInPic( UInt uiAbsPartIndex, Int& riPosX, Int& riPosY )
  • trunk/source/Lib/TLibCommon/TComDataCU.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    5184  UChar*        m_puhHeight;          ///< array of heights
    5285  UChar*        m_puhDepth;           ///< array of depths
     86#if HHI_MPI
    5387  Int*          m_piTextureModeDepth; ///< at which depth is prediction data inherited from texture picture ( -1 : none )
     88#endif
    5489 
    5590  // -------------------------------------------------------------------------------------------------------------------
     
    90125  Bool*         m_pbMergeFlag;        ///< array of merge flags
    91126  UChar*        m_puhMergeIndex;      ///< array of merge candidate indices
     127#if HHI_INTER_VIEW_RESIDUAL_PRED
    92128  Bool*         m_pbResPredAvailable; ///< array of residual prediction available flags
    93129  Bool*         m_pbResPredFlag;      ///< array of residual prediction flags
     130#endif
    94131  UChar*        m_apuhNeighbourCandIdx[ MRG_MAX_NUM_CANDS ];///< array of motion vector predictor candidates indices
    95132  UChar*        m_puhLumaIntraDir;    ///< array of intra directions (luma)
     
    100137  UInt*         m_puiAlfCtrlFlag;     ///< array of ALF flags
    101138  UInt*         m_puiTmpAlfCtrlFlag;  ///< temporal array of ALF flags
    102 #if HHI_DMM_INTRA
     139#if HHI_DMM_WEDGE_INTRA
    103140  UInt*         m_puiWedgeFullTabIdx;
    104141  Int*          m_piWedgeFullDeltaDC1;
     
    109146  Int*          m_piWedgePredDirDeltaDC2;
    110147  Int*          m_piWedgePredDirDeltaEnd;
    111 
     148#endif
     149#if HHI_DMM_PRED_TEX
    112150  UInt*         m_puiWedgePredTexTabIdx;
    113151  Int*          m_piWedgePredTexDeltaDC1;
     
    116154  Int*          m_piContourPredTexDeltaDC1;
    117155  Int*          m_piContourPredTexDeltaDC2;
    118 
    119   Bool*         m_pbTextureModesAllowed;
    120156#endif
    121157 
     
    201237  Void          setDepth              ( UInt uiIdx, UChar  uh ) { m_puhDepth[uiIdx] = uh;   }
    202238 
     239#if HHI_MPI
    203240  Int*          getTextureModeDepth   ()                        { return m_piTextureModeDepth; }
    204241  Int           getTextureModeDepth   ( UInt uiIdx )            { return m_piTextureModeDepth[uiIdx]; }
     
    206243  Void          setTextureModeDepthSubParts( Int iTextureModeDepth, UInt uiAbsPartIdx, UInt uiDepth );
    207244  Void          copyTextureMotionDataFrom( TComDataCU* pcCU, UInt uiDepth, UInt uiAbsPartIdxSrc, UInt uiAbsPartIdxDst = 0 );
     245#endif
    208246
    209247  Void          setDepthSubParts      ( UInt uiDepth, UInt uiAbsPartIdx );
     
    291329  Void          setNeighbourCandIdxSubParts ( UInt uiCandIdx, UChar uhNumCands, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    292330
     331#if HHI_INTER_VIEW_RESIDUAL_PRED
    293332  Bool*         getResPredAvail         ()                        { return m_pbResPredAvailable;        }
    294333  Bool          getResPredAvail         ( UInt uiIdx )            { return m_pbResPredAvailable[uiIdx]; }
     
    302341
    303342  Void          setResPredIndicator     ( Bool bAv, Bool bRP )    { m_pbResPredAvailable[0] = bAv; m_pbResPredFlag[0] = bRP; }
     343#endif
    304344
    305345  Void          setSubPartBool        ( Bool bParameter, Bool* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );
     
    331371  Void          copyAlfCtrlFlagFromTmp();
    332372 
    333 #if HHI_DMM_INTRA
     373#if HHI_DMM_WEDGE_INTRA
    334374  UInt*         getWedgeFullTabIdx         ()                        { return m_puiWedgeFullTabIdx;        }
    335375  UInt          getWedgeFullTabIdx         ( UInt uiIdx )            { return m_puiWedgeFullTabIdx[uiIdx]; }
     
    366406  Void          setWedgePredDirDeltaEnd        ( UInt uiIdx, Int iD ) { m_piWedgePredDirDeltaEnd[uiIdx] = iD;   }
    367407  Void          setWedgePredDirDeltaEndSubParts( Int iDelta, UInt uiAbsPartIdx, UInt uiDepth );
    368 
     408#endif
     409#if HHI_DMM_PRED_TEX
    369410  UInt*         getWedgePredTexTabIdx       ()                       { return m_puiWedgePredTexTabIdx;           }
    370411  UInt          getWedgePredTexTabIdx       ( UInt uiIdx )           { return m_puiWedgePredTexTabIdx[uiIdx];    }
     
    391432  Void          setContourPredTexDeltaDC2       ( UInt uiIdx, Int i )  { m_piContourPredTexDeltaDC2[uiIdx] = i;      }
    392433  Void          setContourPredTexDeltaDC2SubParts( Int iDC2, UInt uiAbsPartIdx, UInt uiDepth );
    393 
    394   Bool*         getTextureModeAllowance         ()                     { return m_pbTextureModesAllowed;          }
    395   Bool          getTextureModeAllowance         ( UInt uiIdx )         { return m_pbTextureModesAllowed[uiIdx];   }
    396   Void          setTextureModeAllowance         ( UInt uiIdx, Bool b ) { m_pbTextureModesAllowed[uiIdx] = b;      }
    397   Void          setTextureModeAllowanceSubParts ( Bool bTMAllowed, UInt uiAbsPartIdx, UInt uiDepth );
    398 #endif
    399 
     434#endif
     435
     436#if HHI_INTER_VIEW_MOTION_PRED
    400437  Int           getPdmMergeCandidate( UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
    401438  Bool          getPdmMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge = false );
    402439  Bool          getIViewOrgDepthMvPred( UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv );
     440#endif
     441#if HHI_INTER_VIEW_RESIDUAL_PRED
    403442  Bool          getResidualSamples( UInt uiPartIdx, TComYuv* pcYuv = 0 );
     443#endif
    404444 
    405445  // -------------------------------------------------------------------------------------------------------------------
     
    517557 
    518558  UInt          getCtxSplitFlag                 ( UInt   uiAbsPartIdx, UInt uiDepth                   );
    519 #if MW_MVI_SIGNALLING_MODE == 0
    520   UInt          getCtxMvInheritanceFlag         ( UInt   uiAbsPartIdx, UInt uiDepth                   );
    521 #endif
    522559  UInt          getCtxCbf                       ( UInt   uiAbsPartIdx, TextType eType, UInt uiTrDepth );
    523560  UInt          getCtxQtCbf                     ( UInt   uiAbsPartIdx, TextType eType, UInt uiTrDepth );
  • trunk/source/Lib/TLibCommon/TComDepthMapGenerator.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    1043#include "TComDepthMapGenerator.h"
    1144
     45
     46#if DEPTH_MAP_GENERATION
    1247
    1348
     
    462497
    463498
     499#if HHI_INTER_VIEW_MOTION_PRED
    464500Void 
    465501TComDepthMapGenerator::covertOrgDepthMap( TComPic* pcPic )
     
    483519  }
    484520}
    485 
     521#endif
    486522
    487523Int
     
    501537
    502538
     539#if HHI_INTER_VIEW_MOTION_PRED
    503540Int
    504541TComDepthMapGenerator::getPdmMergeCandidate( TComDataCU* pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv )
     
    674711  return        true;
    675712}
    676 
     713#endif
    677714
    678715
     
    14091446}
    14101447
     1448#endif // DEPTH_MAP_GENERATION
     1449
  • trunk/source/Lib/TLibCommon/TComDepthMapGenerator.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    1548#include "TComSlice.h"
    1649
     50
     51#if DEPTH_MAP_GENERATION
    1752
    1853
     
    2964
    3065  UInt      getPdm  ()                            { if( m_aacActiveSPS[0][1] ) { return m_aacActiveSPS[0][1]->getPredDepthMapGeneration(); } return 0; }
     66#if HHI_INTER_VIEW_RESIDUAL_PRED
    3167  UInt      getResPrd ()                          { if( m_aacActiveSPS[0][1] ) { return m_aacActiveSPS[0][1]->getMultiviewResPredMode  (); } return 0; }
     68#endif
    3269
    3370private:
     
    84121  Void  dumpDepthMap          ( TComPic*      pcPic, char* pFilenameBase );
    85122
     123#if HHI_INTER_VIEW_MOTION_PRED
    86124  Void  covertOrgDepthMap     ( TComPic*      pcPic );
     125#endif
    87126
    88127  UInt  getBaseViewId         ( UInt          uiIdx ) { AOF( uiIdx < m_auiBaseIdList.size() );  return m_auiBaseIdList[uiIdx]; }
    89128  Int   getDisparity          ( TComPic*      pcPic, Int iPosX, Int iPosY, UInt uiRefViewId );
     129#if HHI_INTER_VIEW_MOTION_PRED
    90130  Int   getPdmMergeCandidate  ( TComDataCU*   pcCU, UInt uiPartIdx, Int* paiPdmRefIdx, TComMv* pacPdmMv );
    91131  Bool  getPdmMvPred          ( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv, Bool bMerge );
    92132  Bool  getIViewOrgDepthMvPred( TComDataCU*   pcCU, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMv );
     133#endif
    93134
    94135  TComPrediction*   getPrediction ()  { return m_pcPrediction;  }
     
    177218};
    178219
     220
     221#endif // DEPTH_MAP_GENERATION
     222
    179223#endif // __TCOM_DEPTH_MAP_GENERATOR__
    180224
  • trunk/source/Lib/TLibCommon/TComList.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComLoopFilter.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComLoopFilter.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComMVDRefData.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    942#include <fstream>
    1043
     44#if HHI_VSO
    1145Void TComMVDRefData::setPicYuvBaseView( InterViewReference eView, Bool bDepth, TComPicYuv* pcOrgView, TComPicYuv* pcRecView )
    1246{
     
    3165TComMVDRefData::TComMVDRefData()
    3266{
    33 //GT VSO
    3467  m_adERViewShiftLUT = 0;
    3568  m_aiERViewShiftLUT = 0;
    3669  m_apcExternalReferenceViews.resize(0);
    37 //GT VSO end
    3870
    3971  for (UInt uiView = 0; uiView < 3; uiView++)
     
    4476    m_apcDepthRec[uiView] = NULL;
    4577
    46    //GT VSO
    4778    m_adBaseViewShiftLUT [uiView] = NULL;
    4879    m_aiBaseViewShiftLUT [uiView] = NULL;
    49     //GT VSO end
     80
    5081  };
    5182}
    5283
    53 //GT VSO
    5484Void TComMVDRefData::getRefPicYuvAndLUT( TComPicYuv**& rpacDistRefPicList, Int***& rppaiShiftLut )
    5585{
    56   //GT
    57 
    5886  UInt uiNextEntry = 0;
    5987  for ( UInt uiViewIdx = 0; uiViewIdx < m_aiExtViewRefInd.size(); uiViewIdx++ )
     
    78106  rppaiShiftLut[2] = m_aiBaseViewShiftLUT[ NEXTVIEW ];
    79107
    80   //GT: Only orginals of this view needed for Mode 1;
    81108  rpacDistRefPicList[0] = NULL;
    82109  rpacDistRefPicList[1] = NULL;
    83110  rpacDistRefPicList[2] = NULL;
    84111}
    85 //GT VSO end
    86 
    87 
    88 
    89 
    90 //Void TComMVDRefData::render( TComPicYuv* pOut )
    91 ////Void TComMVDRefData::render( TComPicYuv* pIn, TComPicYuv* pOut, TComPicYuv* pDepth, Long** aalLUT )
    92 //{
    93 //
    94 //  std::cout << "InRender" << std::endl;
    95 //
    96 //  TComPicYuv* pIn    = getPicYuvOrgVideo(CURRVIEW);
    97 //  //  TComPicYuv* pOut   = getRecVideo(CURRVIEW);
    98 //  TComPicYuv* pDepth = getPicYuvOrgDepth(CURRVIEW);
    99 //
    100 //  Int** aaiLUT = getShiftLUTIERView(0);
    101 //
    102 //  Int iHeight = (Int) pIn->getHeight();
    103 //  Int iWidth  = (Int) pIn->getWidth();
    104 //
    105 //  Pel* piSourceLumaData = pIn   ->getLumaAddr();
    106 //  Pel* piTargetLumaData = pOut  ->getLumaAddr();
    107 //  Pel* piDepthData      = pDepth->getLumaAddr();
    108 //
    109 //  Int iSourceLumaStride = pIn   ->getStride();
    110 //  Int iTargetLumaStride = pOut  ->getStride();
    111 //  Int      iDepthStride = pDepth->getStride();
    112 //
    113 //
    114 //  for (Int iY = 0; iY < iHeight; iY++)
    115 //  {
    116 //    for (Int iX = 0; iX < iWidth; iX++)
    117 //    {
    118 //      piTargetLumaData[iX] = 0;
    119 //    }
    120 //    piTargetLumaData += iTargetLumaStride;
    121 //  }
    122 //
    123 //  piTargetLumaData = pOut  ->getLumaAddr();
    124 //
    125 //  Int iNewPos;
    126 //  for (Int iY = 0; iY < iHeight; iY++)
    127 //  {
    128 //    for (Int iX = 0; iX < iWidth; iX++)
    129 //    {
    130 //      iNewPos = iX - aaiLUT[0][(piDepthData[iX] >> g_uiBitIncrement)];
    131 //      iNewPos = (iNewPos <  0     ) ? 0          : iNewPos;
    132 //      iNewPos = (iNewPos >= iWidth) ? iWidth - 1 : iNewPos;
    133 //
    134 //      piTargetLumaData[iNewPos] = piSourceLumaData[iX];
    135 //    }
    136 //    piSourceLumaData += iSourceLumaStride;
    137 //    piTargetLumaData += iTargetLumaStride;
    138 //    piDepthData      += iDepthStride;
    139 //  }
    140 //}
    141 //
    142 //
    143 //
    144 //
    145 //TComRendererModel::TComRendererModel()
    146 //{
    147 //  m_pcInputSamples  = NULL;
    148 //  m_pcOutputSamples = NULL;
    149 //  m_ppiShiftLUT    = NULL;
    150 //}
    151 //
    152 //TComRendererModel::~TComRendererModel()
    153 //{
    154 //  if ( m_pcOutputSamples )
    155 //    delete[] m_pcOutputSamples;
    156 //
    157 //  if ( m_pcInputSamples )
    158 //    delete[] m_pcInputSamples;
    159 //
    160 //}
    161 //
    162 //Void TComRendererModel::createModel( TComPicYuv* pcYuvDepth, TComPicYuv* pcYuvVideo, TComPicYuv* pcYuvRef, Int** ppiShiftLUT )
    163 //{
    164 //  createModel(pcYuvDepth->getLumaAddr(), pcYuvDepth->getStride(), pcYuvVideo->getLumaAddr(), pcYuvVideo->getStride(), pcYuvVideo->getCbAddr(), pcYuvVideo->getCrAddr(), pcYuvVideo->getCStride(), pcYuvVideo->getWidth(), pcYuvVideo->getHeight(), ppiShiftLUT );
    165 //}
    166 //
    167 //Void TComRendererModel::createModel( TComPicYuv* pcYuvDepth, TComPicYuv* pcYuvVideo, Int** ppiShiftLUT )
    168 //{
    169 //
    170 //}
    171 //
    172 //Void TComRendererModel::createModel( Pel* pcPelDisp, Int iStrideDisp, Pel* pcPelY, Int iStrideY, Pel* pcPelU, Pel* pcPelV, Int iStrideC, Int iWidth, Int iHeight, Int** ppiShiftLUT )
    173 //{
    174 //
    175 //}
    176 //
    177 //Void TComRendererModel::xCreateRenderedView( Pel* pcPelDisp, Int iDispStride, Pel* pcPelY, Int iLStride, Pel* pcPelU, Pel* pcPelV, Int iCStride, Int iWidth, Int iHeight, Int** ppiShiftLUT,Bool bSAD )
    178 //{
    179 //  m_ppiShiftLUT = ppiShiftLUT;
    180 //  m_iWidth       = iWidth;
    181 //  m_iHeight      = iHeight;
    182 //  m_iStride      = iWidth;
    183 //
    184 //  m_pcOutputSamples = new RendererOutputSample[ iWidth * iHeight];
    185 //  m_pcInputSamples  = new RendererInputSample [ iWidth * iHeight];
    186 //
    187 //  RendererInputSample*  pcInputSamples  = m_pcInputSamples ;
    188 //  RendererOutputSample* pcOutputSamples = m_pcOutputSamples ;
    189 //
    190 //  for ( Int iRow = 0; iRow < iHeight; iRow++ )
    191 //  {
    192 //    for ( Int iCol = 0; iCol < iWidth; iCol++ )
    193 //    {
    194 //      pcInputSamples[iCol].m_uiPosX = iCol;
    195 //      pcInputSamples[iCol].m_uiY    = pcPelY[ iCol ];
    196 //      pcInputSamples[iCol].m_uiU    = pcPelU[ iCol >> 1 ];
    197 //      pcInputSamples[iCol].m_uiV    = pcPelV[ iCol >> 1 ];
    198 //      pcOutputSamples[iCol].m_iErr  = 0;
    199 //
    200 //      pcInputSamples[iCol].m_iPosShifted = iCol + m_ppiShiftLUT[0][ pcPelDisp[ iCol ] ];
    201 //      pcInputSamples[iCol].m_uiDisp      = pcPelDisp[ iCol ];
    202 //
    203 //    }
    204 //
    205 //    pcInputSamples  += m_iStride;
    206 //    pcOutputSamples += m_iStride;
    207 //    pcPelY          += iLStride;
    208 //    pcPelDisp       += iDispStride;
    209 //
    210 //    if ( iRow & 1 )
    211 //    {
    212 //      pcPelU += iCStride;
    213 //      pcPelV += iCStride;
    214 //    }
    215 //
    216 //  }
    217 //
    218 //  m_lErr = 0;
    219 //  Long lDump;
    220 //  changeModel(0,0,m_iWidth, m_iHeight, pcPelDisp, iDispStride, lDump, bSAD);
    221 //}
    222 //
    223 //Void TComRendererModel::changeModel( Int iPosX, Int iPosY, Int iWidth, Int iHeight, Pel* pcPelDisp, Int iDispStride, Long& rlErr, Bool bSAD )
    224 //{
    225 //  RendererInputSample*  pcInputSamples  = m_pcInputSamples ;
    226 //  RendererOutputSample* pcOutputSamples = m_pcOutputSamples ;
    227 //
    228 //  Int iMinChangedPosition = 0;
    229 //  Int iMaxChangedPosition = m_iWidth - 1;
    230 //
    231 //  rlErr = 0;
    232 //
    233 //  for ( Int iRow = iPosX; iRow < iHeight; iRow++ )
    234 //  {
    235 //    // Add and Remove samples (Update Model)
    236 //    for ( Int iCol = iPosY; iCol < iWidth; iCol++ )
    237 //    {
    238 //      // Remove from old position
    239 //      Int iOldPosShifted  = pcInputSamples[iCol].m_iPosShifted;
    240 //
    241 //      iMinChangedPosition = Min( iOldPosShifted, iMinChangedPosition );
    242 //      iMaxChangedPosition = Max( iOldPosShifted, iMaxChangedPosition );
    243 //
    244 //      pcOutputSamples[ iOldPosShifted ].removeInputSample( &(pcInputSamples[iCol]) );
    245 //
    246 //      // Add to new position
    247 //      Int iShift = m_ppiShiftLUT[0][ pcPelDisp[ iCol ] ];
    248 //
    249 //      Int iPosShifted = iPosX + iShift;
    250 //
    251 //      iPosShifted = Min(Max(iPosShifted, 0), m_iWidth - 1);
    252 //      iMinChangedPosition = Min(iPosShifted, iMinChangedPosition);
    253 //      iMaxChangedPosition = Max(iPosShifted, iMaxChangedPosition);
    254 //
    255 //      pcInputSamples[iCol].m_uiDisp = pcPelDisp[ iCol ];
    256 //      pcInputSamples[iCol].m_iPosShifted = iPosShifted;
    257 //
    258 //      pcOutputSamples[ iPosShifted ].addInputSample( &(pcInputSamples[iCol]) );
    259 //    }
    260 //
    261 //    // ReRender
    262 //
    263 //    // Get Top Plane
    264 //    Int iMaxInd = -1;
    265 //
    266 //    if ( pcOutputSamples[iMinChangedPosition].m_pcTopSample )
    267 //    {
    268 //      iMaxInd = pcOutputSamples[iMinChangedPosition].m_pcTopSample->m_uiPosX;
    269 //    }
    270 //
    271 //    if ( iMinChangedPosition > 0 && pcOutputSamples[iMinChangedPosition].m_pcTopSample )
    272 //    {
    273 //      iMaxInd = Max( iMaxInd, pcOutputSamples[iMinChangedPosition-1].m_pcTopSample->m_uiPosX );
    274 //    }
    275 //
    276 //    for ( Int iCol = iMinChangedPosition; iCol <= iMaxChangedPosition; iCol++ )
    277 //    {
    278 //      if ( pcOutputSamples[iCol].m_pcTopSample == NULL )
    279 //      {
    280 //        if ( pcOutputSamples[iCol+1].m_pcTopSample == NULL )
    281 //        {
    282 //          // Hole Filling
    283 //          Int iFillStartCol = iCol;
    284 //          iCol++;
    285 //
    286 //          while( ( pcOutputSamples[iCol].m_pcTopSample == NULL ) && (iMinChangedPosition < iMaxChangedPosition) ) iCol++;
    287 //
    288 //          for ( int iFillCol = iFillStartCol; iFillCol < iCol; iFillCol++ )
    289 //          {
    290 //            pcOutputSamples[iFillCol].assignValues( pcOutputSamples[iCol], rlErr, bSAD );
    291 //          }
    292 //
    293 //          if ( iMaxInd == -1 )
    294 //          {
    295 //            iMaxInd = pcOutputSamples[iCol].m_pcTopSample->m_uiPosX;
    296 //          }
    297 //        }
    298 //        else
    299 //        {
    300 //          // Fill Gap here
    301 //          pcOutputSamples[iCol].assignValues( pcOutputSamples[iCol-1], rlErr, bSAD  );
    302 //
    303 //        };
    304 //      }
    305 //      else
    306 //      {
    307 //        if ( pcOutputSamples[iCol].m_pcTopSample->m_uiPosX > iMaxInd)
    308 //        {
    309 //          iMaxInd = pcOutputSamples[iCol].m_pcTopSample->m_uiPosX;
    310 //
    311 //          //assign this Sample
    312 //          pcOutputSamples[iCol].assignValues( pcOutputSamples[iCol],   rlErr, bSAD );
    313 //        }
    314 //        else
    315 //        {
    316 //          //assign last sample
    317 //          pcOutputSamples[iCol].assignValues( pcOutputSamples[iCol-1], rlErr, bSAD );
    318 //        }
    319 //      }
    320 //    }
    321 //
    322 //    pcInputSamples  += m_iStride;
    323 //    pcPelDisp       += iDispStride;
    324 //
    325 //  }
    326 //}
    327 //
    328 //Void RendererOutputSample::assignValues( RendererOutputSample& rpcOutputSample, Long& rlErr, Bool bSAD )
    329 //{
    330 //  m_uiY = rpcOutputSample.m_uiYRef;
    331 //  m_uiU = rpcOutputSample.m_uiURef;
    332 //  m_uiV = rpcOutputSample.m_uiVRef;
    333 //
    334 //  rlErr -= m_iErr;
    335 //
    336 //  int iErr = m_uiY - m_uiYRef;
    337 //
    338 //  if (bSAD)
    339 //  {
    340 //    rlErr += abs(iErr);
    341 //  }
    342 //  else
    343 //  {
    344 //    rlErr += iErr * iErr;
    345 //  }
    346 //}
    347 //
    348 //Void RendererOutputSample::addInputSample( RendererInputSample* pcInputSample )
    349 //{
    350 //  if ( m_acInputSamples.size() == 0 )
    351 //  {
    352 //    m_acInputSamples.push_back( pcInputSample );
    353 //    m_pcTopSample = pcInputSample;
    354 //    pcInputSample->cIter = m_acInputSamples.begin();
    355 //  }
    356 //  else
    357 //  {
    358 //    std::vector <RendererInputSample*>::iterator cIter;
    359 //
    360 //    for ( cIter = m_acInputSamples.begin( ) ; cIter != m_acInputSamples.end( ) ; cIter++ )
    361 //    {
    362 //      if ( (*cIter)->m_uiPosX <= pcInputSample->m_uiPosX ) break;
    363 //    }
    364 //
    365 //    m_acInputSamples.insert( cIter, 1, pcInputSample );
    366 //
    367 //    pcInputSample->cIter = cIter;
    368 //
    369 //    if ( cIter == m_acInputSamples.begin() )
    370 //    {
    371 //      m_pcTopSample = pcInputSample;
    372 //    }
    373 //  }
    374 //}
    375 //
    376 //RendererOutputSample::RendererOutputSample()
    377 //{
    378 //  m_pcTopSample = 0;
    379 //}
    380 //
    381 //Void RendererOutputSample::removeInputSample( RendererInputSample* pcInputSample )
    382 //{
    383 //  m_acInputSamples.erase( pcInputSample->cIter );
    384 //}
    385 //
     112#endif
  • trunk/source/Lib/TLibCommon/TComMVDRefData.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    437#define __TCOMMVDREFDATA__
    538
     39
    640// Include files
     41
    742#include "CommonDef.h"
    843#include "TComPicYuv.h"
    944#include <vector>
    10 
     45#if HHI_VSO
    1146// ====================================================================================================================
    1247// Class definition
     
    2762  Int**       m_aiBaseViewShiftLUT[3];
    2863
    29 
    30 //GT VSO
    3164  //PicYuvs
    3265  std::vector<TComPicYuv*> m_apcExternalReferenceViews;
     
    4073  std::vector<Int> m_aiExtViewRefInd;
    4174  std::vector<Int> m_aiExtViewRefLUTInd;
    42 
    43 //GT VSO end
    4475
    4576public:
     
    6495//  Void render( TComPicYuv* pOut ) /*Void render( TComPicYuv* pIn, TComPicYuv* pOut, TComPicYuv* pDepth, Long** aalLUT ) */;
    6596
    66 //GT VSO
     97
    6798  //  PicYuvs
    6899  TComPicYuv* getPicYuvERView   ( UInt uiReferenceNum )              { return m_apcExternalReferenceViews[uiReferenceNum]; };
     
    82113  Void getRefPicYuvAndLUT     ( TComPicYuv**& rpacDistRefPicList, Int***& rppalShiftLut);
    83114  Void getRefPicYuvAndLUTMode1( TComPicYuv**& rpacDistRefPicList, Int***& rppaiShiftLut );
    84 //GT VSO end
    85115
    86116}; // END CLASS DEFINITION TComMVDRefData
    87 
     117#endif // HHI_VSO
    88118#endif // __TCOMMVDREFDATA__
    89119
  • trunk/source/Lib/TLibCommon/TComMotionInfo.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComMotionInfo.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComMv.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPattern.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    91124                                         Int         iOffsetBottom,
    92125                                         UInt        uiPartDepth,
    93                                          UInt        uiAbsPartIdx,
    94                                          Bool        bPrdDepthMap )
     126                                         UInt        uiAbsPartIdx
     127#if DEPTH_MAP_GENERATION
     128                                        ,Bool        bPrdDepthMap
     129#endif
     130                                         )
    95131{
    96132  m_iOffsetLeft   = iOffsetLeft;
     
    104140  UInt uiAbsZorderIdx = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
    105141 
     142#if DEPTH_MAP_GENERATION
    106143  TComPicYuv* pcPic = ( bPrdDepthMap ? pcCU->getPic()->getPredDepthMap() : pcCU->getPic()->getPicYuvRec() );
     144#else
     145  TComPicYuv* pcPic = pcCU->getPic()->getPicYuvRec();
     146#endif
    107147  if ( iComp == 0 )
    108148  {
     
    142182}
    143183
    144 Void TComPattern::initPattern( TComDataCU* pcCU, UInt uiPartDepth, UInt uiAbsPartIdx, Bool bPrdDepthMap )
     184Void TComPattern::initPattern( TComDataCU* pcCU, UInt uiPartDepth, UInt uiAbsPartIdx
     185#if DEPTH_MAP_GENERATION
     186                             , Bool bPrdDepthMap
     187#endif
     188                             )
    145189{
    146190  Int   uiOffsetLeft  = 0;
     
    185229#endif
    186230
     231#if DEPTH_MAP_GENERATION
    187232  m_cPatternY .setPatternParamCU( pcCU, 0, uiWidth,      uiHeight,      uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx, bPrdDepthMap );
    188233  m_cPatternCb.setPatternParamCU( pcCU, 1, uiWidth >> 1, uiHeight >> 1, uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx, bPrdDepthMap );
    189234  m_cPatternCr.setPatternParamCU( pcCU, 2, uiWidth >> 1, uiHeight >> 1, uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx, bPrdDepthMap );
    190 }
    191 
    192 Void TComPattern::initAdiPattern( TComDataCU* pcCU, UInt uiZorderIdxInPart, UInt uiPartDepth, Int* piAdiBuf, Int iOrgBufStride, Int iOrgBufHeight, Bool& bAbove, Bool& bLeft, Bool bPrdDepthMap )
     235#else
     236  m_cPatternY .setPatternParamCU( pcCU, 0, uiWidth,      uiHeight,      uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx );
     237  m_cPatternCb.setPatternParamCU( pcCU, 1, uiWidth >> 1, uiHeight >> 1, uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx );
     238  m_cPatternCr.setPatternParamCU( pcCU, 2, uiWidth >> 1, uiHeight >> 1, uiOffsetLeft, uiOffsetRight, uiOffsetAbove, 0, uiPartDepth, uiAbsPartIdx );
     239#endif
     240}
     241
     242Void TComPattern::initAdiPattern( TComDataCU* pcCU, UInt uiZorderIdxInPart, UInt uiPartDepth, Int* piAdiBuf, Int iOrgBufStride, Int iOrgBufHeight, Bool& bAbove, Bool& bLeft
     243#if DEPTH_MAP_GENERATION
     244                                , Bool bPrdDepthMap
     245#endif
     246                                )
    193247{
    194248  Pel*  piRoiOrigin;
     
    330384  piAdiTemp   = piAdiBuf;
    331385
     386#if DEPTH_MAP_GENERATION
    332387  if( bPrdDepthMap )
    333388  {
     
    338393#endif
    339394  }
    340 
    341 
    342 #if REFERENCE_SAMPLE_PADDING
     395#endif
     396
     397
     398#if REFERENCE_SAMPLE_PADDING
     399#if DEPTH_MAP_GENERATION
    343400  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride, bPrdDepthMap );
     401#else
     402  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride );
     403#endif
    344404  delete [] bNeighborFlags;
    345405  bNeighborFlags = NULL;
     
    586646
    587647#if REFERENCE_SAMPLE_PADDING
     648#if DEPTH_MAP_GENERATION
    588649  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride, false );
     650#else
     651  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride );
     652#endif
    589653#else // REFERENCE_SAMPLE_PADDING
    590654  for (i=0;i<uiWidth;i++)
     
    648712 
    649713#if REFERENCE_SAMPLE_PADDING
     714#if DEPTH_MAP_GENERATION
    650715  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride, false );
     716#else
     717  fillReferenceSamples ( pcCU, piRoiOrigin, piAdiTemp, bNeighborFlags, iNumIntraNeighbor, iUnitSize, iNumUnitsInCu, iTotalUnits, uiCuWidth, uiCuHeight, uiWidth, uiHeight, iPicStride );
     718#endif
    651719  delete [] bNeighborFlags;
    652720  bNeighborFlags = NULL;
     
    709777
    710778#if REFERENCE_SAMPLE_PADDING
    711 Void TComPattern::fillReferenceSamples( TComDataCU* pcCU, Pel* piRoiOrigin, Int* piAdiTemp, Bool* bNeighborFlags, Int iNumIntraNeighbor, Int iUnitSize, Int iNumUnitsInCu, Int iTotalUnits, UInt uiCuWidth, UInt uiCuHeight, UInt uiWidth, UInt uiHeight, Int iPicStride, Bool bPrdDepthMap )
     779Void TComPattern::fillReferenceSamples( TComDataCU* pcCU, Pel* piRoiOrigin, Int* piAdiTemp, Bool* bNeighborFlags, Int iNumIntraNeighbor, Int iUnitSize, Int iNumUnitsInCu, Int iTotalUnits, UInt uiCuWidth, UInt uiCuHeight, UInt uiWidth, UInt uiHeight, Int iPicStride
     780#if DEPTH_MAP_GENERATION
     781                                        , Bool bPrdDepthMap
     782#endif
     783                                        )
    712784{
    713785  Pel* piRoiTemp;
    714786  Int  i, j;
     787#if DEPTH_MAP_GENERATION
    715788  Int  iDCValue = ( bPrdDepthMap ? PDM_UNDEFINED_DEPTH : ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ) );
     789#else
     790  Int  iDCValue = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
     791#endif
    716792 
    717793  if (iNumIntraNeighbor == 0)
     
    885961
    886962#if QC_MDIS
    887 #if HHI_DISABLE_INTRA_SMOOTHING_DEPTH
    888 Int* TComPattern::getPredictorPtr ( UInt uiDirMode, UInt uiWidthBits, Int iCuWidth, Int iCuHeight, Int* piAdiBuf, Bool bDepth )
    889 #else
    890963Int* TComPattern::getPredictorPtr ( UInt uiDirMode, UInt uiWidthBits, Int iCuWidth, Int iCuHeight, Int* piAdiBuf )
    891 #endif
    892964{
    893965#if MN_MDIS_SIMPLIFICATION
     
    919991  mapPlanartoDC( uiDirMode );
    920992#endif
    921 #if HHI_DISABLE_INTRA_SMOOTHING_DEPTH
    922   UChar ucFiltIdx = 0;
    923   if ( !bDepth )
    924   {
    925     ucFiltIdx = g_aucIntraFilter[uiWidthBits][uiDirMode];
    926   }
    927 #else
    928 #if HHI_DMM_INTRA
     993#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    929994  UChar ucFiltIdx = 0;
    930995  if ( uiDirMode < 34 )
     
    934999#else
    9351000  UChar ucFiltIdx = g_aucIntraFilter[uiWidthBits][uiDirMode];
    936 #endif
    9371001#endif
    9381002
  • trunk/source/Lib/TLibCommon/TComPattern.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    6295                           Int         iOffsetBottom,
    6396                           UInt        uiPartDepth,
    64                            UInt        uiAbsZorderIdx,
    65                            Bool        bPrdDepthMap = false );
     97                           UInt        uiAbsZorderIdx
     98#if DEPTH_MAP_GENERATION
     99                          ,Bool        bPrdDepthMap = false
     100#endif
     101                          );
    66102};
    67103
     
    101137 
    102138#if QC_MDIS
    103 #if HHI_DISABLE_INTRA_SMOOTHING_DEPTH
    104   Int*  getPredictorPtr           ( UInt uiDirMode, UInt uiWidthBits, Int iCuWidth, Int iCuHeight, Int* piAdiBuf, Bool bDepth = false );
    105 #else
    106139  Int*  getPredictorPtr           ( UInt uiDirMode, UInt uiWidthBits, Int iCuWidth, Int iCuHeight, Int* piAdiBuf );
    107 #endif
    108140#endif //QC_MDIS
    109141  // -------------------------------------------------------------------------------------------------------------------
     
    126158  Void  initPattern           ( TComDataCU* pcCU,
    127159                                UInt        uiPartDepth,
    128                                 UInt        uiAbsPartIdx,
    129                                 Bool        bPrdDepthMap = false );
     160                                UInt        uiAbsPartIdx
     161#if DEPTH_MAP_GENERATION
     162                               ,Bool        bPrdDepthMap = false
     163#endif
     164                               );
    130165 
    131166  /// set luma parameters from CU data for accessing ADI data
     
    137172                                Int         iOrgBufHeight,
    138173                                Bool&       bAbove,
    139                                 Bool&       bLeft,
    140                                 Bool        bPrdDepthMap = false );
     174                                Bool&       bLeft
     175#if DEPTH_MAP_GENERATION
     176                               ,Bool        bPrdDepthMap = false
     177#endif
     178                               );
    141179 
    142180  /// set chroma parameters from CU data for accessing ADI data
     
    160198#if REFERENCE_SAMPLE_PADDING
    161199  /// padding of unavailable reference samples for intra prediction
    162   Void  fillReferenceSamples        ( TComDataCU* pcCU, Pel* piRoiOrigin, Int* piAdiTemp, Bool* bNeighborFlags, Int iNumIntraNeighbor, Int iUnitSize, Int iNumUnitsInCu, Int iTotalUnits, UInt uiCuWidth, UInt uiCuHeight, UInt uiWidth, UInt uiHeight, Int iPicStride, Bool bPrdDepthMap );
     200  Void  fillReferenceSamples        ( TComDataCU* pcCU, Pel* piRoiOrigin, Int* piAdiTemp, Bool* bNeighborFlags, Int iNumIntraNeighbor, Int iUnitSize, Int iNumUnitsInCu, Int iTotalUnits, UInt uiCuWidth, UInt uiCuHeight, UInt uiWidth, UInt uiHeight, Int iPicStride
     201#if DEPTH_MAP_GENERATION
     202                                    , Bool bPrdDepthMap
     203#endif
     204                                    );
    163205#endif
    164206#if CONSTRAINED_INTRA_PRED
  • trunk/source/Lib/TLibCommon/TComPic.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    1750  m_apcPicYuv[0]      = NULL;
    1851  m_apcPicYuv[1]      = NULL;
     52#if DEPTH_MAP_GENERATION
    1953  m_pcPredDepthMap    = NULL;
     54#endif
     55#if HHI_INTER_VIEW_MOTION_PRED
    2056  m_pcOrgDepthMap     = NULL;
     57#endif
     58#if HHI_INTER_VIEW_RESIDUAL_PRED
    2159  m_pcResidual        = NULL;
     60#endif
    2261  m_pcPicYuvPred      = NULL;
    2362  m_pcPicYuvResi      = NULL;
     63#if HHI_INTERVIEW_SKIP
    2464  m_pcUsedPelsMap     = NULL;
     65#endif
    2566 
    2667#if PARALLEL_MERGED_DEBLK
     
    76117  }
    77118 
     119#if DEPTH_MAP_GENERATION
    78120  if( m_pcPredDepthMap )
    79121  {
     
    82124    m_pcPredDepthMap = NULL;
    83125  }
    84 
     126#endif
     127
     128#if HHI_INTER_VIEW_MOTION_PRED
    85129  if( m_pcOrgDepthMap )
    86130  {
     
    89133    m_pcOrgDepthMap = NULL;
    90134  }
    91 
     135#endif
     136
     137#if HHI_INTER_VIEW_RESIDUAL_PRED
    92138  if( m_pcResidual )
    93139  {
     
    96142    m_pcResidual = NULL;
    97143  }
    98 
     144#endif
     145
     146#if HHI_INTERVIEW_SKIP
    99147  if( m_pcUsedPelsMap )
    100148  {
     
    103151    m_pcUsedPelsMap = NULL;
    104152  }
     153#endif
    105154
    106155#if PARALLEL_MERGED_DEBLK
     
    160209#endif
    161210
     211#if DEPTH_MAP_GENERATION
    162212Void
    163213TComPic::addPrdDepthMapBuffer()
     
    173223  m_pcPredDepthMap    ->create( iWidth, iHeight, uiMaxCuWidth, uiMaxCuHeight, uiMaxCuDepth );
    174224}
    175 
     225#endif
     226
     227#if HHI_INTER_VIEW_MOTION_PRED
    176228Void
    177229TComPic::addOrgDepthMapBuffer()
     
    187239  m_pcOrgDepthMap     ->create( iWidth, iHeight, uiMaxCuWidth, uiMaxCuHeight, uiMaxCuDepth );
    188240}
    189 
     241#endif
     242
     243#if HHI_INTER_VIEW_RESIDUAL_PRED
    190244Void
    191245TComPic::addResidualBuffer()
     
    201255  m_pcResidual        ->create( iWidth, iHeight, uiMaxCuWidth, uiMaxCuHeight, uiMaxCuDepth );
    202256}
    203 
     257#endif
     258
     259#if HHI_INTERVIEW_SKIP
    204260Void
    205261TComPic::addUsedPelsMapBuffer()
     
    215271  m_pcUsedPelsMap     ->create( iWidth, iHeight, uiMaxCuWidth, uiMaxCuHeight, uiMaxCuDepth );
    216272}
     273#endif
    217274
    218275Void
     
    240297#endif
    241298
     299#if DEPTH_MAP_GENERATION
    242300Void
    243301TComPic::removePrdDepthMapBuffer()
     
    250308  }
    251309}
    252 
     310#endif
     311
     312#if HHI_INTER_VIEW_MOTION_PRED
    253313Void
    254314TComPic::removeOrgDepthMapBuffer()
     
    261321  }
    262322}
    263 
     323#endif
     324
     325#if HHI_INTER_VIEW_RESIDUAL_PRED
    264326Void
    265327TComPic::removeResidualBuffer()
     
    272334  }
    273335}
    274 
     336#endif
     337
     338#if HHI_INTERVIEW_SKIP
    275339Void
    276340TComPic::removeUsedPelsMapBuffer()
     
    283347  }
    284348}
    285 
     349#endif
     350
  • trunk/source/Lib/TLibCommon/TComPic.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    2659private:
    2760  TComPicSym*           m_apcPicSym;              //  Symbol
    28  
     61
    2962  TComPicYuv*           m_apcPicYuv[2];           //  Texture,  0:org / 1:rec
     63#if DEPTH_MAP_GENERATION
    3064  TComPicYuv*           m_pcPredDepthMap;         //  estimated depth map
     65#endif
     66#if HHI_INTER_VIEW_MOTION_PRED
    3167  TComPicYuv*           m_pcOrgDepthMap;          //  original depth map
     68#endif
     69#if HHI_INTER_VIEW_RESIDUAL_PRED
    3270  TComPicYuv*           m_pcResidual;             //  residual buffer (coded or inter-view predicted residual)
    33  
     71#endif
     72
    3473  TComPicYuv*           m_pcPicYuvPred;           //  Prediction
    3574  TComPicYuv*           m_pcPicYuvResi;           //  Residual
     
    3978  Bool                  m_bReconstructed;
    4079  UInt                  m_uiCurrSliceIdx;         // Index of current slice
    41  
     80
    4281  SEImessages* m_SEIs; ///< Any SEI messages that have been received.  If !NULL we own the object.
    4382
    44 //  SB //GT; Why? can be accesed by getSlice()->getXXX?
    4583  SliceType             m_eSliceType;
    4684  double                m_dQP;
     
    5593  Int**                 m_aaiCodedOffset;
    5694
    57   //GT
     95#if HHI_VSO 
    5896  TComMVDRefData        m_cReferenceInfo;
    59   TComPicYuv*           m_pcUsedPelsMap;
     97#endif
     98#if HHI_INTERVIEW_SKIP
     99  TComPicYuv*           m_pcUsedPelsMap;
     100#endif
    60101
    61102
     
    63104  TComPic();
    64105  virtual ~TComPic();
    65  
     106
    66107
    67108  Void          create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth );
    68109  Void          destroy();
    69  
     110
    70111  TComPicSym*   getPicSym()           { return  m_apcPicSym;    }
    71112  TComSlice*    getSlice(Int i)       { return  m_apcPicSym->getSlice(i);  }
     
    78119#endif
    79120  TComDataCU*&  getCU( UInt uiCUAddr )  { return  m_apcPicSym->getCU( uiCUAddr ); }
    80  
    81 // SB
     121
    82122  SliceType     getSliceType()        { return m_eSliceType ;}
    83123  double        getQP()               { return m_dQP ;}
     
    86126  TComPicYuv*   getPicYuvOrg()        { return  m_apcPicYuv[0]; }
    87127  TComPicYuv*   getPicYuvRec()        { return  m_apcPicYuv[1]; }
    88  
     128
     129#if DEPTH_MAP_GENERATION
    89130  TComPicYuv*   getPredDepthMap()     { return  m_pcPredDepthMap; }
     131#endif
     132#if HHI_INTER_VIEW_MOTION_PRED
    90133  TComPicYuv*   getOrgDepthMap()      { return  m_pcOrgDepthMap; }
     134#endif
     135#if HHI_INTER_VIEW_RESIDUAL_PRED
    91136  TComPicYuv*   getResidual()         { return  m_pcResidual; }
     137#endif
     138
     139#if HHI_INTERVIEW_SKIP
    92140  TComPicYuv*   getUsedPelsMap()      { return  m_pcUsedPelsMap; }
     141#endif
    93142
    94143
     
    97146  Void          setPicYuvPred( TComPicYuv* pcPicYuv )       { m_pcPicYuvPred = pcPicYuv; }
    98147  Void          setPicYuvResi( TComPicYuv* pcPicYuv )       { m_pcPicYuvResi = pcPicYuv; }
    99 // SB
    100148  Void          setQP( double dQP )   { m_dQP = dQP; }
    101149  Void          setSliceType( SliceType eSliceType ) { m_eSliceType = eSliceType; }
     
    116164  Int**         getCodedOffset()                      { return m_aaiCodedOffset; }
    117165
    118 //GT
     166#if HHI_VSO
    119167  TComMVDRefData* getMVDReferenceInfo() { return &m_cReferenceInfo; }
    120  
     168#endif
     169
    121170  UInt          getNumCUsInFrame()      { return m_apcPicSym->getNumberOfCUsInFrame(); }
    122171  UInt          getNumPartInWidth()     { return m_apcPicSym->getNumPartInWidth();     }
     
    127176  UInt          getMinCUWidth()         { return m_apcPicSym->getMinCUWidth();         }
    128177  UInt          getMinCUHeight()        { return m_apcPicSym->getMinCUHeight();        }
    129  
     178
    130179  UInt          getParPelX(UChar uhPartIdx) { return getParPelX(uhPartIdx); }
    131180  UInt          getParPelY(UChar uhPartIdx) { return getParPelX(uhPartIdx); }
    132  
     181
    133182  Int           getStride()           { return m_apcPicYuv[1]->getStride(); }
    134183  Int           getCStride()          { return m_apcPicYuv[1]->getCStride(); }
    135  
     184
    136185  Void          setReconMark (Bool b) { m_bReconstructed = b;     }
    137186  Bool          getReconMark ()       { return m_bReconstructed;  }
    138  
     187
    139188#if AMVP_BUFFERCOMPRESS
    140   Void          compressMotion(); 
    141 #endif 
     189  Void          compressMotion();
     190#endif
    142191  UInt          getCurrSliceIdx()            { return m_uiCurrSliceIdx;                }
    143192  Void          setCurrSliceIdx(UInt i)      { m_uiCurrSliceIdx = i;                   }
     
    150199  Void          addDeblockBuffer        ();
    151200#endif
     201#if DEPTH_MAP_GENERATION
    152202  Void          addPrdDepthMapBuffer    ();
     203#endif
     204#if HHI_INTER_VIEW_MOTION_PRED
    153205  Void          addOrgDepthMapBuffer    ();
     206#endif
     207#if HHI_INTER_VIEW_RESIDUAL_PRED
    154208  Void          addResidualBuffer       ();
     209#endif
     210
     211#if HHI_INTERVIEW_SKIP
    155212  Void          addUsedPelsMapBuffer    ();
    156  
     213#endif
     214
    157215  Void          removeOriginalBuffer    ();
    158216#if PARALLEL_MERGED_DEBLK
    159217  Void          removeDeblockBuffer     ();
    160218#endif
     219#if DEPTH_MAP_GENERATION
    161220  Void          removePrdDepthMapBuffer ();
     221#endif
     222#if HHI_INTER_VIEW_MOTION_PRED
    162223  Void          removeOrgDepthMapBuffer ();
     224#endif
     225#if HHI_INTER_VIEW_RESIDUAL_PRED
    163226  Void          removeResidualBuffer    ();
     227#endif
     228#if HHI_INTERVIEW_SKIP
    164229  Void          removeUsedPelsMapBuffer ();
    165  
     230#endif
     231
    166232#if PARALLEL_MERGED_DEBLK
    167233  TComPicYuv*   getPicYuvDeblkBuf()      { return  m_pcPicYuvDeblkBuf; }
  • trunk/source/Lib/TLibCommon/TComPicSym.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPicYuv.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPicYuvMD5.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPredFilter.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPredFilter.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
  • trunk/source/Lib/TLibCommon/TComPrediction.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    268301
    269302#if QC_MDIS
    270 #if HHI_DISABLE_INTRA_SMOOTHING_DEPTH
    271   ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 1, iWidth, iHeight, m_piYuvExt, pcCU->getSlice()->getSPS()->isDepth() );
    272 #else
    273303  ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 1, iWidth, iHeight, m_piYuvExt );
    274 #endif
    275304#else
    276305  ptrSrc = pcTComPattern->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
     
    433462}
    434463
    435 #if HHI_DMM_INTRA
     464#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    436465Void TComPrediction::predIntraLumaDMM( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder )
    437466{
     467#if HHI_DMM_WEDGE_INTRA
    438468  if( uiMode == DMM_WEDGE_FULL_IDX          ) { xPredIntraWedgeFull      ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgeFullTabIdx ( uiAbsPartIdx ) ); }
    439469  if( uiMode == DMM_WEDGE_FULL_D_IDX        ) { xPredIntraWedgeFull      ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true,  pcCU->getWedgeFullTabIdx( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC1( uiAbsPartIdx ), pcCU->getWedgeFullDeltaDC2( uiAbsPartIdx ) ); }
    440470  if( uiMode == DMM_WEDGE_PREDDIR_IDX     ) { xPredIntraWedgeDir       ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false, pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ) ); }
    441471  if( uiMode == DMM_WEDGE_PREDDIR_D_IDX   ) { xPredIntraWedgeDir       ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true,  pcCU->getWedgePredDirDeltaEnd( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredDirDeltaDC2( uiAbsPartIdx ) ); }
     472#endif
     473#if HHI_DMM_PRED_TEX
    442474  if( uiMode == DMM_WEDGE_PREDTEX_IDX       ) { xPredIntraWedgeTex       ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
    443475  if( uiMode == DMM_WEDGE_PREDTEX_D_IDX     ) { xPredIntraWedgeTex       ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getWedgePredTexDeltaDC1( uiAbsPartIdx ), pcCU->getWedgePredTexDeltaDC2( uiAbsPartIdx ) ); }
    444476  if( uiMode == DMM_CONTOUR_PREDTEX_IDX     ) { xPredIntraContourTex     ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, false ); }
    445477  if( uiMode == DMM_CONTOUR_PREDTEX_D_IDX   ) { xPredIntraContourTex     ( pcCU, uiAbsPartIdx, piPred, uiStride, iWidth, iHeight, bAbove, bLeft, bEncoder, true, pcCU->getContourPredTexDeltaDC1( uiAbsPartIdx ), pcCU->getContourPredTexDeltaDC2( uiAbsPartIdx ) ); }
    446   }
     478#endif
     479}
    447480
    448481Void TComPrediction::xDeltaDCQuantScaleUp( TComDataCU* pcCU, Int& riDeltaDC )
     
    459492}
    460493
    461 Void TComPrediction::xPredIntraWedgeFull( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, UInt uiTabIdx, Int iDeltaDC1, Int iDeltaDC2 )
    462 {
    463   assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
    464   WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
    465   TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTabIdx));
    466 
    467   // get wedge pred DCs
    468   Int iPredDC1 = 0;
    469   Int iPredDC2 = 0;
    470 
    471   Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
    472   Int iMaskStride = ( iWidth<<1 ) + 1;
    473   piMask += iMaskStride+1;
    474   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
    475 
    476   if( bDelta )
    477   {
    478     xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
    479     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
    480   }
    481 
    482   // assign wedge pred DCs to prediction
    483   if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
    484   else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1,           iPredDC2           ); }
    485 }
    486 
    487 Void TComPrediction::getWedgePredDCs( TComWedgelet* pcWedgelet, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2, Bool bAbove, Bool bLeft )
    488 {
    489   riPredDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); //pred val, if no neighbors are available
    490   riPredDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
    491 
    492   if( !bAbove && !bLeft ) { return; }
    493 
    494   UInt uiNumSmpDC1 = 0, uiNumSmpDC2 = 0;
    495   Int iPredDC1 = 0, iPredDC2 = 0;
    496 
    497   Bool* pabWedgePattern = pcWedgelet->getPattern();
    498   UInt  uiWedgeStride   = pcWedgelet->getStride();
    499 
    500   if( bAbove )
    501   {
    502     for( Int k = 0; k < pcWedgelet->getWidth(); k++ )
    503     {
    504       if( true == pabWedgePattern[k] )
    505       {
    506         iPredDC2 += piMask[k-iMaskStride];
    507         uiNumSmpDC2++;
    508       }
    509       else
    510       {
    511         iPredDC1 += piMask[k-iMaskStride];
    512         uiNumSmpDC1++;
    513       }
    514     }
    515   }
    516   if( bLeft )
    517   {
    518     for( Int k = 0; k < pcWedgelet->getHeight(); k++ )
    519     {
    520       if( true == pabWedgePattern[k*uiWedgeStride] )
    521       {
    522         iPredDC2 += piMask[k*iMaskStride-1];
    523         uiNumSmpDC2++;
    524       }
    525       else
    526       {
    527         iPredDC1 += piMask[k*iMaskStride-1];
    528         uiNumSmpDC1++;
    529       }
    530     }
    531   }
    532 
    533   if( uiNumSmpDC1 > 0 )
    534   {
    535     iPredDC1 /= uiNumSmpDC1;
    536     riPredDC1 = iPredDC1;
    537   }
    538   if( uiNumSmpDC2 > 0 )
    539   {
    540     iPredDC2 /= uiNumSmpDC2;
    541     riPredDC2 = iPredDC2;
    542   }
    543 }
    544 
    545 Void TComPrediction::getBestContourFromText( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge )
    546 {
    547   pcContourWedge->clear();
    548   Bool* pabContourPattern = pcContourWedge->getPattern();
    549 
    550   // get copy of according texture luma block
    551   UInt uiPartAddr = 0;
    552   Int  iBlockWidth, iBlockHeight;
    553 
    554   pcCU->getPartIndexAndSize( uiAbsPartIdx, uiPartAddr, iBlockWidth, iBlockHeight );
    555 
    556   TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
    557   Int     iRefStride = pcPicYuvRef->getStride();
    558   Pel*    piRefY     = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr );
    559 
    560   TComYuv cTempYuv; cTempYuv.create( pcCU->getWidth(0), pcCU->getHeight(0) ); cTempYuv.clear();
    561   UInt uiTempStride = cTempYuv.getStride();
    562   Pel* piTempY      = cTempYuv.getLumaAddr( uiAbsPartIdx, uiWidth );
    563 
    564   for ( Int y = 0; y < iBlockHeight; y++ )
    565   {
    566     ::memcpy(piTempY, piRefY, sizeof(Pel)*iBlockWidth);
    567     piTempY += uiTempStride;
    568     piRefY += iRefStride;
    569   }
    570   piTempY = cTempYuv.getLumaAddr( uiAbsPartIdx, uiWidth );
    571 
    572   // find contour for texture luma block
    573   UInt iDC = 0;
    574   for( UInt k = 0; k < (iBlockWidth*iBlockHeight); k++ ) { iDC += piTempY[k]; }
    575   iDC /= (iBlockWidth*iBlockHeight);
    576 
    577   for( UInt k = 0; k < (iBlockWidth*iBlockHeight); k++ )
    578   {
    579     pabContourPattern[k] = (piTempY[k] > iDC) ? true : false;
    580   }
    581 
    582   cTempYuv.destroy();
    583 }
    584 
    585 UInt TComPrediction::getBestContinueWedge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
    586 {
    587   UInt uiThisBlockSize = uiWidth;
    588   assert( uiThisBlockSize >= DMM_WEDGEMODEL_MIN_SIZE && uiThisBlockSize <= DMM_WEDGEMODEL_MAX_SIZE );
    589   WedgeList*    pacContDWedgeList    = &g_aacWedgeLists   [(g_aucConvertToBit[uiThisBlockSize])];
    590   WedgeRefList* pacContDWedgeRefList = &g_aacWedgeRefLists[(g_aucConvertToBit[uiThisBlockSize])];
    591 
    592   UInt uiPredDirWedgeTabIdx = 0;
    593   TComDataCU* pcTempCU;
    594   UInt        uiTempPartIdx;
    595   // 1st: try continue above wedgelet
    596   pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    597   if( pcTempCU )
    598   {
    599     UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
    600     if( DMM_WEDGE_FULL_IDX      == uhLumaIntraDir ||
    601         DMM_WEDGE_FULL_D_IDX    == uhLumaIntraDir ||
    602         DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir ||
    603         DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir ||
    604         DMM_WEDGE_PREDTEX_IDX   == uhLumaIntraDir ||
    605         DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir    )
    606     {
    607       UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
    608       WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
    609 
    610       // get offset between current and reference block
    611       UInt uiOffsetX = 0;
    612       UInt uiOffsetY = 0;
    613       xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
    614 
    615       // get reference wedgelet
    616   UInt uiRefWedgeTabIdx = 0;
    617       switch( uhLumaIntraDir )
    618       {
    619       case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
    620       case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
    621       case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
    622       case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
    623       case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
    624       case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
    625       default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
    626       }
    627       TComWedgelet* pcRefWedgelet;
    628       pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
    629      
    630       // find reference wedgelet, if direction is suitable for continue wedge
    631       if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
    632       {
    633         UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
    634         pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
    635         getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
    636         return uiPredDirWedgeTabIdx;
    637       }
    638     }
    639   }
    640 
    641   // 2nd: try continue left wedglelet
    642   pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
    643   if( pcTempCU )
    644   {
    645   UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
    646   if( DMM_WEDGE_FULL_IDX          == uhLumaIntraDir ||
    647       DMM_WEDGE_FULL_D_IDX        == uhLumaIntraDir ||
    648         DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir ||
    649         DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir ||
    650       DMM_WEDGE_PREDTEX_IDX       == uhLumaIntraDir ||
    651       DMM_WEDGE_PREDTEX_D_IDX     == uhLumaIntraDir    )
    652   {
    653       UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
    654       WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
    655 
    656       // get offset between current and reference block
    657       UInt uiOffsetX = 0;
    658       UInt uiOffsetY = 0;
    659       xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
    660 
    661       // get reference wedgelet
    662       UInt uiRefWedgeTabIdx = 0;
    663       switch( uhLumaIntraDir )
    664       {
    665       case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
    666       case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
    667       case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
    668       case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
    669       case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
    670       case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
    671       default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
    672       }
    673       TComWedgelet* pcRefWedgelet;
    674       pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
    675 
    676       // find reference wedgelet, if direction is suitable for continue wedge
    677       if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
    678       {
    679         UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
    680         pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
    681         getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
    682         return uiPredDirWedgeTabIdx;
    683       }
    684     }
    685   }
    686 
    687   // 3rd: (default) make wedglet from intra dir and max slope point
    688   Int iSlopeX = 0;
    689   Int iSlopeY = 0;
    690   UInt uiStartPosX = 0;
    691   UInt uiStartPosY = 0;
    692   if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
    693   {
    694     UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
    695     xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
    696     getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
    697     return uiPredDirWedgeTabIdx;
    698   }
    699 
    700   return uiPredDirWedgeTabIdx;
    701 }
    702 
    703 Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
    704 {
    705   ruiOffsetX = 0;
    706   ruiOffsetY = 0;
    707 
    708     // get offset between current and above/left block
    709     UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
    710   UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
    711 
    712   UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
    713     UInt uiMaxDepthRefCU = 0;
    714     while( uiNumPartInRefCU > 1 )
    715     {
    716       uiNumPartInRefCU >>= 2;
    717       uiMaxDepthRefCU++;
    718     }
    719 
    720   UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
    721     UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
    722   UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
    723 
    724   UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
    725   UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
    726 
    727   if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
    728   if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
    729 }
    730 
    731 Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
    732 {
    733   riSlopeX     = 0;
    734   riSlopeY     = 0;
    735   ruiStartPosX = 0;
    736   ruiStartPosY = 0;
    737 
    738   // 1st step: get wedge start point (max. slope)
    739   Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
    740   Int iSourceStride = ( uiBlockSize<<1 ) + 1;
    741 
    742   UInt uiSlopeMaxAbove = 0;
    743   UInt uiPosSlopeMaxAbove = 0;
    744   for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
    745   {
    746     if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
    747     {
    748       uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
    749       uiPosSlopeMaxAbove = uiPosHor;
    750     }
    751   }
    752 
    753   UInt uiSlopeMaxLeft = 0;
    754   UInt uiPosSlopeMaxLeft = 0;
    755   for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
    756   {
    757     if( abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] ) > uiSlopeMaxLeft )
    758     {
    759       uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] );
    760       uiPosSlopeMaxLeft = uiPosVer;
    761     }
    762   }
    763 
    764   if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 )
    765   {
    766     return false;
    767   }
    768 
    769   if( uiSlopeMaxAbove > uiSlopeMaxLeft )
    770   {
    771     ruiStartPosX = uiPosSlopeMaxAbove;
    772     ruiStartPosY = 0;
    773   }
    774   else
    775   {
    776     ruiStartPosX = 0;
    777     ruiStartPosY = uiPosSlopeMaxLeft;
    778   }
    779 
    780   // 2nd step: derive wedge direction
    781   Int angTable[9] = {0,2,5,9,13,17,21,26,32};
    782 
    783   Int uiPreds[2] = {-1, -1};
    784   Int uiPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds );
    785 
    786   UInt uiDirMode = 0;
    787   if( uiPredNum == 1 )
    788   {
    789     uiDirMode = g_aucAngIntraModeOrder[uiPreds[0]];
    790   }
    791   else if( uiPredNum == 2 )
    792   {
    793     uiDirMode = g_aucAngIntraModeOrder[uiPreds[1]];
    794   }
    795 
    796   if( uiDirMode == 0 )
    797   {
    798     return false;
    799   }
    800 
    801   Bool modeVer       = (uiDirMode < 18);
    802   Bool modeHor       = !modeVer;
    803   Int intraPredAngle = modeVer ? uiDirMode - 9 : modeHor ? uiDirMode - 25 : 0;
    804   Int absAng         = abs(intraPredAngle);
    805   Int signAng        = intraPredAngle < 0 ? -1 : 1;
    806   absAng             = angTable[absAng];
    807   intraPredAngle     = signAng * absAng;
    808 
    809   // 3rd step: set slope for direction
    810   if( modeHor )
    811     {
    812     if( intraPredAngle > 0 )
    813     {
    814       riSlopeX = -32;
    815       riSlopeY = intraPredAngle;
    816     }
    817     else
    818     {
    819       riSlopeX = 32;
    820       riSlopeY = -intraPredAngle;
    821     }
    822     }
    823   else if( modeVer )
    824   {
    825     if( intraPredAngle > 0 )
    826     {
    827       riSlopeX = intraPredAngle;
    828       riSlopeY = -32;
    829   }
    830   else
    831   {
    832       riSlopeX = -intraPredAngle;
    833       riSlopeY = 32;
    834     }
    835   }
    836 
    837     return true;
    838 }
    839 
    840 Void TComPrediction::xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd )
    841 {
    842   ruhXs = 0;
    843   ruhYs = 0;
    844   ruhXe = 0;
    845   ruhYe = 0;
    846   UInt uiOri;
    847 
    848   // scaling of start pos and block size to wedge resolution
    849   UInt uiScaledStartPosX = 0;
    850   UInt uiScaledStartPosY = 0;
    851   UInt uiScaledBlockSize = 0;
    852   WedgeResolution eWedgeRes = g_aeWedgeResolutionList[(UInt)g_aucConvertToBit[uiBlockSize]];
    853   switch( eWedgeRes )
    854   {
    855   case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
    856   case(   FULL_PEL ): { uiScaledStartPosX =  uiPMSPosX;     uiScaledStartPosY =  uiPMSPosY;     uiScaledBlockSize =  uiBlockSize;     break; }
    857   case(   HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
    858 }
    859 
    860   // case above
    861   if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
    862   {
    863     ruhXs = (UChar)uiScaledStartPosX;
    864     ruhYs = 0;
    865 
    866     if( iDeltaY == 0 )
    867 {
    868       if( iDeltaX < 0 )
    869       {
    870         uiOri = 0;
    871         ruhXe = 0;
    872         ruhYe = (UChar)Min( Max( iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
    873         return;
    874       }
    875       else
    876       {
    877         uiOri = 1;
    878         ruhXe = (UChar)(uiScaledBlockSize-1); ;
    879         ruhYe = (UChar)Min( Max( -iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
    880         std::swap( ruhXs, ruhXe );
    881         std::swap( ruhYs, ruhYe );
    882         return;
    883       }
    884     }
    885 
    886     // regular case
    887     Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaX / (Double)iDeltaY) );
    888 
    889     if( iVirtualEndX < 0 )
    890     {
    891       Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
    892       if( iYe < (Int)uiScaledBlockSize )
    893       {
    894         uiOri = 0;
    895         ruhXe = 0;
    896         ruhYe = (UChar)Max( iYe, 0 );
    897         return;
    898       }
    899       else
    900       {
    901         uiOri = 4;
    902         ruhXe = (UChar)Min( (iYe - (uiScaledBlockSize-1)), (uiScaledBlockSize-1) );
    903         ruhYe = (UChar)(uiScaledBlockSize-1);
    904         return;
    905       }
    906     }
    907     else if( iVirtualEndX > (uiScaledBlockSize-1) )
    908     {
    909       Int iYe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
    910       if( iYe < (Int)uiScaledBlockSize )
    911       {
    912         uiOri = 1;
    913         ruhXe = (UChar)(uiScaledBlockSize-1);
    914         ruhYe = (UChar)Max( iYe, 0 );
    915         std::swap( ruhXs, ruhXe );
    916         std::swap( ruhYs, ruhYe );
    917         return;
    918       }
    919       else
    920       {
    921         uiOri = 4;
    922         ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
    923         ruhYe = (UChar)(uiScaledBlockSize-1);
    924         return;
    925       }
    926     }
    927     else
    928     {
    929       Int iXe = iVirtualEndX + iDeltaEnd;
    930       if( iXe < 0 )
    931       {
    932         uiOri = 0;
    933         ruhXe = 0;
    934         ruhYe = (UChar)Max( ((uiScaledBlockSize-1) + iXe), 0 );
    935         return;
    936       }
    937       else if( iXe > (uiScaledBlockSize-1) )
    938       {
    939         uiOri = 1;
    940         ruhXe = (UChar)(uiScaledBlockSize-1);
    941         ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
    942         std::swap( ruhXs, ruhXe );
    943         std::swap( ruhYs, ruhYe );
    944         return;
    945       }
    946       else
    947       {
    948         uiOri = 4;
    949         ruhXe = (UChar)iXe;
    950         ruhYe = (UChar)(uiScaledBlockSize-1);
    951         return;
    952       }
    953     }
    954   }
    955 
    956   // case left
    957   if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
    958   {
    959     ruhXs = 0;
    960     ruhYs = (UChar)uiScaledStartPosY;
    961 
    962     if( iDeltaX == 0 )
    963     {
    964       if( iDeltaY < 0 )
    965       {
    966         uiOri = 0;
    967         ruhXe = (UChar)Min( Max( -iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
    968         ruhYe = 0;
    969         std::swap( ruhXs, ruhXe );
    970         std::swap( ruhYs, ruhYe );
    971         return;
    972       }
    973       else
    974       {
    975         uiOri = 3;
    976         ruhXe = (UChar)Min( Max( iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
    977         ruhYe = (UChar)(uiScaledBlockSize-1);
    978         return;
    979       }
    980     }
    981 
    982     // regular case
    983     Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaY / (Double)iDeltaX) );
    984 
    985     if( iVirtualEndY < 0 )
    986     {
    987       Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
    988       if( iXe < (Int)uiScaledBlockSize )
    989       {
    990         uiOri = 0;
    991         ruhXe = (UChar)Max( iXe, 0 );
    992         ruhYe = 0;
    993         std::swap( ruhXs, ruhXe );
    994         std::swap( ruhYs, ruhYe );
    995         return;
    996       }
    997       else
    998       {
    999         uiOri = 5;
    1000         ruhXe = (UChar)(uiScaledBlockSize-1);
    1001         ruhYe = (UChar)Min( (iXe - (uiScaledBlockSize-1)), (uiScaledBlockSize-1) );
    1002         std::swap( ruhXs, ruhXe );
    1003         std::swap( ruhYs, ruhYe );
    1004         return;
    1005       }
    1006     }
    1007     else if( iVirtualEndY > (uiScaledBlockSize-1) )
    1008     {
    1009       Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
    1010       if( iXe < (Int)uiScaledBlockSize )
    1011       {
    1012         uiOri = 3;
    1013         ruhXe = (UChar)Max( iXe, 0 );
    1014         ruhYe = (UChar)(uiScaledBlockSize-1);
    1015         return;
    1016       }
    1017       else
    1018       {
    1019         uiOri = 5;
    1020         ruhXe = (UChar)(uiScaledBlockSize-1);
    1021         ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
    1022         std::swap( ruhXs, ruhXe );
    1023         std::swap( ruhYs, ruhYe );
    1024         return;
    1025       }
    1026     }
    1027     else
    1028     {
    1029       Int iYe = iVirtualEndY - iDeltaEnd;
    1030       if( iYe < 0 )
    1031       {
    1032         uiOri = 0;
    1033         ruhXe = (UChar)Max( ((uiScaledBlockSize-1) + iYe), 0 );
    1034         ruhYe = 0;
    1035         std::swap( ruhXs, ruhXe );
    1036         std::swap( ruhYs, ruhYe );
    1037         return;
    1038       }
    1039       else if( iYe > (uiScaledBlockSize-1) )
    1040       {
    1041         uiOri = 3;
    1042         ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
    1043         ruhYe = (UChar)(uiScaledBlockSize-1);
    1044         return;
    1045       }
    1046       else
    1047       {
    1048         uiOri = 5;
    1049         ruhXe = (UChar)(uiScaledBlockSize-1);
    1050         ruhYe = (UChar)iYe;
    1051         std::swap( ruhXs, ruhXe );
    1052         std::swap( ruhYs, ruhYe );
    1053         return;
    1054       }
    1055     }
    1056   }
    1057 
    1058   // case origin
    1059   if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
    1060   {
    1061     if( iDeltaX*iDeltaY < 0 )
    1062     {
    1063       return;
    1064     }
    1065 
    1066     ruhXs = 0;
    1067     ruhYs = 0;
    1068 
    1069     if( iDeltaY == 0 )
    1070     {
    1071       uiOri = 1;
    1072       ruhXe = (UChar)(uiScaledBlockSize-1);
    1073       ruhYe = 0;
    1074       std::swap( ruhXs, ruhXe );
    1075       std::swap( ruhYs, ruhYe );
    1076       return;
    1077   }
    1078 
    1079     if( iDeltaX == 0 )
    1080     {
    1081       uiOri = 0;
    1082       ruhXe = 0;
    1083       ruhYe = (UChar)(uiScaledBlockSize-1);
    1084       return;
    1085   }
    1086 
    1087     Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaX / (Double)iDeltaY) );
    1088 
    1089     if( iVirtualEndX > (uiScaledBlockSize-1) )
    1090     {
    1091       Int iYe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
    1092       if( iYe < (Int)uiScaledBlockSize )
    1093       {
    1094         uiOri = 1;
    1095         ruhXe = (UChar)(uiScaledBlockSize-1);
    1096         ruhYe = (UChar)Max( iYe, 0 );
    1097         std::swap( ruhXs, ruhXe );
    1098         std::swap( ruhYs, ruhYe );
    1099         return;
    1100       }
    1101       else
    1102       {
    1103         uiOri = 3;
    1104         ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
    1105         ruhYe = (UChar)(uiScaledBlockSize-1);
    1106         return;
    1107       }
    1108     }
    1109     else
    1110     {
    1111       Int iXe = iVirtualEndX + iDeltaEnd;
    1112       if( iXe < 0 )
    1113       {
    1114         uiOri = 0;
    1115         ruhXe = 0;
    1116         ruhYe = (UChar)Max( ((uiScaledBlockSize-1) + iXe), 0 );
    1117         return;
    1118       }
    1119       else if( iXe > (uiScaledBlockSize-1) )
    1120       {
    1121         uiOri = 1;
    1122         ruhXe = (UChar)(uiScaledBlockSize-1);
    1123         ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
    1124         std::swap( ruhXs, ruhXe );
    1125         std::swap( ruhYs, ruhYe );
    1126         return;
    1127       }
    1128       else
    1129       {
    1130         uiOri = 3;
    1131         ruhXe = (UChar)iXe;
    1132         ruhYe = (UChar)(uiScaledBlockSize-1);
    1133         return;
    1134       }
    1135     }
    1136   }
    1137 }
    1138 
    1139 Bool TComPrediction::getWedgeListIdx( WedgeList* pcWedgeList, WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
    1140       {
    1141   ruiTabIdx = 0;
    1142 
    1143   for( UInt uiIdx = 0; uiIdx < pcWedgeList->size(); uiIdx++ )
    1144       {
    1145     TComWedgelet* pcTestWedge = &(pcWedgeList->at(uiIdx));
    1146 
    1147     if( pcTestWedge->getStartX() == uhXs &&
    1148         pcTestWedge->getStartY() == uhYs &&
    1149         pcTestWedge->getEndX()   == uhXe &&
    1150         pcTestWedge->getEndY()   == uhYe    )
    1151         {
    1152       ruiTabIdx = uiIdx;
    1153       return true;
    1154         }
    1155       }
    1156 
    1157   // additionally search in WedgeRef lists of duplicated patterns
    1158   for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
    1159         {
    1160     TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
    1161 
    1162     if( pcTestWedgeRef->getStartX() == uhXs &&
    1163         pcTestWedgeRef->getStartY() == uhYs &&
    1164         pcTestWedgeRef->getEndX()   == uhXe &&
    1165         pcTestWedgeRef->getEndY()   == uhYe    )
    1166           {
    1167       ruiTabIdx = pcTestWedgeRef->getRefIdx();
    1168       return true;
    1169     }
    1170   }
    1171 
    1172   return false;
    1173 }
    1174 
    1175 Void TComPrediction::xPredIntraWedgeDir( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iWedgeDeltaEnd, Int iDeltaDC1, Int iDeltaDC2 )
    1176 {
    1177   assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
    1178   WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
    1179 
    1180   // get wedge pattern
    1181   UInt uiDirWedgeTabIdx = 0;
    1182   if( bEncoder )
    1183   {
    1184     // encoder: load stored wedge pattern from CU
    1185     uiDirWedgeTabIdx = pcCU->getWedgePredDirTabIdx( uiAbsPartIdx );
    1186   }
    1187   else
    1188   {
    1189     uiDirWedgeTabIdx = getBestContinueWedge( pcCU, uiAbsPartIdx, iWidth, iHeight, iWedgeDeltaEnd );
    1190 
    1191     UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
    1192     pcCU->setWedgePredDirTabIdxSubParts( uiDirWedgeTabIdx, uiAbsPartIdx, uiDepth );
    1193   }
    1194   TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiDirWedgeTabIdx));
    1195 
    1196   // get wedge pred DCs
    1197   Int iPredDC1 = 0;
    1198   Int iPredDC2 = 0;
    1199 
    1200   Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
    1201   Int iMaskStride = ( iWidth<<1 ) + 1;
    1202   piMask += iMaskStride+1;
    1203   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
    1204 
    1205   if( bDelta )
    1206   {
    1207     xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
    1208     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
    1209   }
    1210 
    1211   // assign wedge pred DCs to prediction
    1212   if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
    1213   else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride,        iPredDC1,                   iPredDC2             ); }
    1214 }
    1215 
    1216 Void TComPrediction::xPredIntraWedgeTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
    1217 {
    1218   assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
    1219   WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
    1220 
    1221   // get wedge pattern
    1222   UInt uiTextureWedgeTabIdx = 0;
    1223   if( bEncoder )
    1224   {
    1225      // encoder: load stored wedge pattern from CU
    1226     uiTextureWedgeTabIdx = pcCU->getWedgePredTexTabIdx( uiAbsPartIdx );
    1227   }
    1228   else
    1229   {
    1230     // decoder: get and store wedge pattern in CU
    1231     uiTextureWedgeTabIdx = getBestWedgeFromText( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight );
    1232     UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
    1233     pcCU->setWedgePredTexTabIdxSubParts( uiTextureWedgeTabIdx, uiAbsPartIdx, uiDepth );
    1234   }
    1235   TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTextureWedgeTabIdx));
    1236 
    1237   // get wedge pred DCs
    1238   Int iPredDC1 = 0;
    1239   Int iPredDC2 = 0;
    1240   Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
    1241   Int iMaskStride = ( iWidth<<1 ) + 1;
    1242   piMask += iMaskStride+1;
    1243   getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
    1244 
    1245   if( bDelta )
    1246   {
    1247     xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
    1248     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
    1249   }
    1250 
    1251   // assign wedge pred DCs to prediction
    1252   if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
    1253   else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride,        iPredDC1,                   iPredDC2           ); }
    1254 }
    1255 
    1256 Void TComPrediction::xPredIntraContourTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
    1257 {
    1258   // get contour pattern
    1259   TComWedgelet* pcContourWedge = new TComWedgelet( iWidth, iHeight );
    1260   getBestContourFromText( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, pcContourWedge );
    1261 
    1262   // get wedge pred DCs
    1263   Int iPredDC1 = 0;
    1264   Int iPredDC2 = 0;
    1265   Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
    1266   Int iMaskStride = ( iWidth<<1 ) + 1;
    1267   piMask += iMaskStride+1;
    1268   getWedgePredDCs( pcContourWedge, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
    1269 
    1270   if( bDelta )
    1271   {
    1272     xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
    1273     xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
    1274   }
    1275 
    1276   // assign wedge pred DCs to prediction
    1277   if( bDelta ) { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
    1278   else         { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride,        iPredDC1,                   iPredDC2           ); }
    1279 
    1280   pcContourWedge->destroy();
    1281   delete pcContourWedge;
    1282 }
    1283 #endif
    1284 #if HHI_DMM_INTRA
    1285494Void TComPrediction::calcWedgeDCs( TComWedgelet* pcWedgelet, Pel* piOrig, UInt uiStride, Int& riDC1, Int& riDC2 )
    1286495{
     
    1367576        }
    1368577        else
    1369         {
     578  {
    1370579          piTemp[uiX] = iDC1;
    1371580        }
     
    1377586}
    1378587
    1379 UInt TComPrediction::getBestWedgeFromText( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, WedgeDist eWedgeDist )
     588Void TComPrediction::getWedgePredDCs( TComWedgelet* pcWedgelet, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2, Bool bAbove, Bool bLeft )
     589{
     590  riPredDC1 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) ); //pred val, if no neighbors are available
     591  riPredDC2 = ( 1<<( g_uiBitDepth + g_uiBitIncrement - 1) );
     592
     593  if( !bAbove && !bLeft ) { return; }
     594
     595  UInt uiNumSmpDC1 = 0, uiNumSmpDC2 = 0;
     596  Int iPredDC1 = 0, iPredDC2 = 0;
     597
     598  Bool* pabWedgePattern = pcWedgelet->getPattern();
     599  UInt  uiWedgeStride   = pcWedgelet->getStride();
     600
     601  if( bAbove )
     602  {
     603    for( Int k = 0; k < pcWedgelet->getWidth(); k++ )
     604    {
     605      if( true == pabWedgePattern[k] )
     606      {
     607        iPredDC2 += piMask[k-iMaskStride];
     608        uiNumSmpDC2++;
     609      }
     610      else
     611      {
     612        iPredDC1 += piMask[k-iMaskStride];
     613        uiNumSmpDC1++;
     614      }
     615    }
     616  }
     617  if( bLeft )
     618  {
     619    for( Int k = 0; k < pcWedgelet->getHeight(); k++ )
     620    {
     621      if( true == pabWedgePattern[k*uiWedgeStride] )
     622      {
     623        iPredDC2 += piMask[k*iMaskStride-1];
     624        uiNumSmpDC2++;
     625      }
     626      else
     627      {
     628        iPredDC1 += piMask[k*iMaskStride-1];
     629        uiNumSmpDC1++;
     630      }
     631    }
     632  }
     633
     634  if( uiNumSmpDC1 > 0 )
     635  {
     636    iPredDC1 /= uiNumSmpDC1;
     637    riPredDC1 = iPredDC1;
     638  }
     639  if( uiNumSmpDC2 > 0 )
     640  {
     641    iPredDC2 /= uiNumSmpDC2;
     642    riPredDC2 = iPredDC2;
     643  }
     644}
     645#endif
     646
     647#if HHI_DMM_WEDGE_INTRA
     648Void TComPrediction::xPredIntraWedgeFull( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, UInt uiTabIdx, Int iDeltaDC1, Int iDeltaDC2 )
     649{
     650  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
     651  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
     652  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTabIdx));
     653
     654  // get wedge pred DCs
     655  Int iPredDC1 = 0;
     656  Int iPredDC2 = 0;
     657
     658  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
     659  Int iMaskStride = ( iWidth<<1 ) + 1;
     660  piMask += iMaskStride+1;
     661  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
     662
     663  if( bDelta )
     664  {
     665    xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
     666    xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
     667  }
     668
     669  // assign wedge pred DCs to prediction
     670  if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
     671  else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, iPredDC1,           iPredDC2           ); }
     672}
     673
     674UInt TComPrediction::getBestContinueWedge( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd )
     675{
     676  UInt uiThisBlockSize = uiWidth;
     677  assert( uiThisBlockSize >= DMM_WEDGEMODEL_MIN_SIZE && uiThisBlockSize <= DMM_WEDGEMODEL_MAX_SIZE );
     678  WedgeList*    pacContDWedgeList    = &g_aacWedgeLists   [(g_aucConvertToBit[uiThisBlockSize])];
     679  WedgeRefList* pacContDWedgeRefList = &g_aacWedgeRefLists[(g_aucConvertToBit[uiThisBlockSize])];
     680
     681  UInt uiPredDirWedgeTabIdx = 0;
     682  TComDataCU* pcTempCU;
     683  UInt        uiTempPartIdx;
     684  // 1st: try continue above wedgelet
     685  pcTempCU = pcCU->getPUAbove( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     686  if( pcTempCU )
     687  {
     688    UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
     689    if( DMM_WEDGE_FULL_IDX      == uhLumaIntraDir ||
     690        DMM_WEDGE_FULL_D_IDX    == uhLumaIntraDir ||
     691        DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir ||
     692        DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
     693#if HHI_DMM_PRED_TEX
     694                                                  ||
     695        DMM_WEDGE_PREDTEX_IDX   == uhLumaIntraDir ||
     696        DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir   
     697#endif
     698       )
     699    {
     700      UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
     701      WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
     702
     703      // get offset between current and reference block
     704      UInt uiOffsetX = 0;
     705      UInt uiOffsetY = 0;
     706      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
     707
     708      // get reference wedgelet
     709  UInt uiRefWedgeTabIdx = 0;
     710      switch( uhLumaIntraDir )
     711      {
     712      case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
     713      case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
     714      case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
     715      case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
     716#if HHI_DMM_PRED_TEX
     717      case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
     718      case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
     719#endif
     720      default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
     721      }
     722      TComWedgelet* pcRefWedgelet;
     723      pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
     724     
     725      // find reference wedgelet, if direction is suitable for continue wedge
     726      if( pcRefWedgelet->checkPredDirAbovePossible( uiThisBlockSize, uiOffsetX ) )
     727      {
     728        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     729        pcRefWedgelet->getPredDirStartEndAbove( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetX, iDeltaEnd );
     730        getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     731        return uiPredDirWedgeTabIdx;
     732      }
     733    }
     734  }
     735
     736  // 2nd: try continue left wedglelet
     737  pcTempCU = pcCU->getPULeft( uiTempPartIdx, pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     738  if( pcTempCU )
     739  {
     740    UChar uhLumaIntraDir = pcTempCU->getLumaIntraDir( uiTempPartIdx );
     741    if( DMM_WEDGE_FULL_IDX      == uhLumaIntraDir ||
     742        DMM_WEDGE_FULL_D_IDX    == uhLumaIntraDir ||
     743        DMM_WEDGE_PREDDIR_IDX   == uhLumaIntraDir ||
     744        DMM_WEDGE_PREDDIR_D_IDX == uhLumaIntraDir
     745#if HHI_DMM_PRED_TEX
     746                                                  ||
     747        DMM_WEDGE_PREDTEX_IDX   == uhLumaIntraDir ||
     748        DMM_WEDGE_PREDTEX_D_IDX == uhLumaIntraDir   
     749#endif
     750      )
     751    {
     752      UInt uiRefWedgeSize = (UInt)g_aucIntraSizeIdxToWedgeSize[pcTempCU->getIntraSizeIdx( uiTempPartIdx )];
     753      WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[uiRefWedgeSize])];
     754
     755      // get offset between current and reference block
     756      UInt uiOffsetX = 0;
     757      UInt uiOffsetY = 0;
     758      xGetBlockOffset( pcCU, uiAbsPartIdx, pcTempCU, uiTempPartIdx, uiOffsetX, uiOffsetY );
     759
     760      // get reference wedgelet
     761      UInt uiRefWedgeTabIdx = 0;
     762      switch( uhLumaIntraDir )
     763      {
     764      case( DMM_WEDGE_FULL_IDX      ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
     765      case( DMM_WEDGE_FULL_D_IDX    ): { uiRefWedgeTabIdx = pcTempCU->getWedgeFullTabIdx   ( uiTempPartIdx ); } break;
     766      case( DMM_WEDGE_PREDDIR_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
     767      case( DMM_WEDGE_PREDDIR_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredDirTabIdx( uiTempPartIdx ); } break;
     768#if HHI_DMM_PRED_TEX
     769      case( DMM_WEDGE_PREDTEX_IDX   ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
     770      case( DMM_WEDGE_PREDTEX_D_IDX ): { uiRefWedgeTabIdx = pcTempCU->getWedgePredTexTabIdx( uiTempPartIdx ); } break;
     771#endif
     772      default: { assert( 0 ); return uiPredDirWedgeTabIdx; }
     773      }
     774      TComWedgelet* pcRefWedgelet;
     775      pcRefWedgelet = &(pacWedgeList->at( uiRefWedgeTabIdx ));
     776
     777      // find reference wedgelet, if direction is suitable for continue wedge
     778      if( pcRefWedgelet->checkPredDirLeftPossible( uiThisBlockSize, uiOffsetY ) )
     779      {
     780        UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     781        pcRefWedgelet->getPredDirStartEndLeft( uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, uiThisBlockSize, uiOffsetY, iDeltaEnd );
     782        getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     783        return uiPredDirWedgeTabIdx;
     784      }
     785    }
     786  }
     787
     788  // 3rd: (default) make wedglet from intra dir and max slope point
     789  Int iSlopeX = 0;
     790  Int iSlopeY = 0;
     791  UInt uiStartPosX = 0;
     792  UInt uiStartPosY = 0;
     793  if( xGetWedgeIntraDirPredData( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY ) )
     794  {
     795    UChar uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye;
     796    xGetWedgeIntraDirStartEnd( pcCU, uiAbsPartIdx, uiThisBlockSize, iSlopeX, iSlopeY, uiStartPosX, uiStartPosY, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye, iDeltaEnd );
     797    getWedgeListIdx( pacContDWedgeList, pacContDWedgeRefList, uiPredDirWedgeTabIdx, uhContD_Xs, uhContD_Ys, uhContD_Xe, uhContD_Ye );
     798    return uiPredDirWedgeTabIdx;
     799  }
     800
     801  return uiPredDirWedgeTabIdx;
     802}
     803
     804Void TComPrediction::xGetBlockOffset( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY )
     805{
     806  ruiOffsetX = 0;
     807  ruiOffsetY = 0;
     808
     809  // get offset between current and above/left block
     810  UInt uiThisOriginX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
     811  UInt uiThisOriginY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
     812
     813  UInt uiNumPartInRefCU = pcRefCU->getTotalNumPart();
     814  UInt uiMaxDepthRefCU = 0;
     815  while( uiNumPartInRefCU > 1 )
     816  {
     817    uiNumPartInRefCU >>= 2;
     818    uiMaxDepthRefCU++;
     819  }
     820
     821  UInt uiDepthRefPU = (pcRefCU->getDepth(uiRefAbsPartIdx)) + (pcRefCU->getPartitionSize(uiRefAbsPartIdx) == SIZE_2Nx2N ? 0 : 1);
     822  UInt uiShifts = (uiMaxDepthRefCU - uiDepthRefPU)*2;
     823  UInt uiRefBlockOriginPartIdx = (uiRefAbsPartIdx>>uiShifts)<<uiShifts;
     824
     825  UInt uiRefOriginX = pcRefCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
     826  UInt uiRefOriginY = pcRefCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiRefBlockOriginPartIdx] ];
     827
     828  if( (uiThisOriginX - uiRefOriginX) > 0 ) { ruiOffsetX = (UInt)(uiThisOriginX - uiRefOriginX); }
     829  if( (uiThisOriginY - uiRefOriginY) > 0 ) { ruiOffsetY = (UInt)(uiThisOriginY - uiRefOriginY); }
     830}
     831
     832Bool TComPrediction::xGetWedgeIntraDirPredData( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY )
     833{
     834  riSlopeX     = 0;
     835  riSlopeY     = 0;
     836  ruiStartPosX = 0;
     837  ruiStartPosY = 0;
     838
     839  // 1st step: get wedge start point (max. slope)
     840  Int* piSource = pcCU->getPattern()->getAdiOrgBuf( uiBlockSize, uiBlockSize, m_piYuvExt );
     841  Int iSourceStride = ( uiBlockSize<<1 ) + 1;
     842
     843  UInt uiSlopeMaxAbove = 0;
     844  UInt uiPosSlopeMaxAbove = 0;
     845  for( UInt uiPosHor = 0; uiPosHor < (uiBlockSize-1); uiPosHor++ )
     846  {
     847    if( abs( piSource[uiPosHor+1] - piSource[uiPosHor] ) > uiSlopeMaxAbove )
     848    {
     849      uiSlopeMaxAbove = abs( piSource[uiPosHor+1] - piSource[uiPosHor] );
     850      uiPosSlopeMaxAbove = uiPosHor;
     851    }
     852  }
     853
     854  UInt uiSlopeMaxLeft = 0;
     855  UInt uiPosSlopeMaxLeft = 0;
     856  for( UInt uiPosVer = 0; uiPosVer < (uiBlockSize-1); uiPosVer++ )
     857  {
     858    if( abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] ) > uiSlopeMaxLeft )
     859    {
     860      uiSlopeMaxLeft = abs( piSource[(uiPosVer+1)*iSourceStride] - piSource[uiPosVer*iSourceStride] );
     861      uiPosSlopeMaxLeft = uiPosVer;
     862    }
     863  }
     864
     865  if( uiSlopeMaxAbove == 0 && uiSlopeMaxLeft == 0 )
     866  {
     867    return false;
     868  }
     869
     870  if( uiSlopeMaxAbove > uiSlopeMaxLeft )
     871  {
     872    ruiStartPosX = uiPosSlopeMaxAbove;
     873    ruiStartPosY = 0;
     874  }
     875  else
     876  {
     877    ruiStartPosX = 0;
     878    ruiStartPosY = uiPosSlopeMaxLeft;
     879  }
     880
     881  // 2nd step: derive wedge direction
     882  Int angTable[9] = {0,2,5,9,13,17,21,26,32};
     883
     884  Int uiPreds[2] = {-1, -1};
     885  Int uiPredNum = pcCU->getIntraDirLumaPredictor( uiAbsPartIdx, uiPreds );
     886
     887  UInt uiDirMode = 0;
     888  if( uiPredNum == 1 )
     889  {
     890    uiDirMode = g_aucAngIntraModeOrder[uiPreds[0]];
     891  }
     892  else if( uiPredNum == 2 )
     893  {
     894    uiDirMode = g_aucAngIntraModeOrder[uiPreds[1]];
     895  }
     896
     897  if( uiDirMode == 0 )
     898  {
     899    return false;
     900  }
     901
     902  Bool modeVer       = (uiDirMode < 18);
     903  Bool modeHor       = !modeVer;
     904  Int intraPredAngle = modeVer ? uiDirMode - 9 : modeHor ? uiDirMode - 25 : 0;
     905  Int absAng         = abs(intraPredAngle);
     906  Int signAng        = intraPredAngle < 0 ? -1 : 1;
     907  absAng             = angTable[absAng];
     908  intraPredAngle     = signAng * absAng;
     909
     910  // 3rd step: set slope for direction
     911  if( modeHor )
     912    {
     913    if( intraPredAngle > 0 )
     914    {
     915      riSlopeX = -32;
     916      riSlopeY = intraPredAngle;
     917    }
     918    else
     919    {
     920      riSlopeX = 32;
     921      riSlopeY = -intraPredAngle;
     922    }
     923    }
     924  else if( modeVer )
     925  {
     926    if( intraPredAngle > 0 )
     927    {
     928      riSlopeX = intraPredAngle;
     929      riSlopeY = -32;
     930  }
     931  else
     932  {
     933      riSlopeX = -intraPredAngle;
     934      riSlopeY = 32;
     935    }
     936  }
     937
     938    return true;
     939}
     940
     941Void TComPrediction::xGetWedgeIntraDirStartEnd( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd )
     942{
     943  ruhXs = 0;
     944  ruhYs = 0;
     945  ruhXe = 0;
     946  ruhYe = 0;
     947  UInt uiOri;
     948
     949  // scaling of start pos and block size to wedge resolution
     950  UInt uiScaledStartPosX = 0;
     951  UInt uiScaledStartPosY = 0;
     952  UInt uiScaledBlockSize = 0;
     953  WedgeResolution eWedgeRes = g_aeWedgeResolutionList[(UInt)g_aucConvertToBit[uiBlockSize]];
     954  switch( eWedgeRes )
     955  {
     956  case( DOUBLE_PEL ): { uiScaledStartPosX = (uiPMSPosX>>1); uiScaledStartPosY = (uiPMSPosY>>1); uiScaledBlockSize = (uiBlockSize>>1); break; }
     957  case(   FULL_PEL ): { uiScaledStartPosX =  uiPMSPosX;     uiScaledStartPosY =  uiPMSPosY;     uiScaledBlockSize =  uiBlockSize;     break; }
     958  case(   HALF_PEL ): { uiScaledStartPosX = (uiPMSPosX<<1); uiScaledStartPosY = (uiPMSPosY<<1); uiScaledBlockSize = (uiBlockSize<<1); break; }
     959}
     960
     961  // case above
     962  if( uiScaledStartPosX > 0 && uiScaledStartPosY == 0 )
     963  {
     964    ruhXs = (UChar)uiScaledStartPosX;
     965    ruhYs = 0;
     966
     967    if( iDeltaY == 0 )
     968{
     969      if( iDeltaX < 0 )
     970      {
     971        uiOri = 0;
     972        ruhXe = 0;
     973        ruhYe = (UChar)Min( Max( iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
     974        return;
     975      }
     976      else
     977      {
     978        uiOri = 1;
     979        ruhXe = (UChar)(uiScaledBlockSize-1); ;
     980        ruhYe = (UChar)Min( Max( -iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
     981        std::swap( ruhXs, ruhXe );
     982        std::swap( ruhYs, ruhYe );
     983        return;
     984      }
     985    }
     986
     987    // regular case
     988    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaX / (Double)iDeltaY) );
     989
     990    if( iVirtualEndX < 0 )
     991    {
     992      Int iYe = roftoi( (Double)(0 - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) + iDeltaEnd;
     993      if( iYe < (Int)uiScaledBlockSize )
     994      {
     995        uiOri = 0;
     996        ruhXe = 0;
     997        ruhYe = (UChar)Max( iYe, 0 );
     998        return;
     999      }
     1000      else
     1001      {
     1002        uiOri = 4;
     1003        ruhXe = (UChar)Min( (iYe - (uiScaledBlockSize-1)), (uiScaledBlockSize-1) );
     1004        ruhYe = (UChar)(uiScaledBlockSize-1);
     1005        return;
     1006      }
     1007    }
     1008    else if( iVirtualEndX > (uiScaledBlockSize-1) )
     1009    {
     1010      Int iYe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
     1011      if( iYe < (Int)uiScaledBlockSize )
     1012      {
     1013        uiOri = 1;
     1014        ruhXe = (UChar)(uiScaledBlockSize-1);
     1015        ruhYe = (UChar)Max( iYe, 0 );
     1016        std::swap( ruhXs, ruhXe );
     1017        std::swap( ruhYs, ruhYe );
     1018        return;
     1019      }
     1020      else
     1021      {
     1022        uiOri = 4;
     1023        ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
     1024        ruhYe = (UChar)(uiScaledBlockSize-1);
     1025        return;
     1026      }
     1027    }
     1028    else
     1029    {
     1030      Int iXe = iVirtualEndX + iDeltaEnd;
     1031      if( iXe < 0 )
     1032      {
     1033        uiOri = 0;
     1034        ruhXe = 0;
     1035        ruhYe = (UChar)Max( ((uiScaledBlockSize-1) + iXe), 0 );
     1036        return;
     1037      }
     1038      else if( iXe > (uiScaledBlockSize-1) )
     1039      {
     1040        uiOri = 1;
     1041        ruhXe = (UChar)(uiScaledBlockSize-1);
     1042        ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
     1043        std::swap( ruhXs, ruhXe );
     1044        std::swap( ruhYs, ruhYe );
     1045        return;
     1046      }
     1047      else
     1048      {
     1049        uiOri = 4;
     1050        ruhXe = (UChar)iXe;
     1051        ruhYe = (UChar)(uiScaledBlockSize-1);
     1052        return;
     1053      }
     1054    }
     1055  }
     1056
     1057  // case left
     1058  if( uiScaledStartPosY > 0 && uiScaledStartPosX == 0 )
     1059  {
     1060    ruhXs = 0;
     1061    ruhYs = (UChar)uiScaledStartPosY;
     1062
     1063    if( iDeltaX == 0 )
     1064    {
     1065      if( iDeltaY < 0 )
     1066      {
     1067        uiOri = 0;
     1068        ruhXe = (UChar)Min( Max( -iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
     1069        ruhYe = 0;
     1070        std::swap( ruhXs, ruhXe );
     1071        std::swap( ruhYs, ruhYe );
     1072        return;
     1073      }
     1074      else
     1075      {
     1076        uiOri = 3;
     1077        ruhXe = (UChar)Min( Max( iDeltaEnd, 0 ), (uiScaledBlockSize-1) );
     1078        ruhYe = (UChar)(uiScaledBlockSize-1);
     1079        return;
     1080      }
     1081    }
     1082
     1083    // regular case
     1084    Int iVirtualEndY = (Int)ruhYs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaY / (Double)iDeltaX) );
     1085
     1086    if( iVirtualEndY < 0 )
     1087    {
     1088      Int iXe = roftoi( (Double)(0 - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) - iDeltaEnd;
     1089      if( iXe < (Int)uiScaledBlockSize )
     1090      {
     1091        uiOri = 0;
     1092        ruhXe = (UChar)Max( iXe, 0 );
     1093        ruhYe = 0;
     1094        std::swap( ruhXs, ruhXe );
     1095        std::swap( ruhYs, ruhYe );
     1096        return;
     1097      }
     1098      else
     1099      {
     1100        uiOri = 5;
     1101        ruhXe = (UChar)(uiScaledBlockSize-1);
     1102        ruhYe = (UChar)Min( (iXe - (uiScaledBlockSize-1)), (uiScaledBlockSize-1) );
     1103        std::swap( ruhXs, ruhXe );
     1104        std::swap( ruhYs, ruhYe );
     1105        return;
     1106      }
     1107    }
     1108    else if( iVirtualEndY > (uiScaledBlockSize-1) )
     1109    {
     1110      Int iXe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhYs ) * ((Double)iDeltaX / (Double)iDeltaY) ) + iDeltaEnd;
     1111      if( iXe < (Int)uiScaledBlockSize )
     1112      {
     1113        uiOri = 3;
     1114        ruhXe = (UChar)Max( iXe, 0 );
     1115        ruhYe = (UChar)(uiScaledBlockSize-1);
     1116        return;
     1117      }
     1118      else
     1119      {
     1120        uiOri = 5;
     1121        ruhXe = (UChar)(uiScaledBlockSize-1);
     1122        ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
     1123        std::swap( ruhXs, ruhXe );
     1124        std::swap( ruhYs, ruhYe );
     1125        return;
     1126      }
     1127    }
     1128    else
     1129    {
     1130      Int iYe = iVirtualEndY - iDeltaEnd;
     1131      if( iYe < 0 )
     1132      {
     1133        uiOri = 0;
     1134        ruhXe = (UChar)Max( ((uiScaledBlockSize-1) + iYe), 0 );
     1135        ruhYe = 0;
     1136        std::swap( ruhXs, ruhXe );
     1137        std::swap( ruhYs, ruhYe );
     1138        return;
     1139      }
     1140      else if( iYe > (uiScaledBlockSize-1) )
     1141      {
     1142        uiOri = 3;
     1143        ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
     1144        ruhYe = (UChar)(uiScaledBlockSize-1);
     1145        return;
     1146      }
     1147      else
     1148      {
     1149        uiOri = 5;
     1150        ruhXe = (UChar)(uiScaledBlockSize-1);
     1151        ruhYe = (UChar)iYe;
     1152        std::swap( ruhXs, ruhXe );
     1153        std::swap( ruhYs, ruhYe );
     1154        return;
     1155      }
     1156    }
     1157  }
     1158
     1159  // case origin
     1160  if( uiScaledStartPosX == 0 && uiScaledStartPosY == 0 )
     1161  {
     1162    if( iDeltaX*iDeltaY < 0 )
     1163    {
     1164      return;
     1165    }
     1166
     1167    ruhXs = 0;
     1168    ruhYs = 0;
     1169
     1170    if( iDeltaY == 0 )
     1171    {
     1172      uiOri = 1;
     1173      ruhXe = (UChar)(uiScaledBlockSize-1);
     1174      ruhYe = 0;
     1175      std::swap( ruhXs, ruhXe );
     1176      std::swap( ruhYs, ruhYe );
     1177      return;
     1178  }
     1179
     1180    if( iDeltaX == 0 )
     1181    {
     1182      uiOri = 0;
     1183      ruhXe = 0;
     1184      ruhYe = (UChar)(uiScaledBlockSize-1);
     1185      return;
     1186  }
     1187
     1188    Int iVirtualEndX = (Int)ruhXs + roftoi( (Double)(uiScaledBlockSize-1) * ((Double)iDeltaX / (Double)iDeltaY) );
     1189
     1190    if( iVirtualEndX > (uiScaledBlockSize-1) )
     1191    {
     1192      Int iYe = roftoi( (Double)((Int)(uiScaledBlockSize-1) - (Int)ruhXs) * ((Double)iDeltaY / (Double)iDeltaX) ) - iDeltaEnd;
     1193      if( iYe < (Int)uiScaledBlockSize )
     1194      {
     1195        uiOri = 1;
     1196        ruhXe = (UChar)(uiScaledBlockSize-1);
     1197        ruhYe = (UChar)Max( iYe, 0 );
     1198        std::swap( ruhXs, ruhXe );
     1199        std::swap( ruhYs, ruhYe );
     1200        return;
     1201      }
     1202      else
     1203      {
     1204        uiOri = 3;
     1205        ruhXe = (UChar)Max( ((uiScaledBlockSize-1) - (iYe - (uiScaledBlockSize-1))), 0 );
     1206        ruhYe = (UChar)(uiScaledBlockSize-1);
     1207        return;
     1208      }
     1209    }
     1210    else
     1211    {
     1212      Int iXe = iVirtualEndX + iDeltaEnd;
     1213      if( iXe < 0 )
     1214      {
     1215        uiOri = 0;
     1216        ruhXe = 0;
     1217        ruhYe = (UChar)Max( ((uiScaledBlockSize-1) + iXe), 0 );
     1218        return;
     1219      }
     1220      else if( iXe > (uiScaledBlockSize-1) )
     1221      {
     1222        uiOri = 1;
     1223        ruhXe = (UChar)(uiScaledBlockSize-1);
     1224        ruhYe = (UChar)Max( ((uiScaledBlockSize-1) - (iXe - (uiScaledBlockSize-1))), 0 );
     1225        std::swap( ruhXs, ruhXe );
     1226        std::swap( ruhYs, ruhYe );
     1227        return;
     1228      }
     1229      else
     1230      {
     1231        uiOri = 3;
     1232        ruhXe = (UChar)iXe;
     1233        ruhYe = (UChar)(uiScaledBlockSize-1);
     1234        return;
     1235      }
     1236    }
     1237  }
     1238}
     1239
     1240Bool TComPrediction::getWedgeListIdx( WedgeList* pcWedgeList, WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe )
     1241{
     1242  ruiTabIdx = 0;
     1243
     1244  for( UInt uiIdx = 0; uiIdx < pcWedgeList->size(); uiIdx++ )
     1245  {
     1246    TComWedgelet* pcTestWedge = &(pcWedgeList->at(uiIdx));
     1247
     1248    if( pcTestWedge->getStartX() == uhXs &&
     1249        pcTestWedge->getStartY() == uhYs &&
     1250        pcTestWedge->getEndX()   == uhXe &&
     1251        pcTestWedge->getEndY()   == uhYe    )
     1252    {
     1253      ruiTabIdx = uiIdx;
     1254      return true;
     1255    }
     1256  }
     1257
     1258  // additionally search in WedgeRef lists of duplicated patterns
     1259  for( UInt uiIdx = 0; uiIdx < pcWedgeRefList->size(); uiIdx++ )
     1260  {
     1261    TComWedgeRef* pcTestWedgeRef = &(pcWedgeRefList->at(uiIdx));
     1262
     1263    if( pcTestWedgeRef->getStartX() == uhXs &&
     1264        pcTestWedgeRef->getStartY() == uhYs &&
     1265        pcTestWedgeRef->getEndX()   == uhXe &&
     1266        pcTestWedgeRef->getEndY()   == uhYe    )
     1267    {
     1268      ruiTabIdx = pcTestWedgeRef->getRefIdx();
     1269      return true;
     1270    }
     1271  }
     1272
     1273  return false;
     1274}
     1275
     1276Void TComPrediction::xPredIntraWedgeDir( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iWedgeDeltaEnd, Int iDeltaDC1, Int iDeltaDC2 )
     1277{
     1278  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
     1279  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
     1280
     1281  // get wedge pattern
     1282  UInt uiDirWedgeTabIdx = 0;
     1283  if( bEncoder )
     1284  {
     1285    // encoder: load stored wedge pattern from CU
     1286    uiDirWedgeTabIdx = pcCU->getWedgePredDirTabIdx( uiAbsPartIdx );
     1287  }
     1288  else
     1289  {
     1290    uiDirWedgeTabIdx = getBestContinueWedge( pcCU, uiAbsPartIdx, iWidth, iHeight, iWedgeDeltaEnd );
     1291
     1292    UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
     1293    pcCU->setWedgePredDirTabIdxSubParts( uiDirWedgeTabIdx, uiAbsPartIdx, uiDepth );
     1294  }
     1295  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiDirWedgeTabIdx));
     1296
     1297  // get wedge pred DCs
     1298  Int iPredDC1 = 0;
     1299  Int iPredDC2 = 0;
     1300
     1301  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
     1302  Int iMaskStride = ( iWidth<<1 ) + 1;
     1303  piMask += iMaskStride+1;
     1304  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
     1305
     1306  if( bDelta )
     1307  {
     1308    xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
     1309    xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
     1310  }
     1311
     1312  // assign wedge pred DCs to prediction
     1313  if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
     1314  else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride,        iPredDC1,                   iPredDC2             ); }
     1315}
     1316#endif
     1317
     1318#if HHI_DMM_PRED_TEX
     1319Void TComPrediction::xPredIntraWedgeTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
     1320{
     1321  assert( iWidth >= DMM_WEDGEMODEL_MIN_SIZE && iWidth <= DMM_WEDGEMODEL_MAX_SIZE );
     1322  WedgeList* pacWedgeList = &g_aacWedgeLists[(g_aucConvertToBit[iWidth])];
     1323
     1324  // get wedge pattern
     1325  UInt uiTextureWedgeTabIdx = 0;
     1326  if( bEncoder )
     1327  {
     1328     // encoder: load stored wedge pattern from CU
     1329    uiTextureWedgeTabIdx = pcCU->getWedgePredTexTabIdx( uiAbsPartIdx );
     1330  }
     1331  else
     1332  {
     1333    // decoder: get and store wedge pattern in CU
     1334    uiTextureWedgeTabIdx = getBestWedgeFromText( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight );
     1335    UInt uiDepth = (pcCU->getDepth(0)) + (pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1);
     1336    pcCU->setWedgePredTexTabIdxSubParts( uiTextureWedgeTabIdx, uiAbsPartIdx, uiDepth );
     1337  }
     1338  TComWedgelet* pcWedgelet = &(pacWedgeList->at(uiTextureWedgeTabIdx));
     1339
     1340  // get wedge pred DCs
     1341  Int iPredDC1 = 0;
     1342  Int iPredDC2 = 0;
     1343  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
     1344  Int iMaskStride = ( iWidth<<1 ) + 1;
     1345  piMask += iMaskStride+1;
     1346  getWedgePredDCs( pcWedgelet, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
     1347
     1348  if( bDelta )
     1349  {
     1350    xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
     1351    xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
     1352  }
     1353
     1354  // assign wedge pred DCs to prediction
     1355  if( bDelta ) { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
     1356  else         { assignWedgeDCs2Pred( pcWedgelet, piPred, uiStride,        iPredDC1,                   iPredDC2           ); }
     1357}
     1358
     1359Void TComPrediction::xPredIntraContourTex( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1, Int iDeltaDC2 )
     1360{
     1361  // get contour pattern
     1362  TComWedgelet* pcContourWedge = new TComWedgelet( iWidth, iHeight );
     1363  getBestContourFromText( pcCU, uiAbsPartIdx, (UInt)iWidth, (UInt)iHeight, pcContourWedge );
     1364
     1365  // get wedge pred DCs
     1366  Int iPredDC1 = 0;
     1367  Int iPredDC2 = 0;
     1368  Int* piMask = pcCU->getPattern()->getAdiOrgBuf( iWidth, iHeight, m_piYuvExt );
     1369  Int iMaskStride = ( iWidth<<1 ) + 1;
     1370  piMask += iMaskStride+1;
     1371  getWedgePredDCs( pcContourWedge, piMask, iMaskStride, iPredDC1, iPredDC2, bAbove, bLeft );
     1372
     1373  if( bDelta )
     1374  {
     1375    xDeltaDCQuantScaleUp( pcCU, iDeltaDC1 );
     1376    xDeltaDCQuantScaleUp( pcCU, iDeltaDC2 );
     1377  }
     1378
     1379  // assign wedge pred DCs to prediction
     1380  if( bDelta ) { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride, Clip ( iPredDC1+iDeltaDC1 ), Clip( iPredDC2+iDeltaDC2 ) ); }
     1381  else         { assignWedgeDCs2Pred( pcContourWedge, piPred, uiStride,        iPredDC1,                   iPredDC2           ); }
     1382
     1383  pcContourWedge->destroy();
     1384  delete pcContourWedge;
     1385}
     1386
     1387Void TComPrediction::getBestContourFromText( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge, Pel* piTextureBlock )
     1388{
     1389  pcContourWedge->clear();
     1390  Bool* pabContourPattern = pcContourWedge->getPattern();
     1391
     1392  // get copy of according texture luma block
     1393  Pel* piTempY = NULL;
     1394  TComYuv cTempYuv;
     1395
     1396  if ( piTextureBlock )
     1397  {
     1398    piTempY = piTextureBlock;
     1399  }
     1400  else
     1401  {
     1402    cTempYuv.create( uiWidth, uiHeight ); cTempYuv.clear();
     1403    piTempY      = cTempYuv.getLumaAddr();
     1404
     1405    fillTexturePicTempBlock( pcCU, uiAbsPartIdx, piTempY, uiWidth, uiHeight );
     1406
     1407    piTempY = cTempYuv.getLumaAddr();
     1408  }
     1409
     1410  // find contour for texture luma block
     1411  UInt iDC = 0;
     1412  for( UInt k = 0; k < (uiWidth*uiHeight); k++ ) { iDC += piTempY[k]; }
     1413  iDC /= (uiWidth*uiHeight);
     1414
     1415  if ( piTextureBlock )
     1416  {
     1417    piTempY = piTextureBlock;
     1418  }
     1419  else
     1420  {
     1421    piTempY = cTempYuv.getLumaAddr();
     1422  }
     1423
     1424  for( UInt k = 0; k < (uiWidth*uiHeight); k++ )
     1425  {
     1426    pabContourPattern[k] = (piTempY[k] > iDC) ? true : false;
     1427  }
     1428
     1429  cTempYuv.destroy();
     1430}
     1431
     1432UInt TComPrediction::getBestWedgeFromText( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, WedgeDist eWedgeDist, Pel* piTextureBlock )
    13801433{
    13811434  assert( uiWidth >= DMM_WEDGEMODEL_MIN_SIZE && uiWidth <= DMM_WEDGEMODEL_MAX_SIZE );
     
    13831436
    13841437  // get copy of according texture luma block
    1385   UInt uiPartAddr = 0;
    1386   Int  iBlockWidth, iBlockHeight;
     1438  Pel* piTempY = NULL;   
    13871439  TComYuv     cTempYuv;
    1388   UInt        uiTempStride;
    1389   Pel*        piTempY;     
    1390 
    1391   TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
    1392   Int         iRefStride = pcPicYuvRef->getStride();
    1393   Pel*        piRefY;
    1394 
    1395   pcCU->getPartIndexAndSize( uiAbsPartIdx, uiPartAddr, iBlockWidth, iBlockHeight );
    1396 
    1397   piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiPartAddr );
    1398 
    1399   cTempYuv.create( pcCU->getWidth(0), pcCU->getHeight(0) ); cTempYuv.clear();
    1400   uiTempStride = cTempYuv.getStride();
    1401   piTempY      = cTempYuv.getLumaAddr( uiAbsPartIdx, uiWidth );
    1402 
    1403   for ( Int y = 0; y < iBlockHeight; y++ )
    1404   {
    1405     ::memcpy(piTempY, piRefY, sizeof(Pel)*iBlockWidth);
    1406     piTempY += uiTempStride;
    1407     piRefY += iRefStride;
    1408   }
    1409 
    1410   piTempY = cTempYuv.getLumaAddr( uiAbsPartIdx, uiWidth );
    1411 
     1440
     1441  if ( piTextureBlock )
     1442  {
     1443    piTempY = piTextureBlock;
     1444  }
     1445  else
     1446  {
     1447    cTempYuv.create( uiWidth, uiHeight ); cTempYuv.clear();
     1448    piTempY      = cTempYuv.getLumaAddr();
     1449
     1450    fillTexturePicTempBlock( pcCU, uiAbsPartIdx, piTempY, uiWidth, uiHeight );
     1451
     1452    piTempY = cTempYuv.getLumaAddr();
     1453  }
     1454 
    14121455  TComWedgeDist cWedgeDist;
    14131456  UInt uiTextureWedgeTabIdx = 0;
     
    14291472  for( UInt uiIdx = 0; uiIdx < pacWedgeList->size(); uiIdx++ )
    14301473  {
    1431     calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piTempY,  uiTempStride,  iDC1, iDC2 );
     1474    calcWedgeDCs       ( &(pacWedgeList->at(uiIdx)), piTempY,  uiWidth,  iDC1, iDC2 );
    14321475    assignWedgeDCs2Pred( &(pacWedgeList->at(uiIdx)), piPred, uiPredStride, iDC1, iDC2 );
    14331476
    1434     UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piTempY, uiTempStride, uiWidth, uiHeight, eWedgeDist );
     1477    UInt uiActDist = cWedgeDist.getDistPart( piPred, uiPredStride, piTempY, uiWidth, uiWidth, uiHeight, eWedgeDist );
    14351478
    14361479    if( uiActDist < uiBestDist || uiBestDist == MAX_UINT )
     
    14461489  return uiTextureWedgeTabIdx;
    14471490}
     1491
     1492Void TComPrediction::fillTexturePicTempBlock( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piTempBlockY, UInt uiWidth, UInt uiHeight )
     1493{
     1494  TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getTexturePic()->getPicYuvRec();
     1495  Int         iRefStride = pcPicYuvRef->getStride();
     1496  Pel*        piRefY;
     1497
     1498  piRefY = pcPicYuvRef->getLumaAddr( pcCU->getAddr(), pcCU->getZorderIdxInCU() + uiAbsPartIdx );
     1499
     1500  for ( Int y = 0; y < uiHeight; y++ )
     1501  {
     1502    ::memcpy(piTempBlockY, piRefY, sizeof(Pel)*uiWidth);
     1503    piTempBlockY += uiWidth;
     1504    piRefY += iRefStride;
     1505  }
     1506}
    14481507#endif
    14491508
     
    14981557
    14991558#if HIGH_ACCURACY_BI
     1559#if DEPTH_MAP_GENERATION
    15001560Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, Bool bi )
    15011561#else
     1562Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi )
     1563#endif
     1564#else
     1565#if DEPTH_MAP_GENERATION
    15021566Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap )
     1567#else
     1568Void TComPrediction::xPredInterUni ( TComDataCU* pcCU, UInt uiPartAddr, Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx )
     1569#endif
    15031570#endif
    15041571{
     
    15071574  pcCU->clipMv(cMv);
    15081575
     1576#if DEPTH_MAP_GENERATION
    15091577  if( bPrdDepthMap )
    15101578  {
     
    15171585    return;
    15181586  }
    1519 
    1520 #if MW_DEPTH_MAP_INTERP_FILTER
     1587#endif
     1588
     1589#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
    15211590  if( pcCU->getSlice()->getSPS()->isDepth() )
    15221591  {
     
    15261595    UInt uiRShift = 0;
    15271596#endif
    1528     xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, MW_DEPTH_MAP_INTERP_FILTER );
     1597    xPredInterPrdDepthMap( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred, uiRShift, 2 );
    15291598  }
    15301599  else
     
    15431612  xPredInterLumaBlk       ( pcCU, pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec(), uiPartAddr, &cMv, iWidth, iHeight, rpcYuvPred );
    15441613#endif
    1545 #if MW_DEPTH_MAP_INTERP_FILTER
     1614#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
    15461615  }
    15471616#endif
     
    15811650#if HIGH_ACCURACY_BI
    15821651    if( pcCU->getCUMvField( REF_PIC_LIST_0 )->getRefIdx( uiPartAddr ) >= 0 && pcCU->getCUMvField( REF_PIC_LIST_1 )->getRefIdx( uiPartAddr ) >= 0 )
     1652#if DEPTH_MAP_GENERATION
    15831653      xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap, true );
     1654#else
     1655      xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, true );
     1656#endif
    15841657    else
    1585       xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap );
     1658#if DEPTH_MAP_GENERATION
     1659     xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap );
    15861660#else
     1661     xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx );
     1662#endif
     1663#else
     1664#if DEPTH_MAP_GENERATION
    15871665    xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx, bPrdDepthMap );
     1666#else
     1667    xPredInterUni ( pcCU, uiPartAddr, iWidth, iHeight, eRefPicList, pcMbYuv, iPartIdx );
     1668#endif
    15881669#endif
    15891670  }
     
    16101691  Int     iHor        = ( uiFilterMode == 2 ? ( pcMv->getHor() + 2 ) & iFPelMask : pcMv->getHor() );
    16111692  Int     iVer        = ( uiFilterMode == 2 ? ( pcMv->getVer() + 2 ) & iFPelMask : pcMv->getVer() );
    1612 #if MW_DEPTH_MAP_INTERP_FILTER == 2 && MW_FULL_PEL_DEPTH_MAP_MV_SIGNALLING
     1693#if HHI_FULL_PEL_DEPTH_MAP_MV_ACC
    16131694  if( pcCU->getSlice()->getSPS()->isDepth() )
    16141695  {
     
    25612642#endif
    25622643
    2563 #if HHI_DMM_INTRA
     2644#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    25642645TComWedgeDist::TComWedgeDist()
    25652646{
  • trunk/source/Lib/TLibCommon/TComPrediction.h

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    5588  // motion compensation functions
    5689#if HIGH_ACCURACY_BI
     90#if DEPTH_MAP_GENERATION
    5791  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap, Bool bi=false );
    5892#else
     93  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bi=false );
     94#endif
     95#else
     96#if DEPTH_MAP_GENERATION
    5997  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap );
     98#else
     99  Void xPredInterUni            ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight, RefPicList eRefPicList, TComYuv*& rpcYuvPred, Int iPartIdx );
     100#endif
    60101#endif
    61102  Void xPredInterBi             ( TComDataCU* pcCU,                          UInt uiPartAddr,               Int iWidth, Int iHeight,                         TComYuv*& rpcYuvPred, Int iPartIdx, Bool bPrdDepthMap );
     
    72113#endif
    73114
    74 #if HHI_DMM_INTRA
     115#if HHI_DMM_WEDGE_INTRA
    75116  Void xPredIntraWedgeFull       ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, UInt uiTabIdx, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
     117
    76118  Void xPredIntraWedgeDir        ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iWedgeDeltaEnd, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
    77 
    78   Void xPredIntraWedgeTex        ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
    79   Void xPredIntraContourTex      ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
    80 
    81119  Void xGetBlockOffset           ( TComDataCU* pcCU, UInt uiAbsPartIdx, TComDataCU* pcRefCU, UInt uiRefAbsPartIdx, UInt& ruiOffsetX, UInt& ruiOffsetY );
    82120  Bool xGetWedgeIntraDirPredData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int& riSlopeX, Int& riSlopeY, UInt& ruiStartPosX, UInt& ruiStartPosY );
    83121  Void xGetWedgeIntraDirStartEnd ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiBlockSize, Int iDeltaX, Int iDeltaY, UInt uiPMSPosX, UInt uiPMSPosY, UChar& ruhXs, UChar& ruhYs, UChar& ruhXe, UChar& ruhYe, Int iDeltaEnd = 0 );
     122#endif
     123#if HHI_DMM_PRED_TEX
     124  Void xPredIntraWedgeTex        ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
     125  Void xPredIntraContourTex      ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder, Bool bDelta, Int iDeltaDC1 = 0, Int iDeltaDC2 = 0 );
     126#endif
     127#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    84128  Void xDeltaDCQuantScaleUp      ( TComDataCU* pcCU, Int& riDeltaDC );
    85129#endif
     
    110154  Void predIntraChromaAng         ( TComPattern* pcTComPattern, Int* piSrc, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, TComDataCU* pcCU, Bool bAbove, Bool bLeft );
    111155 
    112 #if HHI_DMM_INTRA
     156#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    113157  Void  predIntraLumaDMM         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft, Bool bEncoder );
    114158
    115   UInt  getBestContinueWedge     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd = 0 );
    116   Void  getBestContourFromText   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge );
    117 
    118159  Void  getWedgePredDCs         ( TComWedgelet* pcWedgelet, Int* piMask, Int iMaskStride, Int& riPredDC1, Int& riPredDC2, Bool bAbove, Bool bLeft );
    119 
    120   Bool  getWedgeListIdx          ( WedgeList* pcWedgeList, WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe );
    121 
    122   UInt  getBestWedgeFromText     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, WedgeDist eWedgeDist = WedgeDist_SAD );
    123160  Void  calcWedgeDCs             ( TComWedgelet* pcWedgelet, Pel* piOrig, UInt uiStride, Int& riDC1, Int& riDC2 );
    124161  Void  assignWedgeDCs2Pred      ( TComWedgelet* pcWedgelet, Pel* piPred,  UInt uiStride, Int   iDC1, Int   iDC2 );
     162#endif
     163#if HHI_DMM_PRED_TEX
     164  Void  getBestContourFromText   ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, TComWedgelet* pcContourWedge, Pel* piTextureBlock = NULL );
     165  UInt  getBestWedgeFromText     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, WedgeDist eWedgeDist = WedgeDist_SAD, Pel* piTextureBlock = NULL );
     166  Void  fillTexturePicTempBlock  ( TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* piTempBlockY, UInt uiWidth, UInt uiHeight );
     167#endif
     168#if HHI_DMM_WEDGE_INTRA
     169  UInt  getBestContinueWedge     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, Int iDeltaEnd = 0 );
     170  Bool  getWedgeListIdx          ( WedgeList* pcWedgeList, WedgeRefList* pcWedgeRefList, UInt& ruiTabIdx, UChar uhXs, UChar uhYs, UChar uhXe, UChar uhYe );
    125171#endif
    126172 
     
    142188};
    143189
    144 #if HHI_DMM_INTRA
     190#if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX
    145191// ====================================================================================================================
    146192// Class definition TComWedgeDist
  • trunk/source/Lib/TLibCommon/TComRdCost.cpp

    r2 r5  
     1/* The copyright in this software is being made available under the BSD
     2 * License, included below. This software may be subject to other third party
     3 * and contributor rights, including patent rights, and no such rights are
     4 * granted under this license.
     5 *
     6 * Copyright (c) 2010-2011, ISO/IEC
     7 * All rights reserved.
     8 *
     9 * Redistribution and use in source and binary forms, with or without
     10 * modification, are permitted provided that the following conditions are met:
     11 *
     12 *  * Redistributions of source code must retain the above copyright notice,
     13 *    this list of conditions and the following disclaimer.
     14 *  * Redistributions in binary form must reproduce the above copyright notice,
     15 *    this list of conditions and the following disclaimer in the documentation
     16 *    and/or other materials provided with the distribution.
     17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
     18 *    be used to endorse or promote products derived from this software without
     19 *    specific prior written permission.
     20 *
     21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
     25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     31 * THE POSSIBILITY OF SUCH DAMAGE.
     32 */
     33
    134
    235
     
    4679  }
    4780 
    48 #if SB_INTERVIEW_SKIP_LAMBDA_SCALE
     81#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    4982  dLambda = m_dLambdaScale * dLambda ;
    5083#endif
     
    125158}
    126159
     160#if HHI_INTER_VIEW_MOTION_PRED
    127161Void
    128162TComRdCost::setLambdaMVReg( Double dLambda )
     
    131165  m_uiLambdaMVRegSSE = (UInt)floor( 65536.0 *       dLambda   );
    132166}
     167#endif
    133168
    134169
     
    223258  m_puiMultiviewRegCostVer      = 0;
    224259
    225 //GT VSO
     260#if HHI_VSO
    226261  m_apRefPics               = NULL;
    227262  m_paaiShiftLUTs           = NULL;
     
    231266  m_fpDistortFuncVSO        = NULL;
    232267  m_pcRenModel              = NULL;
    233 
    234 //GT VSO end
    235 #if SB_INTERVIEW_SKIP_LAMBDA_SCALE
     268#endif
     269
     270#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
    236271  m_dLambdaScale            = 1;
    237272#endif
     
    287322  }
    288323
    289   //GT VSO
     324#if HHI_VSO
    290325  if ( m_apRefPics != NULL )
    291326  {
     
    298333    m_paaiShiftLUTs = NULL;
    299334  };
    300   //GT VSO end
     335#endif
    301336}
    302337
     
    378413  // initialize
    379414  rcDistParam.iSubShift  = 0;
    380 #if SB_INTERVIEW_SKIP
     415#if HHI_INTERVIEW_SKIP
    381416  rcDistParam.pUsed       = 0;
    382417  rcDistParam.iStrideUsed = 0;
     
    401436  // initialize
    402437  rcDistParam.iSubShift  = 0;
    403 #if SB_INTERVIEW_SKIP
     438#if HHI_INTERVIEW_SKIP
    404439  rcDistParam.pUsed       = 0;
    405440  rcDistParam.iStrideUsed = 0;
     
    436471  // initialize
    437472  rcDistParam.iSubShift  = 0;
    438 #if SB_INTERVIEW_SKIP</