[5] | 1 | /* The copyright in this software is being made available under the BSD |
---|
| 2 | * License, included below. This software may be subject to other third party |
---|
| 3 | * and contributor rights, including patent rights, and no such rights are |
---|
[56] | 4 | * granted under this license. |
---|
[5] | 5 | * |
---|
[56] | 6 | * Copyright (c) 2010-2012, ITU/ISO/IEC |
---|
[5] | 7 | * All rights reserved. |
---|
| 8 | * |
---|
| 9 | * Redistribution and use in source and binary forms, with or without |
---|
| 10 | * modification, are permitted provided that the following conditions are met: |
---|
| 11 | * |
---|
| 12 | * * Redistributions of source code must retain the above copyright notice, |
---|
| 13 | * this list of conditions and the following disclaimer. |
---|
| 14 | * * Redistributions in binary form must reproduce the above copyright notice, |
---|
| 15 | * this list of conditions and the following disclaimer in the documentation |
---|
| 16 | * and/or other materials provided with the distribution. |
---|
[56] | 17 | * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may |
---|
[5] | 18 | * be used to endorse or promote products derived from this software without |
---|
| 19 | * specific prior written permission. |
---|
| 20 | * |
---|
| 21 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
---|
| 22 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
| 23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
| 24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS |
---|
| 25 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
---|
| 26 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
---|
| 27 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
---|
| 28 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
---|
| 29 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
---|
| 30 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
---|
| 31 | * THE POSSIBILITY OF SUCH DAMAGE. |
---|
| 32 | */ |
---|
[2] | 33 | |
---|
| 34 | /** \file TEncCavlc.cpp |
---|
| 35 | \brief CAVLC encoder class |
---|
| 36 | */ |
---|
| 37 | |
---|
[56] | 38 | #include "../TLibCommon/CommonDef.h" |
---|
[2] | 39 | #include "TEncCavlc.h" |
---|
| 40 | #include "SEIwrite.h" |
---|
| 41 | |
---|
[56] | 42 | //! \ingroup TLibEncoder |
---|
| 43 | //! \{ |
---|
[2] | 44 | |
---|
[56] | 45 | #if ENC_DEC_TRACE |
---|
| 46 | |
---|
| 47 | #define WRITE_CODE( value, length, name) xWriteCodeTr ( value, length, name ) |
---|
| 48 | #define WRITE_UVLC( value, name) xWriteUvlcTr ( value, name ) |
---|
| 49 | #define WRITE_SVLC( value, name) xWriteSvlcTr ( value, name ) |
---|
| 50 | #define WRITE_FLAG( value, name) xWriteFlagTr ( value, name ) |
---|
| 51 | |
---|
| 52 | Void xWriteUvlcTr ( UInt value, const Char *pSymbolName); |
---|
| 53 | Void xWriteSvlcTr ( Int value, const Char *pSymbolName); |
---|
| 54 | Void xWriteFlagTr ( UInt value, const Char *pSymbolName); |
---|
| 55 | |
---|
| 56 | Void xTraceSPSHeader (TComSPS *pSPS) |
---|
[2] | 57 | { |
---|
[56] | 58 | fprintf( g_hTrace, "=========== Sequence Parameter Set ID: %d ===========\n", pSPS->getSPSId() ); |
---|
| 59 | } |
---|
[2] | 60 | |
---|
[56] | 61 | Void xTracePPSHeader (TComPPS *pPPS) |
---|
| 62 | { |
---|
| 63 | fprintf( g_hTrace, "=========== Picture Parameter Set ID: %d ===========\n", pPPS->getPPSId() ); |
---|
[2] | 64 | } |
---|
| 65 | |
---|
[56] | 66 | Void xTraceAPSHeader (TComAPS *pAPS) |
---|
[2] | 67 | { |
---|
[56] | 68 | fprintf( g_hTrace, "=========== Adaptation Parameter Set ===========\n"); |
---|
[2] | 69 | } |
---|
| 70 | |
---|
[56] | 71 | Void xTraceSliceHeader (TComSlice *pSlice) |
---|
| 72 | { |
---|
| 73 | fprintf( g_hTrace, "=========== Slice ===========\n"); |
---|
| 74 | } |
---|
[2] | 75 | |
---|
| 76 | |
---|
[56] | 77 | Void TEncCavlc::xWriteCodeTr (UInt value, UInt length, const Char *pSymbolName) |
---|
[2] | 78 | { |
---|
[56] | 79 | xWriteCode (value,length); |
---|
| 80 | fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ ); |
---|
| 81 | fprintf( g_hTrace, "%-40s u(%d) : %d\n", pSymbolName, length, value ); |
---|
| 82 | } |
---|
[2] | 83 | |
---|
[56] | 84 | Void TEncCavlc::xWriteUvlcTr (UInt value, const Char *pSymbolName) |
---|
| 85 | { |
---|
| 86 | xWriteUvlc (value); |
---|
| 87 | fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ ); |
---|
| 88 | fprintf( g_hTrace, "%-40s u(v) : %d\n", pSymbolName, value ); |
---|
| 89 | } |
---|
[2] | 90 | |
---|
[56] | 91 | Void TEncCavlc::xWriteSvlcTr (Int value, const Char *pSymbolName) |
---|
| 92 | { |
---|
| 93 | xWriteSvlc(value); |
---|
| 94 | fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ ); |
---|
| 95 | fprintf( g_hTrace, "%-40s s(v) : %d\n", pSymbolName, value ); |
---|
| 96 | } |
---|
[2] | 97 | |
---|
[56] | 98 | Void TEncCavlc::xWriteFlagTr(UInt value, const Char *pSymbolName) |
---|
| 99 | { |
---|
| 100 | xWriteFlag(value); |
---|
| 101 | fprintf( g_hTrace, "%8lld ", g_nSymbolCounter++ ); |
---|
| 102 | fprintf( g_hTrace, "%-40s u(1) : %d\n", pSymbolName, value ); |
---|
| 103 | } |
---|
[2] | 104 | |
---|
| 105 | #else |
---|
| 106 | |
---|
[56] | 107 | #define WRITE_CODE( value, length, name) xWriteCode ( value, length ) |
---|
| 108 | #define WRITE_UVLC( value, name) xWriteUvlc ( value ) |
---|
| 109 | #define WRITE_SVLC( value, name) xWriteSvlc ( value ) |
---|
| 110 | #define WRITE_FLAG( value, name) xWriteFlag ( value ) |
---|
[2] | 111 | |
---|
| 112 | #endif |
---|
| 113 | |
---|
| 114 | |
---|
| 115 | |
---|
[56] | 116 | // ==================================================================================================================== |
---|
| 117 | // Constructor / destructor / create / destroy |
---|
| 118 | // ==================================================================================================================== |
---|
[2] | 119 | |
---|
[56] | 120 | TEncCavlc::TEncCavlc() |
---|
[2] | 121 | { |
---|
[56] | 122 | m_pcBitIf = NULL; |
---|
| 123 | m_uiCoeffCost = 0; |
---|
| 124 | m_bAlfCtrl = false; |
---|
| 125 | m_uiMaxAlfCtrlDepth = 0; |
---|
| 126 | |
---|
| 127 | m_iSliceGranularity = 0; |
---|
[2] | 128 | } |
---|
| 129 | |
---|
[56] | 130 | TEncCavlc::~TEncCavlc() |
---|
[2] | 131 | { |
---|
| 132 | } |
---|
| 133 | |
---|
[56] | 134 | |
---|
| 135 | // ==================================================================================================================== |
---|
| 136 | // Public member functions |
---|
| 137 | // ==================================================================================================================== |
---|
| 138 | |
---|
| 139 | Void TEncCavlc::resetEntropy() |
---|
[2] | 140 | { |
---|
| 141 | } |
---|
| 142 | |
---|
| 143 | /** |
---|
[56] | 144 | * marshall the SEI message sei. |
---|
[2] | 145 | */ |
---|
| 146 | void TEncCavlc::codeSEI(const SEI& sei) |
---|
| 147 | { |
---|
| 148 | writeSEImessage(*m_pcBitIf, sei); |
---|
| 149 | } |
---|
| 150 | |
---|
[56] | 151 | Void TEncCavlc::codeAPSInitInfo(TComAPS* pcAPS) |
---|
[2] | 152 | { |
---|
[56] | 153 | |
---|
| 154 | #if ENC_DEC_TRACE |
---|
| 155 | xTraceAPSHeader(pcAPS); |
---|
[42] | 156 | #endif |
---|
[56] | 157 | //APS ID |
---|
| 158 | WRITE_UVLC( pcAPS->getAPSID(), "aps_id" ); |
---|
[2] | 159 | |
---|
[56] | 160 | WRITE_FLAG( pcAPS->getScalingListEnabled()?1:0, "aps_scaling_list_data_present_flag"); |
---|
| 161 | //DF flag |
---|
| 162 | WRITE_FLAG(pcAPS->getLoopFilterOffsetInAPS()?1:0, "aps_deblocking_filter_flag"); |
---|
[2] | 163 | } |
---|
[56] | 164 | Void TEncCavlc::codeAPSAlflag(UInt uiCode) |
---|
| 165 | { |
---|
| 166 | WRITE_FLAG(uiCode, "aps_adaptive_loop_filter_flag"); |
---|
| 167 | } |
---|
[2] | 168 | |
---|
[56] | 169 | Void TEncCavlc::codeDFFlag(UInt uiCode, const Char *pSymbolName) |
---|
[42] | 170 | { |
---|
[56] | 171 | WRITE_FLAG(uiCode, pSymbolName); |
---|
[42] | 172 | } |
---|
[56] | 173 | Void TEncCavlc::codeDFSvlc(Int iCode, const Char *pSymbolName) |
---|
[2] | 174 | { |
---|
[56] | 175 | WRITE_SVLC(iCode, pSymbolName); |
---|
[2] | 176 | } |
---|
| 177 | |
---|
[56] | 178 | Void TEncCavlc::codeShortTermRefPicSet( TComSPS* pcSPS, TComReferencePictureSet* rps ) |
---|
| 179 | { |
---|
| 180 | #if PRINT_RPS_INFO |
---|
| 181 | int lastBits = getNumberOfWrittenBits(); |
---|
[2] | 182 | #endif |
---|
[56] | 183 | WRITE_FLAG( rps->getInterRPSPrediction(), "inter_ref_pic_set_prediction_flag" ); // inter_RPS_prediction_flag |
---|
| 184 | if (rps->getInterRPSPrediction()) |
---|
| 185 | { |
---|
| 186 | Int deltaRPS = rps->getDeltaRPS(); |
---|
| 187 | WRITE_UVLC( rps->getDeltaRIdxMinus1(), "delta_idx_minus1" ); // delta index of the Reference Picture Set used for prediction minus 1 |
---|
| 188 | WRITE_CODE( (deltaRPS >=0 ? 0: 1), 1, "delta_rps_sign" ); //delta_rps_sign |
---|
| 189 | WRITE_UVLC( abs(deltaRPS) - 1, "abs_delta_rps_minus1"); // absolute delta RPS minus 1 |
---|
[2] | 190 | |
---|
[56] | 191 | for(Int j=0; j < rps->getNumRefIdc(); j++) |
---|
| 192 | { |
---|
| 193 | Int refIdc = rps->getRefIdc(j); |
---|
| 194 | WRITE_CODE( (refIdc==1? 1: 0), 1, "used_by_curr_pic_flag" ); //first bit is "1" if Idc is 1 |
---|
| 195 | if (refIdc != 1) |
---|
| 196 | { |
---|
| 197 | WRITE_CODE( refIdc>>1, 1, "use_delta_flag" ); //second bit is "1" if Idc is 2, "0" otherwise. |
---|
| 198 | } |
---|
| 199 | } |
---|
[2] | 200 | } |
---|
[56] | 201 | else |
---|
[2] | 202 | { |
---|
[56] | 203 | WRITE_UVLC( rps->getNumberOfNegativePictures(), "num_negative_pics" ); |
---|
| 204 | WRITE_UVLC( rps->getNumberOfPositivePictures(), "num_positive_pics" ); |
---|
| 205 | Int prev = 0; |
---|
| 206 | for(Int j=0 ; j < rps->getNumberOfNegativePictures(); j++) |
---|
[2] | 207 | { |
---|
[56] | 208 | WRITE_UVLC( prev-rps->getDeltaPOC(j)-1, "delta_poc_s0_minus1" ); |
---|
| 209 | prev = rps->getDeltaPOC(j); |
---|
| 210 | WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s0_flag"); |
---|
[2] | 211 | } |
---|
[56] | 212 | prev = 0; |
---|
| 213 | for(Int j=rps->getNumberOfNegativePictures(); j < rps->getNumberOfNegativePictures()+rps->getNumberOfPositivePictures(); j++) |
---|
[2] | 214 | { |
---|
[56] | 215 | WRITE_UVLC( rps->getDeltaPOC(j)-prev-1, "delta_poc_s1_minus1" ); |
---|
| 216 | prev = rps->getDeltaPOC(j); |
---|
| 217 | WRITE_FLAG( rps->getUsed(j), "used_by_curr_pic_s1_flag" ); |
---|
[2] | 218 | } |
---|
| 219 | } |
---|
[56] | 220 | |
---|
| 221 | #if PRINT_RPS_INFO |
---|
| 222 | printf("irps=%d (%2d bits) ", rps->getInterRPSPrediction(), getNumberOfWrittenBits() - lastBits); |
---|
| 223 | rps->printDeltaPOC(); |
---|
| 224 | #endif |
---|
[2] | 225 | } |
---|
| 226 | |
---|
[56] | 227 | |
---|
| 228 | Void TEncCavlc::codePPS( TComPPS* pcPPS ) |
---|
[2] | 229 | { |
---|
[56] | 230 | #if ENC_DEC_TRACE |
---|
| 231 | xTracePPSHeader (pcPPS); |
---|
[42] | 232 | #endif |
---|
[56] | 233 | |
---|
| 234 | WRITE_UVLC( pcPPS->getPPSId(), "pic_parameter_set_id" ); |
---|
| 235 | WRITE_UVLC( pcPPS->getSPSId(), "seq_parameter_set_id" ); |
---|
[2] | 236 | |
---|
[56] | 237 | WRITE_FLAG( pcPPS->getSignHideFlag(), "sign_data_hiding_flag" ); |
---|
| 238 | if( pcPPS->getSignHideFlag() ) |
---|
[2] | 239 | { |
---|
[56] | 240 | WRITE_CODE(pcPPS->getTSIG(), 4, "sign_hiding_threshold"); |
---|
[2] | 241 | } |
---|
[56] | 242 | #if CABAC_INIT_FLAG |
---|
| 243 | WRITE_FLAG( pcPPS->getCabacInitPresentFlag() ? 1 : 0, "cabac_init_present_flag" ); |
---|
| 244 | #endif |
---|
| 245 | // entropy_coding_mode_flag |
---|
| 246 | // We code the entropy_coding_mode_flag, it's needed for tests. |
---|
| 247 | WRITE_FLAG( pcPPS->getEntropyCodingMode() ? 1 : 0, "entropy_coding_mode_flag" ); |
---|
| 248 | if (pcPPS->getEntropyCodingMode()) |
---|
[2] | 249 | { |
---|
| 250 | } |
---|
[56] | 251 | // num_ref_idx_l0_default_active_minus1 |
---|
| 252 | // num_ref_idx_l1_default_active_minus1 |
---|
| 253 | WRITE_SVLC( pcPPS->getPicInitQPMinus26(), "pic_init_qp_minus26"); |
---|
| 254 | WRITE_FLAG( pcPPS->getConstrainedIntraPred() ? 1 : 0, "constrained_intra_pred_flag" ); |
---|
| 255 | WRITE_FLAG( pcPPS->getEnableTMVPFlag() ? 1 : 0, "enable_temporal_mvp_flag" ); |
---|
| 256 | WRITE_CODE( pcPPS->getSliceGranularity(), 2, "slice_granularity"); |
---|
| 257 | WRITE_UVLC( pcPPS->getMaxCuDQPDepth() + pcPPS->getUseDQP(), "max_cu_qp_delta_depth" ); |
---|
[2] | 258 | |
---|
[56] | 259 | WRITE_SVLC( pcPPS->getChromaQpOffset(), "chroma_qp_offset" ); |
---|
| 260 | WRITE_SVLC( pcPPS->getChromaQpOffset2nd(), "chroma_qp_offset_2nd" ); |
---|
[2] | 261 | |
---|
[56] | 262 | WRITE_FLAG( pcPPS->getUseWP() ? 1 : 0, "weighted_pred_flag" ); // Use of Weighting Prediction (P_SLICE) |
---|
| 263 | WRITE_CODE( pcPPS->getWPBiPredIdc(), 2, "weighted_bipred_idc" ); // Use of Weighting Bi-Prediction (B_SLICE) |
---|
| 264 | WRITE_FLAG( pcPPS->getOutputFlagPresentFlag() ? 1 : 0, "output_flag_present_flag" ); |
---|
| 265 | if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==1) |
---|
| 266 | { |
---|
| 267 | WRITE_FLAG( pcPPS->getColumnRowInfoPresent(), "tile_info_present_flag" ); |
---|
| 268 | WRITE_FLAG( pcPPS->getTileBehaviorControlPresentFlag(), "tile_control_present_flag"); |
---|
| 269 | if( pcPPS->getColumnRowInfoPresent() == 1 ) |
---|
[2] | 270 | { |
---|
[56] | 271 | WRITE_UVLC( pcPPS->getNumColumnsMinus1(), "num_tile_columns_minus1" ); |
---|
| 272 | WRITE_UVLC( pcPPS->getNumRowsMinus1(), "num_tile_rows_minus1" ); |
---|
| 273 | WRITE_FLAG( pcPPS->getUniformSpacingIdr(), "uniform_spacing_flag" ); |
---|
| 274 | if( pcPPS->getUniformSpacingIdr() == 0 ) |
---|
[2] | 275 | { |
---|
[56] | 276 | for(UInt i=0; i<pcPPS->getNumColumnsMinus1(); i++) |
---|
[2] | 277 | { |
---|
[56] | 278 | WRITE_UVLC( pcPPS->getColumnWidth(i), "column_width" ); |
---|
[2] | 279 | } |
---|
[56] | 280 | for(UInt i=0; i<pcPPS->getNumRowsMinus1(); i++) |
---|
[2] | 281 | { |
---|
[56] | 282 | WRITE_UVLC( pcPPS->getRowHeight(i), "row_height" ); |
---|
[2] | 283 | } |
---|
| 284 | } |
---|
[56] | 285 | } |
---|
[2] | 286 | |
---|
[56] | 287 | if(pcPPS->getTileBehaviorControlPresentFlag() == 1) |
---|
[2] | 288 | { |
---|
[56] | 289 | Int iNumColTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumColumnsMinus1()); |
---|
| 290 | Int iNumRowTilesMinus1 = (pcPPS->getColumnRowInfoPresent() == 1)?(pcPPS->getNumColumnsMinus1()):(pcPPS->getSPS()->getNumRowsMinus1()); |
---|
[2] | 291 | |
---|
[56] | 292 | if(iNumColTilesMinus1 !=0 || iNumRowTilesMinus1 !=0) |
---|
[2] | 293 | { |
---|
[56] | 294 | WRITE_FLAG( pcPPS->getLFCrossTileBoundaryFlag()?1 : 0, "loop_filter_across_tile_flag"); |
---|
[2] | 295 | } |
---|
| 296 | } |
---|
| 297 | } |
---|
[56] | 298 | else if(pcPPS->getSPS()->getTilesOrEntropyCodingSyncIdc()==2) |
---|
[2] | 299 | { |
---|
[56] | 300 | WRITE_UVLC( pcPPS->getNumSubstreams()-1, "num_substreams_minus1" ); |
---|
[2] | 301 | } |
---|
| 302 | |
---|
[56] | 303 | WRITE_FLAG( pcPPS->getDeblockingFilterControlPresent()?1 : 0, "deblocking_filter_control_present_flag"); |
---|
| 304 | WRITE_UVLC( pcPPS->getLog2ParallelMergeLevelMinus2(), "log2_parallel_merge_level_minus2"); |
---|
| 305 | WRITE_FLAG( 0, "pps_extension_flag" ); |
---|
[2] | 306 | } |
---|
| 307 | |
---|
[210] | 308 | #if QC_MVHEVC_B0046 |
---|
| 309 | Void TEncCavlc::codeVPS( TComVPS* pcVPS ) |
---|
| 310 | { |
---|
| 311 | WRITE_CODE( pcVPS->getVPSId(), 4, "video_parameter_set_id" ); |
---|
| 312 | WRITE_FLAG( pcVPS->getTemporalNestingFlag() -1, "temporal_id_nesting_flag" ); |
---|
| 313 | WRITE_CODE( 0, 2, "vps_reserved_zero_2bits" ); |
---|
| 314 | WRITE_CODE( pcVPS->getMaxLayers() - 1, 6, "vps_max_layers_minus1" ); |
---|
| 315 | WRITE_CODE( pcVPS->getMaxTLayers() - 1, 3, "vps_max_sub_layers_minus1" ); |
---|
| 316 | //to be determined |
---|
| 317 | //profile_tier_level( 1, vps_max_sub_layers_minus1 ); |
---|
| 318 | //to be modified |
---|
| 319 | WRITE_CODE( 0, 12, "vps_extension_offset" ); |
---|
| 320 | for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++) |
---|
| 321 | { |
---|
| 322 | WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i), "max_dec_pic_buffering[i]" ); |
---|
| 323 | WRITE_UVLC( pcVPS->getNumReorderPics(i), "num_reorder_pics[i]" ); |
---|
| 324 | WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "max_latency_increase[i]" ); |
---|
| 325 | } |
---|
| 326 | //!!!waste one bit: 3-view, 3; 2-view or more views: 1 |
---|
| 327 | WRITE_UVLC(pcVPS->getNumHRDParameters(), "vps_num_hrd_parameters" ); |
---|
| 328 | assert(pcVPS->getNumHRDParameters()==0); |
---|
| 329 | for ( UInt i = 0; i < pcVPS->getNumHRDParameters(); i ++) |
---|
| 330 | { |
---|
| 331 | // if( i > 0 ) |
---|
| 332 | //{ |
---|
| 333 | // WRITE_UVLC (0, "op_num_layer_id_values_minus1[ opIdx ]"); |
---|
| 334 | // for( i = 0; i <= op_num_layer_id_values_minus1[ opIdx ]; i++ ) |
---|
| 335 | // WRITE_CODE(0, 6, "op_layer_id[ opIdx ][ i ]"); |
---|
| 336 | //} |
---|
| 337 | //hrd_parameters( i = = 0, vps_max_sub_layers_minus1 ); |
---|
| 338 | } |
---|
| 339 | WRITE_CODE( 1, 1, "bit_equal_to_one" ); |
---|
| 340 | //btye aligned |
---|
| 341 | m_pcBitIf->writeAlignOne(); |
---|
| 342 | |
---|
| 343 | if(pcVPS->getMaxLayers() == 3) |
---|
| 344 | pcVPS->setNumAddiLayerOperationPoints (pcVPS->getMaxLayers()); //may be configured |
---|
| 345 | else |
---|
| 346 | pcVPS->setNumAddiLayerOperationPoints (1); |
---|
| 347 | pcVPS->setNumAddiProLevelSets (1); |
---|
| 348 | WRITE_CODE( pcVPS->getNumAddiLayerOperationPoints(), 8, "num_additional_layer_operation_points" ); |
---|
| 349 | WRITE_CODE( pcVPS->getNumAddiProLevelSets(), 8, "num_additional_profile_level_sets" ); |
---|
| 350 | for(UInt i=0; i <= pcVPS->getMaxLayers()-1; i++) |
---|
| 351 | { |
---|
| 352 | WRITE_CODE( 0, 4, "num_types_zero_4bits[i]" ); |
---|
| 353 | WRITE_CODE( 0, 4, "type_zero_4bits[i]" ); |
---|
| 354 | WRITE_CODE( pcVPS->getViewId(i), 8, "view_id[i]" ); |
---|
| 355 | if(i) |
---|
| 356 | { |
---|
| 357 | WRITE_CODE( pcVPS->getNumDirectRefLayer(i), 6, "num_direct_ref_layers[ i ]" ); |
---|
| 358 | for (UInt j = 0; j< pcVPS->getNumDirectRefLayer(i); j++) |
---|
| 359 | { |
---|
| 360 | WRITE_CODE( pcVPS->getDirectRefLayerId (i, j), 6, "ref_layer_id[i][j]" ); |
---|
| 361 | } |
---|
| 362 | } |
---|
| 363 | } |
---|
| 364 | for( UInt i=1; i<=pcVPS->getNumAddiProLevelSets(); i++) |
---|
| 365 | { |
---|
| 366 | //profile_tier_level |
---|
| 367 | } |
---|
| 368 | for( UInt i=1; i<= pcVPS->getNumAddiLayerOperationPoints(); i++) |
---|
| 369 | { |
---|
| 370 | if(pcVPS->getMaxLayers() == 3) |
---|
| 371 | { |
---|
| 372 | pcVPS->setNumOpLayerIdMinus1((i < pcVPS->getNumAddiLayerOperationPoints() ? 1: 2), (i-1)); |
---|
| 373 | } |
---|
| 374 | else if( i==1 ) |
---|
| 375 | { |
---|
| 376 | assert(pcVPS->getNumAddiLayerOperationPoints()==1); |
---|
| 377 | pcVPS->setNumOpLayerIdMinus1(pcVPS->getMaxLayers()-1, (i-1)); |
---|
| 378 | } |
---|
| 379 | WRITE_UVLC( pcVPS->getNumOpLayerIdMinus1(i-1), "op_num_layer_id_values_minus1[ opIdx ]" ); |
---|
| 380 | for(UInt j = 0; j <= pcVPS->getNumOpLayerIdMinus1(i-1); j++ ) |
---|
| 381 | { |
---|
| 382 | if(pcVPS->getMaxLayers() == 3 && i== 2 && j==1) |
---|
| 383 | pcVPS->setNumOpLayerId (2, i-1, j); |
---|
| 384 | else |
---|
| 385 | pcVPS->setNumOpLayerId (j, i-1, j); |
---|
| 386 | WRITE_UVLC( pcVPS->getNumOpLayerId(i-1, j), "op_layer_id[ opIdx ][ i ]" ); |
---|
| 387 | } |
---|
| 388 | if (pcVPS->getNumAddiProLevelSets()) |
---|
| 389 | { |
---|
| 390 | //profile_level_idx[ i ] |
---|
| 391 | } |
---|
| 392 | } |
---|
| 393 | return; |
---|
| 394 | } |
---|
| 395 | #else |
---|
[77] | 396 | #if VIDYO_VPS_INTEGRATION |
---|
| 397 | Void TEncCavlc::codeVPS( TComVPS* pcVPS ) |
---|
| 398 | { |
---|
[100] | 399 | WRITE_CODE( pcVPS->getMaxTLayers() - 1, 3, "max_temporal_layers_minus1" ); |
---|
[77] | 400 | WRITE_CODE( pcVPS->getMaxLayers() - 1, 5, "max_layers_minus1" ); |
---|
| 401 | WRITE_FLAG( pcVPS->getTemporalNestingFlag() - 1, "temporal_id_nesting_flag" ); |
---|
| 402 | WRITE_UVLC( pcVPS->getVPSId(), "video_parameter_set_id" ); |
---|
| 403 | for(UInt i=0; i <= pcVPS->getMaxTLayers()-1; i++) |
---|
| 404 | { |
---|
| 405 | WRITE_UVLC( pcVPS->getMaxDecPicBuffering(i), "max_dec_pic_buffering[i]" ); |
---|
| 406 | WRITE_UVLC( pcVPS->getNumReorderPics(i), "num_reorder_pics[i]" ); |
---|
| 407 | WRITE_UVLC( pcVPS->getMaxLatencyIncrease(i), "max_latency_increase[i]" ); |
---|
| 408 | } |
---|
| 409 | |
---|
| 410 | WRITE_CODE( 1, 1, "bit_equal_to_one" ); |
---|
| 411 | |
---|
| 412 | if( pcVPS->getMaxLayers() - 1 > 0 ) |
---|
| 413 | { |
---|
| 414 | WRITE_UVLC( pcVPS->getExtensionType(), "extension_type" ); |
---|
| 415 | |
---|
| 416 | for(UInt i=1; i <= pcVPS->getMaxLayers()-1; i++) |
---|
| 417 | { |
---|
| 418 | WRITE_FLAG( pcVPS->getDependentFlag(i), "dependent_flag[i]" ); |
---|
| 419 | if( pcVPS->getDependentFlag(i) ) |
---|
| 420 | { |
---|
| 421 | WRITE_UVLC( i - pcVPS->getDependentLayer(i) - 1, "delta_reference_layer_id_minus1[i]" ); |
---|
| 422 | if( pcVPS->getExtensionType() == VPS_EXTENSION_TYPE_MULTI_VIEW ) |
---|
| 423 | { |
---|
| 424 | WRITE_UVLC( pcVPS->getViewId(i), "view_id[i]" ); |
---|
| 425 | WRITE_FLAG( pcVPS->getDepthFlag(i), "depth_flag[i]" ); |
---|
| 426 | WRITE_SVLC( pcVPS->getViewOrderIdx(i), "view_order_idx[i]" ); |
---|
| 427 | } |
---|
| 428 | |
---|
| 429 | } |
---|
| 430 | } |
---|
[296] | 431 | #if INTER_VIEW_VECTOR_SCALING_C0115 |
---|
| 432 | WRITE_FLAG( pcVPS->getIVScalingFlag(), "inter_view_vector_scaling_flag" ); |
---|
| 433 | #endif |
---|
[77] | 434 | } |
---|
| 435 | |
---|
| 436 | WRITE_FLAG( 0, "vps_extension_flag" ); |
---|
| 437 | |
---|
| 438 | //future extensions here.. |
---|
| 439 | |
---|
| 440 | return; |
---|
| 441 | } |
---|
| 442 | #endif |
---|
[210] | 443 | #endif |
---|
[332] | 444 | #if HHI_MPI || H3D_QTL |
---|
[56] | 445 | Void TEncCavlc::codeSPS( TComSPS* pcSPS, Bool bIsDepth ) |
---|
[2] | 446 | #else |
---|
[56] | 447 | Void TEncCavlc::codeSPS( TComSPS* pcSPS ) |
---|
[2] | 448 | #endif |
---|
[56] | 449 | { |
---|
| 450 | #if ENC_DEC_TRACE |
---|
| 451 | xTraceSPSHeader (pcSPS); |
---|
[2] | 452 | #endif |
---|
[56] | 453 | WRITE_CODE( pcSPS->getProfileIdc (), 8, "profile_idc" ); |
---|
| 454 | WRITE_CODE( 0, 8, "reserved_zero_8bits" ); |
---|
| 455 | WRITE_CODE( pcSPS->getLevelIdc (), 8, "level_idc" ); |
---|
| 456 | WRITE_UVLC( pcSPS->getSPSId (), "seq_parameter_set_id" ); |
---|
[77] | 457 | #if VIDYO_VPS_INTEGRATION |
---|
| 458 | WRITE_UVLC( pcSPS->getVPSId (), "video_parameter_set_id" ); |
---|
| 459 | #endif |
---|
[56] | 460 | WRITE_UVLC( pcSPS->getChromaFormatIdc (), "chroma_format_idc" ); |
---|
| 461 | WRITE_CODE( pcSPS->getMaxTLayers() - 1, 3, "max_temporal_layers_minus1" ); |
---|
| 462 | WRITE_UVLC( pcSPS->getPicWidthInLumaSamples (), "pic_width_in_luma_samples" ); |
---|
| 463 | WRITE_UVLC( pcSPS->getPicHeightInLumaSamples(), "pic_height_in_luma_samples" ); |
---|
| 464 | WRITE_FLAG( pcSPS->getPicCroppingFlag(), "pic_cropping_flag" ); |
---|
| 465 | if (pcSPS->getPicCroppingFlag()) |
---|
[2] | 466 | { |
---|
[56] | 467 | WRITE_UVLC( pcSPS->getPicCropLeftOffset(), "pic_crop_left_offset" ); |
---|
| 468 | WRITE_UVLC( pcSPS->getPicCropRightOffset(), "pic_crop_right_offset" ); |
---|
| 469 | WRITE_UVLC( pcSPS->getPicCropTopOffset(), "pic_crop_top_offset" ); |
---|
| 470 | WRITE_UVLC( pcSPS->getPicCropBottomOffset(), "pic_crop_bottom_offset" ); |
---|
[2] | 471 | } |
---|
| 472 | |
---|
[56] | 473 | #if FULL_NBIT |
---|
| 474 | WRITE_UVLC( pcSPS->getBitDepth() - 8, "bit_depth_luma_minus8" ); |
---|
[2] | 475 | #else |
---|
[56] | 476 | WRITE_UVLC( pcSPS->getBitIncrement(), "bit_depth_luma_minus8" ); |
---|
[2] | 477 | #endif |
---|
[56] | 478 | #if FULL_NBIT |
---|
| 479 | WRITE_UVLC( pcSPS->getBitDepth() - 8, "bit_depth_chroma_minus8" ); |
---|
| 480 | #else |
---|
| 481 | WRITE_UVLC( pcSPS->getBitIncrement(), "bit_depth_chroma_minus8" ); |
---|
[2] | 482 | #endif |
---|
| 483 | |
---|
[56] | 484 | WRITE_FLAG( pcSPS->getUsePCM() ? 1 : 0, "pcm_enabled_flag"); |
---|
[2] | 485 | |
---|
[56] | 486 | if( pcSPS->getUsePCM() ) |
---|
[2] | 487 | { |
---|
[56] | 488 | WRITE_CODE( pcSPS->getPCMBitDepthLuma() - 1, 4, "pcm_bit_depth_luma_minus1" ); |
---|
| 489 | WRITE_CODE( pcSPS->getPCMBitDepthChroma() - 1, 4, "pcm_bit_depth_chroma_minus1" ); |
---|
[2] | 490 | } |
---|
[56] | 491 | |
---|
| 492 | #if LOSSLESS_CODING |
---|
| 493 | WRITE_FLAG( (pcSPS->getUseLossless ()) ? 1 : 0, "qpprime_y_zero_transquant_bypass_flag" ); |
---|
[2] | 494 | #endif |
---|
[56] | 495 | |
---|
| 496 | WRITE_UVLC( pcSPS->getBitsForPOC()-4, "log2_max_pic_order_cnt_lsb_minus4" ); |
---|
| 497 | for(UInt i=0; i <= pcSPS->getMaxTLayers()-1; i++) |
---|
[2] | 498 | { |
---|
[56] | 499 | WRITE_UVLC( pcSPS->getMaxDecPicBuffering(i), "max_dec_pic_buffering[i]" ); |
---|
| 500 | WRITE_UVLC( pcSPS->getNumReorderPics(i), "num_reorder_pics[i]" ); |
---|
| 501 | WRITE_UVLC( pcSPS->getMaxLatencyIncrease(i), "max_latency_increase[i]" ); |
---|
[2] | 502 | } |
---|
[56] | 503 | assert( pcSPS->getMaxCUWidth() == pcSPS->getMaxCUHeight() ); |
---|
| 504 | |
---|
| 505 | UInt MinCUSize = pcSPS->getMaxCUWidth() >> ( pcSPS->getMaxCUDepth()-g_uiAddCUDepth ); |
---|
| 506 | UInt log2MinCUSize = 0; |
---|
| 507 | while(MinCUSize > 1) |
---|
[2] | 508 | { |
---|
[56] | 509 | MinCUSize >>= 1; |
---|
| 510 | log2MinCUSize++; |
---|
[2] | 511 | } |
---|
| 512 | |
---|
[56] | 513 | WRITE_FLAG( pcSPS->getRestrictedRefPicListsFlag(), "restricted_ref_pic_lists_flag" ); |
---|
| 514 | if( pcSPS->getRestrictedRefPicListsFlag() ) |
---|
[2] | 515 | { |
---|
[56] | 516 | WRITE_FLAG( pcSPS->getListsModificationPresentFlag(), "lists_modification_present_flag" ); |
---|
[2] | 517 | } |
---|
[56] | 518 | WRITE_UVLC( log2MinCUSize - 3, "log2_min_coding_block_size_minus3" ); |
---|
| 519 | WRITE_UVLC( pcSPS->getMaxCUDepth()-g_uiAddCUDepth, "log2_diff_max_min_coding_block_size" ); |
---|
| 520 | WRITE_UVLC( pcSPS->getQuadtreeTULog2MinSize() - 2, "log2_min_transform_block_size_minus2" ); |
---|
| 521 | WRITE_UVLC( pcSPS->getQuadtreeTULog2MaxSize() - pcSPS->getQuadtreeTULog2MinSize(), "log2_diff_max_min_transform_block_size" ); |
---|
[2] | 522 | |
---|
[56] | 523 | if(log2MinCUSize == 3) |
---|
[2] | 524 | { |
---|
[56] | 525 | xWriteFlag ( (pcSPS->getDisInter4x4()) ? 1 : 0 ); |
---|
[2] | 526 | } |
---|
| 527 | |
---|
[56] | 528 | if( pcSPS->getUsePCM() ) |
---|
[2] | 529 | { |
---|
[56] | 530 | WRITE_UVLC( pcSPS->getPCMLog2MinSize() - 3, "log2_min_pcm_coding_block_size_minus3" ); |
---|
| 531 | WRITE_UVLC( pcSPS->getPCMLog2MaxSize() - pcSPS->getPCMLog2MinSize(), "log2_diff_max_min_pcm_coding_block_size" ); |
---|
[2] | 532 | } |
---|
[56] | 533 | WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthInter() - 1, "max_transform_hierarchy_depth_inter" ); |
---|
| 534 | WRITE_UVLC( pcSPS->getQuadtreeTUMaxDepthIntra() - 1, "max_transform_hierarchy_depth_intra" ); |
---|
| 535 | WRITE_FLAG( pcSPS->getScalingListFlag() ? 1 : 0, "scaling_list_enabled_flag" ); |
---|
| 536 | WRITE_FLAG( pcSPS->getUseLMChroma () ? 1 : 0, "chroma_pred_from_luma_enabled_flag" ); |
---|
| 537 | WRITE_FLAG( pcSPS->getUseDF() ? 1 : 0, "deblocking_filter_in_aps_enabled_flag"); |
---|
| 538 | WRITE_FLAG( pcSPS->getLFCrossSliceBoundaryFlag()?1 : 0, "seq_loop_filter_across_slices_enabled_flag"); |
---|
| 539 | WRITE_FLAG( pcSPS->getUseAMP(), "asymmetric_motion_partitions_enabled_flag" ); |
---|
| 540 | WRITE_FLAG( pcSPS->getUseNSQT(), "non_square_quadtree_enabled_flag" ); |
---|
| 541 | WRITE_FLAG( pcSPS->getUseSAO() ? 1 : 0, "sample_adaptive_offset_enabled_flag"); |
---|
| 542 | WRITE_FLAG( pcSPS->getUseALF () ? 1 : 0, "adaptive_loop_filter_enabled_flag"); |
---|
| 543 | if(pcSPS->getUseALF()) |
---|
[2] | 544 | { |
---|
[56] | 545 | WRITE_FLAG( (pcSPS->getUseALFCoefInSlice()) ? 1 : 0, "alf_coef_in_slice_flag"); |
---|
[2] | 546 | } |
---|
| 547 | |
---|
[56] | 548 | if( pcSPS->getUsePCM() ) |
---|
[2] | 549 | { |
---|
[56] | 550 | WRITE_FLAG( pcSPS->getPCMFilterDisableFlag()?1 : 0, "pcm_loop_filter_disable_flag"); |
---|
[2] | 551 | } |
---|
| 552 | |
---|
[56] | 553 | assert( pcSPS->getMaxTLayers() > 0 ); |
---|
[2] | 554 | |
---|
[56] | 555 | WRITE_FLAG( pcSPS->getTemporalIdNestingFlag() ? 1 : 0, "temporal_id_nesting_flag" ); |
---|
[2] | 556 | |
---|
[56] | 557 | TComRPSList* rpsList = pcSPS->getRPSList(); |
---|
| 558 | TComReferencePictureSet* rps; |
---|
[2] | 559 | |
---|
[56] | 560 | WRITE_UVLC(rpsList->getNumberOfReferencePictureSets(), "num_short_term_ref_pic_sets" ); |
---|
| 561 | for(Int i=0; i < rpsList->getNumberOfReferencePictureSets(); i++) |
---|
[2] | 562 | { |
---|
[56] | 563 | rps = rpsList->getReferencePictureSet(i); |
---|
| 564 | codeShortTermRefPicSet(pcSPS,rps); |
---|
| 565 | } |
---|
| 566 | WRITE_FLAG( pcSPS->getLongTermRefsPresent() ? 1 : 0, "long_term_ref_pics_present_flag" ); |
---|
| 567 | // AMVP mode for each depth |
---|
| 568 | for (Int i = 0; i < pcSPS->getMaxCUDepth(); i++) |
---|
[2] | 569 | { |
---|
[56] | 570 | xWriteFlag( pcSPS->getAMVPMode(i) ? 1 : 0); |
---|
[2] | 571 | } |
---|
| 572 | |
---|
[56] | 573 | Int tilesOrEntropyCodingSyncIdc = 0; |
---|
| 574 | if ( pcSPS->getNumColumnsMinus1() > 0 || pcSPS->getNumRowsMinus1() > 0) |
---|
[2] | 575 | { |
---|
[56] | 576 | tilesOrEntropyCodingSyncIdc = 1; |
---|
[2] | 577 | } |
---|
[56] | 578 | else if ( pcSPS->getNumSubstreams() > 1 ) |
---|
[2] | 579 | { |
---|
[56] | 580 | tilesOrEntropyCodingSyncIdc = 2; |
---|
[2] | 581 | } |
---|
[56] | 582 | pcSPS->setTilesOrEntropyCodingSyncIdc( tilesOrEntropyCodingSyncIdc ); |
---|
| 583 | WRITE_CODE(tilesOrEntropyCodingSyncIdc, 2, "tiles_or_entropy_coding_sync_idc"); |
---|
| 584 | |
---|
| 585 | if(tilesOrEntropyCodingSyncIdc == 1) |
---|
[2] | 586 | { |
---|
[56] | 587 | WRITE_UVLC( pcSPS->getNumColumnsMinus1(), "num_tile_columns_minus1" ); |
---|
| 588 | WRITE_UVLC( pcSPS->getNumRowsMinus1(), "num_tile_rows_minus1" ); |
---|
| 589 | WRITE_FLAG( pcSPS->getUniformSpacingIdr(), "uniform_spacing_flag" ); |
---|
[2] | 590 | |
---|
[56] | 591 | if( pcSPS->getUniformSpacingIdr()==0 ) |
---|
[2] | 592 | { |
---|
[56] | 593 | for(UInt i=0; i<pcSPS->getNumColumnsMinus1(); i++) |
---|
[2] | 594 | { |
---|
[56] | 595 | WRITE_UVLC( pcSPS->getColumnWidth(i), "column_width" ); |
---|
[2] | 596 | } |
---|
[56] | 597 | for(UInt i=0; i<pcSPS->getNumRowsMinus1(); i++) |
---|
[2] | 598 | { |
---|
[56] | 599 | WRITE_UVLC( pcSPS->getRowHeight(i), "row_height" ); |
---|
[2] | 600 | } |
---|
| 601 | } |
---|
[56] | 602 | |
---|
| 603 | if( pcSPS->getNumColumnsMinus1() !=0 || pcSPS->getNumRowsMinus1() != 0) |
---|
[2] | 604 | { |
---|
[56] | 605 | WRITE_FLAG( pcSPS->getLFCrossTileBoundaryFlag()?1 : 0, "loop_filter_across_tile_flag"); |
---|
[2] | 606 | } |
---|
| 607 | } |
---|
[56] | 608 | WRITE_FLAG( 1, "sps_extension_flag" ); |
---|
[210] | 609 | #if !QC_MVHEVC_B0046 |
---|
[56] | 610 | WRITE_FLAG( (pcSPS->getNumberOfUsableInterViewRefs() > 0) ? 1 : 0, "interview_refs_present_flag" ); |
---|
| 611 | if( pcSPS->getNumberOfUsableInterViewRefs() > 0 ) |
---|
[2] | 612 | { |
---|
[56] | 613 | WRITE_UVLC( pcSPS->getNumberOfUsableInterViewRefs() - 1, "num_usable_interview_refs_minus1" ); |
---|
| 614 | |
---|
| 615 | Int prev = 0; |
---|
| 616 | for( Int j = 0 ; j < pcSPS->getNumberOfUsableInterViewRefs(); j++ ) |
---|
| 617 | { |
---|
| 618 | WRITE_UVLC( prev - pcSPS->getUsableInterViewRef( j ) - 1, "delta_usable_interview_ref_minus1" ); |
---|
| 619 | prev = pcSPS->getUsableInterViewRef( j ); |
---|
| 620 | } |
---|
[2] | 621 | } |
---|
| 622 | |
---|
[56] | 623 | #if HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX |
---|
| 624 | WRITE_FLAG( pcSPS->getUseDMM(), "enable_dmm_flag" ); |
---|
[2] | 625 | #endif |
---|
| 626 | |
---|
[56] | 627 | #if HHI_MPI |
---|
| 628 | if( bIsDepth ) |
---|
[2] | 629 | { |
---|
[56] | 630 | WRITE_FLAG( pcSPS->getUseMVI() ? 1 : 0, "use_mvi_flag" ); |
---|
[2] | 631 | } |
---|
| 632 | #endif |
---|
| 633 | |
---|
[332] | 634 | #if H3D_QTL |
---|
[189] | 635 | if( bIsDepth ) |
---|
| 636 | { |
---|
| 637 | WRITE_FLAG( pcSPS->getUseQTLPC() ? 1 : 0, "use_qtlpc_flag"); |
---|
| 638 | } |
---|
| 639 | #endif |
---|
| 640 | |
---|
| 641 | #if RWTH_SDC_DLT_B0036 |
---|
| 642 | if( bIsDepth ) |
---|
| 643 | { |
---|
| 644 | WRITE_FLAG( pcSPS->getUseDLT() ? 1 : 0, "use_dlt_flag" ); |
---|
| 645 | if( pcSPS->getUseDLT() ) |
---|
| 646 | { |
---|
| 647 | // code mapping |
---|
| 648 | xWriteUvlc ( pcSPS->getNumDepthValues() ); |
---|
| 649 | for(UInt i=0; i<pcSPS->getNumDepthValues(); i++) |
---|
| 650 | { |
---|
| 651 | xWriteUvlc( pcSPS->idx2DepthValue(i) ); |
---|
| 652 | } |
---|
| 653 | } |
---|
| 654 | } |
---|
| 655 | #endif |
---|
| 656 | |
---|
[56] | 657 | if( pcSPS->getViewId() || pcSPS->isDepth() ) |
---|
[2] | 658 | { |
---|
[56] | 659 | WRITE_FLAG( 0, "base_view_flag" ); |
---|
| 660 | if( pcSPS->isDepth() ) |
---|
[2] | 661 | { |
---|
[56] | 662 | WRITE_FLAG( 1, "depth_flag" ); |
---|
| 663 | WRITE_UVLC( pcSPS->getViewId(), "view_id" ); |
---|
| 664 | WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" ); |
---|
[313] | 665 | #if FCO_FIX_SPS_CHANGE |
---|
| 666 | if ( pcSPS->getViewId() ) |
---|
| 667 | { |
---|
| 668 | WRITE_UVLC( pcSPS->getCamParPrecision(), "camera_parameter_precision" ); |
---|
| 669 | WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "camera_parameter_in_slice_header" ); |
---|
| 670 | if( !pcSPS->hasCamParInSliceHeader() ) |
---|
| 671 | { |
---|
| 672 | for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ ) |
---|
| 673 | { |
---|
| 674 | WRITE_SVLC( pcSPS->getCodedScale ()[ uiId ], "coded_scale" ); |
---|
| 675 | WRITE_SVLC( pcSPS->getCodedOffset ()[ uiId ], "coded_offset" ); |
---|
| 676 | WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiId ] + pcSPS->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" ); |
---|
| 677 | WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiId ] + pcSPS->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" ); |
---|
| 678 | } |
---|
| 679 | } |
---|
| 680 | } |
---|
| 681 | #endif |
---|
[2] | 682 | } |
---|
| 683 | else |
---|
| 684 | { |
---|
[56] | 685 | WRITE_FLAG( 0, "depth_flag" ); |
---|
| 686 | WRITE_UVLC( pcSPS->getViewId() - 1, "view_id_minus1" ); |
---|
| 687 | WRITE_SVLC( pcSPS->getViewOrderIdx(), "view_order_idx" ); |
---|
| 688 | WRITE_UVLC( pcSPS->getCamParPrecision(), "camera_parameter_precision" ); |
---|
| 689 | WRITE_FLAG( pcSPS->hasCamParInSliceHeader() ? 1 : 0, "camera_parameter_in_slice_header" ); |
---|
| 690 | if( !pcSPS->hasCamParInSliceHeader() ) |
---|
| 691 | { |
---|
| 692 | for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ ) |
---|
| 693 | { |
---|
| 694 | WRITE_SVLC( pcSPS->getCodedScale ()[ uiId ], "coded_scale" ); |
---|
| 695 | WRITE_SVLC( pcSPS->getCodedOffset ()[ uiId ], "coded_offset" ); |
---|
| 696 | WRITE_SVLC( pcSPS->getInvCodedScale ()[ uiId ] + pcSPS->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" ); |
---|
| 697 | WRITE_SVLC( pcSPS->getInvCodedOffset()[ uiId ] + pcSPS->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" ); |
---|
| 698 | } |
---|
[2] | 699 | } |
---|
[56] | 700 | #if DEPTH_MAP_GENERATION |
---|
| 701 | WRITE_UVLC( pcSPS->getPredDepthMapGeneration(), "Pdm_generation" ); |
---|
| 702 | if( pcSPS->getPredDepthMapGeneration() ) |
---|
[2] | 703 | { |
---|
[56] | 704 | WRITE_UVLC( pcSPS->getPdmPrecision(), "Pdm_precision" ); |
---|
| 705 | for( UInt uiId = 0; uiId < pcSPS->getViewId(); uiId++ ) |
---|
| 706 | { |
---|
| 707 | WRITE_SVLC( pcSPS->getPdmScaleNomDelta()[ uiId ], "Pdm_scale_nom_delta" ); |
---|
| 708 | WRITE_SVLC( pcSPS->getPdmOffset ()[ uiId ], "Pdm_offset" ); |
---|
| 709 | } |
---|
[296] | 710 | #if H3D_IVMP |
---|
[56] | 711 | WRITE_UVLC( pcSPS->getMultiviewMvPredMode(), "multi_view_mv_pred_mode" ); |
---|
| 712 | #endif |
---|
[296] | 713 | #if H3D_IVRP |
---|
[56] | 714 | WRITE_FLAG ( pcSPS->getMultiviewResPredMode(), "multi_view_residual_pred_mode" ); |
---|
| 715 | #endif |
---|
[2] | 716 | } |
---|
[56] | 717 | #endif |
---|
[2] | 718 | } |
---|
| 719 | } |
---|
[56] | 720 | else |
---|
[2] | 721 | { |
---|
[56] | 722 | WRITE_FLAG( 1, "base_view_flag" ); |
---|
[2] | 723 | } |
---|
[56] | 724 | WRITE_FLAG( 0, "sps_extension2_flag" ); |
---|
[210] | 725 | #endif |
---|
[56] | 726 | } |
---|
[2] | 727 | |
---|
[56] | 728 | Void TEncCavlc::writeTileMarker( UInt uiTileIdx, UInt uiBitsUsed ) |
---|
| 729 | { |
---|
| 730 | xWriteCode( uiTileIdx, uiBitsUsed ); |
---|
[2] | 731 | } |
---|
| 732 | |
---|
[56] | 733 | Void TEncCavlc::codeSliceHeader ( TComSlice* pcSlice ) |
---|
[2] | 734 | { |
---|
[56] | 735 | #if ENC_DEC_TRACE |
---|
| 736 | xTraceSliceHeader (pcSlice); |
---|
[2] | 737 | #endif |
---|
| 738 | |
---|
[56] | 739 | // if( nal_ref_idc != 0 ) |
---|
| 740 | // dec_ref_pic_marking( ) |
---|
| 741 | // if( entropy_coding_mode_flag && slice_type != I) |
---|
| 742 | // cabac_init_idc |
---|
| 743 | // first_slice_in_pic_flag |
---|
| 744 | // if( first_slice_in_pic_flag == 0 ) |
---|
| 745 | // slice_address |
---|
| 746 | //calculate number of bits required for slice address |
---|
| 747 | Int maxAddrOuter = pcSlice->getPic()->getNumCUsInFrame(); |
---|
| 748 | Int reqBitsOuter = 0; |
---|
| 749 | while(maxAddrOuter>(1<<reqBitsOuter)) |
---|
[2] | 750 | { |
---|
[56] | 751 | reqBitsOuter++; |
---|
[2] | 752 | } |
---|
[56] | 753 | Int maxAddrInner = pcSlice->getPic()->getNumPartInCU()>>(2); |
---|
| 754 | maxAddrInner = (1<<(pcSlice->getPPS()->getSliceGranularity()<<1)); |
---|
| 755 | Int reqBitsInner = 0; |
---|
| 756 | |
---|
| 757 | while(maxAddrInner>(1<<reqBitsInner)) |
---|
[2] | 758 | { |
---|
[56] | 759 | reqBitsInner++; |
---|
[2] | 760 | } |
---|
[56] | 761 | Int lCUAddress; |
---|
| 762 | Int innerAddress; |
---|
| 763 | if (pcSlice->isNextSlice()) |
---|
[2] | 764 | { |
---|
[56] | 765 | // Calculate slice address |
---|
| 766 | lCUAddress = (pcSlice->getSliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU()); |
---|
| 767 | innerAddress = (pcSlice->getSliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1); |
---|
[2] | 768 | } |
---|
| 769 | else |
---|
| 770 | { |
---|
[56] | 771 | // Calculate slice address |
---|
| 772 | lCUAddress = (pcSlice->getEntropySliceCurStartCUAddr()/pcSlice->getPic()->getNumPartInCU()); |
---|
| 773 | innerAddress = (pcSlice->getEntropySliceCurStartCUAddr()%(pcSlice->getPic()->getNumPartInCU()))>>((pcSlice->getSPS()->getMaxCUDepth()-pcSlice->getPPS()->getSliceGranularity())<<1); |
---|
| 774 | |
---|
[2] | 775 | } |
---|
[56] | 776 | //write slice address |
---|
| 777 | Int address = (pcSlice->getPic()->getPicSym()->getCUOrderMap(lCUAddress) << reqBitsInner) + innerAddress; |
---|
| 778 | WRITE_FLAG( address==0, "first_slice_in_pic_flag" ); |
---|
[189] | 779 | |
---|
| 780 | #if LGE_ILLUCOMP_B0045 |
---|
| 781 | // IC flag is on only first_slice_in_pic |
---|
| 782 | if (address==0) |
---|
| 783 | { |
---|
[296] | 784 | if( pcSlice->getSPS()->getViewId() |
---|
| 785 | #if !LGE_ILLUCOMP_DEPTH_C0046 |
---|
| 786 | && !pcSlice->getIsDepth() |
---|
| 787 | #endif |
---|
| 788 | ) |
---|
[189] | 789 | { |
---|
| 790 | WRITE_FLAG( pcSlice->getApplyIC() ? 1 : 0, "applying IC flag" ); |
---|
| 791 | } |
---|
| 792 | } |
---|
| 793 | #endif |
---|
| 794 | |
---|
[56] | 795 | if(address>0) |
---|
[2] | 796 | { |
---|
[56] | 797 | WRITE_CODE( address, reqBitsOuter+reqBitsInner, "slice_address" ); |
---|
[2] | 798 | } |
---|
| 799 | |
---|
[56] | 800 | WRITE_UVLC( pcSlice->getSliceType(), "slice_type" ); |
---|
| 801 | Bool bEntropySlice = (!pcSlice->isNextSlice()); |
---|
| 802 | WRITE_FLAG( bEntropySlice ? 1 : 0, "lightweight_slice_flag" ); |
---|
| 803 | |
---|
| 804 | if (!bEntropySlice) |
---|
[2] | 805 | { |
---|
[210] | 806 | #if QC_MVHEVC_B0046 |
---|
| 807 | WRITE_UVLC( 0, "pic_parameter_set_id" ); |
---|
| 808 | #else |
---|
[56] | 809 | WRITE_UVLC( pcSlice->getPPS()->getPPSId(), "pic_parameter_set_id" ); |
---|
[210] | 810 | #endif |
---|
[56] | 811 | if( pcSlice->getPPS()->getOutputFlagPresentFlag() ) |
---|
[2] | 812 | { |
---|
[56] | 813 | WRITE_FLAG( pcSlice->getPicOutputFlag() ? 1 : 0, "pic_output_flag" ); |
---|
[2] | 814 | } |
---|
[210] | 815 | #if QC_REM_IDV_B0046 |
---|
| 816 | if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR && pcSlice->getViewId() == 0) |
---|
| 817 | #else |
---|
[56] | 818 | if(pcSlice->getNalUnitType()==NAL_UNIT_CODED_SLICE_IDR) |
---|
[210] | 819 | #endif |
---|
[2] | 820 | { |
---|
[56] | 821 | WRITE_UVLC( 0, "idr_pic_id" ); |
---|
| 822 | WRITE_FLAG( 0, "no_output_of_prior_pics_flag" ); |
---|
[2] | 823 | } |
---|
| 824 | else |
---|
| 825 | { |
---|
[56] | 826 | WRITE_CODE( (pcSlice->getPOC()-pcSlice->getLastIDR()+(1<<pcSlice->getSPS()->getBitsForPOC()))%(1<<pcSlice->getSPS()->getBitsForPOC()), pcSlice->getSPS()->getBitsForPOC(), "pic_order_cnt_lsb"); |
---|
[210] | 827 | #if QC_REM_IDV_B0046 |
---|
| 828 | if( pcSlice->getPOC() == 0 && !(pcSlice->getSPS()->getViewId() && (pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR || pcSlice->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))) |
---|
| 829 | #else |
---|
[77] | 830 | if( pcSlice->getPOC() == 0 && pcSlice->getNalUnitType() != NAL_UNIT_CODED_SLICE_IDV ) |
---|
[210] | 831 | #endif |
---|
[77] | 832 | { |
---|
| 833 | TComReferencePictureSet* rps = pcSlice->getRPS(); |
---|
| 834 | if(pcSlice->getRPSidx() < 0) |
---|
| 835 | { |
---|
| 836 | WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag"); |
---|
| 837 | codeShortTermRefPicSet(pcSlice->getSPS(), rps); |
---|
| 838 | } |
---|
| 839 | else |
---|
| 840 | { |
---|
| 841 | WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag"); |
---|
| 842 | WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" ); |
---|
| 843 | } |
---|
| 844 | if(pcSlice->getSPS()->getLongTermRefsPresent()) |
---|
| 845 | { |
---|
| 846 | WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics"); |
---|
| 847 | Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC(); |
---|
| 848 | Int prev = 0; |
---|
| 849 | Int prevDeltaPocLt=0; |
---|
| 850 | Int currDeltaPocLt=0; |
---|
| 851 | for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--) |
---|
| 852 | { |
---|
| 853 | WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt"); |
---|
| 854 | |
---|
| 855 | currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt; |
---|
[2] | 856 | |
---|
[77] | 857 | Int deltaMsbCycle=0; |
---|
| 858 | if( (i==(rps->getNumberOfPictures()-1)) ) |
---|
| 859 | { |
---|
| 860 | deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 861 | } |
---|
| 862 | else if( prevDeltaPocLt!=currDeltaPocLt ) |
---|
| 863 | { |
---|
| 864 | deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 865 | if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) || ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb))) |
---|
| 866 | { |
---|
| 867 | deltaMsbCycle=deltaMsbCycle-1; |
---|
| 868 | } |
---|
| 869 | } |
---|
| 870 | else |
---|
| 871 | { |
---|
| 872 | deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 873 | } |
---|
| 874 | |
---|
| 875 | if(deltaMsbCycle>=0) |
---|
| 876 | { |
---|
| 877 | WRITE_FLAG( 1, "delta_poc_msb_present_flag"); |
---|
| 878 | WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1"); |
---|
| 879 | } |
---|
| 880 | else |
---|
| 881 | { |
---|
| 882 | WRITE_FLAG( 0, "delta_poc_msb_present_flag"); |
---|
| 883 | } |
---|
| 884 | prevDeltaPocLt=currDeltaPocLt; |
---|
| 885 | prev = rps->getDeltaPOC(i); |
---|
| 886 | WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag"); |
---|
| 887 | } |
---|
| 888 | } |
---|
| 889 | } |
---|
| 890 | if( pcSlice->getPOC() != 0 ) |
---|
[2] | 891 | { |
---|
[56] | 892 | TComReferencePictureSet* rps = pcSlice->getRPS(); |
---|
| 893 | if(pcSlice->getRPSidx() < 0) |
---|
| 894 | { |
---|
| 895 | WRITE_FLAG( 0, "short_term_ref_pic_set_sps_flag"); |
---|
| 896 | codeShortTermRefPicSet(pcSlice->getSPS(), rps); |
---|
| 897 | } |
---|
| 898 | else |
---|
[2] | 899 | { |
---|
[56] | 900 | WRITE_FLAG( 1, "short_term_ref_pic_set_sps_flag"); |
---|
| 901 | WRITE_UVLC( pcSlice->getRPSidx(), "short_term_ref_pic_set_idx" ); |
---|
[2] | 902 | } |
---|
[56] | 903 | if(pcSlice->getSPS()->getLongTermRefsPresent()) |
---|
[2] | 904 | { |
---|
[56] | 905 | WRITE_UVLC( rps->getNumberOfLongtermPictures(), "num_long_term_pics"); |
---|
| 906 | Int maxPocLsb = 1<<pcSlice->getSPS()->getBitsForPOC(); |
---|
| 907 | Int prev = 0; |
---|
| 908 | Int prevDeltaPocLt=0; |
---|
| 909 | Int currDeltaPocLt=0; |
---|
| 910 | for(Int i=rps->getNumberOfPictures()-1 ; i > rps->getNumberOfPictures()-rps->getNumberOfLongtermPictures()-1; i--) |
---|
| 911 | { |
---|
| 912 | WRITE_UVLC((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb, "delta_poc_lsb_lt"); |
---|
| 913 | |
---|
| 914 | currDeltaPocLt=((maxPocLsb-rps->getDeltaPOC(i)+prev)%maxPocLsb)+prevDeltaPocLt; |
---|
| 915 | |
---|
| 916 | Int deltaMsbCycle=0; |
---|
| 917 | if( (i==(rps->getNumberOfPictures()-1)) ) |
---|
| 918 | { |
---|
| 919 | deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 920 | } |
---|
| 921 | else if( prevDeltaPocLt!=currDeltaPocLt ) |
---|
| 922 | { |
---|
| 923 | deltaMsbCycle=((-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 924 | if( ((prevDeltaPocLt==maxPocLsb-1) && (currDeltaPocLt==maxPocLsb+1)) || ((prevDeltaPocLt==maxPocLsb-2) && (currDeltaPocLt==maxPocLsb))) |
---|
| 925 | { |
---|
| 926 | deltaMsbCycle=deltaMsbCycle-1; |
---|
| 927 | } |
---|
| 928 | } |
---|
| 929 | else |
---|
| 930 | { |
---|
| 931 | deltaMsbCycle=((rps->getDeltaPOC(i+1)-rps->getDeltaPOC(i))/maxPocLsb)-1; |
---|
| 932 | } |
---|
| 933 | |
---|
| 934 | if(deltaMsbCycle>=0) |
---|
| 935 | { |
---|
| 936 | WRITE_FLAG( 1, "delta_poc_msb_present_flag"); |
---|
| 937 | WRITE_UVLC(deltaMsbCycle, "delta_poc_msb_cycle_lt_minus1"); |
---|
| 938 | } |
---|
| 939 | else |
---|
| 940 | { |
---|
| 941 | WRITE_FLAG( 0, "delta_poc_msb_present_flag"); |
---|
| 942 | } |
---|
| 943 | prevDeltaPocLt=currDeltaPocLt; |
---|
| 944 | prev = rps->getDeltaPOC(i); |
---|
| 945 | WRITE_FLAG( rps->getUsed(i), "used_by_curr_pic_lt_flag"); |
---|
| 946 | } |
---|
[2] | 947 | } |
---|
| 948 | } |
---|
| 949 | } |
---|
[56] | 950 | |
---|
| 951 | if(pcSlice->getSPS()->getUseSAO() || pcSlice->getSPS()->getUseALF()|| pcSlice->getSPS()->getScalingListFlag() || pcSlice->getSPS()->getUseDF()) |
---|
[2] | 952 | { |
---|
[56] | 953 | if (pcSlice->getSPS()->getUseALF()) |
---|
[2] | 954 | { |
---|
[56] | 955 | WRITE_FLAG( pcSlice->getAlfEnabledFlag(), "ALF on/off flag in slice header" ); |
---|
[2] | 956 | } |
---|
[56] | 957 | if (pcSlice->getSPS()->getUseSAO()) |
---|
[2] | 958 | { |
---|
[56] | 959 | WRITE_FLAG( pcSlice->getSaoInterleavingFlag(), "SAO interleaving flag" ); |
---|
| 960 | assert (pcSlice->getSaoEnabledFlag() == pcSlice->getAPS()->getSaoEnabled()); |
---|
| 961 | WRITE_FLAG( pcSlice->getSaoEnabledFlag(), "SAO on/off flag in slice header" ); |
---|
| 962 | if (pcSlice->getSaoInterleavingFlag()&&pcSlice->getSaoEnabledFlag() ) |
---|
| 963 | { |
---|
| 964 | WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[1], "SAO on/off flag for Cb in slice header" ); |
---|
| 965 | WRITE_FLAG( pcSlice->getAPS()->getSaoParam()->bSaoFlag[2], "SAO on/off flag for Cr in slice header" ); |
---|
| 966 | } |
---|
[2] | 967 | } |
---|
[56] | 968 | WRITE_UVLC( pcSlice->getAPS()->getAPSID(), "aps_id"); |
---|
[2] | 969 | } |
---|
[56] | 970 | |
---|
| 971 | // we always set num_ref_idx_active_override_flag equal to one. this might be done in a more intelligent way |
---|
| 972 | if (!pcSlice->isIntra()) |
---|
| 973 | { |
---|
| 974 | WRITE_FLAG( 1 , "num_ref_idx_active_override_flag"); |
---|
| 975 | WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_0 ) - 1, 3, "num_ref_idx_l0_active_minus1" ); |
---|
| 976 | } |
---|
[2] | 977 | else |
---|
| 978 | { |
---|
[56] | 979 | pcSlice->setNumRefIdx(REF_PIC_LIST_0, 0); |
---|
[2] | 980 | } |
---|
[56] | 981 | if (pcSlice->isInterB()) |
---|
[2] | 982 | { |
---|
[56] | 983 | WRITE_CODE( pcSlice->getNumRefIdx( REF_PIC_LIST_1 ) - 1, 3, "num_ref_idx_l1_active_minus1" ); |
---|
[2] | 984 | } |
---|
[56] | 985 | else |
---|
[2] | 986 | { |
---|
[56] | 987 | pcSlice->setNumRefIdx(REF_PIC_LIST_1, 0); |
---|
[2] | 988 | } |
---|
[56] | 989 | if( pcSlice->getSPS()->getListsModificationPresentFlag() ) |
---|
| 990 | { |
---|
| 991 | TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification(); |
---|
| 992 | if( !pcSlice->isIntra() ) |
---|
[2] | 993 | { |
---|
[56] | 994 | WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0() ? 1 : 0, "ref_pic_list_modification_flag_l0" ); |
---|
| 995 | if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL0()) |
---|
[2] | 996 | { |
---|
[56] | 997 | Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc(); |
---|
| 998 | if (NumPocTotalCurr > 1) |
---|
[2] | 999 | { |
---|
[56] | 1000 | Int length = 1; |
---|
| 1001 | NumPocTotalCurr --; |
---|
| 1002 | while ( NumPocTotalCurr >>= 1) |
---|
[2] | 1003 | { |
---|
[56] | 1004 | length ++; |
---|
[2] | 1005 | } |
---|
[56] | 1006 | for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_0 ); i++) |
---|
[2] | 1007 | { |
---|
[56] | 1008 | WRITE_CODE( refPicListModification->getRefPicSetIdxL0(i), length, "list_entry_l0"); |
---|
[2] | 1009 | } |
---|
| 1010 | } |
---|
| 1011 | } |
---|
[56] | 1012 | } |
---|
| 1013 | if(pcSlice->isInterB()) |
---|
| 1014 | { |
---|
| 1015 | WRITE_FLAG(pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1() ? 1 : 0, "ref_pic_list_modification_flag_l1" ); |
---|
| 1016 | if (pcSlice->getRefPicListModification()->getRefPicListModificationFlagL1()) |
---|
[2] | 1017 | { |
---|
[56] | 1018 | Int NumPocTotalCurr = pcSlice->getNumPocTotalCurrMvc(); |
---|
| 1019 | if ( NumPocTotalCurr > 1 ) |
---|
[2] | 1020 | { |
---|
[56] | 1021 | Int length = 1; |
---|
| 1022 | NumPocTotalCurr --; |
---|
| 1023 | while ( NumPocTotalCurr >>= 1) |
---|
[2] | 1024 | { |
---|
[56] | 1025 | length ++; |
---|
[2] | 1026 | } |
---|
[56] | 1027 | for(Int i = 0; i < pcSlice->getNumRefIdx( REF_PIC_LIST_1 ); i++) |
---|
[2] | 1028 | { |
---|
[56] | 1029 | WRITE_CODE( refPicListModification->getRefPicSetIdxL1(i), length, "list_entry_l1"); |
---|
[2] | 1030 | } |
---|
| 1031 | } |
---|
| 1032 | } |
---|
| 1033 | } |
---|
[56] | 1034 | } |
---|
| 1035 | } |
---|
| 1036 | // ref_pic_list_combination( ) |
---|
| 1037 | // maybe move to own function? |
---|
| 1038 | if (pcSlice->isInterB()) |
---|
| 1039 | { |
---|
| 1040 | WRITE_FLAG(pcSlice->getRefPicListCombinationFlag() ? 1 : 0, "ref_pic_list_combination_flag" ); |
---|
| 1041 | if(pcSlice->getRefPicListCombinationFlag()) |
---|
| 1042 | { |
---|
| 1043 | WRITE_UVLC( pcSlice->getNumRefIdx(REF_PIC_LIST_C) - 1, "num_ref_idx lc_active_minus1"); |
---|
| 1044 | |
---|
| 1045 | if( pcSlice->getSPS()->getListsModificationPresentFlag() ) |
---|
[2] | 1046 | { |
---|
[56] | 1047 | WRITE_FLAG( pcSlice->getRefPicListModificationFlagLC() ? 1 : 0, "ref_pic_list_modification_flag_lc" ); |
---|
| 1048 | if(pcSlice->getRefPicListModificationFlagLC()) |
---|
[2] | 1049 | { |
---|
[56] | 1050 | for (UInt i=0;i<pcSlice->getNumRefIdx(REF_PIC_LIST_C);i++) |
---|
| 1051 | { |
---|
| 1052 | WRITE_FLAG( pcSlice->getListIdFromIdxOfLC(i), "pic_from_list_0_flag" ); |
---|
| 1053 | if (((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_0) && pcSlice->getNumRefIdx( REF_PIC_LIST_0 )>1 ) || ((pcSlice->getListIdFromIdxOfLC(i)==REF_PIC_LIST_1) && pcSlice->getNumRefIdx( REF_PIC_LIST_1 )>1 ) ) |
---|
| 1054 | { |
---|
| 1055 | WRITE_UVLC( pcSlice->getRefIdxFromIdxOfLC(i), "ref_idx_list_curr" ); |
---|
| 1056 | } |
---|
| 1057 | } |
---|
[2] | 1058 | } |
---|
| 1059 | } |
---|
| 1060 | } |
---|
| 1061 | } |
---|
[56] | 1062 | |
---|
| 1063 | if (pcSlice->isInterB()) |
---|
[2] | 1064 | { |
---|
[56] | 1065 | WRITE_FLAG( pcSlice->getMvdL1ZeroFlag() ? 1 : 0, "mvd_l1_zero_flag"); |
---|
[2] | 1066 | } |
---|
| 1067 | |
---|
[56] | 1068 | if(pcSlice->getPPS()->getEntropyCodingMode() && !pcSlice->isIntra()) |
---|
[2] | 1069 | { |
---|
[56] | 1070 | #if CABAC_INIT_FLAG |
---|
| 1071 | if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag()) |
---|
[2] | 1072 | { |
---|
[56] | 1073 | SliceType sliceType = pcSlice->getSliceType(); |
---|
| 1074 | Int encCABACTableIdx = pcSlice->getPPS()->getEncCABACTableIdx(); |
---|
| 1075 | Bool encCabacInitFlag = (sliceType!=encCABACTableIdx && encCABACTableIdx!=0) ? true : false; |
---|
| 1076 | pcSlice->setCabacInitFlag( encCabacInitFlag ); |
---|
| 1077 | WRITE_FLAG( encCabacInitFlag?1:0, "cabac_init_flag" ); |
---|
[2] | 1078 | } |
---|
| 1079 | #else |
---|
[56] | 1080 | WRITE_UVLC(pcSlice->getCABACinitIDC(), "cabac_init_idc"); |
---|
[2] | 1081 | #endif |
---|
| 1082 | } |
---|
| 1083 | |
---|
[56] | 1084 | // if( !lightweight_slice_flag ) { |
---|
| 1085 | if (!bEntropySlice) |
---|
[2] | 1086 | { |
---|
[56] | 1087 | Int iCode = pcSlice->getSliceQp() - ( pcSlice->getPPS()->getPicInitQPMinus26() + 26 ); |
---|
| 1088 | WRITE_SVLC( iCode, "slice_qp_delta" ); |
---|
| 1089 | if (pcSlice->getPPS()->getDeblockingFilterControlPresent()) |
---|
[2] | 1090 | { |
---|
[56] | 1091 | if ( pcSlice->getSPS()->getUseDF() ) |
---|
[2] | 1092 | { |
---|
[56] | 1093 | WRITE_FLAG(pcSlice->getInheritDblParamFromAPS(), "inherit_dbl_param_from_APS_flag"); |
---|
[2] | 1094 | } |
---|
[56] | 1095 | if (!pcSlice->getInheritDblParamFromAPS()) |
---|
[2] | 1096 | { |
---|
[56] | 1097 | WRITE_FLAG(pcSlice->getLoopFilterDisable(), "loop_filter_disable"); // should be an IDC |
---|
| 1098 | if(!pcSlice->getLoopFilterDisable()) |
---|
| 1099 | { |
---|
| 1100 | WRITE_SVLC (pcSlice->getLoopFilterBetaOffset(), "beta_offset_div2"); |
---|
| 1101 | WRITE_SVLC (pcSlice->getLoopFilterTcOffset(), "tc_offset_div2"); |
---|
| 1102 | } |
---|
[2] | 1103 | } |
---|
[56] | 1104 | } |
---|
| 1105 | if ( pcSlice->getSliceType() == B_SLICE ) |
---|
| 1106 | { |
---|
| 1107 | WRITE_FLAG( pcSlice->getColDir(), "collocated_from_l0_flag" ); |
---|
| 1108 | } |
---|
[2] | 1109 | |
---|
[56] | 1110 | #if COLLOCATED_REF_IDX |
---|
| 1111 | if ( pcSlice->getSliceType() != I_SLICE && |
---|
| 1112 | ((pcSlice->getColDir()==0 && pcSlice->getNumRefIdx(REF_PIC_LIST_0)>1)|| |
---|
| 1113 | (pcSlice->getColDir()==1 && pcSlice->getNumRefIdx(REF_PIC_LIST_1)>1))) |
---|
| 1114 | { |
---|
| 1115 | WRITE_UVLC( pcSlice->getColRefIdx(), "collocated_ref_idx" ); |
---|
[2] | 1116 | } |
---|
[56] | 1117 | #endif |
---|
[313] | 1118 | |
---|
| 1119 | #if FIX_LGE_WP_FOR_3D_C0223 |
---|
| 1120 | if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPredIdc() && pcSlice->getSliceType()==B_SLICE) ) |
---|
| 1121 | #else |
---|
[56] | 1122 | if ( (pcSlice->getPPS()->getUseWP() && pcSlice->getSliceType()==P_SLICE) || (pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getSliceType()==B_SLICE) ) |
---|
[313] | 1123 | #endif |
---|
[2] | 1124 | { |
---|
[56] | 1125 | xCodePredWeightTable( pcSlice ); |
---|
[2] | 1126 | } |
---|
| 1127 | } |
---|
| 1128 | |
---|
[56] | 1129 | // !!!! sytnax elements not in the WD !!!! |
---|
| 1130 | if (!bEntropySlice) |
---|
[2] | 1131 | { |
---|
[56] | 1132 | if( pcSlice->getSPS()->hasCamParInSliceHeader() ) |
---|
| 1133 | { |
---|
| 1134 | for( UInt uiId = 0; uiId < pcSlice->getSPS()->getViewId(); uiId++ ) |
---|
| 1135 | { |
---|
| 1136 | WRITE_SVLC( pcSlice->getCodedScale ()[ uiId ], "coded_scale" ); |
---|
| 1137 | WRITE_SVLC( pcSlice->getCodedOffset ()[ uiId ], "coded_offset" ); |
---|
| 1138 | WRITE_SVLC( pcSlice->getInvCodedScale ()[ uiId ] + pcSlice->getCodedScale ()[ uiId ], "inverse_coded_scale_plus_coded_scale" ); |
---|
| 1139 | WRITE_SVLC( pcSlice->getInvCodedOffset()[ uiId ] + pcSlice->getCodedOffset()[ uiId ], "inverse_coded_offset_plus_coded_offset" ); |
---|
| 1140 | } |
---|
| 1141 | } |
---|
[2] | 1142 | } |
---|
[56] | 1143 | |
---|
[296] | 1144 | #if ( HHI_MPI || H3D_IVMP ) |
---|
| 1145 | #if ( HHI_MPI && H3D_IVMP ) |
---|
[56] | 1146 | const int iExtraMergeCandidates = ( pcSlice->getSPS()->getUseMVI() || pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0; |
---|
| 1147 | #elif HHI_MPI |
---|
| 1148 | const int iExtraMergeCandidates = pcSlice->getSPS()->getUseMVI() ? 1 : 0; |
---|
[296] | 1149 | #elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137 |
---|
| 1150 | const int iExtraMergeCandidates = ( pcSlice->getIsDepth() || pcSlice->getSPS()->getMultiviewMvPredMode() ) ? 1 : 0; |
---|
[56] | 1151 | #else |
---|
| 1152 | const int iExtraMergeCandidates = pcSlice->getSPS()->getMultiviewMvPredMode() ? 1 : 0; |
---|
| 1153 | #endif |
---|
| 1154 | assert(pcSlice->getMaxNumMergeCand()<=(MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates)); |
---|
| 1155 | assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS); |
---|
| 1156 | WRITE_UVLC(MRG_MAX_NUM_CANDS + iExtraMergeCandidates - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand"); |
---|
[2] | 1157 | #else |
---|
[56] | 1158 | assert(pcSlice->getMaxNumMergeCand()<=MRG_MAX_NUM_CANDS_SIGNALED); |
---|
| 1159 | assert(MRG_MAX_NUM_CANDS_SIGNALED<=MRG_MAX_NUM_CANDS); |
---|
| 1160 | WRITE_UVLC(MRG_MAX_NUM_CANDS - pcSlice->getMaxNumMergeCand(), "maxNumMergeCand"); |
---|
[2] | 1161 | #endif |
---|
| 1162 | } |
---|
| 1163 | |
---|
| 1164 | |
---|
[56] | 1165 | Void TEncCavlc::codeTileMarkerFlag(TComSlice* pcSlice) |
---|
[2] | 1166 | { |
---|
[56] | 1167 | Bool bEntropySlice = (!pcSlice->isNextSlice()); |
---|
| 1168 | if (!bEntropySlice) |
---|
| 1169 | { |
---|
| 1170 | xWriteFlag (pcSlice->getTileMarkerFlag() ? 1 : 0 ); |
---|
| 1171 | } |
---|
[2] | 1172 | } |
---|
| 1173 | |
---|
[56] | 1174 | /** |
---|
| 1175 | - write wavefront substreams sizes for the slice header. |
---|
| 1176 | . |
---|
| 1177 | \param pcSlice Where we find the substream size information. |
---|
| 1178 | */ |
---|
| 1179 | Void TEncCavlc::codeTilesWPPEntryPoint( TComSlice* pSlice ) |
---|
[2] | 1180 | { |
---|
[56] | 1181 | Int tilesOrEntropyCodingSyncIdc = pSlice->getSPS()->getTilesOrEntropyCodingSyncIdc(); |
---|
[2] | 1182 | |
---|
[56] | 1183 | if ( tilesOrEntropyCodingSyncIdc == 0 ) |
---|
[2] | 1184 | { |
---|
[56] | 1185 | return; |
---|
[2] | 1186 | } |
---|
| 1187 | |
---|
[56] | 1188 | UInt numEntryPointOffsets = 0, offsetLenMinus1 = 0, maxOffset = 0; |
---|
| 1189 | UInt *entryPointOffset = NULL; |
---|
| 1190 | if (tilesOrEntropyCodingSyncIdc == 1) // tiles |
---|
[2] | 1191 | { |
---|
[56] | 1192 | numEntryPointOffsets = pSlice->getTileLocationCount(); |
---|
| 1193 | entryPointOffset = new UInt[numEntryPointOffsets]; |
---|
| 1194 | for (Int idx=0; idx<pSlice->getTileLocationCount(); idx++) |
---|
[2] | 1195 | { |
---|
[56] | 1196 | if ( idx == 0 ) |
---|
[2] | 1197 | { |
---|
[56] | 1198 | entryPointOffset [ idx ] = pSlice->getTileLocation( 0 ); |
---|
[2] | 1199 | } |
---|
[56] | 1200 | else |
---|
[2] | 1201 | { |
---|
[56] | 1202 | entryPointOffset [ idx ] = pSlice->getTileLocation( idx ) - pSlice->getTileLocation( idx-1 ); |
---|
[2] | 1203 | } |
---|
| 1204 | |
---|
[56] | 1205 | if ( entryPointOffset[ idx ] > maxOffset ) |
---|
| 1206 | { |
---|
| 1207 | maxOffset = entryPointOffset[ idx ]; |
---|
| 1208 | } |
---|
[2] | 1209 | } |
---|
| 1210 | } |
---|
[56] | 1211 | else if (tilesOrEntropyCodingSyncIdc == 2) // wavefront |
---|
[2] | 1212 | { |
---|
[56] | 1213 | Int numZeroSubstreamsAtEndOfSlice = 0; |
---|
| 1214 | UInt* pSubstreamSizes = pSlice->getSubstreamSizes(); |
---|
| 1215 | // Find number of zero substreams at the end of slice |
---|
| 1216 | for (Int idx=pSlice->getPPS()->getNumSubstreams()-2; idx>=0; idx--) |
---|
[2] | 1217 | { |
---|
[56] | 1218 | if ( pSubstreamSizes[ idx ] == 0 ) |
---|
[2] | 1219 | { |
---|
[56] | 1220 | numZeroSubstreamsAtEndOfSlice++; |
---|
[2] | 1221 | } |
---|
[56] | 1222 | else |
---|
[2] | 1223 | { |
---|
[56] | 1224 | break; |
---|
[2] | 1225 | } |
---|
| 1226 | } |
---|
[56] | 1227 | numEntryPointOffsets = pSlice->getPPS()->getNumSubstreams() - 1 - numZeroSubstreamsAtEndOfSlice; |
---|
| 1228 | entryPointOffset = new UInt[numEntryPointOffsets]; |
---|
| 1229 | for (Int idx=0; idx<numEntryPointOffsets; idx++) |
---|
[2] | 1230 | { |
---|
[56] | 1231 | entryPointOffset[ idx ] = ( pSubstreamSizes[ idx ] >> 3 ) ; |
---|
| 1232 | if ( entryPointOffset[ idx ] > maxOffset ) |
---|
[2] | 1233 | { |
---|
[56] | 1234 | maxOffset = entryPointOffset[ idx ]; |
---|
[2] | 1235 | } |
---|
| 1236 | } |
---|
[56] | 1237 | } |
---|
[2] | 1238 | |
---|
[56] | 1239 | maxOffset += ((m_pcBitIf->getNumberOfWrittenBits() + 16) >> 3) + 8 + 2; // allowing for NALU header, slice header, bytes added for "offset_len_minus1" and "num_entry_point_offsets" |
---|
[2] | 1240 | |
---|
[56] | 1241 | // Determine number of bits "offsetLenMinus1+1" required for entry point information |
---|
| 1242 | offsetLenMinus1 = 0; |
---|
| 1243 | while (1) |
---|
| 1244 | { |
---|
| 1245 | if (maxOffset >= (1 << offsetLenMinus1) ) |
---|
| 1246 | { |
---|
| 1247 | offsetLenMinus1++; |
---|
| 1248 | if ( offsetLenMinus1 > 32 ) |
---|
[2] | 1249 | { |
---|
[56] | 1250 | FATAL_ERROR_0("exceeded 32-bits", -1); |
---|
[2] | 1251 | } |
---|
| 1252 | } |
---|
[56] | 1253 | else |
---|
[2] | 1254 | { |
---|
[56] | 1255 | break; |
---|
[2] | 1256 | } |
---|
| 1257 | } |
---|
| 1258 | |
---|
[56] | 1259 | WRITE_UVLC(numEntryPointOffsets, "num_entry_point_offsets"); |
---|
| 1260 | if (numEntryPointOffsets>0) |
---|
[2] | 1261 | { |
---|
[56] | 1262 | WRITE_UVLC(offsetLenMinus1, "offset_len_minus1"); |
---|
[2] | 1263 | } |
---|
[56] | 1264 | |
---|
| 1265 | for (UInt idx=0; idx<numEntryPointOffsets; idx++) |
---|
[2] | 1266 | { |
---|
[56] | 1267 | if ( idx == 0 ) |
---|
| 1268 | { |
---|
| 1269 | // Adding sizes of NALU header and slice header information to entryPointOffset[ 0 ] |
---|
| 1270 | Int bitDistFromNALUHdrStart = m_pcBitIf->getNumberOfWrittenBits() + 16; |
---|
| 1271 | entryPointOffset[ idx ] += ( bitDistFromNALUHdrStart + numEntryPointOffsets*(offsetLenMinus1+1) ) >> 3; |
---|
| 1272 | } |
---|
| 1273 | WRITE_CODE(entryPointOffset[ idx ], offsetLenMinus1+1, "entry_point_offset"); |
---|
[2] | 1274 | } |
---|
| 1275 | |
---|
[56] | 1276 | delete [] entryPointOffset; |
---|
[2] | 1277 | } |
---|
| 1278 | |
---|
[56] | 1279 | Void TEncCavlc::codeTerminatingBit ( UInt uilsLast ) |
---|
[2] | 1280 | { |
---|
[56] | 1281 | } |
---|
[2] | 1282 | |
---|
[56] | 1283 | Void TEncCavlc::codeSliceFinish () |
---|
| 1284 | { |
---|
| 1285 | } |
---|
[2] | 1286 | |
---|
[296] | 1287 | #if H3D_IVMP |
---|
[56] | 1288 | Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList, Int iNum ) |
---|
[2] | 1289 | #else |
---|
[56] | 1290 | Void TEncCavlc::codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) |
---|
[2] | 1291 | #endif |
---|
[56] | 1292 | { |
---|
| 1293 | assert(0); |
---|
| 1294 | } |
---|
[2] | 1295 | |
---|
[56] | 1296 | Void TEncCavlc::codePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) |
---|
| 1297 | { |
---|
| 1298 | assert(0); |
---|
| 1299 | } |
---|
[2] | 1300 | |
---|
[56] | 1301 | Void TEncCavlc::codePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1302 | { |
---|
| 1303 | assert(0); |
---|
| 1304 | } |
---|
[2] | 1305 | |
---|
[56] | 1306 | Void TEncCavlc::codeMergeFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1307 | { |
---|
| 1308 | assert(0); |
---|
| 1309 | } |
---|
[2] | 1310 | |
---|
[56] | 1311 | Void TEncCavlc::codeMergeIndex ( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1312 | { |
---|
| 1313 | assert(0); |
---|
| 1314 | } |
---|
[2] | 1315 | |
---|
[296] | 1316 | #if H3D_IVRP |
---|
[56] | 1317 | Void |
---|
| 1318 | TEncCavlc::codeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1319 | { |
---|
| 1320 | assert(0); |
---|
| 1321 | } |
---|
[2] | 1322 | #endif |
---|
| 1323 | |
---|
[56] | 1324 | Void TEncCavlc::codeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1325 | { |
---|
| 1326 | if (!m_bAlfCtrl) |
---|
| 1327 | { |
---|
| 1328 | return; |
---|
[2] | 1329 | } |
---|
[56] | 1330 | |
---|
| 1331 | if( pcCU->getDepth(uiAbsPartIdx) > m_uiMaxAlfCtrlDepth && !pcCU->isFirstAbsZorderIdxInDepth(uiAbsPartIdx, m_uiMaxAlfCtrlDepth)) |
---|
| 1332 | { |
---|
| 1333 | return; |
---|
| 1334 | } |
---|
| 1335 | |
---|
| 1336 | // get context function is here |
---|
| 1337 | UInt uiSymbol = pcCU->getAlfCtrlFlag( uiAbsPartIdx ) ? 1 : 0; |
---|
| 1338 | |
---|
| 1339 | xWriteFlag( uiSymbol ); |
---|
| 1340 | } |
---|
[2] | 1341 | |
---|
[56] | 1342 | Void TEncCavlc::codeApsExtensionFlag () |
---|
| 1343 | { |
---|
| 1344 | WRITE_FLAG(0, "aps_extension_flag"); |
---|
[2] | 1345 | } |
---|
| 1346 | |
---|
[56] | 1347 | Void TEncCavlc::codeAlfCtrlDepth() |
---|
| 1348 | { |
---|
| 1349 | if (!m_bAlfCtrl) |
---|
[2] | 1350 | { |
---|
[56] | 1351 | return; |
---|
[2] | 1352 | } |
---|
[56] | 1353 | |
---|
| 1354 | UInt uiDepth = m_uiMaxAlfCtrlDepth; |
---|
| 1355 | |
---|
| 1356 | xWriteUvlc(uiDepth); |
---|
| 1357 | } |
---|
[2] | 1358 | |
---|
[56] | 1359 | Void TEncCavlc::codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode ) |
---|
| 1360 | { |
---|
| 1361 | assert(0); |
---|
| 1362 | } |
---|
[2] | 1363 | |
---|
[56] | 1364 | Void TEncCavlc::codeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1365 | { |
---|
| 1366 | assert(0); |
---|
| 1367 | } |
---|
[2] | 1368 | |
---|
[189] | 1369 | #if LGE_ILLUCOMP_B0045 |
---|
| 1370 | Void TEncCavlc::codeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1371 | { |
---|
| 1372 | assert(0); |
---|
| 1373 | } |
---|
| 1374 | #endif |
---|
| 1375 | |
---|
[56] | 1376 | Void TEncCavlc::codeSplitFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) |
---|
| 1377 | { |
---|
| 1378 | assert(0); |
---|
| 1379 | } |
---|
[2] | 1380 | |
---|
[56] | 1381 | Void TEncCavlc::codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx ) |
---|
| 1382 | { |
---|
| 1383 | assert(0); |
---|
| 1384 | } |
---|
[2] | 1385 | |
---|
[56] | 1386 | Void TEncCavlc::codeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth ) |
---|
| 1387 | { |
---|
| 1388 | assert(0); |
---|
| 1389 | } |
---|
[2] | 1390 | |
---|
[56] | 1391 | Void TEncCavlc::codeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1392 | { |
---|
| 1393 | assert(0); |
---|
| 1394 | } |
---|
[2] | 1395 | |
---|
[56] | 1396 | /** Code I_PCM information. |
---|
| 1397 | * \param pcCU pointer to CU |
---|
| 1398 | * \param uiAbsPartIdx CU index |
---|
| 1399 | * \param numIPCM the number of succesive IPCM blocks with the same size |
---|
| 1400 | * \param firstIPCMFlag |
---|
| 1401 | * \returns Void |
---|
| 1402 | */ |
---|
| 1403 | Void TEncCavlc::codeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Int numIPCM, Bool firstIPCMFlag) |
---|
| 1404 | { |
---|
| 1405 | assert(0); |
---|
| 1406 | } |
---|
[2] | 1407 | |
---|
[382] | 1408 | Void TEncCavlc::codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx |
---|
| 1409 | #if PKU_QC_DEPTH_INTRA_UNI_D0195 |
---|
| 1410 | , Bool bSdcRD |
---|
| 1411 | #endif |
---|
| 1412 | ) |
---|
[56] | 1413 | { |
---|
| 1414 | assert(0); |
---|
| 1415 | } |
---|
[2] | 1416 | |
---|
[56] | 1417 | Void TEncCavlc::codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1418 | { |
---|
| 1419 | assert(0); |
---|
[2] | 1420 | } |
---|
| 1421 | |
---|
[56] | 1422 | Void TEncCavlc::codeInterDir( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
[2] | 1423 | { |
---|
[56] | 1424 | assert(0); |
---|
| 1425 | } |
---|
[2] | 1426 | |
---|
[56] | 1427 | Void TEncCavlc::codeRefFrmIdx( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) |
---|
| 1428 | { |
---|
| 1429 | assert(0); |
---|
[2] | 1430 | } |
---|
| 1431 | |
---|
[56] | 1432 | Void TEncCavlc::codeMvd( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) |
---|
[2] | 1433 | { |
---|
[56] | 1434 | assert(0); |
---|
[2] | 1435 | } |
---|
| 1436 | |
---|
[56] | 1437 | Void TEncCavlc::codeDeltaQP( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1438 | { |
---|
| 1439 | Int iDQp = pcCU->getQP( uiAbsPartIdx ) - pcCU->getRefQP( uiAbsPartIdx ); |
---|
| 1440 | |
---|
| 1441 | Int qpBdOffsetY = pcCU->getSlice()->getSPS()->getQpBDOffsetY(); |
---|
| 1442 | iDQp = (iDQp + 78 + qpBdOffsetY + (qpBdOffsetY/2)) % (52 + qpBdOffsetY) - 26 - (qpBdOffsetY/2); |
---|
| 1443 | |
---|
| 1444 | xWriteSvlc( iDQp ); |
---|
| 1445 | |
---|
| 1446 | return; |
---|
| 1447 | } |
---|
| 1448 | |
---|
| 1449 | Void TEncCavlc::codeCoeffNxN ( TComDataCU* pcCU, TCoeff* pcCoef, UInt uiAbsPartIdx, UInt uiWidth, UInt uiHeight, UInt uiDepth, TextType eTType ) |
---|
| 1450 | { |
---|
| 1451 | assert(0); |
---|
| 1452 | } |
---|
| 1453 | |
---|
| 1454 | Void TEncCavlc::codeAlfFlag( UInt uiCode ) |
---|
| 1455 | { |
---|
| 1456 | xWriteFlag( uiCode ); |
---|
| 1457 | } |
---|
| 1458 | |
---|
[2] | 1459 | Void TEncCavlc::codeAlfCtrlFlag( UInt uiSymbol ) |
---|
| 1460 | { |
---|
| 1461 | xWriteFlag( uiSymbol ); |
---|
| 1462 | } |
---|
| 1463 | |
---|
| 1464 | Void TEncCavlc::codeAlfUvlc( UInt uiCode ) |
---|
| 1465 | { |
---|
| 1466 | xWriteUvlc( uiCode ); |
---|
| 1467 | } |
---|
| 1468 | |
---|
| 1469 | Void TEncCavlc::codeAlfSvlc( Int iCode ) |
---|
| 1470 | { |
---|
| 1471 | xWriteSvlc( iCode ); |
---|
| 1472 | } |
---|
[56] | 1473 | /** Code the fixed length code (smaller than one max value) in OSALF |
---|
| 1474 | * \param idx: coded value |
---|
| 1475 | * \param maxValue: max value |
---|
| 1476 | */ |
---|
| 1477 | Void TEncCavlc::codeAlfFixedLengthIdx( UInt idx, UInt maxValue) |
---|
[2] | 1478 | { |
---|
[56] | 1479 | UInt length = 0; |
---|
| 1480 | assert(idx<=maxValue); |
---|
[2] | 1481 | |
---|
[56] | 1482 | UInt temp = maxValue; |
---|
| 1483 | for(UInt i=0; i<32; i++) |
---|
| 1484 | { |
---|
| 1485 | if(temp&0x1) |
---|
| 1486 | { |
---|
| 1487 | length = i+1; |
---|
| 1488 | } |
---|
| 1489 | temp = (temp >> 1); |
---|
| 1490 | } |
---|
| 1491 | |
---|
| 1492 | if(length) |
---|
| 1493 | { |
---|
| 1494 | xWriteCode( idx, length ); |
---|
| 1495 | } |
---|
| 1496 | } |
---|
| 1497 | |
---|
| 1498 | Void TEncCavlc::codeSaoFlag( UInt uiCode ) |
---|
| 1499 | { |
---|
[2] | 1500 | xWriteFlag( uiCode ); |
---|
| 1501 | } |
---|
| 1502 | |
---|
[56] | 1503 | Void TEncCavlc::codeSaoUvlc( UInt uiCode ) |
---|
[2] | 1504 | { |
---|
| 1505 | xWriteUvlc( uiCode ); |
---|
| 1506 | } |
---|
| 1507 | |
---|
[56] | 1508 | Void TEncCavlc::codeSaoSvlc( Int iCode ) |
---|
[2] | 1509 | { |
---|
| 1510 | xWriteSvlc( iCode ); |
---|
| 1511 | } |
---|
[56] | 1512 | /** Code SAO run. |
---|
| 1513 | * \param uiCode |
---|
| 1514 | * \param maxValue |
---|
| 1515 | */ |
---|
| 1516 | Void TEncCavlc::codeSaoRun( UInt uiCode, UInt maxValue) |
---|
| 1517 | { |
---|
| 1518 | UInt uiLength = 0; |
---|
| 1519 | if (!maxValue) |
---|
| 1520 | { |
---|
| 1521 | return; |
---|
| 1522 | } |
---|
| 1523 | assert(uiCode<=maxValue); |
---|
[2] | 1524 | |
---|
[56] | 1525 | for(UInt i=0; i<32; i++) |
---|
| 1526 | { |
---|
| 1527 | if(maxValue&0x1) |
---|
| 1528 | { |
---|
| 1529 | uiLength = i+1; |
---|
| 1530 | } |
---|
| 1531 | maxValue = (maxValue >> 1); |
---|
| 1532 | } |
---|
| 1533 | WRITE_CODE( uiCode, uiLength, "sao_run_diff"); |
---|
| 1534 | } |
---|
[2] | 1535 | |
---|
[56] | 1536 | Void TEncCavlc::estBit( estBitsSbacStruct* pcEstBitsCabac, Int width, Int height, TextType eTType ) |
---|
[2] | 1537 | { |
---|
| 1538 | // printf("error : no VLC mode support in this version\n"); |
---|
| 1539 | return; |
---|
| 1540 | } |
---|
| 1541 | |
---|
| 1542 | // ==================================================================================================================== |
---|
| 1543 | // Protected member functions |
---|
| 1544 | // ==================================================================================================================== |
---|
| 1545 | |
---|
| 1546 | Void TEncCavlc::xWriteCode ( UInt uiCode, UInt uiLength ) |
---|
| 1547 | { |
---|
| 1548 | assert ( uiLength > 0 ); |
---|
| 1549 | m_pcBitIf->write( uiCode, uiLength ); |
---|
| 1550 | } |
---|
| 1551 | |
---|
| 1552 | Void TEncCavlc::xWriteUvlc ( UInt uiCode ) |
---|
| 1553 | { |
---|
| 1554 | UInt uiLength = 1; |
---|
| 1555 | UInt uiTemp = ++uiCode; |
---|
[56] | 1556 | |
---|
[2] | 1557 | assert ( uiTemp ); |
---|
[56] | 1558 | |
---|
[2] | 1559 | while( 1 != uiTemp ) |
---|
| 1560 | { |
---|
| 1561 | uiTemp >>= 1; |
---|
| 1562 | uiLength += 2; |
---|
| 1563 | } |
---|
[56] | 1564 | |
---|
| 1565 | //m_pcBitIf->write( uiCode, uiLength ); |
---|
| 1566 | // Take care of cases where uiLength > 32 |
---|
| 1567 | m_pcBitIf->write( 0, uiLength >> 1); |
---|
| 1568 | m_pcBitIf->write( uiCode, (uiLength+1) >> 1); |
---|
[2] | 1569 | } |
---|
| 1570 | |
---|
| 1571 | Void TEncCavlc::xWriteSvlc ( Int iCode ) |
---|
| 1572 | { |
---|
| 1573 | UInt uiCode; |
---|
[56] | 1574 | |
---|
[2] | 1575 | uiCode = xConvertToUInt( iCode ); |
---|
| 1576 | xWriteUvlc( uiCode ); |
---|
| 1577 | } |
---|
| 1578 | |
---|
| 1579 | Void TEncCavlc::xWriteFlag( UInt uiCode ) |
---|
| 1580 | { |
---|
| 1581 | m_pcBitIf->write( uiCode, 1 ); |
---|
| 1582 | } |
---|
| 1583 | |
---|
[56] | 1584 | /** Write PCM alignment bits. |
---|
| 1585 | * \returns Void |
---|
| 1586 | */ |
---|
| 1587 | Void TEncCavlc::xWritePCMAlignZero () |
---|
[2] | 1588 | { |
---|
[56] | 1589 | m_pcBitIf->writeAlignZero(); |
---|
[2] | 1590 | } |
---|
| 1591 | |
---|
| 1592 | Void TEncCavlc::xWriteUnaryMaxSymbol( UInt uiSymbol, UInt uiMaxSymbol ) |
---|
| 1593 | { |
---|
| 1594 | if (uiMaxSymbol == 0) |
---|
| 1595 | { |
---|
| 1596 | return; |
---|
| 1597 | } |
---|
| 1598 | xWriteFlag( uiSymbol ? 1 : 0 ); |
---|
| 1599 | if ( uiSymbol == 0 ) |
---|
| 1600 | { |
---|
| 1601 | return; |
---|
| 1602 | } |
---|
[56] | 1603 | |
---|
[2] | 1604 | Bool bCodeLast = ( uiMaxSymbol > uiSymbol ); |
---|
[56] | 1605 | |
---|
[2] | 1606 | while( --uiSymbol ) |
---|
| 1607 | { |
---|
| 1608 | xWriteFlag( 1 ); |
---|
| 1609 | } |
---|
| 1610 | if( bCodeLast ) |
---|
| 1611 | { |
---|
| 1612 | xWriteFlag( 0 ); |
---|
| 1613 | } |
---|
| 1614 | return; |
---|
| 1615 | } |
---|
| 1616 | |
---|
| 1617 | Void TEncCavlc::xWriteExGolombLevel( UInt uiSymbol ) |
---|
| 1618 | { |
---|
| 1619 | if( uiSymbol ) |
---|
| 1620 | { |
---|
| 1621 | xWriteFlag( 1 ); |
---|
| 1622 | UInt uiCount = 0; |
---|
| 1623 | Bool bNoExGo = (uiSymbol < 13); |
---|
[56] | 1624 | |
---|
[2] | 1625 | while( --uiSymbol && ++uiCount < 13 ) |
---|
| 1626 | { |
---|
| 1627 | xWriteFlag( 1 ); |
---|
| 1628 | } |
---|
| 1629 | if( bNoExGo ) |
---|
| 1630 | { |
---|
| 1631 | xWriteFlag( 0 ); |
---|
| 1632 | } |
---|
| 1633 | else |
---|
| 1634 | { |
---|
| 1635 | xWriteEpExGolomb( uiSymbol, 0 ); |
---|
| 1636 | } |
---|
| 1637 | } |
---|
| 1638 | else |
---|
| 1639 | { |
---|
| 1640 | xWriteFlag( 0 ); |
---|
| 1641 | } |
---|
| 1642 | return; |
---|
| 1643 | } |
---|
| 1644 | |
---|
| 1645 | Void TEncCavlc::xWriteEpExGolomb( UInt uiSymbol, UInt uiCount ) |
---|
| 1646 | { |
---|
| 1647 | while( uiSymbol >= (UInt)(1<<uiCount) ) |
---|
| 1648 | { |
---|
| 1649 | xWriteFlag( 1 ); |
---|
| 1650 | uiSymbol -= 1<<uiCount; |
---|
| 1651 | uiCount ++; |
---|
| 1652 | } |
---|
| 1653 | xWriteFlag( 0 ); |
---|
| 1654 | while( uiCount-- ) |
---|
| 1655 | { |
---|
| 1656 | xWriteFlag( (uiSymbol>>uiCount) & 1 ); |
---|
| 1657 | } |
---|
| 1658 | return; |
---|
| 1659 | } |
---|
| 1660 | |
---|
[56] | 1661 | /** code explicit wp tables |
---|
| 1662 | * \param TComSlice* pcSlice |
---|
| 1663 | * \returns Void |
---|
[2] | 1664 | */ |
---|
[56] | 1665 | Void TEncCavlc::xCodePredWeightTable( TComSlice* pcSlice ) |
---|
[2] | 1666 | { |
---|
[56] | 1667 | wpScalingParam *wp; |
---|
| 1668 | Bool bChroma = true; // color always present in HEVC ? |
---|
| 1669 | Int iNbRef = (pcSlice->getSliceType() == B_SLICE ) ? (2) : (1); |
---|
| 1670 | Bool bDenomCoded = false; |
---|
[2] | 1671 | |
---|
[56] | 1672 | UInt uiMode = 0; |
---|
| 1673 | if ( (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()==0 ) ) |
---|
| 1674 | uiMode = 1; // explicit |
---|
| 1675 | else if ( pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==2 ) |
---|
| 1676 | uiMode = 2; // implicit (does not use this mode in this syntax) |
---|
| 1677 | if (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1 && pcSlice->getRefPicListCombinationFlag()) |
---|
| 1678 | uiMode = 3; // combined explicit |
---|
| 1679 | if(uiMode == 1) |
---|
[2] | 1680 | { |
---|
[56] | 1681 | for ( Int iNumRef=0 ; iNumRef<iNbRef ; iNumRef++ ) |
---|
[2] | 1682 | { |
---|
[56] | 1683 | RefPicList eRefPicList = ( iNumRef ? REF_PIC_LIST_1 : REF_PIC_LIST_0 ); |
---|
| 1684 | for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(eRefPicList) ; iRefIdx++ ) |
---|
[2] | 1685 | { |
---|
[56] | 1686 | pcSlice->getWpScaling(eRefPicList, iRefIdx, wp); |
---|
| 1687 | if ( !bDenomCoded ) |
---|
[2] | 1688 | { |
---|
[56] | 1689 | Int iDeltaDenom; |
---|
| 1690 | WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom |
---|
[2] | 1691 | |
---|
[56] | 1692 | if( bChroma ) |
---|
[2] | 1693 | { |
---|
[56] | 1694 | iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom); |
---|
| 1695 | WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom |
---|
[2] | 1696 | } |
---|
[56] | 1697 | bDenomCoded = true; |
---|
| 1698 | } |
---|
[2] | 1699 | |
---|
[56] | 1700 | WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lX_flag" ); // u(1): luma_weight_lX_flag |
---|
[2] | 1701 | |
---|
[56] | 1702 | if ( wp[0].bPresentFlag ) |
---|
| 1703 | { |
---|
| 1704 | Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom)); |
---|
| 1705 | WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lX" ); // se(v): delta_luma_weight_lX |
---|
| 1706 | WRITE_SVLC( wp[0].iOffset, "luma_offset_lX" ); // se(v): luma_offset_lX |
---|
| 1707 | } |
---|
[2] | 1708 | |
---|
[56] | 1709 | if ( bChroma ) |
---|
| 1710 | { |
---|
| 1711 | WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lX_flag" ); // u(1): chroma_weight_lX_flag |
---|
[2] | 1712 | |
---|
[56] | 1713 | if ( wp[1].bPresentFlag ) |
---|
[2] | 1714 | { |
---|
[56] | 1715 | for ( Int j=1 ; j<3 ; j++ ) |
---|
[2] | 1716 | { |
---|
[56] | 1717 | Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom)); |
---|
| 1718 | WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lX" ); // se(v): delta_chroma_weight_lX |
---|
| 1719 | |
---|
| 1720 | Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1)); |
---|
| 1721 | WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lX" ); // se(v): delta_chroma_offset_lX |
---|
[2] | 1722 | } |
---|
| 1723 | } |
---|
| 1724 | } |
---|
| 1725 | } |
---|
| 1726 | } |
---|
| 1727 | } |
---|
[56] | 1728 | else if (uiMode == 3) |
---|
[2] | 1729 | { |
---|
[56] | 1730 | for ( Int iRefIdx=0 ; iRefIdx<pcSlice->getNumRefIdx(REF_PIC_LIST_C) ; iRefIdx++ ) |
---|
| 1731 | { |
---|
| 1732 | RefPicList eRefPicList = (RefPicList)pcSlice->getListIdFromIdxOfLC(iRefIdx); |
---|
| 1733 | Int iCombRefIdx = pcSlice->getRefIdxFromIdxOfLC(iRefIdx); |
---|
[2] | 1734 | |
---|
[56] | 1735 | pcSlice->getWpScaling(eRefPicList, iCombRefIdx, wp); |
---|
| 1736 | if ( !bDenomCoded ) |
---|
[2] | 1737 | { |
---|
[56] | 1738 | Int iDeltaDenom; |
---|
| 1739 | WRITE_UVLC( wp[0].uiLog2WeightDenom, "luma_log2_weight_denom" ); // ue(v): luma_log2_weight_denom |
---|
| 1740 | |
---|
| 1741 | if( bChroma ) |
---|
| 1742 | { |
---|
| 1743 | iDeltaDenom = (wp[1].uiLog2WeightDenom - wp[0].uiLog2WeightDenom); |
---|
| 1744 | WRITE_SVLC( iDeltaDenom, "delta_chroma_log2_weight_denom" ); // se(v): delta_chroma_log2_weight_denom |
---|
| 1745 | } |
---|
| 1746 | bDenomCoded = true; |
---|
[2] | 1747 | } |
---|
| 1748 | |
---|
[56] | 1749 | WRITE_FLAG( wp[0].bPresentFlag, "luma_weight_lc_flag" ); // u(1): luma_weight_lc_flag |
---|
[2] | 1750 | |
---|
[56] | 1751 | if ( wp[0].bPresentFlag ) |
---|
| 1752 | { |
---|
| 1753 | Int iDeltaWeight = (wp[0].iWeight - (1<<wp[0].uiLog2WeightDenom)); |
---|
| 1754 | WRITE_SVLC( iDeltaWeight, "delta_luma_weight_lc" ); // se(v): delta_luma_weight_lc |
---|
| 1755 | WRITE_SVLC( wp[0].iOffset, "luma_offset_lc" ); // se(v): luma_offset_lc |
---|
| 1756 | } |
---|
| 1757 | if ( bChroma ) |
---|
| 1758 | { |
---|
| 1759 | WRITE_FLAG( wp[1].bPresentFlag, "chroma_weight_lc_flag" ); // u(1): luma_weight_lc_flag |
---|
[2] | 1760 | |
---|
[56] | 1761 | if ( wp[1].bPresentFlag ) |
---|
| 1762 | { |
---|
| 1763 | for ( Int j=1 ; j<3 ; j++ ) |
---|
| 1764 | { |
---|
| 1765 | Int iDeltaWeight = (wp[j].iWeight - (1<<wp[1].uiLog2WeightDenom)); |
---|
| 1766 | WRITE_SVLC( iDeltaWeight, "delta_chroma_weight_lc" ); // se(v): delta_chroma_weight_lc |
---|
[2] | 1767 | |
---|
[56] | 1768 | Int iDeltaChroma = (wp[j].iOffset + ( ( (g_uiIBDI_MAX>>1)*wp[j].iWeight)>>(wp[j].uiLog2WeightDenom) ) - (g_uiIBDI_MAX>>1)); |
---|
| 1769 | WRITE_SVLC( iDeltaChroma, "delta_chroma_offset_lc" ); // se(v): delta_chroma_offset_lc |
---|
| 1770 | } |
---|
| 1771 | } |
---|
| 1772 | } |
---|
[2] | 1773 | } |
---|
| 1774 | } |
---|
[56] | 1775 | } |
---|
[2] | 1776 | |
---|
[56] | 1777 | /** code quantization matrix |
---|
| 1778 | * \param scalingList quantization matrix information |
---|
| 1779 | */ |
---|
| 1780 | Void TEncCavlc::codeScalingList( TComScalingList* scalingList ) |
---|
| 1781 | { |
---|
| 1782 | UInt listId,sizeId; |
---|
| 1783 | Bool scalingListPredModeFlag; |
---|
[2] | 1784 | |
---|
[56] | 1785 | #if SCALING_LIST_OUTPUT_RESULT |
---|
| 1786 | Int startBit; |
---|
| 1787 | Int startTotalBit; |
---|
| 1788 | startBit = m_pcBitIf->getNumberOfWrittenBits(); |
---|
| 1789 | startTotalBit = m_pcBitIf->getNumberOfWrittenBits(); |
---|
[2] | 1790 | #endif |
---|
| 1791 | |
---|
[56] | 1792 | WRITE_FLAG( scalingList->getScalingListPresentFlag (), "scaling_list_present_flag" ); |
---|
| 1793 | |
---|
| 1794 | if(scalingList->getScalingListPresentFlag () == false) |
---|
[2] | 1795 | { |
---|
[56] | 1796 | #if SCALING_LIST_OUTPUT_RESULT |
---|
| 1797 | printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startBit); |
---|
[2] | 1798 | #endif |
---|
[56] | 1799 | //for each size |
---|
| 1800 | for(sizeId = 0; sizeId < SCALING_LIST_SIZE_NUM; sizeId++) |
---|
[2] | 1801 | { |
---|
[56] | 1802 | for(listId = 0; listId < g_scalingListNum[sizeId]; listId++) |
---|
[2] | 1803 | { |
---|
[56] | 1804 | #if SCALING_LIST_OUTPUT_RESULT |
---|
| 1805 | startBit = m_pcBitIf->getNumberOfWrittenBits(); |
---|
[2] | 1806 | #endif |
---|
[56] | 1807 | scalingListPredModeFlag = scalingList->checkPredMode( sizeId, listId ); |
---|
| 1808 | WRITE_FLAG( scalingListPredModeFlag, "scaling_list_pred_mode_flag" ); |
---|
| 1809 | if(!scalingListPredModeFlag)// Copy Mode |
---|
[2] | 1810 | { |
---|
[56] | 1811 | WRITE_UVLC( (Int)listId - (Int)scalingList->getRefMatrixId (sizeId,listId) - 1, "scaling_list_pred_matrix_id_delta"); |
---|
[2] | 1812 | } |
---|
[56] | 1813 | else// DPCM Mode |
---|
[2] | 1814 | { |
---|
[56] | 1815 | xCodeScalingList(scalingList, sizeId, listId); |
---|
[2] | 1816 | } |
---|
[56] | 1817 | #if SCALING_LIST_OUTPUT_RESULT |
---|
| 1818 | printf("Matrix [%d][%d] Bit %d\n",sizeId,listId,m_pcBitIf->getNumberOfWrittenBits() - startBit); |
---|
[2] | 1819 | #endif |
---|
| 1820 | } |
---|
| 1821 | } |
---|
| 1822 | } |
---|
[56] | 1823 | #if SCALING_LIST_OUTPUT_RESULT |
---|
| 1824 | else |
---|
[2] | 1825 | { |
---|
[56] | 1826 | printf("Header Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit); |
---|
[2] | 1827 | } |
---|
[56] | 1828 | printf("Total Bit %d\n",m_pcBitIf->getNumberOfWrittenBits()-startTotalBit); |
---|
| 1829 | #endif |
---|
[2] | 1830 | return; |
---|
| 1831 | } |
---|
[56] | 1832 | /** code DPCM |
---|
| 1833 | * \param scalingList quantization matrix information |
---|
| 1834 | * \param sizeIdc size index |
---|
| 1835 | * \param listIdc list index |
---|
| 1836 | */ |
---|
| 1837 | Void TEncCavlc::xCodeScalingList(TComScalingList* scalingList, UInt sizeId, UInt listId) |
---|
[2] | 1838 | { |
---|
[56] | 1839 | Int coefNum = min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId]); |
---|
| 1840 | UInt* scan = g_auiFrameScanXY [ (sizeId == 0)? 1 : 2]; |
---|
| 1841 | Int nextCoef = SCALING_LIST_START_VALUE; |
---|
| 1842 | Int data; |
---|
| 1843 | Int *src = scalingList->getScalingListAddress(sizeId, listId); |
---|
| 1844 | if(sizeId > SCALING_LIST_8x8 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId)) |
---|
[2] | 1845 | { |
---|
[56] | 1846 | WRITE_SVLC( -8, "scaling_list_dc_coef_minus8"); |
---|
[2] | 1847 | } |
---|
[56] | 1848 | else if(sizeId < SCALING_LIST_16x16 && scalingList->getUseDefaultScalingMatrixFlag(sizeId,listId)) |
---|
[2] | 1849 | { |
---|
[56] | 1850 | WRITE_SVLC( -8, "scaling_list_delta_coef"); |
---|
[2] | 1851 | } |
---|
[56] | 1852 | else |
---|
[2] | 1853 | { |
---|
[56] | 1854 | if( sizeId > SCALING_LIST_8x8 ) |
---|
[2] | 1855 | { |
---|
[56] | 1856 | WRITE_SVLC( scalingList->getScalingListDC(sizeId,listId) - 8, "scaling_list_dc_coef_minus8"); |
---|
[2] | 1857 | } |
---|
[56] | 1858 | for(Int i=0;i<coefNum;i++) |
---|
[2] | 1859 | { |
---|
[56] | 1860 | data = src[scan[i]] - nextCoef; |
---|
| 1861 | nextCoef = src[scan[i]]; |
---|
| 1862 | if(data > 127) |
---|
[2] | 1863 | { |
---|
[56] | 1864 | data = data - 256; |
---|
[2] | 1865 | } |
---|
[56] | 1866 | if(data < -128) |
---|
[2] | 1867 | { |
---|
[56] | 1868 | data = data + 256; |
---|
[2] | 1869 | } |
---|
| 1870 | |
---|
[56] | 1871 | WRITE_SVLC( data, "scaling_list_delta_coef"); |
---|
[2] | 1872 | } |
---|
| 1873 | } |
---|
| 1874 | } |
---|
[56] | 1875 | Bool TComScalingList::checkPredMode(UInt sizeId, UInt listId) |
---|
| 1876 | { |
---|
| 1877 | for(Int predListIdx = (Int)listId -1 ; predListIdx >= 0; predListIdx--) |
---|
| 1878 | { |
---|
| 1879 | if( !memcmp(getScalingListAddress(sizeId,listId),getScalingListAddress(sizeId, predListIdx),sizeof(Int)*min(MAX_MATRIX_COEF_NUM,(Int)g_scalingListSize[sizeId])) // check value of matrix |
---|
| 1880 | && ((sizeId < SCALING_LIST_16x16) || (getScalingListDC(sizeId,listId) == getScalingListDC(sizeId,predListIdx)))) // check DC value |
---|
| 1881 | { |
---|
| 1882 | setRefMatrixId(sizeId, listId, predListIdx); |
---|
| 1883 | return false; |
---|
[2] | 1884 | } |
---|
| 1885 | } |
---|
[56] | 1886 | return true; |
---|
[2] | 1887 | } |
---|
[189] | 1888 | |
---|
| 1889 | #if RWTH_SDC_DLT_B0036 |
---|
[382] | 1890 | #if !PKU_QC_DEPTH_INTRA_UNI_D0195 |
---|
[189] | 1891 | Void TEncCavlc::codeSDCFlag ( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1892 | { |
---|
| 1893 | assert(0); |
---|
| 1894 | } |
---|
[382] | 1895 | #endif |
---|
[189] | 1896 | Void TEncCavlc::codeSDCResidualData ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiSegment ) |
---|
| 1897 | { |
---|
| 1898 | assert(0); |
---|
| 1899 | } |
---|
[382] | 1900 | #if !PKU_QC_DEPTH_INTRA_UNI_D0195 |
---|
[189] | 1901 | Void TEncCavlc::codeSDCPredMode ( TComDataCU* pcCU, UInt uiAbsPartIdx ) |
---|
| 1902 | { |
---|
| 1903 | assert(0); |
---|
| 1904 | } |
---|
| 1905 | #endif |
---|
[382] | 1906 | #endif |
---|
[56] | 1907 | //! \} |
---|