> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # SetFrameIntervalX (famille XBOX One) > Établit la durée et la période de l'intervalle d'une image. Établit la durée et la période de l'intervalle d'une image. ## Syntaxe ```cpp theme={null} HRESULT SetFrameIntervalX( IDXGIOutput* pOutputSyncTarget, UINT LengthInMicroseconds, UINT PeriodInIntervals, D3D12XBOX_FRAME_INTERVAL_FLAGS Flags) ``` ### Paramètres *pOutputSyncTarget*   \_In\_opt\_\ Type : [IDXGIOutput](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nn-dxgi-idxgioutput)\* Interface de sortie de l'adaptateur qui identifie l'écran dont la fréquence d'actualisation et la synchronisation doivent servir de base de synchronisation pour la planification des images. Pour utiliser l'adaptateur par défaut, passez null. *LengthInMicroseconds*   \_In\_\ Type : UINT Durée de l'intervalle d'image, en microsecondes. La durée définit la fréquence à laquelle les images seront présentées pour affichage. *PeriodInIntervals*   \_In\_\ Type : UINT Période de l'image, en intervalles. La période définit le nombre d'intervalles entre l'origine d'une image et le moment où elle est présentée pour affichage. La période est basée sur la profondeur souhaitée du pipeline d'images, c'est-à-dire jusqu'à quel point le rendu du processeur est autorisé à devancer l'affichage des images. *Flags*   \_In\_\ Type : [D3D12XBOX\_FRAME\_INTERVAL\_FLAGS](/fr-CA/reference/graphics/d3d12_x/enums/d3d12xbox_frame_interval_flags) Indicateurs utilisés pour offrir un contrôle supplémentaire sur l'intervalle établi. En fonctionnement normal, cet indicateur doit toujours être défini à *D3D12XBOX\_FRAME\_INTERVAL\_FLAG\_NONE*. Pour la prise en charge de 60 FPS et plus, l'indicateur *D3D12XBOX\_FRAME\_INTERVAL\_FLAG\_60FPS\_PLUS* peut être utilisé. ### Valeur de retour Type : HRESULT Code de réussite ou d'erreur HRESULT. Retourne S\_FALSE pour indiquer que l'appel a réussi, mais que le nouvel intervalle d'image n'est pas encore en vigueur. Il prendra effet lors du prochain appel à [ScheduleFrameEventX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_scheduleframeeventx), dont le *Type* doit être *D3D12XBOX\_FRAME\_EVENT\_ORIGIN*. Retourne E\_INVALIDARG pour des valeurs d'intervalle, de période ou d'indicateur non prises en charge. ## Remarques La durée de l'intervalle d'image détermine la fréquence de présentation et spécifie la cadence à laquelle les images seront rendues et envoyées à l'écran. Les durées d'intervalle les plus courantes comprennent les définitions de préprocesseur suivantes : ```cpp theme={null} #define D3D12XBOX_FRAME_INTERVAL_120_HZ 8333 #define D3D12XBOX_FRAME_INTERVAL_60_HZ 16667 #define D3D12XBOX_FRAME_INTERVAL_40_HZ 25000 #define D3D12XBOX_FRAME_INTERVAL_30_HZ 33333 ``` Les durées d'intervalle d'image qui sont un multiple de 16 666 microsecondes, comme 60 Hz et 30 Hz, sont toujours permises avec tous les écrans et toutes les configurations. Toutefois, les durées d'intervalle d'image qui sont un multiple de 8 333 microsecondes, comme 120 Hz et 40 Hz, ne doivent être utilisées que lorsque l'écran et la console prennent en charge cette configuration. Cela peut être vérifié à l'aide de la méthode [IDXGIOutput::GetDisplayModeList](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgioutput-getdisplaymodelist) au lancement de l'application. De plus, les durées d'intervalle qui établissent des fréquences d'actualisation de 20 Hz et de 15 Hz sont également permises. Les titres qui souhaitent cibler une durée d'intervalle d'image entre 60 Hz et 120 Hz peuvent le faire avec l'indicateur `D3D12XBOX_FRAME_INTERVAL_FLAG_60FPS_PLUS`. Consultez [D3D12XBOX\_FRAME\_INTERVAL\_FLAGS](/fr-CA/reference/graphics/d3d12_x/enums/d3d12xbox_frame_interval_flags) pour plus de détails. Les durées d'intervalle d'image sont établies en tant que multiples entiers de l'intervalle d'actualisation de l'écran et sont alignées sur les limites de vblank. C'est pourquoi la durée en microsecondes n'est pas une directive stricte qui établit le temps exact entre les intervalles; il s'agit plutôt d'une valeur qui communique la durée d'intervalle souhaitée. Lorsqu'elle se situe dans un certain seuil, elle sera associée au multiple le plus proche de la fréquence d'actualisation de l'écran. Par exemple, une durée d'image définie de 33 333 microsecondes pourrait en réalité produire une durée d'intervalle de 33 367 microsecondes si la fréquence d'actualisation de l'écran est de 29,97 Hz plutôt que de 30 Hz. Toutefois, l'intervalle défini sera utilisé comme base pour la planification des événements d'image (consultez [ScheduleFrameEventX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12device/methods/id3d12device_scheduleframeeventx)), où le décalage en microsecondes est exprimé en fonction de la durée fournie à SetFrameIntervalX, et non de la valeur à laquelle cette durée a été associée en interne. Par exemple, un décalage d'origine planifié de 16 666 microsecondes utilisé avec une durée d'intervalle définie de 33 333 microsecondes sera converti en interne en un décalage réel de 16 684 microsecondes lorsque la fréquence d'actualisation de l'écran est de 29,97 Hz; cela préserve l'intention de planifier l'origine à mi-chemin dans l'image. La période de l'image (en intervalles) établit la durée maximale d'une image, de son origine à son affichage, et peut être définie à une valeur comprise entre 1 et 4 inclusivement. Cette période est basée sur le chevauchement prévu du rendu du processeur et du GPU, et elle contrôle le moment où le processeur doit être limité en fonction du nombre d'images en cours. Une période de 1 indique qu'une image sera commencée et terminée dans le même intervalle; cela ne prendra pas plus de *LengthInMicroseconds*. Une période de *n* indique qu'une image sera commencée dans un intervalle d'image et terminée *n* - 1 intervalles plus tard. En matière de latence, une image sera généralement maintenue à moins de *PeriodInIntervals* x *LengthInMicroseconds* microsecondes de latence entre son début et le moment où elle atteint l'écran, en supposant qu'aucun vblank n'est manqué. La durée d'un intervalle d'image et sa période servent à établir une échéance d'affichage pour une image. Si l'image n'est pas terminée et présentée pour affichage avant la fin de l'intervalle situé *PeriodInIntervals* - 1 intervalles après son origine, l'image suivante sera limitée et ne pourra pas commencer avant que l'image manquée ait été présentée et basculée à l'écran. Cela vise à éviter l'introduction d'intervalles de latence supplémentaires en cas de vblanks manqués; lorsqu'une image manque son échéance de présentation, elle est généralement retenue pour affichage jusqu'au prochain vblank auquel elle est prête (pour éviter le déchirement). Retarder du même délai le début de l'image suivante sur le processeur évite d'échantillonner les entrées trop tôt et préserve les garanties de latence établies par l'intervalle et la période d'image définis. Les paramètres initiaux de l'intervalle d'image sont appliqués lorsque l'événement d'origine d'image est planifié pour la première fois. Les mises à jour subséquentes sont mises en pipeline avec la présentation, de sorte que les modifications apportées au cours d'un intervalle sont appliquées lorsque la prochaine image présentée est basculée à l'écran. ## Configuration requise **En-tête :** d3d12\_x.h **Bibliothèque :** d3d12\_x.lib **Plateformes prises en charge :** famille XBOX One ## Voir aussi [IDXGIOutput](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nn-dxgi-idxgioutput) ## Related topics - [Répertoire des rubriques NDA : liens actifs vers Microsoft Learn](/fr/nda/nda-topic-directory.md) - [SetShapeDmaNumFrames](/reference/audio/shapedmacontext/functions/setshapedmanumframes.md) - [Documentation de développement de jeux XBOX](/fr-CA/index.md) - [Installer la chaîne d'outils du GDK](/fr/home/setup-install/download-install.md) - [GetMinUpdateIntervalInMicroseconds method](/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_getminupdateintervalinmicroseconds.md)