Artigo: 262127 - Última revisão: segunda-feira, 12 de Fevereiro de 2007 - Revisão: 2.4

INFO: Melhorar o desempenho do controlador do Windows CE vídeo: operações de desenho livre

Dica do SistemaEste artigo aplica-se a um sistema operativo diferente do que está a utilizar. Foi desactivado o conteúdo do artigo, que pode não ser relevante para si.

Nesta página

Expandir tudo | Reduzir tudo

Sumário

A maior parte dos controladores de vídeo Windows CE utilizam GPE (gráficos primitivo Engine) para fornecer processamento primitivos de controlador de visualização predefinida. O método GPE::Line desenha linhas na superfície de destino utilizando os parâmetros fornecidos no GPELineParms e EGPEPhase estruturas de dados. Este artigo define as estruturas de dados GPELineParms e EGPEPhase e descreve como GPE desenha uma linha.

O desenho predefinidas fornecido pelo GPE poderão ser substituído no controlador de visualização por acelerações de emulação de software ou por acelerações de hardware original, como discutido no capítulo Windows CE 2.12 Device Driver Kit sobre controladores de visualização.

Mais Informação

GPELineParms Estrutura

GPELineParms é uma estrutura. GPELineParms é definida neste directório de Platform Builder:
Public\Common\Oak\Inc
GPELineParms é utilizado por GPE e o controlador de visualização para controlar o desenho de linha. Alguns dos parâmetros na estrutura directamente provêm da aplicação ou o contexto de dispositivo actual. Os restantes são calculados pelo GPE.
struct GPELineParms
{
	SCODE 			(GPE::*pLine)(GPELineParms *);
	long				xStart;  //Starting point of line, in X direction
	long				yStart;  //Starting point of line, in Y direction
	int				cPels;  //Length of line in major direction, in pixels
	unsigned long	dM;  //larger of |xStart-Xend| and |yStart-yEnd|, calculated in 1/16ths of a pixel
	unsigned long	dN;  //smaller of |xStart-Xend| and |yStart-yEnd|, calculated in 1/16ths of a pixel
	long				llGamma;  //typically used as the initial starting value for the slope iterator
	int				iDir;  //Octant number for line
	unsigned long	style;  //IN parameter - line attributes (solid or dashed)
	int				styleState;  //state of line style in current path, in pixels
	GPESurf 			*pDst;  //IN parameter - destination surface
	COLOR			solidColor;  //IN parameter brush color
	RECTL			*prclClip;  //clipping rectangle
	unsigned short	mix;  //IN parameter ROP2 values for mark and space
};
O estilo GPELineParms é o estilo de linha. O valor zero (0) implica que é uma linha contínua (ou seja, um único ROP2) enquanto que um estilo de 0xAAAAAAAA é pontos de pixel único (alternar entre dois ROP2s). Como transmitido para a função DrvStrokePath , o sinalizador LA_ALTERNATE plineattrs-> fl implica um estilo de 0xAAAAAAAA. Em alternativa, pode utilizar oparâmetros pstyle e cstyle para tornar complexa tracejado ou pontilhado estilos. Por exemplo, 0xF0F0F0F0 em pParms-> estilo implica mais traços.

mistura GPELineParms é o valor ROP2. É composta por dois bytes, um ROP2 marca e um ROP2 espaço. O valor de cada bit no estilo escolhe entre dois bytes em pParms-> mistura valor. GPELineParms iDir é o número octant para a linha (um dos valores de 8, pelo algoritmo Bresenham). Octant eixo Y de X-Dir-Dir 0 X-principal + 1 + 1 principais de S 1 + 1 + 1 Y-principal 2-1 + 1 X 3-principais-1 + 1 4 X-principais-1-1 Y 5-principais-1-1 Y 6-principais-1 + 1 X 7-principais-1 + 1

EGPEPHASE enumerados tipo

EGPEPHASE é um tipo enumerado. EGPEPHASE é definida no directório de Platform Builder seguinte:
Public\Common\Oak\Inc
enum EGPEPhase
{
	gpeSingle,
	gpePrepare,  //device-specific initialization
	gpeContinue,
	gpeComplete  //device-specific clean up
};

Processamento de desenho livre

Preparar a fase

Desenho de linha começa quando uma aplicação chama o método de polilinha. GDI processa a chamada ao método polilinha. GDI valida que existem pelo menos dois vértices e que o estilo de linha não é nulo. GDI, em seguida, chama a função GPE DrvStrokePath , ou para uma caneta grande, a função DrvFillPath . Quando o GDI invoca a função de membro GPE, transmitir ao longo de informações do contexto de dispositivo:
  • Objecto de superfície
  • Caminho de objecto
  • Rectângulo de clip
  • O Pincel
  • O valor de ROP2
  • Os atributos de linha (sólidos ou tracejados).
