HEVC函数入门（16）——Slice编码

最新推荐文章于 2023-10-30 00:59:50 发布
最新推荐文章于 2023-10-30 00:59:50 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： HM HEVC HEVC函数及应用入门 文章标签： hevc 编码
HEVC 同时被 3 个专栏收录
32 篇文章 15 订阅
订阅专栏
HEVC函数及应用入门
30 篇文章 24 订阅
订阅专栏
HM
24 篇文章 11 订阅
订阅专栏

本文转载整理自：http://blog.csdn.net/NB_vol_1/article/details/51152578
这篇文章很多东西还没搞懂，所以先转载放在这。
入口函数TEncSlice::compressSlice
这个函数主要是设置一些参数和初始化一些东西，然后对片中的每一个LCU调用initCU（初始化CU）和compressCU（对CU编码）和encodeCU（对CU进行熵编码，目的是选择最优参数）。
TEncSlice::compressSlice函数的详解：
（1）计算当前slice的开始CU和结束CU
（2）初始化Sbac编码器
（3）再把slice的熵编码器设置为Sbac编码器
（4）重置熵编码器（主要是上下文的重置）
（5）取得二值化编码器
（6）取得比特计数器
（7）遍历slice中的每一个LCU
①初始化LCU
②调用compressCU，用于求最优模式
③调用encodeCU，进行熵编码
下面放代码：

