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

Grava dados no fluxo.

Sintaxe

HRESULT Write(
  [in]  const BYTE *pb,
  [in]  ULONG      cb,
  [out] ULONG      *pcbWritten
);

Parâmetros

[in] pb

Ponteiro para um buffer que contém os dados a serem gravados.

[in] cb

O tamanho do buffer em bytes.

[out] pcbWritten

Recebe o número de bytes gravados.

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 grava o conteúdo do buffer pb no fluxo, começando na posição atual do fluxo. O número de bytes que foram gravados é retornado no parâmetro pcbWritten .

Esse método é síncrono. Ele é bloqueado até que a operação de gravação 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 gravados no fluxo, que é especificado pelo valor retornado no pcbWritten, ao deslocamento de posição atual.

Outros métodos que podem atualizar a posição atual são Read, BeginRead, 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 grava dados de um buffer de mídia em um fluxo de bytes. Para obter mais informações sobre buffers de mídia, consulte Buffers de mídia.

//-------------------------------------------------------------------
// WriteBufferToByteStream
//
// Writes data from a media buffer to a byte stream.
//-------------------------------------------------------------------

HRESULT WriteBufferToByteStream(
    IMFByteStream *pStream,   // Pointer to the byte stream.
    IMFMediaBuffer *pBuffer,  // Pointer to the media buffer.
    DWORD *pcbWritten         // Receives the number of bytes written.
    )
{
    HRESULT hr = S_OK;
    DWORD cbData = 0;
    DWORD cbWritten = 0;
    BYTE *pMem = NULL;

    hr = pBuffer->Lock(&pMem, NULL, &cbData);

    if (SUCCEEDED(hr))
    {
        hr = pStream->Write(pMem, cbData, &cbWritten);
    }

    if (SUCCEEDED(hr))
    {
        if (pcbWritten)
        {
            *pcbWritten = cbWritten;
        }
    }

    if (pMem)
    {
        pBuffer->Unlock();
    }
    return hr;
}

O modelo de função a seguir grava uma variável tipada em um fluxo de bytes.

template <class T>
HRESULT WriteToStream(
    IMFByteStream *pStream, // Pointer to the byte stream.
    const T* p,             // Data to write to the stream.
    ULONG cb = sizeof(T)    // Size of the data in bytes.
)
{
    ULONG cbWritten = 0;
    HRESULT hr = S_OK;

    hr = pStream->Write((const BYTE*)p, cb, &cbWritten);
    if (SUCCEEDED(hr) && (cbWritten != cb))
    {
        hr = E_FAIL;
    }
    return hr;
}

Requisitos

Confira também

IMFByteStream