Estes parâmetros estavam em conjunto pela aplicação ou são realizados os atributos. GPE utiliza alguns dos parâmetros de entrada para preencher a estrutura GPELineParms.

GPE, em seguida, chama linha função o controlador de visualização, passar in a GPELineParms e passando numa definição EGPEPHASE gpePrepare . O controlador examina as propriedades da linha que está a ser desenhada. O controlador, em seguida, escolhe se pretende utilizar a função GPE EmulatedLine ou processar a linha com própria função acelerada. Antes de seleccionar uma função acelerada, o controlador tem de verificar se o hardware pode processar o estilo de linha e ROP. No controlador de visualização S3Trio64 (no directório Platform Builder Platform\Cepc\Drivers\Display\S3trio64), o controlador define o apontador de função por predefinição para EmulatedLine mas escolhe a aceleração de hardware para linhas que estão na memória de vídeo e utilizar ROP 0x0D0D. O código de exemplo seguinte ilustra este:

#ifdef ENABLE_ACCELERATION
	if( phase == gpeSingle || phase == gpePrepare )
	{
		pLineParms->pLine = EmulatedLine;
//		pLineParms->pLine = (SCODE (GPE::*)(struct GPELineParms *))EmulatedLine;
		if( pLineParms->pDst->InVideoMemory() && pLineParms->mix == 0x0d0d )
		{
			SelectSolidColor( pLineParms->solidColor );
			pLineParms->pLine = (SCODE (GPE::*)(struct GPELineParms *))AcceleratedSolidLine;
		}
//		if( pLineParms->mix == 0x0B07 )	   .. dotted line

	}
#else
		pLineParms->pLine = EmulatedLine;
#endif
Além disso, na fase de preparação, o controlador pode, opcionalmente, efectuar processamento adicional, tais como a inicializar os registos de hardware com a cor seleccionada. Após a fase de preparação, controlo regressa à função GPE DrvStrokePath .

Desenho de cada segmento de gestão de DrvStrokePath

Depois de determinar função de desenho de linha o controlador, a função DrvStrokePath executa os seguintes ciclos. A ordenação destes ciclos foi concebida para maximizar o recorte de hardware. Normalmente, um caminho pertencem a apenas um destes rectângulos recorte.
	for( each clip rectangle in clip list )
	{
		for( each line segment in stroke path )
		{
			calculate line segment clipped to current cliprect

			pParms->pLine(pParms);
		}
	}
a função DrvStrokePath clips segmentos de linha para o rectângulo de recorte. Não é necessário para o controlador para o fazer na respectiva função de linha . Na realidade, o controlador realmente é impedido de recorte porque não existe nenhuma informação de recorte válida durante a fase de preparação. Poderão existir não rectângulo de recorte ou pode existir uma sequência de rectângulos de recorte para uma chamada única preparação completa.
  • EmulatedLine é a função de desenho de linha predefinido

    A função EmulatedLine é a função de desenho de linha GPE. EmulatedLine implementa o seguinte algoritmo:
    	long accum = (long)(pParms->dN) + pParms->llGamma;
    	long axstp = (long)(pParms->dN);
    	long dgstp = (long)(pParms->dN) - (long)(pParms->dM);
    
    for( remainingPels = pParms->cPels; remainingPels; remainingPels-- )
    	{
    		if( axstp )		//  ( axstp == 0 implies horizontal or vertical line being drawn )
    		{
    			if( accum < 0 )
    			{
    				accum += axstp;
    			}
    			else
    			{
    				increment_in_minor_direction;
    				accum += dgstp;
    			}
    		}
    		increment_in_major_direction;
    	}
    Recomendada utilização de EmulatedLine

    Utilize a função EmulatedLine para processar as linhas diagonais. As linhas diagonais são relativamente raras e normalmente não necessitam de ser acelerado. Do mesmo modo, é bastante raro para estilos de linha a ser utilizado. A função EmulatedLine deve ser utilizada como processador predefinido para este incidente bem.

  • Controlador pode substituir a função predefinida

    Para dispositivos que suportam a aceleração do hardware desenho de linha, o controlador pode implementar uma função incorporada acelerada para substituir a função de EmulatedLine predefinida. Em alternativa, o controlador pode chamar uma função existente ou criar uma nova função de emulação de software para processar o desenho de linha. Mesmo se inadequada desenho aceleração estiver disponível, se a aceleração de transferência (BLT) do preenchimento sólido bloco é implementada no hardware, em seguida, este deve ser utilizado para acelerar linhas horizontais e verticais.

    Aceleração do hardware de horizontal e vertical linhas apenas

    A abordagem recomendada para a maior parte das situações deve emular todas as diagonais e com estilo linhas, utilizando o hardware de desenho de linha ou preenchimento blt hardware para acelerar linhas horizontais e verticais que constituem a maioria das linhas desenhadas pelo Windows CE. Para linhas horizontais e verticais, o parâmetro de dN é zero (0) e nenhuma conta tem de ser tomada das informações da sub-pixels a llgamma termo dM parâmetro e de erro.
    if( pLineParms->dN == 0 )
    {
    	// Line is vertical or horizontal
    	// Use fill-blt or h/w line to draw a line starting at
    	// pLineParms->xStart, pLineParms->yStart
    	// in the direction specified by pLineParms->iDir
    	// for a total of pLineParms->cPels pixels
    }
    else
    {
    	return EmulatedLine( pLineParms );	// use S/W for diagonal line
    }
