h263pencode.cpp

H.263的编码程序,加了CPU指令优化,VC版.

			return FALSE;
		}
	}
	// set parameters for m_pStream
	m_pStream->buff_size = option.m_iUseBlock ? option.m_iUseBlock : (m_pEncStatus->lines * m_pEncStatus->pels);
	m_pStream->WriteData = option.m_EncoderCallBack;
	m_pStream->context   = option.m_pCBContext;

	m_pEncStatus->sourceFormat = option.m_iPicFormat;
	m_pEncStatus->version2 = option.m_iUseVersion2;   //!< h.263 or h.263+

	// choose annex
    m_pEncStatus->annex.Advanced_Prediction = option.m_iUseAP;
	if (m_pEncStatus->version2)
	{
		m_pEncStatus->annex.Temporal_Scalability = option.m_iUseBFrame;
		m_pEncStatus->annex.Deblocking_Filter = option.m_iUseDF;
		m_pEncStatus->annex.RPS = option.m_iUseRPS;
		m_pEncStatus->annex.AIC = option.m_iUseAIC;
	}
	else
	{
		m_pEncStatus->annex.Temporal_Scalability = 0;
		m_pEncStatus->annex.Deblocking_Filter = 0;
		m_pEncStatus->annex.RPS = 0;
		m_pEncStatus->annex.AIC = 0;
	}

	m_pEncStatus->mv_outside_frame = m_pEncStatus->annex.Advanced_Prediction || m_pEncStatus->annex.Deblocking_Filter || m_pEncStatus->annex.Temporal_Scalability;
    m_pEncStatus->use4mv = m_pEncStatus->annex.Advanced_Prediction || m_pEncStatus->annex.Deblocking_Filter;
    m_pEncStatus->obmc = m_pEncStatus->annex.Advanced_Prediction;
	m_pEncStatus->filter = m_pEncStatus->annex.Deblocking_Filter;
	m_pEncStatus->B_frame = m_pEncStatus->annex.Temporal_Scalability ? option.m_iBFrame : 0;
	if (m_pEncStatus->B_frame > 10)
	{
		m_pEncStatus->B_frame = 9;           //< The number of B frames inserted must be less than 10 
	}
    m_pEncStatus->buf_cycle = (m_pEncStatus->annex.RPS && option.m_iRefBufSize>2) ? option.m_iRefBufSize : 2;
    m_pEncStatus->advanced_intra_coding = m_pEncStatus->annex.AIC;  

	alloc_mem(m_pEncStatus, m_pMCStatus, m_pStream);

	
	///////////////////////////////////////
	// set global parameters of encoder
    if (!init_para(m_pEncStatus, option.m_iPRate, option.m_iQuantP, option.m_iQuantI, option.m_iQuantB, option.m_iUseGob, option.m_iFrameRate, option.m_iUseRC))
	{
		EncClose();
		return FALSE;
	}
	//initialize frame level parameters
    if (!init_control(m_pEncStatus))
	{
		EncClose();
		return FALSE;
	}
	//initialize mc parameters
    if (!init_MCPara(m_pMCStatus, option.m_iMVSearchWin, option.m_iMVSearchMethod))
	{
		EncClose();
		return FALSE;
	}  
	//initialize coded table and quant table
	if (!init_table(m_pEncStatus))
	{
		EncClose();
		return FALSE;
	}

	return TRUE;
}

