Méthode IAudioClient::Initialize (audioclient.h)
La méthode Initialize initialise le flux audio.
Syntaxe
HRESULT Initialize(
[in] AUDCLNT_SHAREMODE ShareMode,
[in] DWORD StreamFlags,
[in] REFERENCE_TIME hnsBufferDuration,
[in] REFERENCE_TIME hnsPeriodicity,
[in] const WAVEFORMATEX *pFormat,
[in] LPCGUID AudioSessionGuid
);
Paramètres
[in] ShareMode
Mode de partage pour la connexion. Grâce à ce paramètre, le client indique au moteur audio s’il souhaite partager l’appareil de point de terminaison audio avec d’autres clients. Le client doit définir ce paramètre sur l’une des valeurs d’énumération AUDCLNT_SHAREMODE suivantes :
AUDCLNT_SHAREMODE_EXCLUSIVE
AUDCLNT_SHAREMODE_SHARED
[in] StreamFlags
Indicateurs pour contrôler la création du flux. Le client doit définir ce paramètre sur 0 ou sur le bit OR d’une ou plusieurs constantes AUDCLNT_STREAMFLAGS_XXX ou des constantes AUDCLNT_SESSIONFLAGS_XXX.
[in] hnsBufferDuration
Capacité de mémoire tampon en tant que valeur de temps. Ce paramètre est de type REFERENCE_TIME et est exprimé en unités de 100 nanosecondes. Ce paramètre contient la taille de la mémoire tampon que l’appelant demande pour la mémoire tampon que l’application audio partagera avec le moteur audio (en mode partagé) ou avec l’appareil de point de terminaison (en mode exclusif). Si l’appel réussit, la méthode alloue une mémoire tampon d’une taille minimale. Pour plus d’informations sur REFERENCE_TIME, consultez la documentation du Kit de développement logiciel (SDK) Windows. Pour plus d’informations sur les exigences de mise en mémoire tampon, consultez Remarques.
[in] hnsPeriodicity
Période de l’appareil. Ce paramètre peut être différent de zéro uniquement en mode exclusif. En mode partagé, définissez toujours ce paramètre sur 0. En mode exclusif, ce paramètre spécifie la période de planification demandée pour les accès successifs à la mémoire tampon par le périphérique de point de terminaison audio. Si la période d’appareil demandée se trouve en dehors de la plage définie par la période minimale de l’appareil et la période maximale du système, la méthode limite la période à cette plage. Si ce paramètre a la valeur 0, la méthode définit la période de l’appareil sur sa valeur par défaut. Pour obtenir la période d’appareil par défaut, appelez la méthode IAudioClient::GetDevicePeriod . Si l’indicateur de flux de AUDCLNT_STREAMFLAGS_EVENTCALLBACK est défini et que AUDCLNT_SHAREMODE_EXCLUSIVE est défini sur ShareMode, hnsPeriodicity doit être différent de zéro et égal à hnsBufferDuration.
[in] pFormat
Pointeur vers un descripteur de format. Ce paramètre doit pointer vers un descripteur de format valide de type WAVEFORMATEX (ou WAVEFORMATEXTENSIBLE). Pour plus d'informations, consultez la section Notes.
[in] AudioSessionGuid
Pointeur vers un GUID de session. Ce paramètre pointe vers une valeur GUID qui identifie la session audio à laquelle appartient le flux. Si le GUID identifie une session qui a été précédemment ouverte, la méthode ajoute le flux à cette session. Si le GUID n’identifie pas une session existante, la méthode ouvre une nouvelle session et ajoute le flux à cette session. Le flux reste membre de la même session pendant toute sa durée de vie. Définir ce paramètre sur NULL revient à passer un pointeur vers une valeur GUID_NULL.
Valeur retournée
Si la méthode réussit, retourne S_OK. En cas d’échec, les codes de retour possibles incluent, sans s’y limiter, les valeurs indiquées dans le tableau suivant.
| Code de retour | Description |
|---|---|
|
L’objet IAudioClient est déjà initialisé. |
|
L’indicateur AUDCLNT_STREAMFLAGS_LOOPBACK est défini, mais l’appareil de point de terminaison est un appareil de capture, et non un appareil de rendu. |
|
Note S’applique à Windows 7 et versions ultérieures.
|
|
Note S’applique à Windows 7 et versions ultérieures.
|
|
Indique que la durée de passage du processus a dépassé l’utilisation maximale du processeur. Le moteur audio effectue le suivi de l’utilisation du processeur en conservant le nombre de fois où la durée du passage de processus dépasse l’utilisation maximale du processeur. L’utilisation maximale du processeur est calculée en pourcentage de la périodicité du moteur. La valeur de pourcentage est la valeur de limitation du processeur du système (dans la plage de 10 % et 90 %). Si cette valeur est introuvable, la valeur par défaut de 40 % est utilisée pour calculer l’utilisation maximale du processeur. |
|
Le périphérique de point de terminaison audio a été débranché, ou le matériel audio ou les ressources matérielles associées ont été reconfigurés, désactivés, supprimés ou autrement rendus indisponibles. |
|
L’appareil de point de terminaison est déjà utilisé. Soit l’appareil est utilisé en mode exclusif, soit l’appareil est utilisé en mode partagé et l’appelant est invité à utiliser l’appareil en mode exclusif. |
|
La méthode n’a pas pu créer le point de terminaison audio pour l’appareil de rendu ou de capture. Cela peut se produire si le périphérique de point de terminaison audio a été débranché, ou si le matériel audio ou les ressources matérielles associées ont été reconfigurés, désactivés, supprimés ou rendus indisponibles. |
|
Note S’applique à Windows 7 et versions ultérieures.
|
|
Le moteur audio (mode partagé) ou le périphérique de point de terminaison audio (mode exclusif) ne prend pas en charge le format spécifié. |
|
L’appelant demande l’utilisation en mode exclusif de l’appareil de point de terminaison, mais l’utilisateur a désactivé l’utilisation en mode exclusif de l’appareil. |
|
L’indicateur AUDCLNT_STREAMFLAGS_EVENTCALLBACK est défini, mais les paramètres hnsBufferDuration et hnsPeriodicity ne sont pas égaux. |
|
Le service audio Windows n’est pas en cours d’exécution. |
|
Le paramètre pFormat est NULL. |
|
Le paramètre pFormat pointe vers une description de format non valide ; ou l’indicateur AUDCLNT_STREAMFLAGS_LOOPBACK est défini, mais ShareMode n’est pas égal à AUDCLNT_SHAREMODE_SHARED ; ou l’indicateur AUDCLNT_STREAMFLAGS_CROSSPROCESS est défini, mais ShareMode est égal à AUDCLNT_SHAREMODE_EXCLUSIVE.
Un appel antérieur à SetClientProperties a été effectué avec une catégorie non valide pour les flux audio/de rendu. |
|
Mémoire insuffisante. |
Remarques
Après avoir activé une interface IAudioClient sur un appareil de point de terminaison audio, le client doit appeler Initialize une fois et une seule fois pour initialiser le flux audio entre le client et l’appareil. Le client peut se connecter directement au matériel audio (mode exclusif) ou indirectement via le moteur audio (mode partagé). Dans l’appel Initialize , le client spécifie le format de données audio, la taille de la mémoire tampon et la session audio pour le flux.
Si un flux est initialisé pour être piloté par les événements et en mode partagé, ShareMode est défini sur AUDCLNT_SHAREMODE_SHARED et l’un des indicateurs de flux définis inclut AUDCLNT_STREAMFLAGS_EVENTCALLBACK. Pour un tel flux, l’application associée doit également obtenir un handle en effectuant un appel à IAudioClient::SetEventHandle. Lorsqu’il est temps de mettre hors service le flux, le moteur audio peut ensuite utiliser le handle pour libérer les objets de flux. Le fait de ne pas appeler IAudioClient::SetEventHandle avant de libérer les objets de flux peut entraîner un délai de plusieurs secondes (délai d’attente) pendant que le moteur audio attend un handle disponible. Une fois le délai d’expiration expiré, le moteur audio libère les objets stream.
La réussite d’une tentative de création d’un flux en mode exclusif dépend de plusieurs facteurs, notamment la disponibilité de l’appareil et les paramètres contrôlés par l’utilisateur qui régissent le fonctionnement en mode exclusif de l’appareil. Pour plus d’informations, consultez Flux en mode exclusif.
Un objet IAudioClient prend en charge exactement une connexion au moteur audio ou au matériel audio. Cette connexion dure pendant la durée de vie de l’objet IAudioClient .
Le client doit appeler les méthodes suivantes uniquement après avoir appelé Initialize :
- IAudioClient::GetBufferSize
- IAudioClient::GetCurrentPadding
- IAudioClient::GetService
- IAudioClient::GetStreamLatency
- IAudioClient::Reset
- IAudioClient::SetEventHandle
- IAudioClient::Start
- IAudioClient::Stop
Avant d’appeler Initialize pour configurer une connexion en mode partagé ou en mode exclusif, le client peut appeler la méthode IAudioClient::IsFormatSupported pour déterminer si le moteur audio ou l’appareil de point de terminaison audio prend en charge un format particulier dans ce mode. Avant d’ouvrir une connexion en mode partagé, le client peut obtenir le format de mixage du moteur audio en appelant la méthode IAudioClient::GetMixFormat .
La mémoire tampon de point de terminaison partagée entre le client et le moteur audio doit être suffisamment grande pour éviter que des problèmes ne se produisent dans le flux audio entre les passes de traitement par le client et le moteur audio. Pour un point de terminaison de rendu, le thread client écrit régulièrement des données dans la mémoire tampon, et le thread du moteur audio lit régulièrement les données de la mémoire tampon. Pour un point de terminaison de capture, le thread du moteur écrit régulièrement dans la mémoire tampon et le thread client lit régulièrement à partir de la mémoire tampon. Dans les deux cas, si les périodes du thread client et du thread de moteur ne sont pas égales, la mémoire tampon doit être suffisamment grande pour prendre en charge la plus longue des deux périodes sans permettre que des problèmes se produisent.
Le client spécifie une taille de mémoire tampon via le paramètre hnsBufferDuration . Le client est responsable de la demande d’une mémoire tampon suffisamment grande pour s’assurer que les problèmes ne peuvent pas se produire entre les passes de traitement périodiques qu’il effectue sur la mémoire tampon. De même, la méthode Initialize garantit que la mémoire tampon n’est jamais inférieure à la taille minimale de la mémoire tampon nécessaire pour s’assurer que les problèmes ne se produisent pas entre les étapes de traitement périodique effectuées par le thread moteur sur la mémoire tampon. Si le client demande une taille de mémoire tampon inférieure à la taille minimale de mémoire tampon requise du moteur audio, la méthode définit la taille de la mémoire tampon sur cette taille de mémoire tampon minimale plutôt que sur la taille de mémoire tampon demandée par le client.
Si le client demande une taille de mémoire tampon (via le paramètre hnsBufferDuration ) qui n’est pas un nombre intégral d’images audio, la méthode arrondit la taille de mémoire tampon demandée au nombre intégral suivant d’images.
Après l’appel Initialize , le client doit appeler la méthode IAudioClient::GetBufferSize pour obtenir la taille précise de la mémoire tampon du point de terminaison. Lors de chaque passage de traitement, le client a besoin de la taille réelle de la mémoire tampon pour calculer la quantité de données à transférer vers ou à partir de la mémoire tampon. Le client appelle la méthode IAudioClient::GetCurrentPadding pour déterminer la quantité de données dans la mémoire tampon actuellement disponible pour le traitement.
Pour obtenir la latence de flux minimale entre l’application cliente et le périphérique de point de terminaison audio, le thread client doit s’exécuter à la même période que le thread du moteur audio. La période du thread moteur est fixe et ne peut pas être contrôlée par le client. Rendre la période du client plus petite que la période du moteur augmente inutilement la charge du thread client sur le processeur sans améliorer la latence ou diminuer la taille de la mémoire tampon. Pour déterminer la période du thread de moteur, le client peut appeler la méthode IAudioClient::GetDevicePeriod . Pour définir la mémoire tampon sur la taille minimale requise par le thread du moteur, le client doit appeler Initialize avec le paramètre hnsBufferDuration défini sur 0. Après l’appel Initialize , le client peut obtenir la taille de la mémoire tampon résultante en appelant IAudioClient::GetBufferSize.
Un client a la possibilité de demander une taille de mémoire tampon supérieure à ce qui est strictement nécessaire pour rendre les problèmes de minutage rares ou inexistants. L’augmentation de la taille de la mémoire tampon n’augmente pas nécessairement la latence du flux. Pour un flux de rendu, la latence via la mémoire tampon est déterminée uniquement par la séparation entre le pointeur d’écriture du client et le pointeur de lecture du moteur. Pour un flux de capture, la latence via la mémoire tampon est déterminée uniquement par la séparation entre le pointeur d’écriture du moteur et le pointeur de lecture du client.
L’indicateur de bouclage (AUDCLNT_STREAMFLAGS_LOOPBACK) active le bouclage audio. Un client peut activer le bouclage audio uniquement sur un point de terminaison de rendu avec un flux en mode partagé. Le bouclage audio est fourni principalement pour prendre en charge l’annulation d’écho acoustique (AEC).
Un client AEC nécessite à la fois un point de terminaison de rendu et la possibilité de capturer le flux de sortie à partir du moteur audio. Le flux de sortie du moteur est le mix global que le périphérique audio lit à travers les haut-parleurs. Si le bouclage audio est activé, un client peut ouvrir une mémoire tampon de capture pour le mixage audio global en appelant la méthode IAudioClient::GetService pour obtenir une interface IAudioCaptureClient sur l’objet de flux de rendu. Si le bouclage audio n’est pas activé, la tentative d’ouverture d’une mémoire tampon de capture sur un flux de rendu échoue. Les données de bouclage dans la mémoire tampon de capture sont au format de l’appareil, que le client peut obtenir en interrogeant la propriété PKEY_AudioEngine_DeviceFormat de l’appareil .
Sur les versions de Windows antérieures à Windows 10, un client de capture en mode pull ne reçoit aucun événement lorsqu’un flux est initialisé avec une mise en mémoire tampon pilotée par les événements (AUDCLNT_STREAMFLAGS_EVENTCALLBACK) et qu’il est activé en boucle (AUDCLNT_STREAMFLAGS_LOOPBACK). Si le flux est ouvert avec cette configuration, l’appel Initialize réussit, mais les événements pertinents ne sont pas déclenchés pour avertir le client de capture chaque fois qu’une mémoire tampon est prête pour le traitement. Pour contourner ce problème, initialisez un flux de rendu en mode piloté par les événements. Chaque fois que le client reçoit un événement pour le flux de rendu, il doit indiquer au client de capture d’exécuter le thread de capture qui lit l’ensemble d’exemples suivant à partir de la mémoire tampon du point de terminaison de capture. À partir de Windows 10 les handles d’événements appropriés sont désormais définis pour les flux actifs avec bouclage.
Notez que tous les flux doivent être ouverts en mode partage, car les flux en mode exclusif ne peuvent pas fonctionner en mode bouclage. Pour plus d’informations sur le bouclage audio, consultez Enregistrement de bouclage.
L’indicateur AUDCLNT_STREAMFLAGS_EVENTCALLBACK indique que le traitement de la mémoire tampon audio par le client sera piloté par les événements. WASAPI prend en charge la mise en mémoire tampon pilotée par les événements pour permettre le traitement à faible latence des flux en mode partagé et en mode exclusif.
La version initiale de Windows Vista prend en charge la mise en mémoire tampon pilotée par les événements (c’est-à-dire l’utilisation de l’indicateur AUDCLNT_STREAMFLAGS_EVENTCALLBACK) uniquement pour le rendu des flux.
Dans la version initiale de Windows Vista, pour les flux de capture, l’indicateur AUDCLNT_STREAMFLAGS_EVENTCALLBACK est pris en charge uniquement en mode partagé. La définition de cet indicateur n’a aucun effet pour les flux de capture en mode exclusif. Autrement dit, bien que l’application spécifie cet indicateur en mode exclusif par le biais de l’appel Initialize , l’application ne recevra pas d’événements qui sont généralement nécessaires pour capturer le flux audio. Dans la version de Windows Vista Service Pack 1, cet indicateur est fonctionnel en mode partagé et en mode exclusif ; une application peut définir cet indicateur pour activer la mise en mémoire tampon des événements pour les flux de capture. Pour plus d’informations sur la capture d’un flux audio, consultez Capture d’un flux.
Pour activer la mise en mémoire tampon pilotée par les événements, le client doit fournir un handle d’événement au système. Après l’appel Initialize et avant d’appeler la méthode IAudioClient::Start pour démarrer le flux, le client doit appeler la méthode IAudioClient::SetEventHandle pour définir le handle d’événement. Pendant l’exécution du flux, le système signale régulièrement l’événement pour indiquer au client que les données audio sont disponibles pour traitement. Entre les passes de traitement, le thread client attend sur le handle d’événement en appelant une fonction de synchronisation telle que WaitForSingleObject. Pour plus d’informations sur les fonctions de synchronisation, consultez la documentation du Kit de développement logiciel (SDK) Windows.
Pour un flux en mode partagé qui utilise la mise en mémoire tampon pilotée par les événements, l’appelant doit définir hnsPeriodicity et hnsBufferDuration sur 0. La méthode Initialize détermine la taille d’une mémoire tampon à allouer en fonction de la période de planification du moteur audio. Bien que le thread de traitement de la mémoire tampon du client soit piloté par les événements, le processus de gestion de la mémoire tampon de base, comme décrit précédemment, n’est pas affecté. Chaque fois que le thread se réveille, il doit appeler IAudioClient::GetCurrentPadding pour déterminer la quantité de données à écrire dans une mémoire tampon de rendu ou à lire à partir d’une mémoire tampon de capture. Contrairement aux deux mémoires tampons allouées par la méthode Initialize pour un flux en mode exclusif qui utilise la mise en mémoire tampon pilotée par les événements, un flux en mode partagé nécessite une seule mémoire tampon.
Pour un flux en mode exclusif qui utilise la mise en mémoire tampon pilotée par les événements, l’appelant doit spécifier des valeurs différentes de zéro pour hnsPeriodicity et hnsBufferDuration, et les valeurs de ces deux paramètres doivent être égales. La méthode Initialize alloue deux mémoires tampons pour le flux. Chaque mémoire tampon est égale en durée à la valeur du paramètre hnsBufferDuration . Après l’appel Initialiser pour un flux de rendu, l’appelant doit remplir la première des deux mémoires tampons avant de démarrer le flux. Pour un flux de capture, les mémoires tampons sont initialement vides, et l’appelant doit supposer que chaque mémoire tampon reste vide jusqu’à ce que l’événement pour cette mémoire tampon soit signalé. Pendant que le flux est en cours d’exécution, le système envoie alternativement une mémoire tampon ou l’autre au client. Cette forme de double mise en mémoire tampon est appelée « ping-ponging ». Chaque fois que le client reçoit une mémoire tampon du système (ce que le système indique en signalant l’événement), le client doit traiter l’intégralité de la mémoire tampon. Par exemple, si le client demande une taille de paquet à la méthode IAudioRenderClient::GetBuffer qui ne correspond pas à la taille de mémoire tampon, la méthode échoue. Les appels à la méthode IAudioClient::GetCurrentPadding ne sont pas nécessaires, car la taille du paquet doit toujours être égale à la taille de la mémoire tampon. Contrairement aux modes de mise en mémoire tampon abordés précédemment, la latence d’un flux en mode exclusif piloté par les événements dépend directement de la taille de la mémoire tampon.
Comme expliqué dans Sessions audio, le comportement par défaut d’une session qui contient des flux de rendu est que ses paramètres de volume et de désactivation persistent entre les redémarrages de l’application. L’indicateur AUDCLNT_STREAMFLAGS_NOPERSIST remplace le comportement par défaut et rend les paramètres non persistants. Cet indicateur n’a aucun effet sur les sessions qui contiennent des flux de capture. Les paramètres de ces sessions ne sont jamais persistants. En outre, les paramètres d’une session qui contient un flux de bouclage (un flux initialisé avec l’indicateur AUDCLNT_STREAMFLAGS_LOOPBACK) ne sont pas persistants.
Seule une session qui se connecte à un appareil de point de terminaison de rendu peut avoir des paramètres de volume et de désactivation persistants. Le premier flux à ajouter à la session détermine si les paramètres de la session sont persistants. Par conséquent, si l’indicateur AUDCLNT_STREAMFLAGS_NOPERSIST ou AUDCLNT_STREAMFLAGS_LOOPBACK est défini lors de l’initialisation du premier flux, les paramètres de la session ne sont pas persistants. Sinon, ils sont persistants. Leur persistance n’est pas affectée par des flux supplémentaires qui peuvent être ajoutés ou supprimés ultérieurement pendant la durée de vie de l’objet de session.
Une fois qu’un appel à Initialize a correctement initialisé une interface IAudioClient instance, un appel Initialize suivant pour initialiser la même interface instance échoue et retourne le code d’erreur E_ALREADY_INITIALIZED.
Si l’appel initial à Initialize échoue, les appels initialisés suivants peuvent échouer et retourner le code d’erreur E_ALREADY_INITIALIZED, même si l’interface n’a pas été initialisée. Si cela se produit, relâchez l’interface IAudioClient et obtenez une nouvelle interface IAudioClient à partir de l’API MMDevice avant d’appeler à nouveau Initialize .
Pour obtenir des exemples de code qui appellent la méthode Initialize , consultez les rubriques suivantes :
À compter de Windows 7, Initialize peut retourner AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED pour un rendu ou un périphérique de capture. Cela indique que la taille de mémoire tampon, spécifiée par l’appelant dans le paramètre hnsBufferDuration , n’est pas alignée. Ce code d’erreur est retourné uniquement si l’appelant a demandé un flux en mode exclusif (AUDCLNT_SHAREMODE_EXCLUSIVE) et une mise en mémoire tampon pilotée par les événements (AUDCLNT_STREAMFLAGS_EVENTCALLBACK).Si Initialize retourne AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED, l’appelant doit à nouveau appeler Initialize et spécifier la taille de mémoire tampon alignée. Utiliser les étapes suivantes :
- Appelez IAudioClient::GetBufferSize et recevez la taille de mémoire tampon alignée la plus élevée (en images).
- Appelez IAudioClient::Release pour libérer le client audio utilisé dans l’appel précédent qui a retourné AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED.
- Calculez la taille de mémoire tampon alignée en unités de 100 nanosecondes (hns). La taille de la mémoire tampon est
(REFERENCE_TIME)((10000.0 * 1000 / WAVEFORMATEX.nSamplesPerSecond * nFrames) + 0.5). Dans cette formule,nFramesest la taille de mémoire tampon récupérée par GetBufferSize. - Appelez la méthode IMMDevice::Activate avec le paramètre iid défini sur REFIID IID_IAudioClient pour créer un client audio.
- Appelez à nouveau Initialize sur le client audio créé et spécifiez la nouvelle taille et la périodicité de la mémoire tampon.
À compter de Windows 10, les flux audio déchargés par le matériel doivent être pilotés par les événements. Cela signifie que si vous appelez IAudioClient2::SetClientProperties et que vous définissez le paramètre bIsOffloadd’AudioClientProperties sur TRUE, vous devez spécifier l’indicateur AUDCLNT_STREAMFLAGS_EVENTCALLBACK dans le paramètre StreamFlags sur IAudioClient::Initialize.
Exemples
L’exemple de code suivant montre comment répondre au AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED code de retour.
#define REFTIMES_PER_SEC 10000000
HRESULT CreateAudioClient(IMMDevice* pDevice, IAudioClient** ppAudioClient)
{
if (!pDevice)
{
return E_INVALIDARG;
}
if (!ppAudioClient)
{
return E_POINTER;
}
HRESULT hr = S_OK;
WAVEFORMATEX *pwfx = NULL;
REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
UINT32 nFrames = 0;
IAudioClient *pAudioClient = NULL;
// Get the audio client.
CHECK_HR( hr = pDevice->Activate(
__uuidof(IAudioClient),
CLSCTX_ALL,
NULL,
(void**)&pAudioClient));
// Get the device format.
CHECK_HR( hr = pAudioClient->GetMixFormat(&pwfx));
// Open the stream and associate it with an audio session.
hr = pAudioClient->Initialize(
AUDCLNT_SHAREMODE_EXCLUSIVE,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
hnsRequestedDuration,
hnsRequestedDuration,
pwfx,
NULL);
// If the requested buffer size is not aligned...
if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED)
{
// Get the next aligned frame.
CHECK_HR( hr = pAudioClient->GetBufferSize(&nFrames));
hnsRequestedDuration = (REFERENCE_TIME)
((10000.0 * 1000 / pwfx->nSamplesPerSec * nFrames) + 0.5);
// Release the previous allocations.
SAFE_RELEASE(pAudioClient);
CoTaskMemFree(pwfx);
// Create a new audio client.
CHECK_HR( hr = pDevice->Activate(
__uuidof(IAudioClient),
CLSCTX_ALL,
NULL,
(void**)&pAudioClient));
// Get the device format.
CHECK_HR( hr = pAudioClient->GetMixFormat(&pwfx));
// Open the stream and associate it with an audio session.
CHECK_HR( hr = pAudioClient->Initialize(
AUDCLNT_SHAREMODE_EXCLUSIVE,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
hnsRequestedDuration,
hnsRequestedDuration,
pwfx,
NULL));
}
else
{
CHECK_HR (hr);
}
// Return to the caller.
*(ppAudioClient) = pAudioClient;
(*ppAudioClient)->AddRef();
done:
// Clean up.
CoTaskMemFree(pwfx);
SAFE_RELEASE(pAudioClient);
return hr;
}
Configuration requise
| Plateforme cible | Windows |
| En-tête | audioclient.h |
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour