init.cpp

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

	return 1;
}
/*
*******************************************************************************
*
*   Name:          
*   Description:   
*   Input:         
*   Output:        
*   Last modified: 2002/12/21
*
*******************************************************************************/
int  init_table(H263VencStatus *encoder)
{
	int n;
	int mbr = encoder->lines/16;
	int mbc = encoder->pels/16;

	for (n = 0; n < mbr+1; n++)
	{
		encoder->coded_tab[n][0] = 0;
		encoder->quant_tab[n][0] = 0;
	}
	for (n = 1; n < mbc+1; n++)
	{
		encoder->coded_tab[0][n] = 0;
		encoder->quant_tab[0][n] = 0;
	}

	return 1;
}
/*!
*******************************************************************************
*
*   Name:          
*   Description:   
*   Input:         
*   Output:        
*   Last modified: 2002/12/21
*
*******************************************************************************/
int  init_MCPara(MCParam *MC, int search_range, int search_method)
{
	MC->mv = NULL;
	if(search_range > 0 && search_range < 16)
	{
		MC->search_range = search_range;
	}
	else
	{
		printf (E_INITENC_WRONG_SEARCH_RANGE);
		return 0;
	}
	if(search_method >= 0 && search_method <4)
	{
		MC->method = search_method;
	}
	else
	{
		printf (E_INITENC_WRONG_SEARCH_METHOD);
		return 0;
	}
	MC->search_range_8x8 = 0;  /*< if this is set to zero, only half pel estimation of 8x8 block
                                           will be performed actually*/

    //initiation of m_MCStatus.mv_frame was done in function alloc_mem

    //initialize matrix for full search
	if (0 == search_method)
	{
		init_fs(MC);
	}
	
	return 1;
}
/*!
*******************************************************************************
*
*   Name:          GetSourceFrame
*   Description:   Get the address of source image to be encoded
*   Input:         address of source image, width and height of picture
*   Output:        
*   Last modified: 2002/12/4
*
*******************************************************************************/
int  GetSourceFrame(H263VencStatus * encoder, unsigned char* pCap)
{
	int offset1;
	int offset2;

	if (NULL ==  pCap)
	{
		printf(E_INITENC_NO_PICTURE);
		return 0;
	}

	offset1 = encoder->lines * encoder->pels;
	offset2 = offset1*5/4;
    
	if (encoder->VideoFormat == YUV420)
	{
		encoder->frameToEncode.pLum = pCap;
		encoder->frameToEncode.pCb  = pCap + offset1;
		encoder->frameToEncode.pCr  = pCap + offset2;
	}
	else if (encoder->VideoFormat == YUV411)
	{
		int h = encoder->pels/8;
		int v = encoder->lines/2;
		int i, j;
		unsigned char *p1;
		unsigned char *p2;
		unsigned char *pLum1;
		unsigned char *pLum2;
		unsigned char *pCb;
		unsigned char *pCr;

		for (j = 0; j < v; j++)
		{
			for (i = 0; i < h; i++)
			{
				p1 = pCap + i * 12 + j * 2 * h * 12;
				p2 = p1 + h * 12;
				pLum1 = encoder->frameToEncode.pLum + i * 8 + j * 2 * h * 8;
				pLum2 = pLum1 + h * 8;
				pCb = encoder->frameToEncode.pCb + i * 4 + j * h * 4;
				pCr = encoder->frameToEncode.pCr + i * 4 + j * h * 4;

				pLum1[0] = p1[1];
				pLum1[1] = p1[3];
				pLum1[2] = p1[5];
				pLum1[3] = p1[7];
				pLum1[4] = p1[8];
				pLum1[5] = p1[9];
				pLum1[6] = p1[10];
				pLum1[7] = p1[11];

				pLum2[0] = p2[1];
				pLum2[1] = p2[3];
				pLum2[2] = p2[5];
				pLum2[3] = p2[7];
				pLum2[4] = p2[8];
				pLum2[5] = p2[9];
				pLum2[6] = p2[10];
				pLum2[7] = p2[11];

				pCb[1] = pCb[0] = (p1[0] + p2[0] + 1)>>1;
				pCb[3] = pCb[2] = (p1[4] + p2[4] + 1)>>1;

				pCr[1] = pCr[0] = (p1[2] + p2[2] + 1)>>1;
				pCr[3] = pCr[2] = (p1[6] + p2[6] + 1)>>1;
			}
		}
	}
	else if (encoder->VideoFormat == RGB24)
	{
		int i, j, k, l;

		for (j = 0; j < encoder->lines*encoder->pels; j++)
		{
			encoder->frameToEncode.pLum[j] = 0;
		}

		rgbtoyuv(pCap, encoder->lines, encoder->pels, encoder->frameToEncode.pLum, encoder->frameToEncode.pCb, encoder->frameToEncode.pCr);
		for (j = 0, k = 0; j < encoder->lines; j+=2, k++)
		{
			for (i = 0, l = 0; i < encoder->pels; i+=2, l++)
			{
				encoder->frameToEncode.pCr[l + k*encoder->pels/2] = (encoder->frameToEncode.pCr[i + j*encoder->pels] +
					                                               encoder->frameToEncode.pCr[i+1 + j*encoder->pels] +
																   encoder->frameToEncode.pCr[i + (j+1)*encoder->pels] +
																   encoder->frameToEncode.pCr[i+1, (j+1)*encoder->pels] + 2)>>2; 
				encoder->frameToEncode.pCb[l + k*encoder->pels/2] = (encoder->frameToEncode.pCb[i + j*encoder->pels] +
					                                              encoder->frameToEncode.pCb[i+1 +j*encoder->pels] +
																  encoder->frameToEncode.pCb[i + (j+1)*encoder->pels] +
																  encoder->frameToEncode.pCb[i+1 + (j+1)*encoder->pels] + 2)>>2; 

			}
		}
#ifdef _DEBUG
/*	{
		FILE *fp = fopen("c:\\result.yuv", "wb");
		fwrite(encoder->frameToEncode.pLum, sizeof(unsigned char), encoder->lines*encoder->pels, fp);
		fwrite(encoder->frameToEncode.pCb, sizeof(unsigned char), encoder->lines*encoder->pels/4, fp);
		fwrite(encoder->frameToEncode.pCr, sizeof(unsigned char), encoder->lines*encoder->pels/4, fp);
        fclose(fp);
	}*/	
#endif

	}
	else
	{
		printf("unrecognized video format!\n");
		exit(1);
	}

	return 1;

}


