Sample Blit Acceleration

Artigo
08/12/2009

Windows Mobile Not Supported Windows Embedded CE Supported

9/8/2008

Por padrão, um driver exibir roteia todas as blits para a GPE. Como alternativas, um driver exibir pode manipulação blit cores rota diretamente para a biblioteca de emulação de hardware ou.

O driver exibir ATI serve como um modelo para demonstrar como um driver exibir pode invocar todos os três desses métodos. Codificar o ATI exemplo está localizado na Diretório %_WINCEROOT%\Public\Common\OAK\Drivers\Display\ATI.

O seguinte exemplo de código é a partir de driver exibir ATI exemplo e mostra como o processamento blit cores começa quando o GDI chama do o driver BltPrepare função.

O driver inicializa os parâmetros blit de cores e determina qual função usar para executar o individual blits. Normalmente, o driver inicializa o GPE para processamento blit cores usar como padrão identificador.

SCODE ATI::BltPrepare(GPEBltParms *pBltParms)
{
// Put debug messages and optional timing processing here.

pBltParms->pBlt = EmulatedBlt; // Generic BLT processing

Para melhor desempenho, BltPrepare pode examinar as características de blit de cores e o associado exibir surfaces para determinar se um blit cores acelerado é apropriado. Depois de codificar inicialização, o driver exibir pode conter codificar para hardware ou software acelerações.

Após configuração o manipulador usar como padrão, o driver ATI distribui blits para a aceleração hardware, se disponível e, em seguida, emulação de software-acelerado, se disponível.

Primeiro ele verifica se a superfície destino está em vídeo memória. Essa é uma verificação importante que a maioria dos drivers exibir devem fazer antes de usar a aceleração hardware porque o GDI usa o driver exibir para processar saída da impressora, as well as exibir saída. Saída da impressora é processada na memória sistema, não no vídeo memória.

A maioria dos hardware exibir pode executar acelerado Desenho em somente duas situações:

Quando a superfície destino estiver em vídeo memória (por exemplo, para blits sem uma superfície origem)
Quando as superfícies origem e destino estão em vídeo memória (por exemplo, para blits com uma superfície origem)

Portanto, se o hardware possui essa limitação, o driver deve verificar a origem e destino surfaces antes chamado de função de aceleração.

O seguinte exemplo de código mostra como o driver avalia a codificar operação de varredura (ROP) e direciona o blit de cores para com suporte a aceleração hardware, quando disponível.

O ROP SRCCOPY ilustra como o driver procura uma superfície origem no vídeo memória antes chamando a aceleração hardware.

if (((ATISurf*)(pBltParms->pDst))->InVideoMemory() ) {
    switch( pBltParms->rop4 ) {
        case 0x0000:// BLACKNESS
            pBltParms->solidColor = 0x0;
            pBltParms->pBlt = (SCODE (GPE::*)
           (struct GPEBltParms *)) AcceleratedFillRect;
            break;
        case 0xFFFF:// WHITENESS
            pBltParms->solidColor = 0xffffff;
            pBltParms->pBlt = (SCODE (GPE::*)
            (struct GPEBltParms *))AcceleratedFillRect;
            break;
        case 0xF0F0:// PATCOPY and PATINVERT: emulate color 
        case 0x5A5A:// conversion.
            if (pBltParms->solidColor == -1) // emulate if not solid
            {                                // color
                break;
            }
            pBltParms->pBlt = (SCODE (GPE::*)(struct GPEBltParms *))
                              AcceleratedFillRect;
            break; 
        case 0x6666:// SRCINVERT, SRCAND, SRCCOPY and SRCPAINT:
        case 0x8888:// cannot accelerate if src is not in video ram.
        case 0xCCCC:// cannot accelerate if there are color translations.
        case 0xEEEE: 
            if (!pBltParms->pSrc->InVideoMemory() ||
                pBltParms->pLookup ||
                pBltParms->pConvert ||
                pBltParms->bltFlags & BLT_STRETCH)
                break;
            pBltParms->pBlt = (SCODE (GPE::*)(struct GPEBltParms *))
            AcceleratedSrcCopyBlt;
            break; 
    } // end switch

O driver exibir ATI mostra como usar a biblioteca de emulação blit de cores. Após configuração acelerações hardware de usar como padrão blit cores manipulador e manipulação, o driver procura acelerações software possíveis.

A biblioteca de emulação contém funções seleção blit de cores para os modos que são bpp 8 e 16. Essas funções seleção tornam mais fácil selecionar a função blit cores software correto acelerado. Você pode usar essas funções seleção diretamente no seu driver ou você pode utilizá-las como um modelo para escrever sua própria lógica seleção.

O seguinte exemplo de código mostra como o exemplo driver ATI Utiliza as funções seleção para selecionar a partir qualquer disponível software acelerado função blit de cores.

if (pBltParms->pBlt == EmulatedBlt)
    {
        EmulatedBltSelect08 (pBltParms);
        EmulatedBltSelect16 (pBltParms);
    }

Porque o driver ATI pode executar em várias intensidades cor diferente, a função seleção deve pesquisa para as condições que poderia evitar de blit de cores de usar a emulação.

As software acelerado blit cores funções na biblioteca de emulação incluem o seguinte restrições:

Intensidade da cor a superfície destino e intensidade da cor da função de emulada devem corresponder.
Nenhum transparência ou esticar é permitida.
Nenhuma conversão cor ou pesquisa é permitida.

O seguinte exemplo de código mostra como a função seleção determina se o blit de cores pode usar as funções blit cores software acelerado.

// check the input parameters for validity
if (pBltParms->pDst->Format() != gpe8Bpp)
{
    return S_OK;
}
if ((pParms->bltFlags & (BLT_TRANSPARENT | BLT_STRETCH)))
{
    return S_OK;
}
if ((pParms->pLookup) || (pParms->pConvert))
{
    return S_OK;
}

Após confirmar que as funções biblioteca de emulação podem executar um blit de cores, a função seleção examina os ROPs, com suporte distribuir ROPs para o apropriado função.

O seguinte exemplo de código mostra como a função seleção procura o valor ROP4 para escolher qual função blit de cores para usar.

#define FUNCNAME(basename) (SCODE (GPE::*)(struct GPEBltParms \
*))Emulator::Emulated##basename
switch (pBltParms->rop4) {
    case 0x0000:    // BLACKNESS
        pBltParms->solidColor = 0;
        pBltParms->pBlt = FUNCNAME(BltFill08);
        break;
    case 0xFFFF:    // WHITENESS
        pBltParms->solidColor = 0x00ffffff;
        pBltParms->pBlt = FUNCNAME(BltFill08);
        break;
    case 0xF0F0: // PATCOPY
        if (pParms->solidColor == -1) // really a patterned brush?
        {
            pParms->pBlt = FUNCNAME(BltPatternCopy08);
        }
        else // must be a solid colored brush
        {
            pParms->pBlt = FUNCNAME(BltFill08);
        }
        break;

Compartilhar via

Sample Blit Acceleration

See Also

Concepts

Recursos adicionais