// 对条带编码  
Void TEncSlice::compressSlice( TComPic*& rpcPic )  
{  
    // CU的地址  
    UInt  uiCUAddr;  
    // CU的开始地址  
    UInt   uiStartCUAddr;  
    // CU的边界地址  
    UInt   uiBoundingCUAddr;  
    // 条带中当前的比特数量是0  
    rpcPic->getSlice(getSliceIdx())->setSliceSegmentBits(0);  
    TEncBinCABAC* pppcRDSbacCoder = NULL;  

    // 当前的条带  
    TComSlice* pcSlice            = rpcPic->getSlice(getSliceIdx());  

    // 得到CU（LCU）的开始和结束地址      
    xDetermineStartAndBoundingCUAddr ( uiStartCUAddr, uiBoundingCUAddr, rpcPic, false );  
    //uiStartCUAddr = 0, uiBoundingCUAddr = 2304  

    // initialize cost values  
    // 图像总的比特数  
    m_uiPicTotalBits  = 0;  
    // 率失真代价  
    m_dPicRdCost      = 0;  
    // 帧的distortion（失真）  
    m_uiPicDist       = 0;  

    // set entropy coder  
    // 初始化熵编码器  
    m_pcSbacCoder->init( m_pcBinCABAC );  
    // 设置熵编码器  
    m_pcEntropyCoder->setEntropyCoder   ( m_pcSbacCoder, pcSlice );  
    // 重置熵编码  
    // //!< 主要进行上下文模型的初始化，codILow和codIRange的初始化等  
    m_pcEntropyCoder->resetEntropy      ();  
    // 加载熵编码器SBAC  
    m_pppcRDSbacCoder[0][CI_CURR_BEST]->load(m_pcSbacCoder);  
    pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();  
    pppcRDSbacCoder->setBinCountingEnableFlag( false );  
    pppcRDSbacCoder->setBinsCoded( 0 );  

    //------------------------------------------------------------------------------  
    //  Weighted Prediction parameters estimation.  
    //------------------------------------------------------------------------------  
    // calculate AC/DC values for current picture  
    // 不进入，因为没有使用波前前向预测  
    if( pcSlice->getPPS()->getUseWP() || pcSlice->getPPS()->getWPBiPred() )  
    {  
        xCalcACDCParamSlice(pcSlice);  
    }  

    Bool bWp_explicit = (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) || (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred());  

    // 不进入  
    if ( bWp_explicit )  
    {  
        //------------------------------------------------------------------------------  
        //  Weighted Prediction implemented at Slice level. SliceMode=2 is not supported yet.  
        //------------------------------------------------------------------------------  
        if ( pcSlice->getSliceMode()==2 || pcSlice->getSliceSegmentMode()==2 )  
        {  
            printf("Weighted Prediction is not supported with slice mode determined by max number of bins.\n"); exit(0);  
        }  

        xEstimateWPParamSlice( pcSlice );  
        pcSlice->initWpScaling();  

        // check WP on/off  
        xCheckWPEnable( pcSlice );  
    }  

    // 自适应量化步长  
#if ADAPTIVE_QP_SELECTION  
    // 不进入  
    if( m_pcCfg->getUseAdaptQpSelect() )  
    {  
        m_pcTrQuant->clearSliceARLCnt();  
        if(pcSlice->getSliceType()!=I_SLICE)  
        {  
            Int qpBase = pcSlice->getSliceQpBase();  
            pcSlice->setSliceQp(qpBase + m_pcTrQuant->getQpDelta(qpBase));  
        }  
    }  
#endif  

    // 获取编码器的配置  
    TEncTop* pcEncTop = (TEncTop*) m_pcCfg;  

    // 从配置中取得sbac编码器  
    TEncSbac**** ppppcRDSbacCoders    = pcEncTop->getRDSbacCoders();  
    // 从配置中获取比特计数器  
    TComBitCounter* pcBitCounters     = pcEncTop->getBitCounters();  

    // 子流的数量  
    Int  iNumSubstreams = 1;  
    // 穿过区块的个数  
    UInt uiTilesAcross  = 0;  

    iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();//1  
    uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;//1  
    delete[] m_pcBufferSbacCoders;  
    delete[] m_pcBufferBinCoderCABACs;  
    m_pcBufferSbacCoders     = new TEncSbac    [uiTilesAcross];  
    m_pcBufferBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];  
    for (Int ui = 0; ui < uiTilesAcross; ui++)  
    {  
        m_pcBufferSbacCoders[ui].init( &m_pcBufferBinCoderCABACs[ui] );  
    }  
    for (UInt ui = 0; ui < uiTilesAcross; ui++)  
    {  
        m_pcBufferSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);  //init. state  
    }  

    for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ ) //init all sbac coders for RD optimization  
    {  
        ppppcRDSbacCoders[ui][0][CI_CURR_BEST]->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);  
    }  

    delete[] m_pcBufferLowLatSbacCoders;  
    delete[] m_pcBufferLowLatBinCoderCABACs;  
    m_pcBufferLowLatSbacCoders     = new TEncSbac    [uiTilesAcross];  
    m_pcBufferLowLatBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];  
    for (Int ui = 0; ui < uiTilesAcross; ui++)  
    {  
        m_pcBufferLowLatSbacCoders[ui].init( &m_pcBufferLowLatBinCoderCABACs[ui] );  
    }  
    for (UInt ui = 0; ui < uiTilesAcross; ui++)  
        m_pcBufferLowLatSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);  //init. state  

    // 获取一帧图像中纵向可以存放多少个CU（目前是3个）  
    // 同理垂直方向上也有可以存放3个，因此，一个slice中有3*3=9个LCU  
    UInt uiWidthInLCUs  = rpcPic->getPicSym()->getFrameWidthInCU();       // 3  
    //UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();  
    UInt uiCol=0, uiLin=0, uiSubStrm=0;  
    UInt uiTileCol      = 0;  
    UInt uiTileStartLCU = 0;  
    UInt uiTileLCUX     = 0;  
    // 禁用了依赖性条带片段  
    Bool depSliceSegmentsEnabled = pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag(); // false  
    uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());//0  
    uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();//0  

    // 是否启用了条带片段功能  
    if( depSliceSegmentsEnabled )  
    {  
        if((pcSlice->getSliceSegmentCurStartCUAddr()!= pcSlice->getSliceCurStartCUAddr())&&(uiCUAddr != uiTileStartLCU))  
        {  
            if( m_pcCfg->getWaveFrontsynchro() )  
            {  
                uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);  
                m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] );  
                Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();  
                uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());   
                uiLin     = uiCUAddr / uiWidthInLCUs;  
                uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(rpcPic->getPicSym()->getCUOrderMap(uiCUAddr))*iNumSubstreamsPerTile  
                    + uiLin%iNumSubstreamsPerTile;  
                if ( (uiCUAddr%uiWidthInLCUs+1) >= uiWidthInLCUs  )  
                {  
                    uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;  
                    uiCol     = uiCUAddr % uiWidthInLCUs;  
                    if(uiCol==uiTileStartLCU)  
                    {  
                        CTXMem[0]->loadContexts(m_pcSbacCoder);  
                    }  
                }  
            }  
            m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( CTXMem[0] );  
            ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->loadContexts( CTXMem[0] );  
        }  
        else  
        {  
            if(m_pcCfg->getWaveFrontsynchro())  
            {  
                CTXMem[1]->loadContexts(m_pcSbacCoder);  
            }  
            CTXMem[0]->loadContexts(m_pcSbacCoder);  
        }  
    }  

    // for every CU in slice  
    // 处理条带中的每一个CU  

    int nLCUofSlice = 0;  
    // 编码CU的顺序  
    UInt uiEncCUOrder;  

    // rpcPic->getNumPartInCU()获取一个LCU分裂的个数，即它内部包含多少个CU  
    for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();  
        uiEncCUOrder < (uiBoundingCUAddr+(rpcPic->getNumPartInCU()-1))/rpcPic->getNumPartInCU();  
        uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )  
    {  
        // initialize CU encoder  
        // 根据CU的地址取得CU（LCU）   
        TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );  

        // 初始化CU  
        pcCU->initCU( rpcPic, uiCUAddr );  

        // HM15.0中似乎没有用到区块  
        // inherit from TR if necessary, select substream to use.  
        uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?  // 0  
        uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr(); // 0  
        uiTileLCUX = uiTileStartLCU % uiWidthInLCUs; // 0  
        //UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();  
        uiCol     = uiCUAddr % uiWidthInLCUs; // 0  
        uiLin     = uiCUAddr / uiWidthInLCUs; // 0  

        // 子比特流数量是1，所以没有进去  
        if (pcSlice->getPPS()->getNumSubstreams() > 1)  
        {  
            // independent tiles => substreams are "per tile".  iNumSubstreams has already been multiplied.  
            Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();  
            uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)*iNumSubstreamsPerTile  
                + uiLin%iNumSubstreamsPerTile;  
        }  
        else  
        {  
            // dependent tiles => substreams are "per frame".  
            uiSubStrm = uiLin % iNumSubstreams; //0  
        }  

        //  
        if ( ((pcSlice->getPPS()->getNumSubstreams() > 1) || depSliceSegmentsEnabled ) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())  
        {  
            // We'll sync if the TR is available.  
            TComDataCU *pcCUUp = pcCU->getCUAbove();  
            UInt uiWidthInCU = rpcPic->getFrameWidthInCU();  
            UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);  
            TComDataCU *pcCUTR = NULL;  
            if ( pcCUUp && ((uiCUAddr%uiWidthInCU+1) < uiWidthInCU)  )  
            {  
                pcCUTR = rpcPic->getCU( uiCUAddr - uiWidthInCU + 1 );  
            }  
            if ( ((pcCUTR==NULL) || (pcCUTR->getSlice()==NULL) ||  
                (pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getSliceCurStartCUAddr()) ||  
                ((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))  
                )  
                )  
            {  
                // TR not available.  
            }  
            else  
            {  
                // TR is available, we use it.  
                ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );  
            }  
        }  
        m_pppcRDSbacCoder[0][CI_CURR_BEST]->load( ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST] ); //this load is used to simplify the code  

        // reset the entropy coder  
        // 重置熵编码器  
        if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() &&                                   // must be first CU of tile  
            uiCUAddr!=0 &&                                                                                                                                    // cannot be first CU of picture  
            uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceSegmentCurStartCUAddr())/rpcPic->getNumPartInCU() &&  
            uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU())     // cannot be first CU of slice  
        {  
            SliceType sliceType = pcSlice->getSliceType();  
            if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag() && pcSlice->getPPS()->getEncCABACTableIdx()!=I_SLICE)  
            {  
                sliceType = (SliceType) pcSlice->getPPS()->getEncCABACTableIdx();  
            }  
            m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp(), false );  
            m_pcEntropyCoder->setEntropyCoder     ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );  
            m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp() );  
            m_pcEntropyCoder->setEntropyCoder     ( m_pcSbacCoder, pcSlice );  
        }  

        // set go-on entropy coder  
        m_pcEntropyCoder->setEntropyCoder ( m_pcRDGoOnSbacCoder, pcSlice );  
        m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );  

        ((TEncBinCABAC*)m_pcRDGoOnSbacCoder->getEncBinIf())->setBinCountingEnableFlag(true);  

        Double oldLambda = m_pcRdCost->getLambda();//57.9。。。  

        // 没有使用码率控制  
        if ( m_pcCfg->getUseRateCtrl() )  
        {  
            Int estQP        = pcSlice->getSliceQp();  
            Double estLambda = -1.0;  
            Double bpp       = -1.0;  

            if ( ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE && m_pcCfg->getForceIntraQP() ) || !m_pcCfg->getLCULevelRC() )  
            {  
                estQP = pcSlice->getSliceQp();  
            }  
            else  
            {  
                bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp(pcSlice->getSliceType());  
                if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE)  
                {  
                    estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambdaAndQP(bpp, pcSlice->getSliceQp(), &estQP);  
                }  
                else  
                {  
                    estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );  
                    estQP     = m_pcRateCtrl->getRCPic()->getLCUEstQP    ( estLambda, pcSlice->getSliceQp() );  
                }  

                estQP     = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, estQP );  

                m_pcRdCost->setLambda(estLambda);  