/*!
*******************************************************************************
*
*   Name:          close_encoder
*   Description:   Set free memory allocated at the beginning of encoding
*   Input:         
*   Output:        
*   Last modified: 2002/12/4
*
*******************************************************************************/
void close_encoder (H263VencStatus *encoder, MCParam *mc, putstrm *pStrm)
{
	int i, j;
	int width = encoder->pels;
	int height = encoder->lines;
	unsigned char *tmp;

	if (encoder->VideoFormat == YUV411)
	{
		free(encoder->frameToEncode.pLum);
	}

	for (i = 0; i < height/16+1; i++)
	{
		for (j = 0; j < width/16+2; j++)
		{
			free(mc->mv_frame[0][i][j]);
			free(mc->mv_frame[1][i][j]);
			free(mc->mv_frame[2][i][j]);
			free(mc->mv_frame[3][i][j]);
			free(mc->mv_frame[4][i][j]);
			free(mc->mv_frame[5][i][j]);
		}
	}
	if (encoder->B_frame)
	{
		for (i = 0; i < height/16; i++)
		{
			for (j = 0; j < width/16; j++)
			{
				free(mc->mv_lastframe[0][i][j]);
				free(mc->mv_lastframe[1][i][j]);
				free(mc->mv_lastframe[2][i][j]);
				free(mc->mv_lastframe[3][i][j]);
				free(mc->mv_lastframe[4][i][j]);
			}
		}
	}

	for (i = 0; i < encoder->buf_cycle; i++)
	{
		tmp = encoder->mv_outside_frame ? (encoder->frame_buf[i].pLum - (width+32)*16-16) : encoder->frame_buf[i].pLum;
		free(tmp);
	}

	for (i = 0; i <= encoder->B_frame; i++)
	{
		tmp = encoder->BPicture[i].pLum;
		free(tmp);
	}

	tmp = encoder->mv_outside_frame ? encoder->prev_ipol-(width*2+64)*32-32 : encoder->prev_ipol; 
	free(tmp);
	if (encoder->B_frame)
	{
		tmp = encoder->mv_outside_frame ? encoder->next_ipol-(width*2+64)*32-32 : encoder->next_ipol; 
		free(tmp);
	}
	
	free(pStrm->poutint);
}

/*!
*******************************************************************************
*
*   Name:          init_fs
*   Description:   produce spiral for full search
*   Input:         
*   Output:        
*   Author:        copyed from tml8.0 
*   Last modified: 2002/11/23 by lcl
*
*******************************************************************************/
void init_fs(MCParam *mc)
{
	int i,j,k,l,l2;

	k=1;
	for (l=1; l < 41; l++) {
		l2=l+l;
		for (i=-l+1; i < l; i++) {
			for (j=-l; j < l+1; j += l2) {
				mc->SpiralX[k] = i;
				mc->SpiralY[k] = j;
				k++;
			}
		}

		for (j=-l; j <= l; j++) {
			for (i=-l;i <= l; i += l2) {
				mc->SpiralX[k] = i;
				mc->SpiralY[k] = j;
				k++;
			}
		}
	}
}