Método IMFByteStream::Read (mfobjects.h)

Lê dados do fluxo.

Sintaxe

HRESULT Read(
  [in]  BYTE  *pb,
  [in]  ULONG cb,
  [out] ULONG *pcbRead
);

Parâmetros

[in] pb

Ponteiro para um buffer que recebe os dados. O chamador deve alocar o buffer.

[in] cb

O tamanho do buffer em bytes.

[out] pcbRead

Recebe o número de bytes copiados para o buffer. Esse parâmetro não pode ser NULL.

Retornar valor

Se o método for bem-sucedido, ele retornará S_OK. Caso contrário, ele retornará um código de erro HRESULT.

Comentários

Esse método lê no máximo os bytes cb da posição atual no fluxo e os copia para o buffer fornecido pelo chamador. O número de bytes que foram lidos é retornado no parâmetro pcbRead . O método não retorna um código de erro ao chegar ao final do arquivo, portanto, o aplicativo deve marcar o valor em pcbRead após o retorno do método.

Esse método é síncrono. Ele é bloqueado até que a operação de leitura seja concluída.

Notas de implementação:Esse método deve atualizar a posição atual no fluxo adicionando o número de bytes que foram lidos, que é especificado pelo valor retornado no parâmetro pcbRead , à posição atual. Outros métodos que podem atualizar a posição atual são Leitura, Gravação, BeginWrite, Seek e SetCurrentPosition.

Essa interface estará disponível nas seguintes plataformas se os componentes redistribuíveis do SDK do Windows Media Format 11 estiverem instalados:

• Windows XP com Service Pack 2 (SP2) e posterior.
• Windows XP Media Center Edition 2005 com KB900325 (Windows XP Media Center Edition 2005) e KB925766 (pacote cumulativo de atualizações de outubro de 2006 para Windows XP Media Center Edition) instalados.

Exemplos

O exemplo a seguir lê dados de um fluxo de bytes em um buffer de mídia alocado pelo chamador. Para obter mais informações sobre buffers de mídia, consulte Buffers de mídia.

// Read data from a byte stream into a media buffer.
//
// This function reads a maximum of cbMax bytes, or up to the size of the 
// buffer, whichever is smaller. If the end of the byte stream is reached, the 
// actual amount of data read might be less than either of these values.
//
// To find out how much data was read, call IMFMediaBuffer::GetCurrentLength.

HRESULT ReadFromByteStream(
    IMFByteStream *pStream,     // Pointer to the byte stream.
    IMFMediaBuffer *pBuffer,    // Pointer to the media buffer.
    DWORD cbMax                 // Maximum amount to read.
    )
{
    DWORD cbBufferMax = 0;
    DWORD cbRead = 0;
    BYTE *pData= NULL;

    HRESULT hr = pBuffer->Lock(&pData, &cbBufferMax, NULL);

    // Do not exceed the maximum size of the buffer.
    if (SUCCEEDED(hr))
    {
        if (cbMax > cbBufferMax)
        {
            cbMax = cbBufferMax;
        }

        // Read up to cbMax bytes.
        hr = pStream->Read(pData, cbMax, &cbRead);
    }

    // Update the size of the valid data in the buffer.
    if (SUCCEEDED(hr))
    {
        hr = pBuffer->SetCurrentLength(cbRead);
    }
    if (pData)
    {
        pBuffer->Unlock();
    }
    return hr;
}

O próximo exemplo é semelhante, mas aloca um novo buffer de mídia para armazenar os dados.

//-------------------------------------------------------------------
// AllocReadFromByteStream
//
// Reads data from a byte stream and returns a media buffer that
// contains the data.
//-------------------------------------------------------------------

HRESULT AllocReadFromByteStream(
    IMFByteStream *pStream,         // Pointer to the byte stream.
    DWORD cbToRead,                 // Number of bytes to read.
    IMFMediaBuffer **ppBuffer       // Receives a pointer to the media buffer. 
    )
{
    HRESULT hr = S_OK;
    BYTE *pData = NULL;
    DWORD cbRead = 0;   // Actual amount of data read.

    IMFMediaBuffer *pBuffer = NULL;

    // Create the media buffer. 
    // This function allocates the memory for the buffer.
    hr = MFCreateMemoryBuffer(cbToRead, &pBuffer);

    // Get a pointer to the memory buffer.
    if (SUCCEEDED(hr))
    {
        hr = pBuffer->Lock(&pData, NULL, NULL);
    }

    // Read the data from the byte stream.
    if (SUCCEEDED(hr))
    {
        hr = pStream->Read(pData, cbToRead, &cbRead);
    }

    // Update the size of the valid data in the buffer.
    if (SUCCEEDED(hr))
    {
        hr = pBuffer->SetCurrentLength(cbRead);
    }

    // Return the pointer to the caller.
    if (SUCCEEDED(hr))
    {
        *ppBuffer = pBuffer;
        (*ppBuffer)->AddRef();
    }

    if (pData)
    {
        pBuffer->Unlock();
    }
    SafeRelease(&pBuffer);
    return hr;
}

Requisitos

Confira também

IMFByteStream