#if RDOQ_CHROMA_LAMBDA  
                // set lambda for RDOQ  
                Double weight=m_pcRdCost->getChromaWeight();  
                const Double lambdaArray[3] = { estLambda, (estLambda / weight), (estLambda / weight) };  
                m_pcTrQuant->setLambdas( lambdaArray );  
#else  
                m_pcTrQuant->setLambda( estLambda );  
#endif  
            }  

            m_pcRateCtrl->setRCQP( estQP );  
#if ADAPTIVE_QP_SELECTION  
            pcCU->getSlice()->setSliceQpBase( estQP );  
#endif  
        }  

        // run CU encoder  
        // 对CU进行编码（压缩）  
        // 帧内预测，帧间预测编码还有变换编码  
        // 这里很重要  
        // 编码单元编码  
        // 最重要的部分！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！  
        // 注意这个只是尝试进行，然后选出最优熵编码方案，下面的encodeCU才是真正进行熵编码的地方  
        m_pcCuEncoder->compressCU( pcCU );  
        // 最重要的部分！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！  

        // restore entropy coder to an initial stage  
        // 熵编码器设置为Sbac  
        m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );  
        // 设置需要写入的比特流  
        m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );  
        m_pcCuEncoder->setBitCounter( &pcBitCounters[uiSubStrm] );  
        // 比特计数器（用于统计熵编码器写入到比特流中的比特数）  
        m_pcBitCounter = &pcBitCounters[uiSubStrm];  
        pppcRDSbacCoder->setBinCountingEnableFlag( true );  
        m_pcBitCounter->resetBits();  
        pppcRDSbacCoder->setBinsCoded( 0 );  

        // 对CU进编码  
        // 这里是真正的进行熵编码！！！！  
        // 重要！！！！！！！！！！！！！  
        m_pcCuEncoder->encodeCU( pcCU );  
        // 重要！！！！！！！！！！！！！  

        pppcRDSbacCoder->setBinCountingEnableFlag( false );  

        // 这两个判断，是为了判断该CU是否为条带中的最后一个CU，如果是则跳出循环  
        if (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES && ( ( pcSlice->getSliceBits() + m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)  
        {  
            pcSlice->setNextSlice( true );  
            break;  
        }  
        if (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceSegmentBits()+m_pcEntropyCoder->getNumberOfWrittenBits() > (m_pcCfg->getSliceSegmentArgument() << 3) &&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getSliceSegmentCurEndCUAddr())  
        {  
            pcSlice->setNextSliceSegment( true );  
            break;  
        }  

        ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );  
        //Store probabilties of second LCU in line into buffer  
        if ( ( uiCol == uiTileLCUX+1) && (depSliceSegmentsEnabled || (pcSlice->getPPS()->getNumSubstreams() > 1)) && m_pcCfg->getWaveFrontsynchro())  
        {  
            m_pcBufferSbacCoders[uiTileCol].loadContexts(ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]);  
        }  

        // 没有使用码率控制  
        if ( m_pcCfg->getUseRateCtrl() )  
        {  

            Int actualQP        = g_RCInvalidQPValue;  
            Double actualLambda = m_pcRdCost->getLambda();  
            Int actualBits      = pcCU->getTotalBits();  
            Int numberOfEffectivePixels    = 0;  
            for ( Int idx = 0; idx < rpcPic->getNumPartInCU(); idx++ )  
            {  
                if ( pcCU->getPredictionMode( idx ) != MODE_NONE && ( !pcCU->isSkipped( idx ) ) )  
                {  
                    numberOfEffectivePixels = numberOfEffectivePixels + 16;  
                    break;  
                }  
            }  

            if ( numberOfEffectivePixels == 0 )  
            {  
                actualQP = g_RCInvalidQPValue;  
            }  
            else  
            {  
                actualQP = pcCU->getQP( 0 );  
            }  
            m_pcRdCost->setLambda(oldLambda);  

            m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,  
                pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );  
        }  

        // 计算总的比特数  
        m_uiPicTotalBits += pcCU->getTotalBits();  
        // 计算运行代价  
        m_dPicRdCost     += pcCU->getTotalCost();  
        // 计算失真率  
        m_uiPicDist      += pcCU->getTotalDistortion();  
    } // for end  

    if ((pcSlice->getPPS()->getNumSubstreams() > 1) && !depSliceSegmentsEnabled)  
    {  
        pcSlice->setNextSlice( true );  
    }  
    if(m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES || m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES)  
    {  
        if(pcSlice->getSliceCurEndCUAddr()<=pcSlice->getSliceSegmentCurEndCUAddr())  
        {  
            pcSlice->setNextSlice( true );  
        }  
        else  
        {  
            pcSlice->setNextSliceSegment( true );  
        }  
    }  
    if( depSliceSegmentsEnabled )  
    {  
        if (m_pcCfg->getWaveFrontsynchro())  
        {  
            CTXMem[1]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );//ctx 2.LCU  
        }  
        CTXMem[0]->loadContexts( m_pppcRDSbacCoder[0][CI_CURR_BEST] );//ctx end of dep.slice  
    }  
    // 存储WP参数  
    xRestoreWPparam( pcSlice );  
}
慢慢积累不怕寂寞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HEVC编码结构：Slice和Tile
慢慢积累
10-07 1万+
HEVC编码结构中的Slice、Tile结构概念及两者关系
多slice码流
qq_34754747的博客
07-30 2715
现象 在iOS平台的硬解的实践中，我们可能会遇到如下图的这种情况（上面一部分有画面，下面部分是绿屏）： 原因 有的推流端出于编码性能的考虑，会选择通过切片的方式来编码，这样一个frame的数据就可能被切片分散于多个nalu中(哥伦布编码)，但是videotoolbox解码又必须是整个frame合并到一个nalu中解码，暂时不知道合并算法，但是通过ffmpeg打开得到的流是合并过的(据说的熵编码)。 例子 下面是一个切片的裸流数据(PES包后的裸数据) 00 00 00 01 67 64..
HEVC中的条带(slice)与条带片段(slice segment)
lessconcern的专栏
06-26 2541
HEVC中提出了条带与条带片段两个概念。 按照定义，条带是由独立条带片段(independent slice segment)及其所附属的非独立条带片段(dependent slice segment)(如果存在的话)构成的。编码非独立条带片段时，条带头就只需标明其起始地址及其它非常少的必要信息即可，其它头信息可参考其对应的独立条带片段即可。 因此当我们谈到条带的地址(Slic
HM编码器代码阅读(7)——整个编码流程以及相关的函数
NB_vol_1的专栏
04-13 7205
来自网上的文档，但是最初来源不知道是哪，谢谢这个作者！ 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每一帧，对每一帧进行单独编码 2、每一帧又会被划分成若干slice（HM15中，每一帧对应一个slice），因此对每一帧的处理就转换成对每一片的处理。 3、每一个slice都会调用com
HEVC编码之precompressSlice函数
杨杨子江的博客
04-22 569
HEVC中每一个slice的QP值并不一定像设定的QP值一样，之所以会这样都是precompressSlice函数的“功劳” Void TEncSlice::precompressSlice( TComPic* pcPic ) { // if deltaQP RD is not used, simply return if ( m_pcCfg->getDeltaQpRD() == 0...
HEVC编码原理讲义.zip
09-09
《HEVC编码原理详解》 HEVC（High Efficiency Video Coding），即高效视频编码，是现代视频编码技术的重要标准，旨在显著提高视频压缩效率，降低存储和传输成本。本讲义结合PPT和PDF资料，全面解析HEVC的核心原理与...
HEVC入门论文(多篇)
11-06
这篇paper重要性不言而喻，粗糙的讲解了HEVC，作为入门必备，第一遍看不懂正常，我看第三遍才有点感觉，里面的术语缩写知道啥意思后就明了了，看得快了。 2.第二篇非<High performance, low complexity video ...
HEVC/h.265视频编码解码
12-09
在HEVC编码中，视频被分割成更小的编码单元，例如最小单元可以是4x4、8x8或16x16像素的块，这样可以根据每个块的内容差异进行更精细的编码。 描述中提到"可直接使用VS打开运行，自带配置文件"，这表明提供的压缩包...
H.265/HEVC压缩编码标准
06-03
JCTVC-L1003_v9(High Efficiency Video Coding (HEVC) text specification draft 10 (for FDIS & Consent))； 是为了了解SPS每一个参数的意义找的，确实有说明每一个参数，像毕厚杰那本“新一代压缩标准H264”介绍...
HEVC 视频扩展 —— 微软应用商店版本
05-10
官方描述：在 Windows 10 设备上的任何视频应用中播放高效率视频编码(HEVC)视频。这些扩展旨在利用某些较新设备(例如配备 Intel 第 7 代 Core 处理器和较新 GPU 的设备)上的硬件功能支持 4K 和 Ultra HD 内容。对于...
H.264视频编码：Slice的艺术与实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-30 343
H.264视频编码：Slice的艺术与实践
hevc slice头字段
fantasy_ARM9的博客
12-08 768
hevc slice head
HEVC 片与片段(Slice 和Slice Segment)说明
z373248439的博客
12-06 1954
HEVC 片与片段(Slice 和Slice Segment)说明 一幅图像可以被分割为一个或多个片(Slice)，每个片的压缩数据都是独立的，Slice头信息无法通过前一个Slice的头信息推断得到。这就要求Slice不能跨过它的边界来进行帧内或帧间预测，且在进行熵编码前需要进行初始化。但在进行环路滤波时，允许滤波器跨越Slice的边界进行滤波。除了Slice的边界可能受环路滤波影响外，Slice的解码过程可以不使用任何来自其他Slice的影响，且有利于实现并行运算。使用Slice的主要目的是当数据丢失后
如何设置编码器分片参数
骑驴看唱本
03-30 1511
SliceMode             =  0   # Slice mode (0=off 1=fixed #mb in slice 2=fixed #bytes in slice 3=use callback) 正如注释所说： 值为 0，表示不采用分片。也就是一个片组为一个片，如果不采用片组那么就是一幅图像为一个片。 值为 1，表示将每 SliceArgument 个宏块分为一个片；
HEVC的并行解码语法和条带结构Slice和Tile
不是他人太努力，只是自己努力不够罢了
06-14 7307
本文内容转载自：http://blog.sina.com.cn/s/blog_520811730101ij6p.html 并部分整理自：http://blog.csdn.net/lin453701006/article/details/52748678 和http://blog.sina.com.cn/s/blog_77d329940102v6ly.html首先是Slice和Tile这两个我一直
HEVC代码学习38：decompressSlice函数
慢慢积累
05-11 1174
好久没看HEVC了，今天回归，来学习一下解码端的decompressSlice函数，有两个，一个是TDecGop类的成员函数，另一个是TDecSlice类的。 TDecGop::decompressSlice 该函数比较简单，是解码一帧图像的上层入口函数，在TDecGop::xDecodeSlice中被调用。主要功能是完成熵解码器初始化和计时工作，并会调用TDecSlice::decompre...
ffmpeg的hevc slice多线程解码
qq_37287599的博客
08-09 1580
ff_thread_init判断对slice并行或者frame并行进行初始化 int ff_thread_init(AVCodecContext *avctx) 71 { 72 validate_thread_parameters(avctx); 73 74 if (avctx->active_thread_type&FF_THREAD_SLICE) 75 ...
探索算法迷宫：揭秘寻找最短路径的神兵利器
最新发布
08-19
数据结构是计算机科学中的一个基本概念，它指的是数据的组织、管理和存储方式，以及对数据的操作。数据结构使得数据的访问和修改更加高效和有序。常见的数据结构包括： 1. **数组**（Array）：一种线性数据结构，可以存储相同类型的元素，并通过索引访问。 2. **链表**（Linked List）：一种线性数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。 3. **栈**（Stack）：一种后进先出（LIFO, Last In First Out）的数据结构，只能在一端进行添加或删除操作。 4. **队列**（Queue）：一种先进先出（FIFO, First In First Out）的数据结构，允许在一端添加元素，在另一端删除元素。 5. **哈希表**（Hash Table）：通过键值对存储数据的数据结构，可以快速地通过键来访问数据。 6. **树**（Tree）：一种层次结构的数据结构，每个节点有零个或多个子节点，通常用于表示具有层次关系的数据。 7. **图**（Graph）：由顶点（节点）和边组成，可以表示复杂的关系和网络结构。 每种数据结构都有其
基于Android习惯养成APP设计与实现.docx
08-19
基于Android习惯养成APP设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值