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

Article
02/28/2024

Lit les données du flux.

Syntaxe

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

Paramètres

[in] pb

Pointeur vers une mémoire tampon qui reçoit les données. L’appelant doit allouer la mémoire tampon.

[in] cb

Taille, en octets, de la mémoire tampon.

[out] pcbRead

Reçoit le nombre d’octets qui sont copiés dans la mémoire tampon. Ce paramètre ne peut pas avoir la valeur NULL.

Valeur retournée

Si cette méthode réussit, elle retourne S_OK. Sinon, elle retourne un code d’erreur HRESULT.

Remarques

Cette méthode lit au maximum les octets cb à partir de la position actuelle dans le flux et les copie dans la mémoire tampon fournie par l’appelant. Le nombre d’octets qui ont été lus est retourné dans le paramètre pcbRead . La méthode ne retourne pas de code d’erreur à la fin du fichier. L’application doit donc case activée la valeur dans pcbRead après le retour de la méthode.

Cette méthode est synchrone. Il se bloque jusqu’à la fin de l’opération de lecture.

Notes d’implémentation :Cette méthode doit mettre à jour la position actuelle dans le flux en ajoutant à la position actuelle le nombre d’octets qui ont été lus, spécifié par la valeur retournée dans le paramètre pcbRead . Les autres méthodes qui peuvent mettre à jour la position actuelle sont Read, Write, BeginWrite, Seek et SetCurrentPosition.

Cette interface est disponible sur les plateformes suivantes si les composants redistribuables du SDK Windows Media Format 11 sont installés :

Windows XP avec Service Pack 2 (SP2) et versions ultérieures.
Windows XP Media Center Edition 2005 avec KB900325 (Windows XP Media Center Edition 2005) et KB925766 (correctif cumulatif d’octobre 2006 pour Windows XP Édition Media Center) installés.

Exemples

L’exemple suivant lit les données d’un flux d’octets dans une mémoire tampon multimédia allouée à l’appelant. Pour plus d’informations sur les mémoires tampons multimédias, consultez Mémoires tampons multimédias.

// 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;
}

L’exemple suivant est similaire, mais alloue une nouvelle mémoire tampon multimédia pour contenir les données.

Note Cet exemple utilise la fonction SafeRelease pour libérer les pointeurs d’interface.

//-------------------------------------------------------------------
// 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;
}

Configuration requise

Condition requise	Valeur
Client minimal pris en charge	Windows Vista [applications de bureau \| applications UWP]
Serveur minimal pris en charge	Windows Server 2008 [applications de bureau \| applications UWP]
Plateforme cible	Windows
En-tête	mfobjects.h (inclure Mfidl.h)
Bibliothèque	Mfuuid.lib

Voir aussi

IMFByteStream

Partager via