x265探索与研究（七）：encode()函数

x265探索与研究（七）：encode()函数

 

        在x265中，main()函数中调用了encoder_encode()函数，而encoder_encode()函数调用了encode()函数，encode()函数的主要功能是输入一帧图像，得到一帧图像的输出。

 

        encode()函数主要包括大致三个部分：

（1）分析是否由于错误造成的代码终止，如g_checkFailures、m_aborted。

（2）判断是否有输入帧，若有，则判断该输入帧的像素深度、颜色空间是否支持，并判断List是否为空，若为空则创建；除此之外，还有一个比较重要的变量，即ret，此处初始化了ret为0，ret用于判断encode()函数的执行状况，0代表当前没有可供输出的重构帧，则返回encoder_encode()函数进行处理，1代表有输出，从encode()函数的最后一行代码return ret可以证实这一点。

（3）用一个do/while()判断是否有输出，若有则ret为1，并且调用了startCompressFrame()函数，startCompressFrame()函数的主要目的就是触发线程，为进一步的编码做准备。

 

        对应的代码分析如下：

/*=============================================================*/
/*
 ====== Analysed by: RuiDong Fang 
 ====== Csdn Blog:	 http://blog.csdn.net/frd2009041510 
 ====== Date:		 2016.04.14
 ====== Funtion：	 encode()函数,Feed one new input frame into the encoder, get one frame out.
 */
/*=============================================================*/
/**
 * Feed one new input frame into the encoder, get one frame out. If pic_in is
 * NULL, a flush condition is implied and pic_in must be NULL for all subsequent
 * calls for this encoder instance.
 *
 * pic_in  input original YUV picture or NULL
 * pic_out pointer to reconstructed picture struct
 *
 * returns 0 if no frames are currently available for output
 *         1 if frame was output, m_nalList contains access unit
 *         negative on malloc error or abort */