Aceleração do hardware de linhas diagonais

É importante ter em atenção que para linhas diagonais, os valores no parâmetro dM , parâmetro de dN , e erro termo llgamma campos de GPELineParms contêm informações de sub-pixels. Esta informação deve ser utilizada quando regista a inicialização do desenho de linha de hardware. Caso contrário, as linhas diagonais são cortadas incorrectamente são desenhadas. Este efeito pode ser bastante visível quando mover uma janela através de outra janela que contém uma linha diagonal.

Na fase de preparação, o controlador efectua uma inspecção geral dos parâmetros de linha para determinar se ele pode acelerar. Quando a função de aceleração é chamada, o controlador necessitar de efectuar a validação adicional. Isto acontece porque quando acelerado função o controlador é chamada, destina-se um segmento de caminho específico, cortado para uma região de recorte específico. O controlador necessita assegurar que, por exemplo, o comprimento do segmento de linha não provocarão respectivos registos de hardware para capacidade excedida. Por exemplo, no controlador S3Trio64, este nível adicional de verificação é efectuada no código que se segue. Porque os valores dM e dN originalmente são expressos em 1/16ths de pixels, declive os iteradores hardware do dispositivo tem de ser capaz de manter estes comprimentos para qualquer segmento de linha é desenhado. Uma grande quantidade de hardware foi concebida para conseguir desenhar uma linha diagonal no ecrã inteiro mas espera dM e valores dN (ou equivalentes) para ser expressa em pixels. Uma vez que GPE utiliza sub-pixels precisão, estes contadores ter quatro (4) mais bits. Para linhas curtas, não se trata de um problema mas para linhas extensas estes valores podem excesso os registos que resulta numa linhas apenas zinging desactivado para algumas extremidade do ecrã ou mesmo moldar à volta de algumas vezes.

Apesar das linhas diagonais são comuns, linhas diagonais longo são extremamente raras sendo o tempo decorrido para compor linhas diagonais tempo utilizando a função EmulatedLine minúsculas.
int errTerm = (int)pLineParms->dN + (int)pLineParms->llGamma - ( ( command & PLUS_X ) ? 0 : 1 );

	if(
		( pLineParms->dN > 4090 ) ||
		( pLineParms->dM-pLineParms->dN > 4090 ) ||		// remember dM >= dN
		( errTerm > 4090 ) ||
		( errTerm < -4090 ) )
	{
		RetVal = EmulatedLine( pLineParms );	// The hardware DDA would overflow so use the emulation
	}
	else
	{
		WaitForFIFO(7); // seven parameters required
		reg_ALT_CURXY = ((pLineParms->xStart + ((S3Trio64Surf *)(pLineParms->pDst))->Left()) << 16 ) |
						(pLineParms->yStart + ((S3Trio64Surf *)(pLineParms->pDst))->Top());
		reg_MAJ_AXIS_PCNT = (pLineParms->cPels-1);
		reg_ALT_STEP = (((pLineParms->dN-pLineParms->dM)/*&0x3FFF*/)<<16) | (pLineParms->dN /*&0x3FFF*/);
		reg_ERR_TERM = errTerm /*&0x3FFF*/;
		reg_CMD = command;
		RetVal = S_OK;
	}

Concluir fase

Depois da função DrvStrokePath concluída desenho de linha, DrvStrokePath chama novamente linha função o controlador desta vez transmitir o conjunto de EGPEphase para gpeComplete . O controlador deve limpar qualquer estado de desenho de linha necessário o hardware neste momento.

A informação contida neste artigo aplica-se a:
  • Microsoft Windows CE Platform Builder 2.11
  • Microsoft Windows CE Platform Builder 2.12
  • Microsoft Encarta Reference Suite 2001
Palavras-chave: 
kbmt kbinfo KB262127 KbMtpt
Tradução automáticaTradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 262127  (http://support.microsoft.com/kb/262127/en-us/ )