/*!
*********************************************************
*    Encode one frame
*********************************************************/
int  CH263Encoder::EncOneFrame(unsigned char *pCapture, unsigned int &nTimeStamp)
{
	int size = 0;
	int type;
	int ref_type;

	/* get addresses of source buffer and stream buffer */
	GetSourceFrame(m_pEncStatus, pCapture);

	/* encode one frame */
	if (INTRA == m_pEncStatus->PTYPE)                   //encode an I-frame
	{
		type = INTRA;
		init_bitstrm(type, nTimeStamp, m_pStream);              //! initialize stream buffer
		if (!m_pEncStatus->target_bitrate)
		{
			m_pEncStatus->total_Q = m_pEncStatus->QI;               //! fixed Quant value
		}
		m_pEncStatus->totalBits = EncIfrm(m_pEncStatus);
		m_pEncStatus->framebits[m_pEncStatus->pic_nbr%m_pEncStatus->framerate] = m_pEncStatus->totalBits;
		m_pEncStatus->TRP[m_pEncStatus->zero_index] = m_pEncStatus->TR;
		m_pEncStatus->frame_skip = ratectrl(m_pEncStatus->target_bitrate, m_pEncStatus->framerate, m_pEncStatus->framebits, &m_pEncStatus->total_Q);
		size = m_pEncStatus->totalBits/8;
	}
	else if (INTER == m_pEncStatus->PTYPE)                       //encode a P-frame
	{
		type = INTER;
		ref_type = (m_pEncStatus->pcount - 1)%(m_pEncStatus->buf_cycle - 1);  //< for RPS use
		ref_type = ref_type << 16;
		type = type | ref_type;
		init_bitstrm(type, nTimeStamp, m_pStream);              //! initialize stream buffer
		if (!m_pEncStatus->target_bitrate)
		{
			m_pEncStatus->total_Q = m_pEncStatus->QP;               //! fixed Quant value
		}
		m_pEncStatus->totalBits = EncPfrm(m_pEncStatus, m_pMCStatus);
		m_pEncStatus->TRP[m_pEncStatus->zero_index] = m_pEncStatus->TR;		
		m_pEncStatus->framebits[m_pEncStatus->pic_nbr%m_pEncStatus->framerate] = m_pEncStatus->totalBits;
		m_pEncStatus->frame_skip = ratectrl(m_pEncStatus->target_bitrate, m_pEncStatus->framerate, m_pEncStatus->framebits, &m_pEncStatus->total_Q);
		size = m_pEncStatus->totalBits/8;

	}
	else if (B_IMG == m_pEncStatus->PTYPE)
	{
        unsigned int tmp = m_pEncStatus->nTime[m_pEncStatus->B_count];
		int          pic_size = m_pEncStatus->pels * m_pEncStatus->lines * 3 / 2;

		type = B_IMG;
		init_bitstrm(type, tmp, m_pStream);              //! initialize stream buffer
		if (!m_pEncStatus->target_bitrate)
		{
			m_pEncStatus->total_Q = m_pEncStatus->QB;    //! fixed Quant value
		}	
		m_pEncStatus->totalBits = EncBfrm(m_pEncStatus, m_pMCStatus);
		m_pEncStatus->framebits[m_pEncStatus->pic_nbr%m_pEncStatus->framerate] = m_pEncStatus->totalBits;
		m_pEncStatus->frame_skip = ratectrl(m_pEncStatus->target_bitrate, m_pEncStatus->framerate, m_pEncStatus->framebits, &m_pEncStatus->total_Q);
		memcpy(m_pEncStatus->BPicture[m_pEncStatus->B_count].pLum, m_pEncStatus->frameToEncode.pLum, pic_size);
		m_pEncStatus->TR4BPicture[m_pEncStatus->B_count] = m_pEncStatus->TR; //< save time reference of the captured frame
		m_pEncStatus->nTime[m_pEncStatus->B_count] = nTimeStamp; //< save time stamp of the captured frame
		nTimeStamp = tmp;                                    //< modify time stamp
		size = m_pEncStatus->totalBits/8;	
		


	}
	else if (STORE == m_pEncStatus->PTYPE)
	{
		int pic_size = m_pEncStatus->pels * m_pEncStatus->lines * 3 / 2;

		memcpy(m_pEncStatus->BPicture[m_pEncStatus->B_count].pLum, m_pEncStatus->frameToEncode.pLum, pic_size);
		m_pEncStatus->TR4BPicture[m_pEncStatus->B_count] = m_pEncStatus->TR; //< save time reference of the captured frame
		m_pEncStatus->nTime[m_pEncStatus->B_count] = nTimeStamp; //< save time stamp of the captured frame
		m_pEncStatus->totalBits = 0;
		m_pEncStatus->framebits[m_pEncStatus->pic_nbr%m_pEncStatus->framerate] = m_pEncStatus->totalBits;
		type = STORE;
		nTimeStamp = 0;
		size = 0;		

	}
	else
	{
		m_pEncStatus->totalBits = 0;
		m_pEncStatus->framebits[m_pEncStatus->pic_nbr%m_pEncStatus->framerate] = m_pEncStatus->totalBits;
		type = SKIP;
		nTimeStamp = 0;
		size = 0;
	}
    /* regulation and control */


	if (!m_pEncStatus->frame_skip)
	{
		if (m_pEncStatus->B_count < m_pEncStatus->B_frame)
		{
			m_pEncStatus->B_count++;
			m_pEncStatus->PTYPE = B_IMG;
			m_pEncStatus->TRB = m_pEncStatus->TR4BPicture[m_pEncStatus->B_count];
			if (m_pEncStatus->pcount == 0)
			{
				m_pEncStatus->PTYPE = STORE;
			}
			
		}
		else
		{
			m_pEncStatus->B_count = 0;
			if (m_pEncStatus->pcount < m_pEncStatus->p_rate)
			{
				m_pEncStatus->pcount++;
				m_pEncStatus->PTYPE = INTER;
			}
			else
			{
				m_pEncStatus->pcount = 0;
				m_pEncStatus->PTYPE = INTRA;
			}
		}
	}
	else
	{
		m_pEncStatus->PTYPE = SKIP;
		m_pEncStatus->frame_skip--;
	}


	m_pEncStatus->gfid = m_pEncStatus->PTYPE;
	m_pEncStatus->ref_pic = (m_pEncStatus->pcount<m_pEncStatus->buf_cycle) ? m_pEncStatus->pcount : m_pEncStatus->buf_cycle-1;
	m_pEncStatus->zero_index = m_pEncStatus->pcount % m_pEncStatus->buf_cycle;
	m_pEncStatus->ref_index  = (m_pEncStatus->pcount - m_pEncStatus->ref_pic) % m_pEncStatus->buf_cycle;
	m_pEncStatus->pic_nbr++;
	m_pEncStatus->TR = (m_pEncStatus->TR + 1)%256;

	if (!(m_pEncStatus->pic_nbr%m_pEncStatus->framerate))
	{
		for (int i = 0; i < m_pEncStatus->framerate; i++)
			m_pEncStatus->framebits[i] = -1;
	}

	return size;
}

/*!
*********************************************************
*    Close encoder, set free memory
*********************************************************/
void CH263Encoder::EncClose()
{
	close_encoder(m_pEncStatus, m_pMCStatus, m_pStream);
	free(m_pEncStatus);
	free(m_pMCStatus);
//	fclose(m_pStream->bitstrmfptr);  //!< close stream

}