Ticket #1392: replaceCharWithSCharAndTChar.patch

File replaceCharWithSCharAndTChar.patch, 83.9 KB (added by karlsharman, 10 years ago)

  • source/App/TAppDecoder/TAppDecCfg.cpp

     
    5858/** \param argc number of arguments
    5959    \param argv array of arguments
    6060 */
    61 Bool TAppDecCfg::parseCfg( Int argc, Char* argv[] )
     61Bool TAppDecCfg::parseCfg( Int argc, TChar* argv[] )
    6262{
    6363  Bool do_help = false;
    6464  string cfg_BitstreamFile;
    … …  
    9696
    9797  po::setDefaults(opts);
    9898  po::ErrorReporter err;
    99   const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv, err);
     99  const list<const TChar*>& argv_unhandled = po::scanArgv(opts, argc, (const TChar**) argv, err);
    100100
    101   for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
     101  for (list<const TChar*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    102102  {
    103103    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
    104104  }

  • source/App/TAppDecoder/TAppDecCfg.h

     
    5656class TAppDecCfg
    5757{
    5858protected:
    59   Char*         m_pchBitstreamFile;                     ///< input bitstream file name
    60   Char*         m_pchReconFile;                         ///< output reconstruction file name
     59  TChar*        m_pchBitstreamFile;                     ///< input bitstream file name
     60  TChar*        m_pchReconFile;                         ///< output reconstruction file name
    6161  Int           m_iSkipFrame;                           ///< counter for frames prior to the random access point to skip
    6262  Int           m_outputBitDepth[MAX_NUM_CHANNEL_TYPE]; ///< bit depth used for writing output
    6363  InputColourSpaceConversion m_outputColourSpaceConvert;
    … …  
    9595
    9696  virtual ~TAppDecCfg() {}
    9797
    98   Bool  parseCfg        ( Int argc, Char* argv[] );   ///< initialize option class from configuration
     98  Bool  parseCfg        ( Int argc, TChar* argv[] );   ///< initialize option class from configuration
    9999};
    100100
    101101//! \}

  • source/App/TAppEncoder/TAppEncCfg.h

     
    5555{
    5656protected:
    5757  // file I/O
    58   Char*     m_pchInputFile;                                   ///< source file name
    59   Char*     m_pchBitstreamFile;                               ///< output bitstream file
    60   Char*     m_pchReconFile;                                   ///< output reconstruction file
     58  TChar*    m_pchInputFile;                                   ///< source file name
     59  TChar*    m_pchBitstreamFile;                               ///< output bitstream file
     60  TChar*    m_pchReconFile;                                   ///< output reconstruction file
    6161  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
    6262  // source specification
    6363  Int       m_iFrameRate;                                     ///< source frame-rates (Hz)
    … …  
    129129  // coding quality
    130130  Double    m_fQP;                                            ///< QP value of key-picture (floating point)
    131131  Int       m_iQP;                                            ///< QP value of key-picture (integer)
    132   Char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
     132  TChar*    m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
    133133  Int*      m_aidQP;                                          ///< array of slice QP values
    134134  Int       m_iMaxDeltaQP;                                    ///< max. |delta QP|
    135135  UInt      m_uiDeltaQpRD;                                    ///< dQP range for multi-pass slice QP optimization
    … …  
    323323  Int       m_RCInitialQP;                        ///< inital QP for rate control
    324324  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
    325325  ScalingListMode m_useScalingListId;                         ///< using quantization matrix
    326   Char*     m_scalingListFile;                                ///< quantization matrix file name
     326  TChar*    m_scalingListFile;                                ///< quantization matrix file name
    327327
    328328  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
    329329  Bool      m_CUTransquantBypassFlagForce;                    ///< if transquant_bypass_enable_flag, then, if true, all CU transquant bypass flags will be set to true.
    … …  
    383383public:
    384384  Void  create    ();                                         ///< create option handling class
    385385  Void  destroy   ();                                         ///< destroy option handling class
    386   Bool  parseCfg  ( Int argc, Char* argv[] );                 ///< parse configuration file to fill member variables
     386  Bool  parseCfg  ( Int argc, TChar* argv[] );                ///< parse configuration file to fill member variables
    387387
    388388};// END CLASS DEFINITION TAppEncCfg
    389389

  • source/App/TAppEncoder/TAppEncCfg.cpp

     
    186186  return in;
    187187}
    188188
    189 Bool confirmPara(Bool bflag, const Char* message);
     189Bool confirmPara(Bool bflag, const TChar* message);
    190190
    191191static inline ChromaFormat numberToChromaFormat(const Int val)
    192192{
    … …  
    202202
    203203static const struct MapStrToProfile
    204204{
    205   const Char* str;
     205  const TChar* str;
    206206  Profile::Name value;
    207207}
    208208strToProfile[] =
    … …  
    217217
    218218static const struct MapStrToExtendedProfile
    219219{
    220   const Char* str;
     220  const TChar* str;
    221221  ExtendedProfileName value;
    222222}
    223223strToExtendedProfile[] =
    … …  
    276276
    277277static const struct MapStrToTier
    278278{
    279   const Char* str;
     279  const TChar* str;
    280280  Level::Tier value;
    281281}
    282282strToTier[] =
    … …  
    287287
    288288static const struct MapStrToLevel
    289289{
    290   const Char* str;
     290  const TChar* str;
    291291  Level::Name value;
    292292}
    293293strToLevel[] =
    … …  
    311311
    312312static const struct MapStrToCostMode
    313313{
    314   const Char* str;
     314  const TChar* str;
    315315  CostMode    value;
    316316}
    317317strToCostMode[] =
    … …  
    324324
    325325static const struct MapStrToScalingListMode
    326326{
    327   const Char* str;
     327  const TChar* str;
    328328  ScalingListMode value;
    329329}
    330330strToScalingListMode[] =
    … …  
    428428  }
    429429  if (!str.empty())
    430430  {
    431     const Char *pStr=str.c_str();
     431    const TChar *pStr=str.c_str();
    432432    // soak up any whitespace
    433433    for(;isspace(*pStr);pStr++);
    434434
    435435    while (*pStr != 0)
    436436    {
    437       Char *eptr;
     437      TChar *eptr;
    438438      UInt val=strtoul(pStr, &eptr, 0);
    439439      if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
    440440      {
    … …  
    480480  }
    481481  if (!str.empty())
    482482  {
    483     const Char *pStr=str.c_str();
     483    const TChar *pStr=str.c_str();
    484484    // soak up any whitespace
    485485    for(;isspace(*pStr);pStr++);
    486486
    487487    while (*pStr != 0)
    488488    {
    489       Char *eptr;
     489      TChar *eptr;
    490490      Int val=strtol(pStr, &eptr, 0);
    491491      if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
    492492      {
    … …  
    532532  }
    533533  if (!str.empty())
    534534  {
    535     const Char *pStr=str.c_str();
     535    const TChar *pStr=str.c_str();
    536536    // soak up any whitespace
    537537    for(;isspace(*pStr);pStr++);
    538538
    539539    while (*pStr != 0)
    540540    {
    541       Char *eptr;
     541      TChar *eptr;
    542542      Int val=strtol(pStr, &eptr, 0);
    543543      if (*eptr!=0 && !isspace(*eptr) && *eptr!=',')
    544544      {
    … …  
    657657    \param  argv        array of arguments
    658658    \retval             true when success
    659659 */
    660 Bool TAppEncCfg::parseCfg( Int argc, Char* argv[] )
     660Bool TAppEncCfg::parseCfg( Int argc, TChar* argv[] )
    661661{
    662662  Bool do_help = false;
    663663
    … …  
    10871087  }
    10881088  po::setDefaults(opts);
    10891089  po::ErrorReporter err;
    1090   const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv, err);
     1090  const list<const TChar*>& argv_unhandled = po::scanArgv(opts, argc, (const TChar**) argv, err);
    10911091
    1092   for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
     1092  for (list<const TChar*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    10931093  {
    10941094    fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);
    10951095  }
    … …  
    22912291  }
    22922292}
    22932293
    2294 const Char *profileToString(const Profile::Name profile)
     2294const TChar *profileToString(const Profile::Name profile)
    22952295{
    22962296  static const UInt numberOfProfiles = sizeof(strToProfile)/sizeof(*strToProfile);
    22972297
    … …  
    24842484  fflush(stdout);
    24852485}
    24862486
    2487 Bool confirmPara(Bool bflag, const Char* message)
     2487Bool confirmPara(Bool bflag, const TChar* message)
    24882488{
    24892489  if (!bflag)
    24902490  {

  • source/Lib/TLibCommon/TComDataCU.h

     
    9191  // -------------------------------------------------------------------------------------------------------------------
    9292
    9393  Bool*          m_skipFlag;           ///< array of skip flags
    94   Char*          m_pePartSize;         ///< array of partition sizes
    95   Char*          m_pePredMode;         ///< array of prediction modes
    96   Char*          m_crossComponentPredictionAlpha[MAX_NUM_COMPONENT]; ///< array of cross-component prediction alpha values
     94  SChar*         m_pePartSize;         ///< array of partition sizes
     95  SChar*         m_pePredMode;         ///< array of prediction modes
     96  SChar*         m_crossComponentPredictionAlpha[MAX_NUM_COMPONENT]; ///< array of cross-component prediction alpha values
    9797  Bool*          m_CUTransquantBypass;   ///< array of cu_transquant_bypass flags
    98   Char*          m_phQP;               ///< array of QP values
     98  SChar*         m_phQP;               ///< array of QP values
    9999  UChar*         m_ChromaQpAdj;        ///< array of chroma QP adjustments (indexed). when value = 0, cu_chroma_qp_offset_flag=0; when value>0, indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=value-1
    100100  UInt           m_codedChromaQpAdj;
    101101  UChar*         m_puhTrIdx;           ///< array of transform indices
    … …  
    135135#endif
    136136  UChar*        m_puhIntraDir[MAX_NUM_CHANNEL_TYPE]; // 0-> Luma, 1-> Chroma
    137137  UChar*        m_puhInterDir;        ///< array of inter directions
    138   Char*         m_apiMVPIdx[NUM_REF_PIC_LIST_01];       ///< array of motion vector predictor candidates
    139   Char*         m_apiMVPNum[NUM_REF_PIC_LIST_01];       ///< array of number of possible motion vectors predictors
     138  SChar*        m_apiMVPIdx[NUM_REF_PIC_LIST_01];       ///< array of motion vector predictor candidates
     139  SChar*        m_apiMVPNum[NUM_REF_PIC_LIST_01];       ///< array of number of possible motion vectors predictors
    140140  Bool*         m_pbIPCMFlag;         ///< array of intra_pcm flags
    141141
    142142  // -------------------------------------------------------------------------------------------------------------------
    … …  
    148148  Distortion    m_uiTotalDistortion;  ///< sum of partition distortion
    149149  UInt          m_uiTotalBits;        ///< sum of partition bits
    150150  UInt          m_uiTotalBins;        ///< sum of partition bins
    151   Char          m_codedQP;
     151  SChar         m_codedQP;
    152152  UChar*        m_explicitRdpcmMode[MAX_NUM_COMPONENT]; ///< Stores the explicit RDPCM mode for all TUs belonging to this CU
    153153
    154154protected:
    … …  
    215215  // member functions for CU data
    216216  // -------------------------------------------------------------------------------------------------------------------
    217217
    218   Char*         getPartitionSize      ()                        { return m_pePartSize;        }
     218  SChar*        getPartitionSize      ()                        { return m_pePartSize;        }
    219219  PartSize      getPartitionSize      ( UInt uiIdx )            { return static_cast<PartSize>( m_pePartSize[uiIdx] ); }
    220220  Void          setPartitionSize      ( UInt uiIdx, PartSize uh){ m_pePartSize[uiIdx] = uh;   }
    221221  Void          setPartSizeSubParts   ( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth );
    … …  
    226226  Void          setSkipFlag           ( UInt idx, Bool skip)     { m_skipFlag[idx] = skip;   }
    227227  Void          setSkipFlagSubParts   ( Bool skip, UInt absPartIdx, UInt depth );
    228228
    229   Char*         getPredictionMode     ()                        { return m_pePredMode;        }
     229  SChar*        getPredictionMode     ()                        { return m_pePredMode;        }
    230230  PredMode      getPredictionMode     ( UInt uiIdx )            { return static_cast<PredMode>( m_pePredMode[uiIdx] ); }
    231231  Void          setPredictionMode     ( UInt uiIdx, PredMode uh){ m_pePredMode[uiIdx] = uh;   }
    232232  Void          setPredModeSubParts   ( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth );
    233233
    234   Char*         getCrossComponentPredictionAlpha( ComponentID compID )             { return m_crossComponentPredictionAlpha[compID];         }
    235   Char          getCrossComponentPredictionAlpha( UInt uiIdx, ComponentID compID ) { return m_crossComponentPredictionAlpha[compID][uiIdx];  }
     234  SChar*        getCrossComponentPredictionAlpha( ComponentID compID )             { return m_crossComponentPredictionAlpha[compID];         }
     235  SChar         getCrossComponentPredictionAlpha( UInt uiIdx, ComponentID compID ) { return m_crossComponentPredictionAlpha[compID][uiIdx];  }
    236236
    237237  Bool*         getCUTransquantBypass ()                        { return m_CUTransquantBypass;        }
    238238  Bool          getCUTransquantBypass( UInt uiIdx )             { return m_CUTransquantBypass[uiIdx]; }
    … …  
    247247
    248248  Void          setSizeSubParts       ( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth );
    249249
    250   Char*         getQP                 ()                        { return m_phQP;              }
    251   Char          getQP                 ( UInt uiIdx ) const      { return m_phQP[uiIdx];       }
    252   Void          setQP                 ( UInt uiIdx, Char value ){ m_phQP[uiIdx] =  value;     }
     250  SChar*        getQP                 ()                        { return m_phQP;              }
     251  SChar         getQP                 ( UInt uiIdx ) const      { return m_phQP[uiIdx];       }
     252  Void          setQP                 ( UInt uiIdx, SChar value){ m_phQP[uiIdx] =  value;     }
    253253  Void          setQPSubParts         ( Int qp,   UInt uiAbsPartIdx, UInt uiDepth );
    254254  Int           getLastValidPartIdx   ( Int iAbsPartIdx );
    255   Char          getLastCodedQP        ( UInt uiAbsPartIdx );
     255  SChar         getLastCodedQP        ( UInt uiAbsPartIdx );
    256256  Void          setQPSubCUs           ( Int qp, UInt absPartIdx, UInt depth, Bool &foundNonZeroCbf );
    257   Void          setCodedQP            ( Char qp )               { m_codedQP = qp;             }
    258   Char          getCodedQP            ()                        { return m_codedQP;           }
     257  Void          setCodedQP            ( SChar qp )              { m_codedQP = qp;             }
     258  SChar         getCodedQP            ()                        { return m_codedQP;           }
    259259
    260260  UChar*        getChromaQpAdj        ()                        { return m_ChromaQpAdj;       } ///< array of chroma QP adjustments (indexed). when value = 0, cu_chroma_qp_offset_flag=0; when value>0, indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=value-1
    261261  UChar         getChromaQpAdj        (Int idx)           const { return m_ChromaQpAdj[idx];  } ///< When value = 0, cu_chroma_qp_offset_flag=0; when value>0, indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=value-1
    262262  Void          setChromaQpAdj        (Int idx, UChar val)      { m_ChromaQpAdj[idx] = val;   } ///< When val = 0,   cu_chroma_qp_offset_flag=0; when val>0,   indicates cu_chroma_qp_offset_flag=1 and cu_chroma_qp_offset_idx=val-1
    263263  Void          setChromaQpAdjSubParts( UChar val, Int absPartIdx, Int depth );
    264   Void          setCodedChromaQpAdj   ( Char qp )               { m_codedChromaQpAdj = qp;    }
    265   Char          getCodedChromaQpAdj   ()                        { return m_codedChromaQpAdj;  }
     264  Void          setCodedChromaQpAdj   ( SChar qp )              { m_codedChromaQpAdj = qp;    }
     265  SChar         getCodedChromaQpAdj   ()                        { return m_codedChromaQpAdj;  }
    266266
    267267  Bool          isLosslessCoded       ( UInt absPartIdx );
    268268
    … …  
    281281
    282282  Bool          isRDPCMEnabled         ( UInt uiAbsPartIdx )  { return getSlice()->getSPS()->getSpsRangeExtension().getRdpcmEnabledFlag(isIntra(uiAbsPartIdx) ? RDPCM_SIGNAL_IMPLICIT : RDPCM_SIGNAL_EXPLICIT); }
    283283
    284   Void          setCrossComponentPredictionAlphaPartRange    ( Char alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
     284  Void          setCrossComponentPredictionAlphaPartRange    ( SChar alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
    285285  Void          setTransformSkipPartRange                    ( UInt useTransformSkip, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes );
    286286
    287287  UInt          getQuadtreeTULog2MinSizeInCU( UInt uiIdx );
    … …  
    367367
    368368  Void          setMVPIdx             ( RefPicList eRefPicList, UInt uiIdx, Int iMVPIdx)  { m_apiMVPIdx[eRefPicList][uiIdx] = iMVPIdx;  }
    369369  Int           getMVPIdx             ( RefPicList eRefPicList, UInt uiIdx)               { return m_apiMVPIdx[eRefPicList][uiIdx];     }
    370   Char*         getMVPIdx             ( RefPicList eRefPicList )                          { return m_apiMVPIdx[eRefPicList];            }
     370  SChar*        getMVPIdx             ( RefPicList eRefPicList )                          { return m_apiMVPIdx[eRefPicList];            }
    371371
    372372  Void          setMVPNum             ( RefPicList eRefPicList, UInt uiIdx, Int iMVPNum ) { m_apiMVPNum[eRefPicList][uiIdx] = iMVPNum;  }
    373373  Int           getMVPNum             ( RefPicList eRefPicList, UInt uiIdx )              { return m_apiMVPNum[eRefPicList][uiIdx];     }
    374   Char*         getMVPNum             ( RefPicList eRefPicList )                          { return m_apiMVPNum[eRefPicList];            }
     374  SChar*        getMVPNum             ( RefPicList eRefPicList )                          { return m_apiMVPNum[eRefPicList];            }
    375375
    376376  Void          setMVPIdxSubParts     ( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    377377  Void          setMVPNumSubParts     ( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth );
    … …  
    412412
    413413  TComDataCU*   getQpMinCuLeft              ( UInt&  uiLPartUnitIdx , UInt uiCurrAbsIdxInCtu );
    414414  TComDataCU*   getQpMinCuAbove             ( UInt&  uiAPartUnitIdx , UInt uiCurrAbsIdxInCtu );
    415   Char          getRefQP                    ( UInt   uiCurrAbsIdxInCtu                       );
     415  SChar         getRefQP                    ( UInt   uiCurrAbsIdxInCtu                       );
    416416
    417417  /// returns CU and part index of the PU above the top row of the current uiCurrPartUnitIdx of the CU, at a horizontal offset (to the right) of uiPartUnitOffset (in parts)
    418418  TComDataCU*   getPUAboveRight             ( UInt&  uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true );

  • source/Lib/TLibCommon/TComSampleAdaptiveOffset.h

     
    9595
    9696
    9797  Int m_lineBufWidth;
    98   Char* m_signLineBuf1;
    99   Char* m_signLineBuf2;
     98  SChar* m_signLineBuf1;
     99  SChar* m_signLineBuf2;
    100100  ChromaFormat m_chromaFormatIDC;
    101101private:
    102102  Bool m_picSAOEnabled[MAX_NUM_COMPONENT];

  • source/Lib/TLibCommon/TComRom.cpp

     
    5050//! \ingroup TLibCommon
    5151//! \{
    5252
    53 const Char* nalUnitTypeToString(NalUnitType type)
     53const TChar* nalUnitTypeToString(NalUnitType type)
    5454{
    5555  switch (type)
    5656  {
    … …  
    569569// Misc.
    570570// ====================================================================================================================
    571571
    572 Char  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
     572SChar  g_aucConvertToBit  [ MAX_CU_SIZE+1 ];
    573573
    574574#if ENC_DEC_TRACE
    575575FILE*  g_hTrace = NULL; // Set to NULL to open up a file. Set to stdout to use the current output
    … …  
    597597const UInt g_uiMinInGroup[ LAST_SIGNIFICANT_GROUPS ] = {0,1,2,3,4,6,8,12,16,24};
    598598const UInt g_uiGroupIdx[ MAX_TU_SIZE ]   = {0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9};
    599599
    600 const Char *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
     600const TChar *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
    601601{
    602602  {
    603603    "INTRA4X4_LUMA",
    … …  
    633633  },
    634634};
    635635
    636 const Char *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
     636const TChar *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM] =
    637637{
    638638  {
    639639  },

  • source/Lib/TLibCommon/TComBitStream.cpp

     
    9090  m_numBitsRead=0;
    9191}
    9292
    93 Char* TComOutputBitstream::getByteStream() const
     93UChar* TComOutputBitstream::getByteStream() const
    9494{
    95   return (Char*) &m_fifo.front();
     95  return (UChar*) &m_fifo.front();
    9696}
    9797
    9898UInt TComOutputBitstream::getByteStreamLength()

  • source/Lib/TLibCommon/TComPicYuv.cpp

     
    246246
    247247
    248248// NOTE: This function is never called, but may be useful for developers.
    249 Void TComPicYuv::dump (const Char* pFileName, const BitDepths &bitDepths, Bool bAdd) const
     249Void TComPicYuv::dump (const TChar* pFileName, const BitDepths &bitDepths, Bool bAdd) const
    250250{
    251251  FILE* pFile;
    252252  if (!bAdd)

  • source/Lib/TLibCommon/TComMotionInfo.h

     
    9393private:
    9494  TComMv*   m_pcMv;
    9595  TComMv*   m_pcMvd;
    96   Char*     m_piRefIdx;
     96  SChar*    m_piRefIdx;
    9797  UInt      m_uiNumPartition;
    9898  AMVPInfo  m_cAMVPInfo;
    9999
    … …  
    152152    m_piRefIdx = src->m_piRefIdx + offset;
    153153  }
    154154
    155   Void compress(Char* pePredMode, Int scale);
     155  Void compress(SChar* pePredMode, Int scale);
    156156};
    157157
    158158//! \}

  • source/Lib/TLibCommon/TComMotionInfo.cpp

     
    5959
    6060  m_pcMv     = new TComMv[ uiNumPartition ];
    6161  m_pcMvd    = new TComMv[ uiNumPartition ];
    62   m_piRefIdx = new Char [ uiNumPartition ];
     62  m_piRefIdx = new SChar [ uiNumPartition ];
    6363
    6464  m_uiNumPartition = uiNumPartition;
    6565}
    … …  
    314314
    315315Void TComCUMvField::setAllRefIdx ( Int iRefIdx, PartSize eCUMode, Int iPartAddr, UInt uiDepth, Int iPartIdx )
    316316{
    317   setAll(m_piRefIdx, static_cast<Char>(iRefIdx), eCUMode, iPartAddr, uiDepth, iPartIdx);
     317  setAll(m_piRefIdx, static_cast<SChar>(iRefIdx), eCUMode, iPartAddr, uiDepth, iPartIdx);
    318318}
    319319
    320320Void TComCUMvField::setAllMvField( TComMvField const & mvField, PartSize eCUMode, Int iPartAddr, UInt uiDepth, Int iPartIdx )
    … …  
    327327 * \param pePredMode Pointer to prediction modes
    328328 * \param scale      Factor by which to subsample motion information
    329329 */
    330 Void TComCUMvField::compress(Char* pePredMode, Int scale)
     330Void TComCUMvField::compress(SChar* pePredMode, Int scale)
    331331{
    332332  Int N = scale * scale;
    333333  assert( N > 0 && N <= m_uiNumPartition);

  • source/Lib/TLibCommon/TComCodingStatistics.h

     
    9494  STATS__NUM_STATS
    9595};
    9696
    97 static inline const Char* getName(TComCodingStatisticsType name)
     97static inline const TChar* getName(TComCodingStatisticsType name)
    9898{
    99   static const Char *statNames[]=
     99  static const TChar *statNames[]=
    100100  {
    101101    "NAL_UNIT_TOTAL_BODY", // This is a special case and is not included in the total sums.
    102102    "NAL_UNIT_PACKING",
    … …  
    142142    "CABAC_BITS__ALIGNED_SIGN_BIT",
    143143    "CABAC_BITS__ALIGNED_ESCAPE_BITS"
    144144  };
    145   assert(STATS__NUM_STATS == sizeof(statNames)/sizeof(Char *) && name < STATS__NUM_STATS);
     145  assert(STATS__NUM_STATS == sizeof(statNames)/sizeof(TChar *) && name < STATS__NUM_STATS);
    146146  return statNames[name];
    147147}
    148148
    … …  
    182182    return subClass%CODING_STATS_NUM_WIDTHS;
    183183  }
    184184
    185   static const Char *GetSubClassString(const UInt subClass)
     185  static const TChar *GetSubClassString(const UInt subClass)
    186186  {
    187187    assert (subClass<CODING_STATS_NUM_SUBCLASSES);
    188     static const Char *strings[1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE]={"-", "Y", "Cb", "Cr", "Luma", "Chroma"};
     188    static const TChar *strings[1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE]={"-", "Y", "Cb", "Cr", "Luma", "Chroma"};
    189189    return strings[subClass/CODING_STATS_NUM_WIDTHS];
    190190  }
    191191
    … …  
    242242    TComCodingStatistics() : data()
    243243    { }
    244244
    245     static Void OutputLine(const Char *pName, const Char sep, UInt width, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
     245    static Void OutputLine(const TChar *pName, const TChar sep, UInt width, const TChar *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
    246246    {
    247247      if (width==0)
    248248      {
    … …  
    255255              sCABAC.count, sCABAC.sum, sCABAC.bits, sEP.count, sEP.sum, sEP.bits, sCABAC.bits+sEP.bits, (sCABAC.bits+sEP.bits)/8, sep=='~'?']':' ');
    256256      }
    257257    }
    258     static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
     258    static Void OutputLine(const TChar *pName, const TChar sep, const TChar *pWidthString, const TChar *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
    259259    {
    260260      printf("%c%-45s%c  %6s %6s %12lld %12lld %12lld %12lld %12lld %12lld %12lld (%12lld)%c\n",
    261261          sep=='~'?'[':' ', pName, sep, pWidthString, pSubClassStr,
    262262              sCABAC.count, sCABAC.sum, sCABAC.bits, sEP.count, sEP.sum, sEP.bits, sCABAC.bits+sEP.bits, (sCABAC.bits+sEP.bits)/8, sep=='~'?']':' ');
    263263    }
    264     static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr,  const SStat &sEP)
     264    static Void OutputLine(const TChar *pName, const TChar sep, const TChar *pWidthString, const TChar *pSubClassStr,  const SStat &sEP)
    265265    {
    266266      printf("%c%-45s%c  %6s %6s %12s %12s %12s %12lld %12lld %12lld %12lld (%12lld)%c\n",
    267267          sep=='~'?'[':' ', pName, sep, pWidthString, pSubClassStr,
    268268              "", "", "", sEP.count, sEP.sum, sEP.bits, sEP.bits, (sEP.bits)/8, sep=='~'?']':' ');
    269269    }
    270270
    271     static Void OutputDashedLine(const Char *pText)
     271    static Void OutputDashedLine(const TChar *pText)
    272272    {
    273273      printf("--%s",pText);
    274274      UInt tot=0;
    … …  
    313313      {
    314314        SStat cabacSubTotal, epSubTotal;
    315315        Bool bHadClassifiedEntry=false;
    316         const Char *pName=getName(TComCodingStatisticsType(i));
     316        const TChar *pName=getName(TComCodingStatisticsType(i));
    317317
    318318        for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c++)
    319319        {
    … …  
    441441
    442442    static SStat &GetStatisticEP(const std::string &str) { return GetSingletonInstance().data.mappings_ep[str]; }
    443443
    444     static SStat &GetStatisticEP(const Char *pKey) {return GetStatisticEP(std::string(pKey)); }
     444    static SStat &GetStatisticEP(const TChar *pKey) {return GetStatisticEP(std::string(pKey)); }
    445445
    446446    static Void IncrementStatisticEP(const TComCodingStatisticsClassType &stat, const Int numBits, const Int value)
    447447    {
    … …  
    459459      s.sum+=value;
    460460    }
    461461
    462     static Void IncrementStatisticEP(const Char *pKey, const Int numBits, const Int value)
     462    static Void IncrementStatisticEP(const TChar *pKey, const Int numBits, const Int value)
    463463    {
    464464      SStat &s=GetStatisticEP(pKey);
    465465      s.bits+=numBits;

  • source/Lib/TLibCommon/SEI.cpp

     
    114114}
    115115
    116116// Static member
    117 const Char *SEI::getSEIMessageString(SEI::PayloadType payloadType)
     117const TChar *SEI::getSEIMessageString(SEI::PayloadType payloadType)
    118118{
    119119  switch (payloadType)
    120120  {

  • source/Lib/TLibCommon/Debug.h

     
    4747#include <TLibCommon/CommonDef.h>
    4848
    4949#if DEBUG_STRING
    50 extern const Char *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1];
    51 extern const Char *partSizeToString[NUMBER_OF_PART_SIZES];
     50extern const TChar *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1];
     51extern const TChar *partSizeToString[NUMBER_OF_PART_SIZES];
    5252#endif
    5353
    5454// ---------------------------------------------------------------------------------------------- //
    … …  
    149149UInt getDecimalWidth(const Double value);
    150150UInt getZScanIndex(const UInt x, const UInt y);
    151151
    152 //template specialisation for Char types to get it to render as a number
     152//template specialisation for SChar/UChar types to get it to render as a number
    153153template <typename ValueType> inline Void writeValueToStream       (const ValueType &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<      value;  }
    154 template <>                   inline Void writeValueToStream<Char >(const Char      &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<  Int(value); }
     154template <>                   inline Void writeValueToStream<SChar>(const SChar     &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) <<  Int(value); }
    155155template <>                   inline Void writeValueToStream<UChar>(const UChar     &value, std::ostream &stream, const UInt outputWidth) { stream << std::setw(outputWidth) << UInt(value); }
    156156
    157157template <typename ValueType>
    … …  
    231231
    232232
    233233template <typename T>
    234 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, const T * blkSrc, const UInt width, const UInt height, const UInt stride, const UInt subBlockWidth=0, const UInt subBlockHeight=0, const UInt defWidth=3 )
     234Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, const T * blkSrc, const UInt width, const UInt height, const UInt stride, const UInt subBlockWidth=0, const UInt subBlockHeight=0, const UInt defWidth=3 )
    235235{
    236236  for (UInt y=0; y<height; y++)
    237237  {
    … …  
    255255}
    256256
    257257class TComYuv;
    258 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross=1, const UInt numSubBlocksUp=1, const UInt defWidth=3 );
     258Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross=1, const UInt numSubBlocksUp=1, const UInt defWidth=3 );
    259259
    260260// ---------------------------------------------------------------------------------------------- //
    261261

  • source/Lib/TLibCommon/TComBitStream.h

     
    114114   * NB, data is arranged such that subsequent bytes in the
    115115   * bytestream are stored in ascending addresses.
    116116   */
    117   Char* getByteStream() const;
     117  UChar* getByteStream() const;
    118118
    119119  /**
    120120   * Return the number of valid bytes available from  getByteStream()

  • source/Lib/TLibCommon/Debug.cpp

     
    4848
    4949#if DEBUG_STRING
    5050// these strings are used to reorder the debug output so that the encoder and decoder match.
    51 const Char *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1]
     51const TChar *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1]
    5252 = {"Start of channel 0 inter debug\n", "Start of channel 1 inter debug\n", "Start of channel 2 inter debug\n", "End of inter residual debug\n"} ;
    53 const Char *partSizeToString[NUMBER_OF_PART_SIZES]={"2Nx2N(0)", "2NxN(1)", "Nx2N(2)", "NxN(3)", "2Nx(N/2+3N/2)(4)", "2Nx(3N/2+N/2)(5)", "(N/2+3N/2)x2N(6)", "(3N/2+N/2)x2N(7)"};
     53const TChar *partSizeToString[NUMBER_OF_PART_SIZES]={"2Nx2N(0)", "2NxN(1)", "Nx2N(2)", "NxN(3)", "2Nx(N/2+3N/2)(4)", "2Nx(3N/2+N/2)(5)", "(N/2+3N/2)x2N(6)", "(3N/2+N/2)x2N(7)"};
    5454#endif
    5555
    5656// --------------------------------------------------------------------------------------------------------------------- //
    … …  
    417417// --------------------------------------------------------------------------------------------------------------------- //
    418418
    419419
    420 Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
     420Void printBlockToStream( std::ostream &ss, const TChar *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
    421421{
    422422  const UInt numValidComp=src.getNumberValidComponents();
    423423

  • source/Lib/TLibCommon/SEI.h

     
    8989  SEI() {}
    9090  virtual ~SEI() {}
    9191
    92   static const Char *getSEIMessageString(SEI::PayloadType payloadType);
     92  static const TChar *getSEIMessageString(SEI::PayloadType payloadType);
    9393
    9494  virtual PayloadType payloadType() const = 0;
    9595};

  • source/Lib/TLibCommon/TComPicYuvMD5.cpp

     
    208208
    209209std::string hashToString(const TComPictureHash &digest, Int numChar)
    210210{
    211   static const Char* hex = "0123456789abcdef";
     211  static const TChar* hex = "0123456789abcdef";
    212212  std::string result;
    213213
    214214  for(Int pos=0; pos<Int(digest.hash.size()); pos++)

  • source/Lib/TLibCommon/TComSlice.h

     
    170170
    171171  Void       checkDcOfMatrix();
    172172  Void       processRefMatrix(UInt sizeId, UInt listId , UInt refListId );
    173   Bool       xParseScalingList(Char* pchFile);
     173  Bool       xParseScalingList(TChar* pchFile);
    174174  Void       setDefaultScalingList();
    175175  Bool       checkDefaultScalingList();
    176176

  • source/Lib/TLibCommon/TypeDef.h

     
    170170typedef       void                Void;
    171171typedef       bool                Bool;
    172172
    173 #ifdef __arm__
    174 typedef       signed char         Char;
    175 #else
    176 typedef       char                Char;
    177 #endif
    178 typedef       unsigned char       UChar;
     173typedef       char                TChar; // Used for text/characters
     174typedef       signed char         SChar; // Signed 8-bit values
     175typedef       unsigned char       UChar; // Unsigned 8-bit values
    179176typedef       short               Short;
    180177typedef       unsigned short      UShort;
    181178typedef       int                 Int;

  • source/Lib/TLibCommon/TComDataCU.cpp

     
    122122
    123123  if ( !bDecSubCu )
    124124  {
    125     m_phQP               = (Char*     )xMalloc(Char,     uiNumPartition);
     125    m_phQP               = (SChar*    )xMalloc(SChar,    uiNumPartition);
    126126    m_puhDepth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
    127127    m_puhWidth           = (UChar*    )xMalloc(UChar,    uiNumPartition);
    128128    m_puhHeight          = (UChar*    )xMalloc(UChar,    uiNumPartition);
    129129
    130130    m_ChromaQpAdj        = new UChar[ uiNumPartition ];
    131131    m_skipFlag           = new Bool[ uiNumPartition ];
    132     m_pePartSize         = new Char[ uiNumPartition ];
     132    m_pePartSize         = new SChar[ uiNumPartition ];
    133133    memset( m_pePartSize, NUMBER_OF_PART_SIZES,uiNumPartition * sizeof( *m_pePartSize ) );
    134     m_pePredMode         = new Char[ uiNumPartition ];
     134    m_pePredMode         = new SChar[ uiNumPartition ];
    135135    m_CUTransquantBypass = new Bool[ uiNumPartition ];
    136136
    137137    m_pbMergeFlag        = (Bool*  )xMalloc(Bool,   uiNumPartition);
    … …  
    148148    for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
    149149    {
    150150      const RefPicList rpl=RefPicList(i);
    151       m_apiMVPIdx[rpl]       = new Char[ uiNumPartition ];
    152       m_apiMVPNum[rpl]       = new Char[ uiNumPartition ];
    153       memset( m_apiMVPIdx[rpl], -1,uiNumPartition * sizeof( Char ) );
     151      m_apiMVPIdx[rpl]       = new SChar[ uiNumPartition ];
     152      m_apiMVPNum[rpl]       = new SChar[ uiNumPartition ];
     153      memset( m_apiMVPIdx[rpl], -1,uiNumPartition * sizeof( SChar ) );
    154154    }
    155155
    156156    for (UInt comp=0; comp<MAX_NUM_COMPONENT; comp++)
    … …  
    159159      const UInt chromaShift = getComponentScaleX(compID, chromaFormatIDC) + getComponentScaleY(compID, chromaFormatIDC);
    160160      const UInt totalSize   = (uiWidth * uiHeight) >> chromaShift;
    161161
    162       m_crossComponentPredictionAlpha[compID] = (Char*  )xMalloc(Char,   uiNumPartition);
     162      m_crossComponentPredictionAlpha[compID] = (SChar* )xMalloc(SChar,  uiNumPartition);
    163163      m_puhTransformSkip[compID]              = (UChar* )xMalloc(UChar,  uiNumPartition);
    164164      m_explicitRdpcmMode[compID]             = (UChar* )xMalloc(UChar,  uiNumPartition);
    165165      m_puhCbf[compID]                        = (UChar* )xMalloc(UChar,  uiNumPartition);
    … …  
    645645
    646646  Int iSizeInUchar = sizeof( UChar  ) * m_uiNumPartition;
    647647  Int iSizeInBool  = sizeof( Bool   ) * m_uiNumPartition;
    648   Int sizeInChar = sizeof( Char  ) * m_uiNumPartition;
     648  Int sizeInChar = sizeof( SChar  ) * m_uiNumPartition;
    649649
    650650  memset( m_phQP,              qp,  sizeInChar );
    651651  memset( m_pbMergeFlag,        0, iSizeInBool  );
    … …  
    872872  Int iSizeInUchar  = sizeof( UChar ) * uiNumPartition;
    873873  Int iSizeInBool   = sizeof( Bool  ) * uiNumPartition;
    874874
    875   Int sizeInChar  = sizeof( Char ) * uiNumPartition;
     875  Int sizeInChar  = sizeof( SChar ) * uiNumPartition;
    876876  memcpy( m_skipFlag   + uiOffset, pcCU->getSkipFlag(),       sizeof( *m_skipFlag )   * uiNumPartition );
    877877  memcpy( m_phQP       + uiOffset, pcCU->getQP(),             sizeInChar                        );
    878878  memcpy( m_pePartSize + uiOffset, pcCU->getPartitionSize(),  sizeof( *m_pePartSize ) * uiNumPartition );
    … …  
    954954
    955955  Int iSizeInUchar  = sizeof( UChar ) * m_uiNumPartition;
    956956  Int iSizeInBool   = sizeof( Bool  ) * m_uiNumPartition;
    957   Int sizeInChar  = sizeof( Char ) * m_uiNumPartition;
     957  Int sizeInChar  = sizeof( SChar ) * m_uiNumPartition;
    958958
    959959  memcpy( pCtu->getSkipFlag() + m_absZIdxInCtu, m_skipFlag, sizeof( *m_skipFlag ) * m_uiNumPartition );
    960960
    … …  
    12951295
    12961296/** Get reference QP from left QpMinCu or latest coded QP
    12971297*\param   uiCurrAbsIdxInCtu
    1298 *\returns Char   reference QP value
     1298*\returns SChar   reference QP value
    12991299*/
    1300 Char TComDataCU::getRefQP( UInt uiCurrAbsIdxInCtu )
     1300SChar TComDataCU::getRefQP( UInt uiCurrAbsIdxInCtu )
    13011301{
    13021302  UInt lPartIdx = MAX_UINT;
    13031303  UInt aPartIdx = MAX_UINT;
    … …  
    13181318  return iLastValidPartIdx;
    13191319}
    13201320
    1321 Char TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
     1321SChar TComDataCU::getLastCodedQP( UInt uiAbsPartIdx )
    13221322{
    13231323  UInt uiQUPartIdxMask = ~((1<<((getSlice()->getSPS()->getMaxTotalCUDepth() - getSlice()->getPPS()->getMaxCuDQPDepth())<<1))-1);
    13241324  Int iLastValidPartIdx = getLastValidPartIdx( uiAbsPartIdx&uiQUPartIdxMask ); // A idx will be invalid if it is off the right or bottom edge of the picture.
    … …  
    18131813
    18141814Void TComDataCU::setMVPIdxSubParts( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    18151815{
    1816   setSubPart<Char>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
     1816  setSubPart<SChar>( iMVPIdx, m_apiMVPIdx[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
    18171817}
    18181818
    18191819Void TComDataCU::setMVPNumSubParts( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )
    18201820{
    1821   setSubPart<Char>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
     1821  setSubPart<SChar>( iMVPNum, m_apiMVPNum[eRefPicList], uiAbsPartIdx, uiDepth, uiPartIdx );
    18221822}
    18231823
    18241824
    … …  
    18511851  memset((m_puhTransformSkip[compID] + uiAbsPartIdx), useTransformSkip, (sizeof(UChar) * uiCoveredPartIdxes));
    18521852}
    18531853
    1854 Void TComDataCU::setCrossComponentPredictionAlphaPartRange( Char alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
     1854Void TComDataCU::setCrossComponentPredictionAlphaPartRange( SChar alphaValue, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )
    18551855{
    1856   memset((m_crossComponentPredictionAlpha[compID] + uiAbsPartIdx), alphaValue, (sizeof(Char) * uiCoveredPartIdxes));
     1856  memset((m_crossComponentPredictionAlpha[compID] + uiAbsPartIdx), alphaValue, (sizeof(SChar) * uiCoveredPartIdxes));
    18571857}
    18581858
    18591859Void TComDataCU::setExplicitRdpcmModePartRange ( UInt rdpcmMode, ComponentID compID, UInt uiAbsPartIdx, UInt uiCoveredPartIdxes )

  • source/Lib/TLibCommon/TComPicYuv.h

     
    150150  Void          extendPicBorder   ();
    151151
    152152  //  Dump picture
    153   Void          dump              (const Char* pFileName, const BitDepths &bitDepths, Bool bAdd = false) const ;
     153  Void          dump              (const TChar* pFileName, const BitDepths &bitDepths, Bool bAdd = false) const ;
    154154
    155155  // Set border extension flag
    156156  Void          setBorderExtension(Bool b) { m_bIsBorderExtended = b; }

  • source/Lib/TLibCommon/TComRom.h

     
    124124// Misc.
    125125// ====================================================================================================================
    126126
    127 extern       Char   g_aucConvertToBit  [ MAX_CU_SIZE+1 ];   // from width to log2(width)-2
     127extern       SChar   g_aucConvertToBit  [ MAX_CU_SIZE+1 ];   // from width to log2(width)-2
    128128
    129129
    130130#if ENC_DEC_TRACE
    … …  
    158158
    159159#endif
    160160
    161 const Char* nalUnitTypeToString(NalUnitType type);
     161const TChar* nalUnitTypeToString(NalUnitType type);
    162162
    163 extern const Char *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    164 extern const Char *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     163extern const TChar *MatrixType[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
     164extern const TChar *MatrixType_DC[SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM];
    165165
    166166extern const Int g_quantTSDefault4x4[4*4];
    167167extern const Int g_quantIntraDefault8x8[8*8];

  • source/Lib/TLibCommon/TComSampleAdaptiveOffset.cpp

     
    323323      delete[] m_signLineBuf1;
    324324      m_signLineBuf1 = NULL;
    325325    }
    326     m_signLineBuf1 = new Char[m_lineBufWidth+1];
     326    m_signLineBuf1 = new SChar[m_lineBufWidth+1];
    327327
    328328    if (m_signLineBuf2)
    329329    {
    330330      delete[] m_signLineBuf2;
    331331      m_signLineBuf2 = NULL;
    332332    }
    333     m_signLineBuf2 = new Char[m_lineBufWidth+1];
     333    m_signLineBuf2 = new SChar[m_lineBufWidth+1];
    334334  }
    335335
    336336  const Int maxSampleValueIncl = (1<< channelBitDepth )-1;
    337337
    338338  Int x,y, startX, startY, endX, endY, edgeType;
    339339  Int firstLineStartX, firstLineEndX, lastLineStartX, lastLineEndX;
    340   Char signLeft, signRight, signDown;
     340  SChar signLeft, signRight, signDown;
    341341
    342342  Pel* srcLine = srcBlk;
    343343  Pel* resLine = resBlk;
    … …  
    351351      endX   = isRightAvail ? width : (width -1);
    352352      for (y=0; y< height; y++)
    353353      {
    354         signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     354        signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    355355        for (x=startX; x< endX; x++)
    356356        {
    357           signRight = (Char)sgn(srcLine[x] - srcLine[x+1]);
     357          signRight = (SChar)sgn(srcLine[x] - srcLine[x+1]);
    358358          edgeType =  signRight + signLeft;
    359359          signLeft  = -signRight;
    360360
    … …  
    369369  case SAO_TYPE_EO_90:
    370370    {
    371371      offset += 2;
    372       Char *signUpLine = m_signLineBuf1;
     372      SChar *signUpLine = m_signLineBuf1;
    373373
    374374      startY = isAboveAvail ? 0 : 1;
    375375      endY   = isBelowAvail ? height : height-1;
    … …  
    382382      Pel* srcLineAbove= srcLine- srcStride;
    383383      for (x=0; x< width; x++)
    384384      {
    385         signUpLine[x] = (Char)sgn(srcLine[x] - srcLineAbove[x]);
     385        signUpLine[x] = (SChar)sgn(srcLine[x] - srcLineAbove[x]);
    386386      }
    387387
    388388      Pel* srcLineBelow;
    … …  
    392392
    393393        for (x=0; x< width; x++)
    394394        {
    395           signDown  = (Char)sgn(srcLine[x] - srcLineBelow[x]);
     395          signDown  = (SChar)sgn(srcLine[x] - srcLineBelow[x]);
    396396          edgeType = signDown + signUpLine[x];
    397397          signUpLine[x]= -signDown;
    398398
    … …  
    407407  case SAO_TYPE_EO_135:
    408408    {
    409409      offset += 2;
    410       Char *signUpLine, *signDownLine, *signTmpLine;
     410      SChar *signUpLine, *signDownLine, *signTmpLine;
    411411
    412412      signUpLine  = m_signLineBuf1;
    413413      signDownLine= m_signLineBuf2;
    … …  
    419419      Pel* srcLineBelow= srcLine+ srcStride;
    420420      for (x=startX; x< endX+1; x++)
    421421      {
    422         signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x- 1]);
     422        signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x- 1]);
    423423      }
    424424
    425425      //1st line
    … …  
    443443
    444444        for (x=startX; x<endX; x++)
    445445        {
    446           signDown =  (Char)sgn(srcLine[x] - srcLineBelow[x+ 1]);
     446          signDown =  (SChar)sgn(srcLine[x] - srcLineBelow[x+ 1]);
    447447          edgeType =  signDown + signUpLine[x];
    448448          resLine[x] = Clip3<Int>(0, maxSampleValueIncl, srcLine[x] + offset[edgeType]);
    449449
    450450          signDownLine[x+1] = -signDown;
    451451        }
    452         signDownLine[startX] = (Char)sgn(srcLineBelow[startX] - srcLine[startX-1]);
     452        signDownLine[startX] = (SChar)sgn(srcLineBelow[startX] - srcLine[startX-1]);
    453453
    454454        signTmpLine  = signUpLine;
    455455        signUpLine   = signDownLine;
    … …  
    474474  case SAO_TYPE_EO_45:
    475475    {
    476476      offset += 2;
    477       Char *signUpLine = m_signLineBuf1+1;
     477      SChar *signUpLine = m_signLineBuf1+1;
    478478
    479479      startX = isLeftAvail ? 0 : 1;
    480480      endX   = isRightAvail ? width : (width -1);
    … …  
    483483      Pel* srcLineBelow= srcLine+ srcStride;
    484484      for (x=startX-1; x< endX; x++)
    485485      {
    486         signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x+1]);
     486        signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x+1]);
    487487      }
    488488
    489489
    … …  
    506506
    507507        for(x= startX; x< endX; x++)
    508508        {
    509           signDown =  (Char)sgn(srcLine[x] - srcLineBelow[x-1]);
     509          signDown =  (SChar)sgn(srcLine[x] - srcLineBelow[x-1]);
    510510          edgeType =  signDown + signUpLine[x];
    511511          resLine[x] = Clip3<Int>(0, maxSampleValueIncl, srcLine[x] + offset[edgeType]);
    512512          signUpLine[x-1] = -signDown;
    513513        }
    514         signUpLine[endX-1] = (Char)sgn(srcLineBelow[endX-1] - srcLine[endX]);
     514        signUpLine[endX-1] = (SChar)sgn(srcLineBelow[endX-1] - srcLine[endX]);
    515515        srcLine  += srcStride;
    516516        resLine += resStride;
    517517      }

  • source/Lib/TLibCommon/TComSlice.cpp

     
    19191919  }
    19201920}
    19211921
    1922 Bool TComScalingList::xParseScalingList(Char* pchFile)
     1922Bool TComScalingList::xParseScalingList(TChar* pchFile)
    19231923{
    19241924  static const Int LINE_SIZE=1024;
    19251925  FILE *fp = NULL;
    1926   Char line[LINE_SIZE];
     1926  TChar line[LINE_SIZE];
    19271927
    19281928  if (pchFile == NULL)
    19291929  {
    … …  
    19641964          Bool bFound=false;
    19651965          while ((!feof(fp)) && (!bFound))
    19661966          {
    1967             Char *ret = fgets(line, LINE_SIZE, fp);
    1968             Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
     1967            TChar *ret = fgets(line, LINE_SIZE, fp);
     1968            TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType[sizeIdc][listIdc]);
    19691969            // This could be a match against the DC string as well, so verify it isn't
    19701970            if (findNamePosition!= NULL && (MatrixType_DC[sizeIdc][listIdc]==NULL || strstr(line, MatrixType_DC[sizeIdc][listIdc])==NULL))
    19711971            {
    … …  
    20042004            Bool bFound=false;
    20052005            while ((!feof(fp)) && (!bFound))
    20062006            {
    2007               Char *ret = fgets(line, LINE_SIZE, fp);
    2008               Char *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
     2007              TChar *ret = fgets(line, LINE_SIZE, fp);
     2008              TChar *findNamePosition= ret==NULL ? NULL : strstr(line, MatrixType_DC[sizeIdc][listIdc]);
    20092009              if (findNamePosition!= NULL)
    20102010              {
    20112011                // This won't be a match against the non-DC string.

  • source/Lib/TLibVideoIO/TVideoIOYuv.h

     
    6363  TVideoIOYuv()           {}
    6464  virtual ~TVideoIOYuv()  {}
    6565
    66   Void  open  ( Char* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] ); ///< open or create file
     66  Void  open  ( TChar* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] ); ///< open or create file
    6767  Void  close ();                                           ///< close file
    6868
    6969  Void skipFrames(UInt numFrames, UInt width, UInt height, ChromaFormat format);

  • source/Lib/TLibVideoIO/TVideoIOYuv.cpp

     
    115115 * \param MSBExtendedBitDepth
    116116 * \param internalBitDepth bit-depth array to scale image data to/from when reading/writing.
    117117 */
    118 Void TVideoIOYuv::open( Char* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] )
     118Void TVideoIOYuv::open( TChar* pchFile, Bool bWriteMode, const Int fileBitDepth[MAX_NUM_CHANNEL_TYPE], const Int MSBExtendedBitDepth[MAX_NUM_CHANNEL_TYPE], const Int internalBitDepth[MAX_NUM_CHANNEL_TYPE] )
    119119{
    120120  //NOTE: files cannot have bit depth greater than 16
    121121  for(UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++)
    … …  
    216216  m_cHandle.clear();
    217217
    218218  /* fall back to consuming the input */
    219   Char buf[512];
     219  UChar buf[512];
    220220  const streamoff offset_mod_bufsize = offset % sizeof(buf);
    221221  for (streamoff i = 0; i < offset - offset_mod_bufsize; i += sizeof(buf))
    222222  {
    223     m_cHandle.read(buf, sizeof(buf));
     223    m_cHandle.read(reinterpret_cast<char*>(buf), sizeof(buf));
    224224  }
    225   m_cHandle.read(buf, offset_mod_bufsize);
     225  m_cHandle.read(reinterpret_cast<char*>(buf), offset_mod_bufsize);
    226226}
    227227
    228228/**
    … …  
    310310      if ((y444&mask_y_file)==0)
    311311      {
    312312        // read a new line
    313         fd.read(reinterpret_cast<Char*>(buf), stride_file);
     313        fd.read(reinterpret_cast<char*>(buf), stride_file);
    314314        if (fd.eof() || fd.fail() )
    315315        {
    316316          delete[] buf;
    … …  
    446446          }
    447447        }
    448448
    449         fd.write(reinterpret_cast<Char*>(buf), stride_file);
     449        fd.write(reinterpret_cast<const char*>(buf), stride_file);
    450450        if (fd.eof() || fd.fail() )
    451451        {
    452452          delete[] buf;
    … …  
    505505          }
    506506        }
    507507
    508         fd.write(reinterpret_cast<Char*>(buf), stride_file);
     508        fd.write(reinterpret_cast<const char*>(buf), stride_file);
    509509        if (fd.eof() || fd.fail() )
    510510        {
    511511          delete[] buf;
    … …  
    576576          }
    577577        }
    578578
    579         fd.write(reinterpret_cast<Char*>(buf), (stride_file * 2));
     579        fd.write(reinterpret_cast<const char*>(buf), (stride_file * 2));
    580580        if (fd.eof() || fd.fail() )
    581581        {
    582582          delete[] buf;
    … …  
    641641          }
    642642        }
    643643
    644         fd.write(reinterpret_cast<Char*>(buf), (stride_file * 2));
     644        fd.write(reinterpret_cast<const char*>(buf), (stride_file * 2));
    645645        if (fd.eof() || fd.fail() )
    646646        {
    647647          delete[] buf;

  • source/Lib/TLibEncoder/TEncBinCoderCABACCounter.cpp

     
    8989
    9090  if (g_debugCounter >= debugEncoderSearchBinTargetLine)
    9191  {
    92     Char breakPointThis;
     92    UChar breakPointThis;
    9393    breakPointThis = 7;
    9494  }
    9595  if (g_debugCounter >= (debugEncoderSearchBinTargetLine + debugEncoderSearchBinWindow))

  • source/Lib/TLibEncoder/TEncAnalyze.h

     
    136136  }
    137137
    138138
    139   Void    printOut ( Char cDelim, const ChromaFormat chFmt, const Bool printMSEBasedSNR, const Bool printSequenceMSE, const BitDepths &bitDepths )
     139  Void    printOut ( TChar cDelim, const ChromaFormat chFmt, const Bool printMSEBasedSNR, const Bool printSequenceMSE, const BitDepths &bitDepths )
    140140  {
    141141    Double dFps     =   m_dFrmRate; //--CFG_KDY
    142142    Double dScale   = dFps / 1000 / (Double)m_uiNumPic;

  • source/Lib/TLibEncoder/SyntaxElementWriter.h

     
    8282  Void  xWriteSvlc            ( Int  iCode   );
    8383  Void  xWriteFlag            ( UInt uiCode );
    8484#if ENC_DEC_TRACE
    85   Void  xWriteCodeTr          ( UInt value, UInt  length, const Char *pSymbolName);
    86   Void  xWriteUvlcTr          ( UInt value,               const Char *pSymbolName);
    87   Void  xWriteSvlcTr          ( Int  value,               const Char *pSymbolName);
    88   Void  xWriteFlagTr          ( UInt value,               const Char *pSymbolName);
     85  Void  xWriteCodeTr          ( UInt value, UInt  length, const TChar *pSymbolName);
     86  Void  xWriteUvlcTr          ( UInt value,               const TChar *pSymbolName);
     87  Void  xWriteSvlcTr          ( Int  value,               const TChar *pSymbolName);
     88  Void  xWriteFlagTr          ( UInt value,               const TChar *pSymbolName);
    8989#endif
    9090  Void xWriteRbspTrailingBits();
    9191

  • source/Lib/TLibEncoder/TEncGOP.cpp

     
    794794      const std::size_t numberOfAdditionalCabacZeroBytes=numberOfAdditionalCabacZeroWords*3;
    795795      if (cabacZeroWordPaddingEnabled)
    796796      {
    797         std::vector<Char> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, Char(0));
     797        std::vector<UChar> zeroBytesPadding(numberOfAdditionalCabacZeroBytes, UChar(0));
    798798        for(std::size_t i=0; i<numberOfAdditionalCabacZeroWords; i++)
    799799        {
    800800          zeroBytesPadding[i*3+2]=3;  // 00 00 03
    801801        }
    802         nalUnitData.write(&(zeroBytesPadding[0]), numberOfAdditionalCabacZeroBytes);
     802        nalUnitData.write(reinterpret_cast<const char*>(&(zeroBytesPadding[0])), numberOfAdditionalCabacZeroBytes);
    803803        printf("Adding %d bytes of padding\n", UInt(numberOfAdditionalCabacZeroWords*3));
    804804      }
    805805      else
    … …  
    20332033    m_gcAnalyzeB.addResult (dPSNR, (Double)uibits, MSEyuvframe);
    20342034  }
    20352035
    2036   Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
     2036  TChar c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
    20372037  if (!pcSlice->isReferenced())
    20382038  {
    20392039    c += 32;

  • source/Lib/TLibEncoder/TEncSearch.h

     
    8080  TComYuv*        m_pcQTTempTComYuv;
    8181  TComYuv         m_tmpYuvPred; // To be used in xGetInterPredictionError() to avoid constant memory allocation/deallocation
    8282
    83   Char*           m_phQTTempCrossComponentPredictionAlpha[MAX_NUM_COMPONENT];
     83  SChar*          m_phQTTempCrossComponentPredictionAlpha[MAX_NUM_COMPONENT];
    8484  Pel*            m_pSharedPredTransformSkip[MAX_NUM_COMPONENT];
    8585  TCoeff*         m_pcQTTempTUCoeff[MAX_NUM_COMPONENT];
    8686  UChar*          m_puhQTTempTransformSkipFlag[MAX_NUM_COMPONENT];
    … …  
    274274                                               const Int     strideResi,
    275275                                               const Int     strideBest );
    276276
    277   Char xCalcCrossComponentPredictionAlpha    (       TComTU &rTu,
     277  SChar xCalcCrossComponentPredictionAlpha   (       TComTU &rTu,
    278278                                               const ComponentID compID,
    279279                                               const Pel*        piResiL,
    280280                                               const Pel*        piResiC,

  • source/Lib/TLibEncoder/AnnexBwrite.h

     
    5959    const NALUnitEBSP& nalu = **it;
    6060    UInt size = 0; /* size of annexB unit in bytes */
    6161
    62     static const Char start_code_prefix[] = {0,0,0,1};
     62    static const UChar start_code_prefix[] = {0,0,0,1};
    6363    if (it == au.begin() || nalu.m_nalUnitType == NAL_UNIT_VPS || nalu.m_nalUnitType == NAL_UNIT_SPS || nalu.m_nalUnitType == NAL_UNIT_PPS)
    6464    {
    6565      /* From AVC, When any of the following conditions are fulfilled, the
    … …  
    7070       *    unit of an access unit in decoding order, as specified by subclause
    7171       *    7.4.1.2.3.
    7272       */
    73       out.write(start_code_prefix, 4);
     73      out.write(reinterpret_cast<const char*>(start_code_prefix), 4);
    7474      size += 4;
    7575    }
    7676    else
    7777    {
    78       out.write(start_code_prefix+1, 3);
     78      out.write(reinterpret_cast<const char*>(start_code_prefix+1), 3);
    7979      size += 3;
    8080    }
    8181    out << nalu.m_nalUnitData.str();

  • source/Lib/TLibEncoder/TEncBinCoderCABAC.cpp

     
    235235
    236236  if (g_debugCounter >= debugCabacBinTargetLine)
    237237  {
    238     Char breakPointThis;
     238    UChar breakPointThis;
    239239    breakPointThis = 7;
    240240  }
    241241  if (g_debugCounter >= (debugCabacBinTargetLine + debugCabacBinWindow))

  • source/Lib/TLibEncoder/TEncSearch.cpp

     
    276276#endif
    277277    }
    278278
    279     m_phQTTempCrossComponentPredictionAlpha[ch]    = new Char  [uiNumPartitions];
     279    m_phQTTempCrossComponentPredictionAlpha[ch]    = new SChar  [uiNumPartitions];
    280280    m_pSharedPredTransformSkip[ch]                 = new Pel   [MAX_CU_SIZE*MAX_CU_SIZE];
    281281    m_pcQTTempTUCoeff[ch]                          = new TCoeff[MAX_CU_SIZE*MAX_CU_SIZE];
    282282#if ADAPTIVE_QP_SELECTION
    … …  
    18621862  }
    18631863}
    18641864
    1865 Char
     1865SChar
    18661866TEncSearch::xCalcCrossComponentPredictionAlpha(       TComTU &rTu,
    18671867                                                const ComponentID compID,
    18681868                                                const Pel*        piResiL,
    … …  
    18791879  const Int  absPartIdx = rTu.GetAbsPartIdxTU( compID );
    18801880  const Int diffBitDepth = pCU->getSlice()->getSPS()->getDifferentialLumaChromaBitDepth();
    18811881
    1882   Char alpha = 0;
     1882  SChar alpha = 0;
    18831883  Int SSxy  = 0;
    18841884  Int SSxx  = 0;
    18851885
    … …  
    18991899  if( SSxx != 0 )
    19001900  {
    19011901    Double dAlpha = SSxy / Double( SSxx );
    1902     alpha = Char(Clip3<Int>(-16, 16, (Int)(dAlpha * 16)));
     1902    alpha = SChar(Clip3<Int>(-16, 16, (Int)(dAlpha * 16)));
    19031903
    1904     static const Char alphaQuant[17] = {0, 1, 1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
     1904    static const SChar alphaQuant[17] = {0, 1, 1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
    19051905
    19061906    alpha = (alpha < 0) ? -alphaQuant[Int(-alpha)] : alphaQuant[Int(alpha)];
    19071907  }
    … …  
    19801980        Distortion singleDistCTmp            = 0;
    19811981        Double     singleCostTmp             = 0;
    19821982        UInt       singleCbfCTmp             = 0;
    1983         Char       bestCrossCPredictionAlpha = 0;
     1983        SChar      bestCrossCPredictionAlpha = 0;
    19841984        Int        bestTransformSkipMode     = 0;
    19851985
    19861986        const Bool checkCrossComponentPrediction =    (pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, subTUAbsPartIdx) == DM_CHROMA_IDX)
    … …  
    26432643              const ComponentID compID = ComponentID(componentIndex);
    26442644              ::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
    26452645              ::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
    2646               ::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, uiQPartNum * sizeof( Char ) );
     2646              ::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, uiQPartNum * sizeof( SChar ) );
    26472647            }
    26482648          }
    26492649        }
    … …  
    26562656          const ComponentID compID = ComponentID(componentIndex);
    26572657          ::memcpy( pcCU->getCbf( compID )+uiPartOffset, m_puhQTTempCbf[compID], uiQPartNum * sizeof( UChar ) );
    26582658          ::memcpy( pcCU->getTransformSkip( compID )+uiPartOffset, m_puhQTTempTransformSkipFlag[compID], uiQPartNum * sizeof( UChar ) );
    2659           ::memcpy( pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( Char ) );
     2659          ::memcpy( pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( SChar ) );
    26602660        }
    26612661      }
    26622662
    … …  
    43714371    {
    43724372      const ComponentID component = ComponentID(comp);
    43734373      ::memset( pcCU->getCbf( component ) , 0, uiQPartNum * sizeof(UChar) );
    4374       ::memset( pcCU->getCrossComponentPredictionAlpha(component), 0, ( uiQPartNum * sizeof(Char) ) );
     4374      ::memset( pcCU->getCrossComponentPredictionAlpha(component), 0, ( uiQPartNum * sizeof(SChar) ) );
    43754375    }
    43764376    static const UInt useTS[MAX_NUM_COMPONENT]={0,0,0};
    43774377    pcCU->setTransformSkipSubParts ( useTS, 0, pcCU->getDepth(0) );
    … …  
    44714471  UInt       uiBestTransformMode         [MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{0,0},{0,0},{0,0}};
    44724472  //  Stores the best explicit RDPCM mode for a TU encoded without split
    44734473  UInt       bestExplicitRdpcmModeUnSplit[MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{3,3}, {3,3}, {3,3}};
    4474   Char       bestCrossCPredictionAlpha   [MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{0,0},{0,0},{0,0}};
     4474  SChar      bestCrossCPredictionAlpha   [MAX_NUM_COMPONENT][2/*0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU*/] = {{0,0},{0,0},{0,0}};
    44754475
    44764476  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
    44774477
    … …  
    45384538                                                         && pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag()
    45394539                                                         && (pcCU->getCbf(subTUAbsPartIdx, COMPONENT_Y, uiTrMode) != 0);
    45404540
    4541           Char preCalcAlpha = 0;
     4541          SChar preCalcAlpha = 0;
    45424542          const Pel *pLumaResi = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( COMPONENT_Y, rTu.getRect( COMPONENT_Y ).x0, rTu.getRect( COMPONENT_Y ).y0 );
    45434543
    45444544          if (isCrossCPredictionAvailable)

  • source/Lib/TLibEncoder/SEIwrite.cpp

     
    209209 */
    210210Void SEIWriter::xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei)
    211211{
    212   const Char *traceString="\0";
     212  const TChar *traceString="\0";
    213213  switch (sei.method)
    214214  {
    215215    case SEIDecodedPictureHash::MD5: traceString="picture_md5"; break;

  • source/Lib/TLibEncoder/NALwrite.cpp

     
    4444//! \ingroup TLibEncoder
    4545//! \{
    4646
    47 static const Char emulation_prevention_three_byte[] = {3};
     47static const UChar emulation_prevention_three_byte[] = {3};
    4848
    4949Void writeNalUnitHeader(ostream& out, OutputNALUnit& nalu)       // nal_unit_header()
    5050{
    … …  
    5555  bsNALUHeader.write(nalu.m_nuhLayerId, 6);   // nuh_layer_id
    5656  bsNALUHeader.write(nalu.m_temporalId+1, 3); // nuh_temporal_id_plus1
    5757
    58   out.write(bsNALUHeader.getByteStream(), bsNALUHeader.getByteStreamLength());
     58  out.write(reinterpret_cast<const char*>(bsNALUHeader.getByteStream()), bsNALUHeader.getByteStreamLength());
    5959}
    6060/**
    6161 * write nalu to bytestream out, performing RBSP anti startcode
    … …  
    119119  {
    120120    outputBuffer[outputAmount++]=emulation_prevention_three_byte[0];
    121121  }
    122   out.write((Char*)&(*outputBuffer.begin()), outputAmount);
     122  out.write(reinterpret_cast<const char*>(&(*outputBuffer.begin())), outputAmount);
    123123}
    124124
    125125//! \}

  • source/Lib/TLibEncoder/SyntaxElementWriter.cpp

     
    4343
    4444#if ENC_DEC_TRACE
    4545
    46 Void  SyntaxElementWriter::xWriteCodeTr (UInt value, UInt  length, const Char *pSymbolName)
     46Void  SyntaxElementWriter::xWriteCodeTr (UInt value, UInt  length, const TChar *pSymbolName)
    4747{
    4848  xWriteCode (value,length);
    4949  if( g_HLSTraceEnable )
    … …  
    6060  }
    6161}
    6262
    63 Void  SyntaxElementWriter::xWriteUvlcTr (UInt value, const Char *pSymbolName)
     63Void  SyntaxElementWriter::xWriteUvlcTr (UInt value, const TChar *pSymbolName)
    6464{
    6565  xWriteUvlc (value);
    6666  if( g_HLSTraceEnable )
    … …  
    7070  }
    7171}
    7272
    73 Void  SyntaxElementWriter::xWriteSvlcTr (Int value, const Char *pSymbolName)
     73Void  SyntaxElementWriter::xWriteSvlcTr (Int value, const TChar *pSymbolName)
    7474{
    7575  xWriteSvlc(value);
    7676  if( g_HLSTraceEnable )
    … …  
    8080  }
    8181}
    8282
    83 Void  SyntaxElementWriter::xWriteFlagTr(UInt value, const Char *pSymbolName)
     83Void  SyntaxElementWriter::xWriteFlagTr(UInt value, const TChar *pSymbolName)
    8484{
    8585  xWriteFlag(value);
    8686  if( g_HLSTraceEnable )

  • source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

     
    904904      delete[] m_signLineBuf1;
    905905      m_signLineBuf1 = NULL;
    906906    }
    907     m_signLineBuf1 = new Char[m_lineBufWidth+1];
     907    m_signLineBuf1 = new SChar[m_lineBufWidth+1];
    908908
    909909    if (m_signLineBuf2)
    910910    {
    911911      delete[] m_signLineBuf2;
    912912      m_signLineBuf2 = NULL;
    913913    }
    914     m_signLineBuf2 = new Char[m_lineBufWidth+1];
     914    m_signLineBuf2 = new SChar[m_lineBufWidth+1];
    915915  }
    916916
    917917  Int x,y, startX, startY, endX, endY, edgeType, firstLineStartX, firstLineEndX;
    918   Char signLeft, signRight, signDown;
     918  SChar signLeft, signRight, signDown;
    919919  Int64 *diff, *count;
    920920  Pel *srcLine, *orgLine;
    921921  Int* skipLinesR = m_skipLinesR[compIdx];
    … …  
    945945                                                 ;
    946946        for (y=0; y<endY; y++)
    947947        {
    948           signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     948          signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    949949          for (x=startX; x<endX; x++)
    950950          {
    951             signRight =  (Char)sgn(srcLine[x] - srcLine[x+1]);
     951            signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
    952952            edgeType  =  signRight + signLeft;
    953953            signLeft  = -signRight;
    954954
    … …  
    967967
    968968            for(y=0; y<skipLinesB[typeIdx]; y++)
    969969            {
    970               signLeft = (Char)sgn(srcLine[startX] - srcLine[startX-1]);
     970              signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
    971971              for (x=startX; x<endX; x++)
    972972              {
    973                 signRight =  (Char)sgn(srcLine[x] - srcLine[x+1]);
     973                signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
    974974                edgeType  =  signRight + signLeft;
    975975                signLeft  = -signRight;
    976976
    … …  
    988988      {
    989989        diff +=2;
    990990        count+=2;
    991         Char *signUpLine = m_signLineBuf1;
     991        SChar *signUpLine = m_signLineBuf1;
    992992
    993993        startX = (!isCalculatePreDeblockSamples) ? 0
    994994                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : width)
    … …  
    10071007        Pel* srcLineAbove = srcLine - srcStride;
    10081008        for (x=startX; x<endX; x++)
    10091009        {
    1010           signUpLine[x] = (Char)sgn(srcLine[x] - srcLineAbove[x]);
     1010          signUpLine[x] = (SChar)sgn(srcLine[x] - srcLineAbove[x]);
    10111011        }
    10121012
    10131013        Pel* srcLineBelow;
    … …  
    10171017
    10181018          for (x=startX; x<endX; x++)
    10191019          {
    1020             signDown  = (Char)sgn(srcLine[x] - srcLineBelow[x]);
     1020            signDown  = (SChar)sgn(srcLine[x] - srcLineBelow[x]);
    10211021            edgeType  = signDown + signUpLine[x];
    10221022            signUpLine[x]= -signDown;
    10231023
    … …  
    10571057      {
    10581058        diff +=2;
    10591059        count+=2;
    1060         Char *signUpLine, *signDownLine, *signTmpLine;
     1060        SChar *signUpLine, *signDownLine, *signTmpLine;
    10611061
    10621062        signUpLine  = m_signLineBuf1;
    10631063        signDownLine= m_signLineBuf2;
    … …  
    10751075        Pel* srcLineBelow = srcLine + srcStride;
    10761076        for (x=startX; x<endX+1; x++)
    10771077        {
    1078           signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x-1]);
     1078          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x-1]);
    10791079        }
    10801080
    10811081        //1st line
    … …  
    10991099
    11001100          for (x=startX; x<endX; x++)
    11011101          {
    1102             signDown = (Char)sgn(srcLine[x] - srcLineBelow[x+1]);
     1102            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x+1]);
    11031103            edgeType = signDown + signUpLine[x];
    11041104            diff [edgeType] += (orgLine[x] - srcLine[x]);
    11051105            count[edgeType] ++;
    11061106
    11071107            signDownLine[x+1] = -signDown;
    11081108          }
    1109           signDownLine[startX] = (Char)sgn(srcLineBelow[startX] - srcLine[startX-1]);
     1109          signDownLine[startX] = (SChar)sgn(srcLineBelow[startX] - srcLine[startX-1]);
    11101110
    11111111          signTmpLine  = signUpLine;
    11121112          signUpLine   = signDownLine;
    … …  
    11441144      {
    11451145        diff +=2;
    11461146        count+=2;
    1147         Char *signUpLine = m_signLineBuf1+1;
     1147        SChar *signUpLine = m_signLineBuf1+1;
    11481148
    11491149        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
    11501150                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
    … …  
    11581158        Pel* srcLineBelow = srcLine + srcStride;
    11591159        for (x=startX-1; x<endX; x++)
    11601160        {
    1161           signUpLine[x] = (Char)sgn(srcLineBelow[x] - srcLine[x+1]);
     1161          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x+1]);
    11621162        }
    11631163
    11641164
    … …  
    11871187
    11881188          for(x=startX; x<endX; x++)
    11891189          {
    1190             signDown = (Char)sgn(srcLine[x] - srcLineBelow[x-1]);
     1190            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x-1]);
    11911191            edgeType = signDown + signUpLine[x];
    11921192
    11931193            diff [edgeType] += (orgLine[x] - srcLine[x]);
    … …  
    11951195
    11961196            signUpLine[x-1] = -signDown;
    11971197          }
    1198           signUpLine[endX-1] = (Char)sgn(srcLineBelow[endX-1] - srcLine[endX]);
     1198          signUpLine[endX-1] = (SChar)sgn(srcLineBelow[endX-1] - srcLine[endX]);
    11991199          srcLine  += srcStride;
    12001200          orgLine  += orgStride;
    12011201        }

  • source/Lib/TLibEncoder/TEncCfg.h

     
    5656  Int m_temporalId;
    5757  Bool m_refPic;
    5858  Int m_numRefPicsActive;
    59   Char m_sliceType;
     59  SChar m_sliceType;
    6060  Int m_numRefPics;
    6161  Int m_referencePics[MAX_NUM_REF_PICS];
    6262  Int m_usedByCurrPic[MAX_NUM_REF_PICS];
    … …  
    321321  UInt      m_log2ParallelMergeLevelMinus2;       ///< Parallel merge estimation region
    322322  UInt      m_maxNumMergeCand;                    ///< Maximum number of merge candidates
    323323  ScalingListMode m_useScalingListId;            ///< Using quantization matrix i.e. 0=off, 1=default, 2=file.
    324   Char*     m_scalingListFile;          ///< quantization matrix file name
     324  TChar*    m_scalingListFile;          ///< quantization matrix file name
    325325  Int       m_TMVPModeId;
    326326  Bool      m_signHideFlag;
    327327  Bool      m_RCEnableRateControl;
    … …  
    795795  UInt         getMaxNumMergeCand                ()                  { return m_maxNumMergeCand;   }
    796796  Void         setUseScalingListId    ( ScalingListMode u )          { m_useScalingListId       = u;   }
    797797  ScalingListMode getUseScalingListId    ()                          { return m_useScalingListId;      }
    798   Void         setScalingListFile     ( Char*  pch )                 { m_scalingListFile     = pch; }
    799   Char*        getScalingListFile     ()                             { return m_scalingListFile;    }
     798  Void         setScalingListFile     ( TChar*  pch )                { m_scalingListFile     = pch; }
     799  TChar*       getScalingListFile     ()                             { return m_scalingListFile;    }
    800800  Void         setTMVPModeId ( Int  u )                              { m_TMVPModeId = u;    }
    801801  Int          getTMVPModeId ()                                      { return m_TMVPModeId; }
    802802  Void         setSignHideFlag( Bool signHideFlag )                  { m_signHideFlag = signHideFlag; }

  • source/Lib/TLibDecoder/SEIread.cpp

     
    6262}
    6363#endif
    6464
    65 Void SEIReader::sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const Char *pSymbolName)
     65Void SEIReader::sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const TChar *pSymbolName)
    6666{
    6767  READ_CODE(uiLength, ruiCode, pSymbolName);
    6868  if (pOS)
    … …  
    7171  }
    7272}
    7373
    74 Void SEIReader::sei_read_uvlc(std::ostream *pOS, UInt& ruiCode, const Char *pSymbolName)
     74Void SEIReader::sei_read_uvlc(std::ostream *pOS, UInt& ruiCode, const TChar *pSymbolName)
    7575{
    7676  READ_UVLC(ruiCode, pSymbolName);
    7777  if (pOS)
    … …  
    8080  }
    8181}
    8282
    83 Void SEIReader::sei_read_svlc(std::ostream *pOS, Int& ruiCode, const Char *pSymbolName)
     83Void SEIReader::sei_read_svlc(std::ostream *pOS, Int& ruiCode, const TChar *pSymbolName)
    8484{
    8585  READ_SVLC(ruiCode, pSymbolName);
    8686  if (pOS)
    … …  
    8989  }
    9090}
    9191
    92 Void SEIReader::sei_read_flag(std::ostream *pOS, UInt& ruiCode, const Char *pSymbolName)
     92Void SEIReader::sei_read_flag(std::ostream *pOS, UInt& ruiCode, const TChar *pSymbolName)
    9393{
    9494  READ_FLAG(ruiCode, pSymbolName);
    9595  if (pOS)
    … …  
    415415  sei_read_code( pDecodedMessageOutputStream, 8, val, "hash_type");
    416416  sei.method = static_cast<SEIDecodedPictureHash::Method>(val); bytesRead++;
    417417
    418   const Char *traceString="\0";
     418  const TChar *traceString="\0";
    419419  switch (sei.method)
    420420  {
    421421    case SEIDecodedPictureHash::MD5: traceString="picture_md5"; break;

  • source/Lib/TLibDecoder/SEIread.h

     
    8080  Void xParseSEIKneeFunctionInfo              (SEIKneeFunctionInfo& sei,              UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    8181  Void xParseSEIMasteringDisplayColourVolume  (SEIMasteringDisplayColourVolume& sei,  UInt payloadSize,                     std::ostream *pDecodedMessageOutputStream);
    8282
    83   Void sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const Char *pSymbolName);
    84   Void sei_read_uvlc(std::ostream *pOS,                UInt& ruiCode, const Char *pSymbolName);
    85   Void sei_read_svlc(std::ostream *pOS,                Int&  ruiCode, const Char *pSymbolName);
    86   Void sei_read_flag(std::ostream *pOS,                UInt& ruiCode, const Char *pSymbolName);
     83  Void sei_read_code(std::ostream *pOS, UInt uiLength, UInt& ruiCode, const TChar *pSymbolName);
     84  Void sei_read_uvlc(std::ostream *pOS,                UInt& ruiCode, const TChar *pSymbolName);
     85  Void sei_read_svlc(std::ostream *pOS,                Int&  ruiCode, const TChar *pSymbolName);
     86  Void sei_read_flag(std::ostream *pOS,                UInt& ruiCode, const TChar *pSymbolName);
    8787};
    8888
    8989

  • source/Lib/TLibDecoder/SyntaxElementParser.h

     
    8989  virtual ~SyntaxElementParser() {};
    9090
    9191#if RExt__DECODER_DEBUG_BIT_STATISTICS
    92   Void  xReadCode    ( UInt   length, UInt& val, const Char *pSymbolName );
    93   Void  xReadUvlc    ( UInt&  val, const Char *pSymbolName );
    94   Void  xReadSvlc    ( Int&   val, const Char *pSymbolName );
    95   Void  xReadFlag    ( UInt&  val, const Char *pSymbolName );
     92  Void  xReadCode    ( UInt   length, UInt& val, const TChar *pSymbolName );
     93  Void  xReadUvlc    ( UInt&  val, const TChar *pSymbolName );
     94  Void  xReadSvlc    ( Int&   val, const TChar *pSymbolName );
     95  Void  xReadFlag    ( UInt&  val, const TChar *pSymbolName );
    9696#else
    9797  Void  xReadCode    ( UInt   length, UInt& val );
    9898  Void  xReadUvlc    ( UInt&  val );
    … …  
    100100  Void  xReadFlag    ( UInt&  val );
    101101#endif
    102102#if ENC_DEC_TRACE
    103   Void  xReadCodeTr  (UInt  length, UInt& rValue, const Char *pSymbolName);
    104   Void  xReadUvlcTr  (              UInt& rValue, const Char *pSymbolName);
    105   Void  xReadSvlcTr  (               Int& rValue, const Char *pSymbolName);
    106   Void  xReadFlagTr  (              UInt& rValue, const Char *pSymbolName);
     103  Void  xReadCodeTr  (UInt  length, UInt& rValue, const TChar *pSymbolName);
     104  Void  xReadUvlcTr  (              UInt& rValue, const TChar *pSymbolName);
     105  Void  xReadSvlcTr  (               Int& rValue, const TChar *pSymbolName);
     106  Void  xReadFlagTr  (              UInt& rValue, const TChar *pSymbolName);
    107107#endif
    108108public:
    109109  Void  setBitstream ( TComInputBitstream* p )   { m_pcBitstream = p; }

  • source/Lib/TLibDecoder/TDecGop.cpp

     
    152152  }
    153153
    154154  pcPic->compressMotion();
    155   Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
     155  TChar c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
    156156  if (!pcSlice->isReferenced())
    157157  {
    158158    c += 32;
    … …  
    210210  /* calculate MD5sum for entire reconstructed picture */
    211211  TComPictureHash recon_digest;
    212212  Int numChar=0;
    213   const Char* hashType = "\0";
     213  const TChar* hashType = "\0";
    214214
    215215  if (pictureHashSEI)
    216216  {
    … …  
    243243  }
    244244
    245245  /* compare digest against received version */
    246   const Char* ok = "(unk)";
     246  const TChar* ok = "(unk)";
    247247  Bool mismatch = false;
    248248
    249249  if (pictureHashSEI)

  • source/Lib/TLibDecoder/TDecSbac.cpp

     
    859859
    860860  if (!pcCU->isIntra(uiAbsPartIdx) || (pcCU->getIntraDir( CHANNEL_TYPE_CHROMA, uiAbsPartIdx ) == DM_CHROMA_IDX))
    861861  {
    862     Char alpha  = 0;
     862    SChar alpha  = 0;
    863863    UInt symbol = 0;
    864864
    865865    DTRACE_CABAC_VL( g_nSymbolCounter++ )

  • source/Lib/TLibDecoder/TDecBinCoderCABAC.cpp

     
    168168
    169169  if (g_debugCounter >= debugCabacBinTargetLine)
    170170  {
    171     Char breakPointThis;
     171    UChar breakPointThis;
    172172    breakPointThis = 7;
    173173  }
    174174  if (g_debugCounter >= (debugCabacBinTargetLine + debugCabacBinWindow))

  • source/Lib/TLibDecoder/SyntaxElementParser.cpp

     
    4848
    4949#if ENC_DEC_TRACE
    5050
    51 Void  SyntaxElementParser::xReadCodeTr           (UInt length, UInt& rValue, const Char *pSymbolName)
     51Void  SyntaxElementParser::xReadCodeTr           (UInt length, UInt& rValue, const TChar *pSymbolName)
    5252{
    5353#if RExt__DECODER_DEBUG_BIT_STATISTICS
    5454  xReadCode (length, rValue, pSymbolName);
    … …  
    6767  fflush ( g_hTrace );
    6868}
    6969
    70 Void  SyntaxElementParser::xReadUvlcTr           (UInt& rValue, const Char *pSymbolName)
     70Void  SyntaxElementParser::xReadUvlcTr           (UInt& rValue, const TChar *pSymbolName)
    7171{
    7272#if RExt__DECODER_DEBUG_BIT_STATISTICS
    7373  xReadUvlc (rValue, pSymbolName);
    … …  
    7979  fflush ( g_hTrace );
    8080}
    8181
    82 Void  SyntaxElementParser::xReadSvlcTr           (Int& rValue, const Char *pSymbolName)
     82Void  SyntaxElementParser::xReadSvlcTr           (Int& rValue, const TChar *pSymbolName)
    8383{
    8484#if RExt__DECODER_DEBUG_BIT_STATISTICS
    8585  xReadSvlc (rValue, pSymbolName);
    … …  
    9191  fflush ( g_hTrace );
    9292}
    9393
    94 Void  SyntaxElementParser::xReadFlagTr           (UInt& rValue, const Char *pSymbolName)
     94Void  SyntaxElementParser::xReadFlagTr           (UInt& rValue, const TChar *pSymbolName)
    9595{
    9696#if RExt__DECODER_DEBUG_BIT_STATISTICS
    9797  xReadFlag (rValue, pSymbolName);
    … …  
    120120// Protected member functions
    121121// ====================================================================================================================
    122122#if RExt__DECODER_DEBUG_BIT_STATISTICS
    123 Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode, const Char *pSymbolName)
     123Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode, const TChar *pSymbolName)
    124124#else
    125125Void SyntaxElementParser::xReadCode (UInt uiLength, UInt& ruiCode)
    126126#endif
    … …  
    133133}
    134134
    135135#if RExt__DECODER_DEBUG_BIT_STATISTICS
    136 Void SyntaxElementParser::xReadUvlc( UInt& ruiVal, const Char *pSymbolName)
     136Void SyntaxElementParser::xReadUvlc( UInt& ruiVal, const TChar *pSymbolName)
    137137#else
    138138Void SyntaxElementParser::xReadUvlc( UInt& ruiVal)
    139139#endif
    … …  
    171171}
    172172
    173173#if RExt__DECODER_DEBUG_BIT_STATISTICS
    174 Void SyntaxElementParser::xReadSvlc( Int& riVal, const Char *pSymbolName)
     174Void SyntaxElementParser::xReadSvlc( Int& riVal, const TChar *pSymbolName)
    175175#else
    176176Void SyntaxElementParser::xReadSvlc( Int& riVal)
    177177#endif
    … …  
    209209}
    210210
    211211#if RExt__DECODER_DEBUG_BIT_STATISTICS
    212 Void SyntaxElementParser::xReadFlag (UInt& ruiCode, const Char *pSymbolName)
     212Void SyntaxElementParser::xReadFlag (UInt& ruiCode, const TChar *pSymbolName)
    213213#else
    214214Void SyntaxElementParser::xReadFlag (UInt& ruiCode)
    215215#endif