Changeset 1260 in SHVCSoftware for branches/SHM-dev/source/Lib/TLibCommon


Ignore:
Timestamp:
14 Jul 2015, 03:24:13 (10 years ago)
Author:
seregin
Message:

port rev 4257

Location:
branches/SHM-dev/source/Lib/TLibCommon
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev/source/Lib/TLibCommon/ContextModel3DBuffer.cpp

    r1259 r1260  
    6060
    6161/**
    62  * Initialize 3D buffer with respect to slicetype, QP and given initial probability table
     62 * Initialize 3D buffer with respect to slice type, QP and given initial probability table
    6363 *
    64  * \param  eSliceType      slice type
    65  * \param  iQp             input QP value
    66  * \param  psCtxModel      given probability table
     64 * \param  sliceType      slice type
     65 * \param  qp             input QP value
     66 * \param  ctxModel       given probability table
    6767 */
    6868Void ContextModel3DBuffer::initBuffer( SliceType sliceType, Int qp, UChar* ctxModel )

  • branches/SHM-dev/source/Lib/TLibCommon/NAL.h

    r1259 r1260  
    107107
    108108  /**
    109    * convert the OutputNALUnit #nalu# into EBSP format by writing out
     109   * convert the OutputNALUnit nalu into EBSP format by writing out
    110110   * the NALUnit header, then the rbsp_bytes including any
    111111   * emulation_prevention_three_byte symbols.

  • branches/SHM-dev/source/Lib/TLibCommon/TComBitStream.cpp

    r1259 r1260  
    215215
    216216/**
    217  * read #uiNumberOfBits# from bitstream without updating the bitstream
    218  * state, storing the result in #ruiBits#.
    219  *
    220  * If reading #uiNumberOfBits# would overrun the bitstream buffer,
    221  * the bitsream is effectively padded with sufficient zero-bits to
     217 * read uiNumberOfBits from bitstream without updating the bitstream
     218 * state, storing the result in ruiBits.
     219 *
     220 * If reading uiNumberOfBits would overrun the bitstream buffer,
     221 * the bitstream is effectively padded with sufficient zero-bits to
    222222 * avoid the overrun.
    223223 */
    … …  
    344344
    345345/**
    346  - extract substream from the current bitstream
    347  .
    348  \param  pcBitstream  bitstream which contains substreams
     346 Extract substream from the current bitstream.
     347
    349348 \param  uiNumBits    number of bits to transfer
    350349 */

  • branches/SHM-dev/source/Lib/TLibCommon/TComBitStream.h

    r1259 r1260  
    176176public:
    177177  /**
    178    * Create a new bitstream reader object that reads from #buf#.  Ownership
    179    * of #buf# remains with the callee, although the constructed object
    180    * will hold a reference to #buf#
     178   * Create a new bitstream reader object that reads from buf.  Ownership
     179   * of buf remains with the callee, although the constructed object
     180   * will hold a reference to buf
    181181   */
    182182  TComInputBitstream(std::vector<uint8_t>* buf);

  • branches/SHM-dev/source/Lib/TLibCommon/TComDataCU.cpp

    r1259 r1260  
    15331533*\param   uiAbsPartIdx    partition index
    15341534*\param   uiIntraDirPred  pointer to the array for MPM storage
    1535 *\param   compID          color component ID
     1535*\param   compID          colour component ID
    15361536*\param   piMode          it is set with MPM mode in case both MPM are equal. It is used to restrict RD search at encode side.
    15371537*\returns Number of MPM
    … …  
    17261726
    17271727/** Sets a coded block flag for all sub-partitions of a partition
    1728  * \param uiCbf The value of the coded block flag to be set
    1729  * \param eTType
     1728 * \param uiCbf          The value of the coded block flag to be set
     1729 * \param compID
    17301730 * \param uiAbsPartIdx
    17311731 * \param uiPartIdx
    17321732 * \param uiDepth
    1733  * \returns Void
    17341733 */
    17351734Void TComDataCU::setCbfSubParts ( UInt uiCbf, ComponentID compID, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth )

  • branches/SHM-dev/source/Lib/TLibCommon/TComInterpolationFilter.cpp

    r1259 r1260  
    288288 *
    289289 * \tparam N          Number of taps
     290 * \param  bitDepth   Bit depth
    290291 * \param  src        Pointer to source samples
    291292 * \param  srcStride  Stride of source samples
    … …  
    326327 * \brief Filter a block of Luma/Chroma samples (horizontal)
    327328 *
     329 * \param  compID     Chroma component ID
    328330 * \param  src        Pointer to source samples
    329331 * \param  srcStride  Stride of source samples
    … …  
    334336 * \param  frac       Fractional sample offset
    335337 * \param  isLast     Flag indicating whether it is the last filtering operation
     338 * \param  fmt        Chroma format
    336339 */
    337340Void TComInterpolationFilter::filterHor(const ComponentID compID, Pel *src, Int srcStride, Pel *dst, Int dstStride, Int width, Int height, Int frac, Bool isLast, const ChromaFormat fmt )
    … …  
    358361 * \brief Filter a block of Luma/Chroma samples (vertical)
    359362 *
     363 * \param  compID     Colour component ID
    360364 * \param  src        Pointer to source samples
    361365 * \param  srcStride  Stride of source samples
    … …  
    367371 * \param  isFirst    Flag indicating whether it is the first filtering operation
    368372 * \param  isLast     Flag indicating whether it is the last filtering operation
     373 * \param  fmt        Chroma format
    369374 */
    370375Void TComInterpolationFilter::filterVer(const ComponentID compID, Pel *src, Int srcStride, Pel *dst, Int dstStride, Int width, Int height, Int frac, Bool isFirst, Bool isLast, const ChromaFormat fmt )

  • branches/SHM-dev/source/Lib/TLibCommon/TComLoopFilter.cpp

    r1259 r1260  
    161161
    162162/**
    163  - Deblocking filter process in CU-based (the same function as conventional's)
    164  .
    165  \param Edge          the direction of the edge in block boundary (horizonta/vertical), which is added newly
     163 Deblocking filter process in CU-based (the same function as conventional's)
     164
     165 \param pcCU             Pointer to CTU/CU structure
     166 \param uiAbsZorderIdx   Position in CU
     167 \param uiDepth          Depth in CU
     168 \param edgeDir          the direction of the edge in block boundary (horizontal/vertical), which is added newly
    166169*/
    167170Void TComLoopFilter::xDeblockCU( TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, DeblockEdgeDir edgeDir )

  • branches/SHM-dev/source/Lib/TLibCommon/TComPattern.cpp

    r1259 r1260  
    7070// ====================================================================================================================
    7171
    72 /** \param  piTexture     pixel data
     72/**
     73 \param  piTexture     pixel data
    7374 \param  iRoiWidth     pattern width
    7475 \param  iRoiHeight    pattern height
    7576 \param  iStride       buffer stride
    76  \param  iOffsetLeft   neighbour offset (left)
    77  \param  iOffsetRight  neighbour offset (right)
    78  \param  iOffsetAbove  neighbour offset (above)
    79  \param  iOffsetBottom neighbour offset (bottom)
    8077 */
    8178Void TComPatternParam::setPatternParamPel ( Pel* piTexture,
    … …  
    524521}
    525522
    526 /** Get pointer to reference samples for intra prediction
    527  * \param uiDirMode   prediction mode index
    528  * \param log2BlkSize size of block (2 = 4x4, 3 = 8x8, 4 = 16x16, 5 = 32x32, 6 = 64x64)
    529  * \param piAdiBuf    pointer to unfiltered reference samples
    530  * \return            pointer to (possibly filtered) reference samples
    531  *
    532  * The prediction mode index is used to determine whether a smoothed reference sample buffer is returned.
    533  */
    534 
    535523Bool TComPrediction::filteringIntraReferenceSamples(const ComponentID compID, UInt uiDirMode, UInt uiTuChWidth, UInt uiTuChHeight, const ChromaFormat chFmt, const Bool intraReferenceSmoothingDisabled)
    536524{

  • branches/SHM-dev/source/Lib/TLibCommon/TComPrediction.cpp

    r1259 r1260  
    224224
    225225/** Function for deriving the simplified angular intra predictions.
    226  * \param pSrc pointer to reconstructed sample array
    227  * \param srcStride the stride of the reconstructed sample array
    228  * \param rpDst reference to pointer for the prediction sample array
    229  * \param dstStride the stride of the prediction sample array
    230  * \param width the width of the block
    231  * \param height the height of the block
    232  * \param dirMode the intra prediction mode index
    233  * \param blkAboveAvailable boolean indication if the block above is available
    234  * \param blkLeftAvailable boolean indication if the block to the left is available
     226 * \param bitDepth           bit depth
     227 * \param pSrc               pointer to reconstructed sample array
     228 * \param srcStride          the stride of the reconstructed sample array
     229 * \param pTrueDst           reference to pointer for the prediction sample array
     230 * \param dstStrideTrue      the stride of the prediction sample array
     231 * \param uiWidth            the width of the block
     232 * \param uiHeight           the height of the block
     233 * \param channelType        type of pel array (luma/chroma)
     234 * \param format             chroma format
     235 * \param dirMode            the intra prediction mode index
     236 * \param blkAboveAvailable  boolean indication if the block above is available
     237 * \param blkLeftAvailable   boolean indication if the block to the left is available
     238 * \param bEnableEdgeFilters indication whether to enable edge filters
    235239 *
    236240 * This function derives the prediction samples for the angular mode based on the prediction direction indicated by
    … …  
    491495}
    492496
    493 /** Function for checking identical motion.
    494  * \param TComDataCU* pcCU
    495  * \param UInt PartAddr
     497/** Check for identical motion in both motion vector direction of a bi-directional predicted CU
     498  * \returns true, if motion vectors and reference pictures match
    496499 */
    497500Bool TComPrediction::xCheckIdenticalMotion ( TComDataCU* pcCU, UInt PartAddr )
    … …  
    669672 * \brief Generate motion-compensated block
    670673 *
     674 * \param compID   Colour component ID
    671675 * \param cu       Pointer to current CU
    672676 * \param refPic   Pointer to reference picture
    … …  
    756760
    757761/** Function for deriving planar intra prediction.
    758  * \param pSrc pointer to reconstructed sample array
    759  * \param srcStride the stride of the reconstructed sample array
    760  * \param rpDst reference to pointer for the prediction sample array
    761  * \param dstStride the stride of the prediction sample array
    762  * \param width the width of the block
    763  * \param height the height of the block
     762 * \param pSrc        pointer to reconstructed sample array
     763 * \param srcStride   the stride of the reconstructed sample array
     764 * \param rpDst       reference to pointer for the prediction sample array
     765 * \param dstStride   the stride of the prediction sample array
     766 * \param width       the width of the block
     767 * \param height      the height of the block
     768 * \param channelType type of pel array (luma, chroma)
     769 * \param format      chroma format
    764770 *
    765771 * This function derives the prediction samples for planar mode (intra coding).
    … …  
    821827 * \param pSrc pointer to reconstructed sample array
    822828 * \param iSrcStride the stride of the reconstructed sample array
    823  * \param rpDst reference to pointer for the prediction sample array
     829 * \param pDst reference to pointer for the prediction sample array
    824830 * \param iDstStride the stride of the prediction sample array
    825831 * \param iWidth the width of the block
    826832 * \param iHeight the height of the block
     833 * \param channelType type of pel array (luma, chroma)
    827834 *
    828835 * This function performs filtering left and top edges of the prediction samples for DC mode (intra coding).

  • branches/SHM-dev/source/Lib/TLibCommon/TComSampleAdaptiveOffset.cpp

    r1259 r1260  
    649649/** PCM LF disable process.
    650650 * \param pcPic picture (TComPic) pointer
    651  * \returns Void
    652651 *
    653652 * \note Replace filtered sample values of PCM mode blocks with the transmitted and reconstructed ones.
    … …  
    660659/** Picture-level PCM restoration.
    661660 * \param pcPic picture (TComPic) pointer
    662  * \returns Void
    663661 */
    664662Void TComSampleAdaptiveOffset::xPCMRestoration(TComPic* pcPic)
    … …  
    678676
    679677/** PCM CU restoration.
    680  * \param pcCU pointer to current CU
    681  * \param uiAbsPartIdx part index
    682  * \param uiDepth CU depth
    683  * \returns Void
     678 * \param pcCU            pointer to current CU
     679 * \param uiAbsZorderIdx  part index
     680 * \param uiDepth         CU depth
    684681 */
    685682Void TComSampleAdaptiveOffset::xPCMCURestoration ( TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth )
    … …  
    720717
    721718/** PCM sample restoration.
    722  * \param pcCU pointer to current CU
    723  * \param uiAbsPartIdx part index
    724  * \param uiDepth CU depth
    725  * \param ttText texture component type
    726  * \returns Void
     719 * \param pcCU           pointer to current CU
     720 * \param uiAbsZorderIdx part index
     721 * \param uiDepth        CU depth
     722 * \param compID         texture component type
    727723 */
    728724Void TComSampleAdaptiveOffset::xPCMSampleRestoration (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, const ComponentID compID)

  • branches/SHM-dev/source/Lib/TLibCommon/TComSampleAdaptiveOffset.h

    r1259 r1260  
    8686  Void xPCMRestoration(TComPic* pcPic);
    8787  Void xPCMCURestoration ( TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth );
    88   Void xPCMSampleRestoration (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, ComponentID component);
     88  Void xPCMSampleRestoration (TComDataCU* pcCU, UInt uiAbsZorderIdx, UInt uiDepth, const ComponentID compID);
    8989protected:
    9090  UInt m_offsetStepLog2[MAX_NUM_COMPONENT]; //offset step

  • branches/SHM-dev/source/Lib/TLibCommon/TComSlice.cpp

    r1259 r1260  
    18211821}
    18221822
    1823 /** get AC and DC values for weighted pred
    1824  * \param *wp
    1825  * \returns Void
    1826  */
     1823//! get AC and DC values for weighted pred
    18271824Void  TComSlice::getWpAcDcParam(WPACDCParam *&wp)
    18281825{
    … …  
    18301827}
    18311828
    1832 /** init AC and DC values for weighted pred
    1833  * \returns Void
    1834  */
     1829//! init AC and DC values for weighted pred
    18351830Void  TComSlice::initWpAcDcParam()
    18361831{
    … …  
    18421837}
    18431838
    1844 /** get WP tables for weighted pred
    1845  * \param RefPicList
    1846  * \param iRefIdx
    1847  * \param *&WPScalingParam
    1848  * \returns Void
    1849  */
     1839//! get tables for weighted prediction
    18501840Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, WPScalingParam *&wp )
    18511841{
    … …  
    18541844}
    18551845
    1856 /** reset Default WP tables settings : no weight.
    1857  * \param WPScalingParam
    1858  * \returns Void
    1859  */
     1846//! reset Default WP tables settings : no weight.
    18601847Void  TComSlice::resetWpScaling()
    18611848{
    … …  
    18771864}
    18781865
    1879 /** init WP table
    1880  * \returns Void
    1881  */
     1866//! init WP table
    18821867Void  TComSlice::initWpScaling(const TComSPS *sps)
    18831868{
    … …  
    23972382}
    23982383
    2399 /** set the reference idc value at uiBufferNum entry to the value of iRefIdc
    2400  * \param uiBufferNum
    2401  * \param iRefIdc
    2402  * \returns Void
    2403  */
     2384//! set the reference idc value at uiBufferNum entry to the value of iRefIdc
    24042385Void TComReferencePictureSet::setRefIdc(Int bufferNum, Int refIdc)
    24052386{
    … …  
    24072388}
    24082389
    2409 /** get the reference idc value at uiBufferNum
    2410  * \param uiBufferNum
    2411  * \returns Int
    2412  */
     2390//! get the reference idc value at uiBufferNum
    24132391Int  TComReferencePictureSet::getRefIdc(Int bufferNum) const
    24142392{
    … …  
    25332511
    25342512/** get scaling matrix from RefMatrixID
    2535  * \param sizeId size index
    2536  * \param Index of input matrix
    2537  * \param Index of reference matrix
     2513 * \param sizeId    size index
     2514 * \param listId    index of input matrix
     2515 * \param refListId index of reference matrix
    25382516 */
    25392517Void TComScalingList::processRefMatrix( UInt sizeId, UInt listId , UInt refListId )
    … …  
    27712749/** process of default matrix
    27722750 * \param sizeId size index
    2773  * \param Index of input matrix
     2751 * \param listId index of input matrix
    27742752 */
    27752753Void TComScalingList::processDefaultMatrix(UInt sizeId, UInt listId)

  • branches/SHM-dev/source/Lib/TLibCommon/TComTrQuant.cpp

    r1259 r1260  
    392392 *  \param dst   output data (transform coefficients)
    393393 *  \param shift specifies right shift after 1D transform
     394 *  \param line
    394395 */
    395396Void partialButterfly4(TCoeff *src, TCoeff *dst, Int shift, Int line)
    … …  
    477478 *  \param dst   output data (residual)
    478479 *  \param shift specifies right shift after 1D transform
     480 *  \param line
     481 *  \param outputMinimum  minimum for clipping
     482 *  \param outputMaximum  maximum for clipping
    479483 */
    480484Void partialButterflyInverse4(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
    … …  
    507511 *  \param dst   output data (transform coefficients)
    508512 *  \param shift specifies right shift after 1D transform
     513 *  \param line
    509514 */
    510515Void partialButterfly8(TCoeff *src, TCoeff *dst, Int shift, Int line)
    … …  
    548553 *  \param dst   output data (residual)
    549554 *  \param shift specifies right shift after 1D transform
     555 *  \param line
     556 *  \param outputMinimum  minimum for clipping
     557 *  \param outputMaximum  maximum for clipping
    550558 */
    551559Void partialButterflyInverse8(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
    … …  
    589597 *  \param dst   output data (transform coefficients)
    590598 *  \param shift specifies right shift after 1D transform
     599 *  \param line
    591600 */
    592601Void partialButterfly16(TCoeff *src, TCoeff *dst, Int shift, Int line)
    … …  
    644653
    645654/** 16x16 inverse transform implemented using partial butterfly structure (1D)
    646  *  \param src   input data (transform coefficients)
    647  *  \param dst   output data (residual)
    648  *  \param shift specifies right shift after 1D transform
     655 *  \param src            input data (transform coefficients)
     656 *  \param dst            output data (residual)
     657 *  \param shift          specifies right shift after 1D transform
     658 *  \param line
     659 *  \param outputMinimum  minimum for clipping
     660 *  \param outputMaximum  maximum for clipping
    649661 */
    650662Void partialButterflyInverse16(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
    … …  
    701713 *  \param dst   output data (transform coefficients)
    702714 *  \param shift specifies right shift after 1D transform
     715 *  \param line
    703716 */
    704717Void partialButterfly32(TCoeff *src, TCoeff *dst, Int shift, Int line)
    … …  
    774787 *  \param dst   output data (residual)
    775788 *  \param shift specifies right shift after 1D transform
     789 *  \param line
     790 *  \param outputMinimum  minimum for clipping
     791 *  \param outputMaximum  maximum for clipping
    776792 */
    777793Void partialButterflyInverse32(TCoeff *src, TCoeff *dst, Int shift, Int line, const TCoeff outputMinimum, const TCoeff outputMaximum)
    … …  
    841857
    842858/** MxN forward transform (2D)
    843 *  \param block input data (residual)
    844 *  \param coeff output data (transform coefficients)
    845 *  \param iWidth input data (width of transform)
    846 *  \param iHeight input data (height of transform)
     859*  \param bitDepth          [in]  bit depth
     860*  \param block             [in]  residual block
     861*  \param coeff             [out] transform coefficients
     862*  \param iWidth            [in]  width of transform
     863*  \param iHeight           [in]  height of transform
     864*  \param useDST            [in]
     865*  \param maxTrDynamicRange [in]
     866
    847867*/
    848868Void xTrMxN(Int bitDepth, TCoeff *block, TCoeff *coeff, Int iWidth, Int iHeight, Bool useDST, const Int maxTrDynamicRange)
    … …  
    905925
    906926/** MxN inverse transform (2D)
    907 *  \param coeff input data (transform coefficients)
    908 *  \param block output data (residual)
    909 *  \param iWidth input data (width of transform)
    910 *  \param iHeight input data (height of transform)
     927*  \param bitDepth          [in]  bit depth
     928*  \param coeff             [in]  transform coefficients
     929*  \param block             [out] residual block
     930*  \param iWidth            [in]  width of transform
     931*  \param iHeight           [in]  height of transform
     932*  \param useDST            [in]
     933*  \param maxTrDynamicRange [in]
    911934*/
    912935Void xITrMxN(Int bitDepth, TCoeff *coeff, TCoeff *block, Int iWidth, Int iHeight, Bool useDST, const Int maxTrDynamicRange)
    … …  
    18321855
    18331856/** Wrapper function between HM interface and core NxN forward transform (2D)
     1857 *  \param compID colour component ID
     1858 *  \param useDST
    18341859 *  \param piBlkResi input data (residual)
     1860 *  \param uiStride stride of input residual data
    18351861 *  \param psCoeff output data (transform coefficients)
    1836  *  \param uiStride stride of input residual data
    1837  *  \param iSize transform size (iSize x iSize)
    1838  *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
     1862 *  \param iWidth transform width
     1863 *  \param iHeight transform height
    18391864 */
    18401865Void TComTrQuant::xT( const ComponentID compID, Bool useDST, Pel* piBlkResi, UInt uiStride, TCoeff* psCoeff, Int iWidth, Int iHeight )
    … …  
    18651890
    18661891/** Wrapper function between HM interface and core NxN inverse transform (2D)
     1892 *  \param compID colour component ID
     1893 *  \param useDST
    18671894 *  \param plCoef input data (transform coefficients)
    18681895 *  \param pResidual output data (residual)
    18691896 *  \param uiStride stride of input residual data
    1870  *  \param iSize transform size (iSize x iSize)
    1871  *  \param uiMode is Intra Prediction mode used in Mode-Dependent DCT/DST only
     1897 *  \param iWidth transform width
     1898 *  \param iHeight transform height
    18721899 */
    18731900Void TComTrQuant::xIT( const ComponentID compID, Bool useDST, TCoeff* plCoef, Pel* pResidual, UInt uiStride, Int iWidth, Int iHeight )
    … …  
    19071934/** Wrapper function between HM interface and core 4x4 transform skipping
    19081935 *  \param piBlkResi input data (residual)
     1936 *  \param uiStride stride of input residual data
    19091937 *  \param psCoeff output data (transform coefficients)
    1910  *  \param uiStride stride of input residual data
    1911  *  \param iSize transform size (iSize x iSize)
     1938 *  \param rTu reference to transform data
     1939 *  \param component colour component
    19121940 */
    19131941Void TComTrQuant::xTransformSkip( Pel* piBlkResi, UInt uiStride, TCoeff* psCoeff, TComTU &rTu, const ComponentID component )
    … …  
    19551983 *  \param pResidual output data (residual)
    19561984 *  \param uiStride stride of input residual data
    1957  *  \param iSize transform size (iSize x iSize)
     1985 *  \param rTu reference to transform data
     1986 *  \param component colour component ID
    19581987 */
    19591988Void TComTrQuant::xITransformSkip( TCoeff* plCoef, Pel* pResidual, UInt uiStride, TComTU &rTu, const ComponentID component )
    … …  
    19992028
    20002029/** RDOQ with CABAC
    2001  * \param pcCU pointer to coding unit structure
     2030 * \param rTu reference to transform data
    20022031 * \param plSrcCoeff pointer to input buffer
    20032032 * \param piDstCoeff reference to pointer to output buffer
    2004  * \param uiWidth block width
    2005  * \param uiHeight block height
     2033 * \param piArlDstCoeff
    20062034 * \param uiAbsSum reference to absolute sum of quantized transform coefficient
    2007  * \param eTType plane type / luminance or chrominance
    2008  * \param uiAbsPartIdx absolute partition index
    2009  * \returns Void
     2035 * \param compID colour component ID
     2036 * \param cQP reference to quantization parameters
     2037
    20102038 * Rate distortion optimized quantization for entropy
    20112039 * coding engines using probability models like CABAC
    … …  
    25582586 * \param uiCGPosX column of current coefficient group
    25592587 * \param uiCGPosY row of current coefficient group
    2560  * \param width width of the block
    2561  * \param height height of the block
     2588 * \param widthInGroups width of the block
     2589 * \param heightInGroups height of the block
    25622590 * \returns pattern for current coefficient group
    25632591 */
    … …  
    25902618/** Context derivation process of coeff_abs_significant_flag
    25912619 * \param patternSigCtx pattern for current coefficient group
    2592  * \param codingParameters coding parmeters for the TU (includes the scan)
     2620 * \param codingParameters coding parameters for the TU (includes the scan)
    25932621 * \param scanPosition current position in scan order
    25942622 * \param log2BlockWidth log2 width of the block
    25952623 * \param log2BlockHeight log2 height of the block
    2596  * \param ChannelType channel type (CHANNEL_TYPE_LUMA/CHROMA)
     2624 * \param chanType channel type (CHANNEL_TYPE_LUMA/CHROMA)
    25972625 * \returns ctxInc for current scan position
    25982626 */
    … …  
    27062734 * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
    27072735 * \param ui16AbsGoRice current Rice parameter for coeff_abs_level_minus3
     2736 * \param c1Idx
     2737 * \param c2Idx
    27082738 * \param iQBits quantization step size
    2709  * \param dTemp correction factor
     2739 * \param errorScale
    27102740 * \param bLast indicates if the coefficient is the last significant
     2741 * \param useLimitedPrefixLength
     2742 * \param channelType  texture channel type (luma/chroma)
    27112743 * \returns best quantized transform level for given scan position
    27122744 * This method calculates the best quantized transform level for a given scan position.
    … …  
    27752807 * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
    27762808 * \param ui16AbsGoRice Rice parameter for coeff_abs_level_minus3
     2809 * \param c1Idx
     2810 * \param c2Idx
     2811 * \param useLimitedPrefixLength
     2812 * \param channelType  texture channel type (luma/chroma)
    27772813 * \returns cost of given absolute transform level
    27782814 */
    … …  
    28622898 * \param uiPosX X coordinate of the last significant coefficient
    28632899 * \param uiPosY Y coordinate of the last significant coefficient
     2900 * \param component colour component ID
    28642901 * \returns cost of last significant coefficient
    28652902 */
    … …  
    28872924}
    28882925
    2889  /** Calculates the cost for specific absolute transform level
    2890  * \param uiAbsLevel scaled quantized level
    2891  * \param ui16CtxNumOne current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
    2892  * \param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
    2893  * \param ui16CtxBase current global offset for coeff_abs_level_greater1 and coeff_abs_level_greater2
    2894  * \returns cost of given absolute transform level
    2895  */
    28962926__inline Double TComTrQuant::xGetRateSigCoef  ( UShort                          uiSignificance,
    28972927                                                UShort                          ui16CtxNumSig ) const
    … …  
    29192949/** Context derivation process of coeff_abs_significant_flag
    29202950 * \param uiSigCoeffGroupFlag significance map of L1
    2921  * \param uiBlkX column of current scan position
    2922  * \param uiBlkY row of current scan position
    2923  * \param uiLog2BlkSize log2 value of block size
     2951 * \param uiCGPosX column of current scan position
     2952 * \param uiCGPosY row of current scan position
     2953 * \param widthInGroups width of the block
     2954 * \param heightInGroups height of the block
    29242955 * \returns ctxInc for current scan position
    29252956 */
    … …  
    29472978
    29482979/** set quantized matrix coefficient for encode
    2949  * \param scalingList quantaized matrix address
     2980 * \param scalingList quantized matrix address
     2981 * \param format      chroma format
    29502982 */
    29512983Void TComTrQuant::setScalingList(TComScalingList *scalingList, const ChromaFormat format)
    … …  
    29683000}
    29693001/** set quantized matrix coefficient for decode
    2970  * \param scalingList quantaized matrix address
     3002 * \param scalingList quantized matrix address
     3003 * \param format      chroma format
    29713004 */
    29723005Void TComTrQuant::setScalingListDec(const TComScalingList &scalingList, const ChromaFormat format)
    … …  
    29883021/** set error scale coefficients
    29893022 * \param list List ID
    2990  * \param uiSize Size
    2991  * \param uiQP Quantization parameter
     3023 * \param size Size
     3024 * \param qp  Quantization parameter
    29923025 */
    29933026Void TComTrQuant::setErrScaleCoeff(UInt list, UInt size, Int qp)
    … …  
    30163049
    30173050/** set quantized matrix coefficient for encode
    3018  * \param scalingList quantaized matrix address
     3051 * \param scalingList quantized matrix address
    30193052 * \param listId List index
    30203053 * \param sizeId size index
    3021  * \param uiQP Quantization parameter
     3054 * \param qp Quantization parameter
     3055 * \param format chroma format
    30223056 */
    30233057Void TComTrQuant::xSetScalingListEnc(TComScalingList *scalingList, UInt listId, UInt sizeId, Int qp, const ChromaFormat format)
    … …  
    30423076/** set quantized matrix coefficient for decode
    30433077 * \param scalingList quantaized matrix address
    3044  * \param list List index
    3045  * \param size size index
    3046  * \param uiQP Quantization parameter
     3078 * \param listId List index
     3079 * \param sizeId size index
     3080 * \param qp Quantization parameter
     3081 * \param format chroma format
    30473082 */
    30483083Void TComTrQuant::xSetScalingListDec(const TComScalingList &scalingList, UInt listId, UInt sizeId, Int qp, const ChromaFormat format)
    … …  
    30883123/** set flat matrix value to quantized coefficient
    30893124 * \param list List ID
    3090  * \param uiQP Quantization parameter
    3091  * \param uiSize Size
     3125 * \param size size index
     3126 * \param qp Quantization parameter
     3127 * \param format chroma format
    30923128 */
    30933129Void TComTrQuant::xsetFlatScalingList(UInt list, UInt size, Int qp, const ChromaFormat format)

  • branches/SHM-dev/source/Lib/TLibCommon/TComWeightPrediction.cpp

    r1259 r1260  
    6262
    6363
    64 /** weighted averaging for bi-pred
    65  * \param TComYuv* pcYuvSrc0
    66  * \param TComYuv* pcYuvSrc1
    67  * \param iPartUnitIdx
    68  * \param iWidth
    69  * \param iHeight
    70  * \param WPScalingParam *wp0
    71  * \param WPScalingParam *wp1
    72  * \param TComYuv* rpcYuvDst
    73  * \returns Void
    74  */
     64//! weighted averaging for bi-pred
    7565Void TComWeightPrediction::addWeightBi( const TComYuv              *pcYuvSrc0,
    7666                                        const TComYuv              *pcYuvSrc1,
    … …  
    137127
    138128
    139 /** weighted averaging for uni-pred
    140  * \param TComYuv* pcYuvSrc0
    141  * \param iPartUnitIdx
    142  * \param iWidth
    143  * \param iHeight
    144  * \param WPScalingParam *wp0
    145  * \param TComYuv* rpcYuvDst
    146  * \returns Void
    147  */
     129//! weighted averaging for uni-pred
    148130Void TComWeightPrediction::addWeightUni( const TComYuv        *const pcYuvSrc0,
    149131                                         const UInt                  iPartUnitIdx,
    … …  
    200182//  getWpScaling()
    201183//=======================================================
    202 /** derivation of wp tables
    203  * \param TComDataCU* pcCU
    204  * \param iRefIdx0
    205  * \param iRefIdx1
    206  * \param WPScalingParam *&wp0
    207  * \param WPScalingParam *&wp1
    208  * \param ibdi
    209  * \returns Void
    210  */
     184//! derivation of wp tables
    211185Void TComWeightPrediction::getWpScaling(       TComDataCU *const pcCU,
    212186                                         const Int               iRefIdx0,
    … …  
    287261
    288262
    289 /** weighted prediction for bi-pred
    290  * \param TComDataCU* pcCU
    291  * \param TComYuv* pcYuvSrc0
    292  * \param TComYuv* pcYuvSrc1
    293  * \param iRefIdx0
    294  * \param iRefIdx1
    295  * \param uiPartIdx
    296  * \param iWidth
    297  * \param iHeight
    298  * \param TComYuv* rpcYuvDst
    299  * \returns Void
    300  */
     263//! weighted prediction for bi-pred
    301264Void TComWeightPrediction::xWeightedPredictionBi(       TComDataCU *const pcCU,
    302265                                                  const TComYuv    *const pcYuvSrc0,
    … …  
    335298
    336299
    337 /** weighted prediction for uni-pred
    338  * \param TComDataCU* pcCU
    339  * \param TComYuv* pcYuvSrc
    340  * \param uiPartAddr
    341  * \param iWidth
    342  * \param iHeight
    343  * \param eRefPicList
    344  * \param TComYuv* pcYuvPred
    345  * \param iPartIdx
    346  * \param iRefIdx
    347  * \returns Void
    348  */
     300//! weighted prediction for uni-pred
    349301Void TComWeightPrediction::xWeightedPredictionUni(       TComDataCU *const pcCU,
    350302                                                   const TComYuv    *const pcYuvSrc,
Note: See TracChangeset for help on using the changeset viewer.