int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
{
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////1
#if CHECKED_BUILD || _DEBUG
    if (g_checkFailures)
    {
        x265_log(m_param, X265_LOG_ERROR, "encoder aborting because of internal error\n");
        return -1;
    }
#endif
    if (m_aborted)
        return -1;

    if (m_exportedPic)
    {
        ATOMIC_DEC(&m_exportedPic->m_countRefEncoders);
        m_exportedPic = NULL;
        m_dpb->recycleUnreferenced();
    }

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////2
	//若有输入时
    if (pic_in)
    {
        //判断输入帧的颜色空间是否支持，若不支持，打印错误
		if (pic_in->colorSpace != m_param->internalCsp)
        {
            x265_log(m_param, X265_LOG_ERROR, "Unsupported color space (%d) on input\n",
                     pic_in->colorSpace);
            return -1;
        }

		//输入的每一帧的深度必须处于8至16范围内
        if (pic_in->bitDepth < 8 || pic_in->bitDepth > 16)
        {
            x265_log(m_param, X265_LOG_ERROR, "Input bit depth (%d) must be between 8 and 16\n",
                     pic_in->bitDepth);
            return -1;
        }

        Frame *inFrame;
        if (m_dpb->m_freeList.empty())	//若List为空，则创建
        {
            inFrame = new Frame;
            x265_param* p = m_reconfigured? m_latestParam : m_param;
            if (inFrame->create(p))
            {
                /* the first PicYuv created is asked to generate the CU and block unit offset
                 * arrays which are then shared with all subsequent PicYuv (orig and recon) 
                 * allocated by this top level encoder */
                if (m_cuOffsetY)
                {
                    inFrame->m_fencPic->m_cuOffsetC = m_cuOffsetC;
                    inFrame->m_fencPic->m_cuOffsetY = m_cuOffsetY;
                    inFrame->m_fencPic->m_buOffsetC = m_buOffsetC;
                    inFrame->m_fencPic->m_buOffsetY = m_buOffsetY;
                }
                else
                {
                    if (!inFrame->m_fencPic->createOffsets(m_sps))
                    {
                        m_aborted = true;
                        x265_log(m_param, X265_LOG_ERROR, "memory allocation failure, aborting encode\n");
                        inFrame->destroy();
                        delete inFrame;
                        return -1;
                    }
                    else
                    {
                        m_cuOffsetC = inFrame->m_fencPic->m_cuOffsetC;
                        m_cuOffsetY = inFrame->m_fencPic->m_cuOffsetY;
                        m_buOffsetC = inFrame->m_fencPic->m_buOffsetC;
                        m_buOffsetY = inFrame->m_fencPic->m_buOffsetY;
                    }
                }
            }
            else
            {
                m_aborted = true;
                x265_log(m_param, X265_LOG_ERROR, "memory allocation failure, aborting encode\n");
                inFrame->destroy();
                delete inFrame;
                return -1;
            }
        }
        else	//若List不为空，则popBack
        {
            inFrame = m_dpb->m_freeList.popBack();
            inFrame->m_lowresInit = false;
        }

        /* Copy input picture into a Frame and PicYuv, send to lookahead */
        inFrame->m_fencPic->copyFromPicture(*pic_in, m_sps.conformanceWindow.rightOffset, m_sps.conformanceWindow.bottomOffset);

        inFrame->m_poc       = ++m_pocLast;
        inFrame->m_userData  = pic_in->userData;
        inFrame->m_pts       = pic_in->pts;
        inFrame->m_forceqp   = pic_in->forceqp;
        inFrame->m_param     = m_reconfigured ? m_latestParam : m_param;

        if (m_pocLast == 0)	//若POC=0
            m_firstPts = inFrame->m_pts;
        if (m_bframeDelay && m_pocLast == m_bframeDelay)
            m_bframeDelayTime = inFrame->m_pts - m_firstPts;

        /* Encoder holds a reference count until stats collection is finished */
        ATOMIC_INC(&inFrame->m_countRefEncoders);

        if ((m_param->rc.aqMode || m_param->bEnableWeightedPred || m_param->bEnableWeightedBiPred) &&
            (m_param->rc.cuTree && m_param->rc.bStatRead))
        {
            if (!m_rateControl->cuTreeReadFor2Pass(inFrame))
            {
                m_aborted = 1;
                return -1;
            }
        }

        /* Use the frame types from the first pass, if available */
        int sliceType = (m_param->rc.bStatRead) ? m_rateControl->rateControlSliceType(inFrame->m_poc) : pic_in->sliceType;

        /* In analysisSave mode, x265_analysis_data is allocated in pic_in and inFrame points to this */
        /* Load analysis data before lookahead->addPicture, since sliceType has been decided */
        if (m_param->analysisMode == X265_ANALYSIS_LOAD)
        {
            x265_picture* inputPic = const_cast<x265_picture*>(pic_in);
            /* readAnalysisFile reads analysis data for the frame and allocates memory based on slicetype */
            readAnalysisFile(&inputPic->analysisData, inFrame->m_poc);
            inFrame->m_analysisData.poc = inFrame->m_poc;
            inFrame->m_analysisData.sliceType = inputPic->analysisData.sliceType;
            inFrame->m_analysisData.numCUsInFrame = inputPic->analysisData.numCUsInFrame;
            inFrame->m_analysisData.numPartitions = inputPic->analysisData.numPartitions;
            inFrame->m_analysisData.interData = inputPic->analysisData.interData;
            inFrame->m_analysisData.intraData = inputPic->analysisData.intraData;
            sliceType = inputPic->analysisData.sliceType;
        }

        m_lookahead->addPicture(*inFrame, sliceType);
        m_numDelayedPic++;
    }
    else //若没有输入
        m_lookahead->flush();

    FrameEncoder *curEncoder = m_frameEncoder[m_curEncoder];
    m_curEncoder = (m_curEncoder + 1) % m_param->frameNumThreads;	//当前要编码的帧
    
	/*ret用于判断该整体函数的状况：
	若当前没有可供输出的帧则为0（if no frames are currently available for output），
	否则为1（1 if frame was output, m_nalList contains access unit negative on malloc error or abort）。*/
	int ret = 0;	

    /* Normal operation is to wait for the current frame encoder to complete its current frame
     * and then to give it a new frame to work on.  In zero-latency mode, we must encode this
     * input picture before returning so the order must be reversed. This do/while() loop allows
     * us to alternate the order of the calls without ugly code replication */
    Frame* outFrame = NULL;
    Frame* frameEnc = NULL;
    int pass = 0;
    
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////3
	//do/while() loop
	do
    {
        /* getEncodedPicture() should block until the FrameEncoder has completed
         * encoding the frame.  This is how back-pressure through the API is
         * accomplished when the encoder is full */
        if (!m_bZeroLatency || pass)
            outFrame = curEncoder->getEncodedPicture(m_nalList);
        if (outFrame)
        {
            Slice *slice = outFrame->m_encData->m_slice;
            x265_frame_stats* frameData = NULL;

            /* Free up pic_in->analysisData since it has already been used */
            if (m_param->analysisMode == X265_ANALYSIS_LOAD)
                freeAnalysis(&outFrame->m_analysisData);

            if (pic_out)	//若有输出
            {
                PicYuv *recpic = outFrame->m_reconPic;
                pic_out->poc = slice->m_poc;
                pic_out->bitDepth = X265_DEPTH;
                pic_out->userData = outFrame->m_userData;
                pic_out->colorSpace = m_param->internalCsp;
                frameData = &(pic_out->frameData);

                pic_out->pts = outFrame->m_pts;
                pic_out->dts = outFrame->m_dts;

				//判断该帧的类型--I/P/B
                switch (slice->m_sliceType)
                {
                case I_SLICE:
                    pic_out->sliceType = outFrame->m_lowres.bKeyframe ? X265_TYPE_IDR : X265_TYPE_I;
                    break;
                case P_SLICE:
                    pic_out->sliceType = X265_TYPE_P;
                    break;
                case B_SLICE:
                    pic_out->sliceType = X265_TYPE_B;
                    break;
                }

                pic_out->planes[0] = recpic->m_picOrg[0];
                pic_out->stride[0] = (int)(recpic->m_stride * sizeof(pixel));
                pic_out->planes[1] = recpic->m_picOrg[1];
                pic_out->stride[1] = (int)(recpic->m_strideC * sizeof(pixel));
                pic_out->planes[2] = recpic->m_picOrg[2];
                pic_out->stride[2] = (int)(recpic->m_strideC * sizeof(pixel));

                /* Dump analysis data from pic_out to file in save mode and free */
                if (m_param->analysisMode == X265_ANALYSIS_SAVE)
                {
                    pic_out->analysisData.poc = pic_out->poc;
                    pic_out->analysisData.sliceType = pic_out->sliceType;
                    pic_out->analysisData.numCUsInFrame = outFrame->m_analysisData.numCUsInFrame;
                    pic_out->analysisData.numPartitions = outFrame->m_analysisData.numPartitions;
                    pic_out->analysisData.interData = outFrame->m_analysisData.interData;
                    pic_out->analysisData.intraData = outFrame->m_analysisData.intraData;
                    writeAnalysisFile(&pic_out->analysisData);
                    freeAnalysis(&pic_out->analysisData);
                }
            }
            if (slice->m_sliceType == P_SLICE)
            {
                if (slice->m_weightPredTable[0][0][0].bPresentFlag)
                    m_numLumaWPFrames++;
                if (slice->m_weightPredTable[0][0][1].bPresentFlag ||
                    slice->m_weightPredTable[0][0][2].bPresentFlag)
                    m_numChromaWPFrames++;
            }
            else if (slice->m_sliceType == B_SLICE)
            {
                bool bLuma = false, bChroma = false;
                for (int l = 0; l < 2; l++)
                {
                    if (slice->m_weightPredTable[l][0][0].bPresentFlag)
                        bLuma = true;
                    if (slice->m_weightPredTable[l][0][1].bPresentFlag ||
                        slice->m_weightPredTable[l][0][2].bPresentFlag)
                        bChroma = true;
                }

                if (bLuma)
                    m_numLumaWPBiFrames++;
                if (bChroma)
                    m_numChromaWPBiFrames++;
            }

            if (m_aborted)
                return -1;

            finishFrameStats(outFrame, curEncoder, curEncoder->m_accessUnitBits, frameData);

            /* Write RateControl Frame level stats in multipass encodes */
            if (m_param->rc.bStatWrite)
                if (m_rateControl->writeRateControlFrameStats(outFrame, &curEncoder->m_rce))
                    m_aborted = true;

            /* Allow this frame to be recycled if no frame encoders are using it for reference */
            if (!pic_out)
            {
                ATOMIC_DEC(&outFrame->m_countRefEncoders);
                m_dpb->recycleUnreferenced();
            }
            else
                m_exportedPic = outFrame;

            m_numDelayedPic--;

            ret = 1;	//有输出，则ret为1
        }

        /* pop a single frame from decided list, then provide to frame encoder
         * curEncoder is guaranteed to be idle at this point */
        if (!pass)
            frameEnc = m_lookahead->getDecidedPicture();
        
		if (frameEnc && !pass)
        {
            /* give this frame a FrameData instance before encoding */
            if (m_dpb->m_picSymFreeList)
            {
                frameEnc->m_encData = m_dpb->m_picSymFreeList;
                m_dpb->m_picSymFreeList = m_dpb->m_picSymFreeList->m_freeListNext;
                frameEnc->reinit(m_sps);
            }
            else
            {
                frameEnc->allocEncodeData(m_param, m_sps);
                Slice* slice = frameEnc->m_encData->m_slice;
                slice->m_sps = &m_sps;
                slice->m_pps = &m_pps;
                slice->m_maxNumMergeCand = m_param->maxNumMergeCand;
                slice->m_endCUAddr = slice->realEndAddress(m_sps.numCUsInFrame * NUM_4x4_PARTITIONS);
                frameEnc->m_reconPic->m_cuOffsetC = m_cuOffsetC;
                frameEnc->m_reconPic->m_cuOffsetY = m_cuOffsetY;
                frameEnc->m_reconPic->m_buOffsetC = m_buOffsetC;
                frameEnc->m_reconPic->m_buOffsetY = m_buOffsetY;
            }

            curEncoder->m_rce.encodeOrder = m_encodedFrameNum++;
            if (m_bframeDelay)
            {
                int64_t *prevReorderedPts = m_prevReorderedPts;
                frameEnc->m_dts = m_encodedFrameNum > m_bframeDelay
                    ? prevReorderedPts[(m_encodedFrameNum - m_bframeDelay) % m_bframeDelay]
                    : frameEnc->m_reorderedPts - m_bframeDelayTime;
                prevReorderedPts[m_encodedFrameNum % m_bframeDelay] = frameEnc->m_reorderedPts;
            }
            else
                frameEnc->m_dts = frameEnc->m_reorderedPts;

            /* Allocate analysis data before encode in save mode. This is allocated in frameEnc */
            if (m_param->analysisMode == X265_ANALYSIS_SAVE)
            {
                x265_analysis_data* analysis = &frameEnc->m_analysisData;
                analysis->poc = frameEnc->m_poc;
                analysis->sliceType = frameEnc->m_lowres.sliceType;
                uint32_t widthInCU       = (m_param->sourceWidth  + g_maxCUSize - 1) >> g_maxLog2CUSize;
                uint32_t heightInCU      = (m_param->sourceHeight + g_maxCUSize - 1) >> g_maxLog2CUSize;

                uint32_t numCUsInFrame   = widthInCU * heightInCU;
                analysis->numCUsInFrame  = numCUsInFrame;
                analysis->numPartitions  = NUM_4x4_PARTITIONS;
                allocAnalysis(analysis);
            }

            /* determine references, setup RPS, etc */
            m_dpb->prepareEncode(frameEnc);	//========================准备编码前的一些工作，如决定参考帧,设置RPS等等

            if (m_param->rc.rateControlMode != X265_RC_CQP)
                m_lookahead->getEstimatedPictureCost(frameEnc);

            /* Allow FrameEncoder::compressFrame() to start in the frame encoder thread */
            if (!curEncoder->startCompressFrame(frameEnc))	//========================编码线程的开始，调用了startCompressFrame()函数，而startCompressFrame()调用了m_enable.trigger()以触发线程
                m_aborted = true;
        }
        else if (m_encodedFrameNum)
            m_rateControl->setFinalFrameCount(m_encodedFrameNum); 
    }
    while (m_bZeroLatency && ++pass < 2);

    return ret;
}