Traitement vidéo DXVA

Le traitement vidéo DXVA encapsule les fonctions du matériel graphique qui sont consacrées au traitement des images vidéo non compressées. Les services de traitement vidéo incluent le déinterlacement et le mixage vidéo.

Cette rubrique contient les sections suivantes :

Vue d’ensemble

Le matériel graphique peut utiliser l’unité de traitement graphique (GPU) pour traiter des images vidéo non compressées. Un périphérique de traitement vidéo est un composant logiciel qui encapsule ces fonctions. Les applications peuvent utiliser un périphérique de traitement vidéo pour effectuer des fonctions telles que :

  • Déinterlacation et télécine inverse
  • Mélange de sous-flux vidéo sur l’image vidéo principale
  • Ajustement des couleurs (ProcAmp) et filtrage d’images
  • Mise à l'échelle de l’image
  • Conversion d’espace de couleur
  • Fusion alpha

Le diagramme suivant montre les étapes du pipeline de traitement vidéo. Le diagramme n’est pas destiné à afficher une implémentation réelle. Par exemple, le pilote graphique peut combiner plusieurs étapes en une seule opération. Toutes ces opérations peuvent être effectuées dans un seul appel à l’appareil de traitement vidéo. Certaines étapes présentées ici, telles que le filtrage du bruit et des détails, peuvent ne pas être prises en charge par le pilote.

diagram showing the stages of dxva video processing.

L’entrée du pipeline de traitement vidéo inclut toujours un flux vidéo principal , qui contient les données d’image principales. Le flux vidéo principal détermine la fréquence d’images de la vidéo de sortie. Chaque image de la vidéo de sortie est calculée par rapport aux données d’entrée du flux vidéo principal. Les pixels du flux principal sont toujours opaques, sans données alpha par pixel. Le flux vidéo principal peut être progressif ou entrelacé.

Si vous le souhaitez, le pipeline de traitement vidéo peut recevoir jusqu’à 15 sous-flux vidéo. Un sous-flux contient des données d’image auxiliaires, telles que des sous-titres de sous-titres ou dvd. Ces images sont affichées sur le flux vidéo principal et ne sont généralement pas destinées à être affichées par eux-mêmes. Les images de sous-flux peuvent contenir des données alpha par pixel et sont toujours des images progressives. L’appareil de traitement vidéo combine les images de sous-flux avec l’image déinterlacée actuelle du flux vidéo principal.

Dans le reste de cette rubrique, le terme image est utilisé pour les données d’entrée sur un appareil de traitement vidéo. Une image peut se composer d’un cadre progressif, d’un champ unique ou de deux champs entrelacés. La sortie est toujours un frame déinterlacé.

Un pilote vidéo peut implémenter plusieurs périphériques de traitement vidéo pour fournir différents ensembles de fonctionnalités de traitement vidéo. Les appareils sont identifiés par GUID. Les GUID suivants sont prédéfinis :

  • DXVA2_VideoProcBobDevice. Cet appareil effectue une désinterlacation bob.
  • DXVA2_VideoProcProgressiveDevice. Cet appareil est utilisé si la vidéo contient uniquement des images progressives, sans trames entrelacées. (Certains contenus vidéo contiennent un mélange de trames progressives et entrelacées. L’appareil progressif ne peut pas être utilisé pour ce type de contenu vidéo « mixte », car une étape de déinterlacation est requise pour les images entrelacées.)

Chaque pilote graphique qui prend en charge le traitement vidéo DXVA doit implémenter au moins ces deux appareils. Le pilote graphique peut également fournir d’autres périphériques, identifiés par des GUID spécifiques au pilote. Par exemple, un pilote peut implémenter un algorithme de déinterlacement propriétaire qui produit une sortie de meilleure qualité que le déinterlacage bob. Certains algorithmes de déinterlacation peuvent nécessiter des images de référence vers l’avant ou vers l’arrière à partir du flux principal. Dans ce cas, l’appelant doit fournir ces images au pilote dans la séquence correcte, comme décrit plus loin dans cette section.

Un périphérique logiciel de référence est également fourni. L’appareil logiciel est optimisé pour la qualité plutôt que la vitesse, et peut ne pas être suffisant pour le traitement vidéo en temps réel. L’appareil logiciel de référence utilise la valeur GUID DXVA2_VideoProcSoftwareDevice.

Création d’un appareil de traitement vidéo

Avant d’utiliser le traitement vidéo DXVA, l’application doit créer un périphérique de traitement vidéo. Voici un bref aperçu des étapes décrites plus en détail dans le reste de cette section :

  1. Obtenez un pointeur vers l’interface IDirectXVideoProcessorService .
  2. Créez une description du format vidéo pour le flux vidéo principal. Utilisez cette description pour obtenir la liste des appareils de traitement vidéo qui prennent en charge le format vidéo. Les appareils sont identifiés par GUID.
  3. Pour un appareil particulier, obtenez la liste des formats de cible de rendu pris en charge par l’appareil. Les formats sont retournés sous forme de liste de valeurs D3DFORMAT . Si vous envisagez de combiner des sous-flux, obtenez également la liste des formats de sous-flux pris en charge.
  4. Interrogez les fonctionnalités de chaque appareil.
  5. Créez l’appareil de traitement vidéo.

Parfois, vous pouvez omettre certaines de ces étapes. Par exemple, au lieu d’obtenir la liste des formats de cible de rendu, vous pouvez simplement essayer de créer l’appareil de traitement vidéo avec votre format préféré et voir si elle réussit. Un format courant tel que D3DFMT_X8R8G8B8 est susceptible de réussir.

Le reste de cette section décrit ces étapes en détail.

Obtenir le pointeur IDirectXVideoProcessorService

L’interface IDirectXVideoProcessorService est obtenue à partir de l’appareil Direct3D. Il existe deux façons d’obtenir un pointeur vers cette interface :

Si vous avez un pointeur vers un appareil Direct3D, vous pouvez obtenir un pointeur IDirectXVideoProcessorService en appelant la fonction DXVA2CreateVideoService . Passez un pointeur vers l’interface IDirect3DDevice9 de l’appareil et spécifiez IID_IDirectXVideoProcessorService pour le paramètre riid , comme indiqué dans le code suivant :

    // Create the DXVA-2 Video Processor service.
    hr = DXVA2CreateVideoService(g_pD3DD9, IID_PPV_ARGS(&g_pDXVAVPS));

n certains cas, un objet crée l’appareil Direct3D, puis le partage avec d’autres objets via le Gestionnaire de périphériques Direct3D. Dans ce cas, vous pouvez appeler IDirect3DDeviceManager9::GetVideoService sur le gestionnaire de périphériques pour obtenir le pointeur IDirectXVideoProcessorService , comme illustré dans le code suivant :

HRESULT GetVideoProcessorService(
    IDirect3DDeviceManager9 *pDeviceManager,
    IDirectXVideoProcessorService **ppVPService
    )
{
    *ppVPService = NULL;

    HANDLE hDevice;

    HRESULT hr = pDeviceManager->OpenDeviceHandle(&hDevice);
    if (SUCCEEDED(hr))
    {
        // Get the video processor service 
        HRESULT hr2 = pDeviceManager->GetVideoService(
            hDevice, 
            IID_PPV_ARGS(ppVPService)
            );

        // Close the device handle.
        hr = pDeviceManager->CloseDeviceHandle(hDevice);

        if (FAILED(hr2))
        {
            hr = hr2;
        }
    }

    if (FAILED(hr))
    {
        SafeRelease(ppVPService);
    }

    return hr;
}

Énumérer les appareils de traitement vidéo

Pour obtenir la liste des appareils de traitement vidéo, renseignez une structure DXVA2_VideoDesc au format du flux vidéo principal et transmettez cette structure à la méthode IDirectXVideoProcessorService::GetVideoProcessorDeviceGuids . La méthode retourne un tableau de GUID, un pour chaque appareil de traitement vidéo qui peut être utilisé avec ce format vidéo.

Envisagez une application qui affiche un flux vidéo au format YUY2, à l’aide de la définition BT.709 de couleur YUV, avec une fréquence d’images de 29,97 images par seconde. Supposons que le contenu vidéo se compose entièrement d’images progressives. Le fragment de code suivant montre comment remplir la description de format et obtenir les GUID de l’appareil :

    // Initialize the video descriptor.

    g_VideoDesc.SampleWidth                         = VIDEO_MAIN_WIDTH;
    g_VideoDesc.SampleHeight                        = VIDEO_MAIN_HEIGHT;
    g_VideoDesc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_MPEG2;
    g_VideoDesc.SampleFormat.NominalRange           = DXVA2_NominalRange_16_235;
    g_VideoDesc.SampleFormat.VideoTransferMatrix    = EX_COLOR_INFO[g_ExColorInfo][0];
    g_VideoDesc.SampleFormat.VideoLighting          = DXVA2_VideoLighting_dim;
    g_VideoDesc.SampleFormat.VideoPrimaries         = DXVA2_VideoPrimaries_BT709;
    g_VideoDesc.SampleFormat.VideoTransferFunction  = DXVA2_VideoTransFunc_709;
    g_VideoDesc.SampleFormat.SampleFormat           = DXVA2_SampleProgressiveFrame;
    g_VideoDesc.Format                              = VIDEO_MAIN_FORMAT;
    g_VideoDesc.InputSampleFreq.Numerator           = VIDEO_FPS;
    g_VideoDesc.InputSampleFreq.Denominator         = 1;
    g_VideoDesc.OutputFrameFreq.Numerator           = VIDEO_FPS;
    g_VideoDesc.OutputFrameFreq.Denominator         = 1;

    // Query the video processor GUID.

    UINT count;
    GUID* guids = NULL;

    hr = g_pDXVAVPS->GetVideoProcessorDeviceGuids(&g_VideoDesc, &count, &guids);

Le code de cet exemple est extrait de l’exemple DXVA2_VideoProc SDK.

Le tableau pGuids de cet exemple est alloué par la méthode GetVideoProcessorDeviceGuids , de sorte que l’application doit libérer le tableau en appelant CoTaskMemFree. Les étapes restantes peuvent être effectuées à l’aide de l’un des GUID d’appareil retournés par cette méthode.

Énumérer les formats de Render-Target

Pour obtenir la liste des formats de cible de rendu pris en charge par l’appareil, transmettez le GUID de l’appareil et la structure DXVA2_VideoDesc à la méthode IDirectXVideoProcessorService::GetVideoProcessorRenderTargets , comme illustré dans le code suivant :

    // Query the supported render-target formats.

    UINT i, count;
    D3DFORMAT* formats = NULL;

    HRESULT hr = g_pDXVAVPS->GetVideoProcessorRenderTargets(
        guid, &g_VideoDesc, &count, &formats);

    if (FAILED(hr))
    {
        DBGMSG((L"GetVideoProcessorRenderTargets failed: 0x%x.\n", hr));
        return FALSE;
    }

    for (i = 0; i < count; i++)
    {
        if (formats[i] == VIDEO_RENDER_TARGET_FORMAT)
        {
            break;
        }
    }

    CoTaskMemFree(formats);

    if (i >= count)
    {
        DBGMSG((L"The device does not support the render-target format.\n"));
        return FALSE;
    }

La méthode retourne un tableau de valeurs D3DFORMAT . Dans cet exemple, où le type d’entrée est YUY2, une liste classique de formats peut être D3DFMT_X8R8G8B8 (RVB 32 bits) et D3DMFT_YUY2 (format d’entrée). Toutefois, la liste exacte dépend du pilote.

La liste des formats disponibles pour les sous-flux peut varier en fonction du format cible de rendu et du format d’entrée. Pour obtenir la liste des formats de sous-flux, transmettez le GUID de l’appareil, la structure de format et le format de cible de rendu à la méthode IDirectXVideoProcessorService::GetVideoProcessorSubStreamFormats , comme illustré dans le code suivant :

    // Query the supported substream formats.

    formats = NULL;

    hr = g_pDXVAVPS->GetVideoProcessorSubStreamFormats(
        guid, &g_VideoDesc, VIDEO_RENDER_TARGET_FORMAT, &count, &formats);

    if (FAILED(hr))
    {
        DBGMSG((L"GetVideoProcessorSubStreamFormats failed: 0x%x.\n", hr));
        return FALSE;
    }

    for (i = 0; i < count; i++)
    {
        if (formats[i] == VIDEO_SUB_FORMAT)
        {
            break;
        }
    }

    CoTaskMemFree(formats);

    if (i >= count)
    {
        DBGMSG((L"The device does not support the substream format.\n"));
        return FALSE;
    }

Cette méthode retourne un autre tableau de valeurs D3DFORMAT . Les formats de sous-flux classiques sont AYUV et AI44.

Interroger les fonctionnalités de l’appareil

Pour obtenir les fonctionnalités d’un appareil particulier, transmettez le GUID de l’appareil, la structure de format et un format de cible de rendu à la méthode IDirectXVideoProcessorService::GetVideoProcessorCaps . La méthode remplit une structure de structure DXVA2_VideoProcessorCaps avec les fonctionnalités de l’appareil.

    // Query video processor capabilities.

    hr = g_pDXVAVPS->GetVideoProcessorCaps(
        guid, &g_VideoDesc, VIDEO_RENDER_TARGET_FORMAT, &g_VPCaps);

    if (FAILED(hr))
    {
        DBGMSG((L"GetVideoProcessorCaps failed: 0x%x.\n", hr));
        return FALSE;
    }

Créer l’appareil

Pour créer l’appareil de traitement vidéo, appelez IDirectXVideoProcessorService::CreateVideoProcessor. L’entrée de cette méthode est le GUID de l’appareil, la description du format, le format cible de rendu et le nombre maximal de sous-flux que vous envisagez de combiner. La méthode retourne un pointeur vers l’interface IDirectXVideoProcessor , qui représente l’appareil de traitement vidéo.

    // Finally create a video processor device.

    hr = g_pDXVAVPS->CreateVideoProcessor(
        guid,
        &g_VideoDesc,
        VIDEO_RENDER_TARGET_FORMAT,
        SUB_STREAM_COUNT,
        &g_pDXVAVPD
        );

Processus vidéo Blit

L’opération principale de traitement vidéo est la blit de traitement vidéo. (Une blit est n’importe quelle opération qui combine deux bitmaps ou plus en une seule bitmap. Un traitement vidéo blit combine les images d’entrée pour créer un frame de sortie.) Pour effectuer une blit de traitement vidéo, appelez IDirectXVideoProcessor::VideoProcessBlt. Cette méthode transmet un ensemble d’exemples vidéo à l’appareil de traitement vidéo. En réponse, l’appareil de traitement vidéo traite les images d’entrée et génère un cadre de sortie. Le traitement peut inclure le déinterlacage, la conversion d’espace de couleur et le mélange de sous-flux. La sortie est écrite dans une surface de destination fournie par l’appelant.

La méthode VideoProcessBlt prend les paramètres suivants :

  • pRT pointe vers une surface cible de rendu IDirect3DSurface9 qui recevra l’image vidéo traitée.
  • pBltParams pointe vers une structure DXVA2_VideoProcessBltParams qui spécifie les paramètres de la blit.
  • pSamples est l’adresse d’un tableau de structures DXVA2_VideoSample . Ces structures contiennent les exemples d’entrée pour le blit.
  • NumSamples donne la taille du tableau pSamples .
  • Le paramètre réservé est réservé et doit être défini sur NULL.

Dans le tableau pSamples , l’appelant doit fournir les exemples d’entrée suivants :

  • Image actuelle à partir du flux vidéo principal.
  • Images de référence vers l’avant et vers l’arrière, si nécessaire par l’algorithme de déinterlacation.
  • Zéro ou plusieurs images de sous-flux, jusqu’à un maximum de 15 sous-flux.

Le pilote s’attend à ce que ce tableau soit dans un ordre particulier, comme décrit dans l’exemple de commande d’entrée.

Paramètres Blit

La structure DXVA2_VideoProcessBltParams contient des paramètres généraux pour le blit. Les paramètres les plus importants sont stockés dans les membres suivants de la structure :

  • TargetFrame est l’heure de présentation de l’image de sortie. Pour le contenu progressif, cette fois-ci doit égaler l’heure de début de l’image actuelle à partir du flux vidéo principal. Cette fois- ci est spécifiée dans le membre Démarrer de la structure DXVA2_VideoSample pour cet exemple d’entrée.

    Pour le contenu interlacé, une trame avec deux champs entrelacés produit deux images de sortie déinterlacées. Dans la première trame de sortie, l’heure de présentation doit être égale à l’heure de début de l’image actuelle dans le flux vidéo principal, tout comme le contenu progressif. Dans la deuxième trame de sortie, l’heure de début doit être égale au point intermédiaire entre l’heure de début de l’image actuelle dans le flux vidéo principal et l’heure de début de l’image suivante dans le flux. Par exemple, si la vidéo d’entrée est de 25 images par seconde (50 champs par seconde), les images de sortie ont les horodatages affichés dans le tableau suivant. Les horodatages sont affichés en unités de 100 nanosecondes.

    Image d’entrée TargetFrame (1) TargetFrame (2)
    0 0 200000
    400000 0 600000
    800000 800000 1000000
    1200000 1200000 1400000

     

    Si le contenu interlacé se compose de champs uniques plutôt que de champs entrelacés, les heures de sortie correspondent toujours aux heures d’entrée, comme avec le contenu progressif.

  • TargetRect définit une région rectangulaire dans l’aire de destination. Le blit écrit la sortie dans cette région. Plus précisément, chaque pixel à l’intérieur de TargetRect sera modifié et aucun pixel en dehors de TargetRect ne sera modifié. Le rectangle cible définit le rectangle englobant pour tous les flux vidéo d’entrée. Le placement de flux individuels dans ce rectangle est contrôlé par le biais du paramètre pSamples de IDirectXVideoProcessor::VideoProcessBlt.

  • BackgroundColor donne la couleur de l’arrière-plan où aucune image vidéo n’apparaît. Par exemple, lorsqu’une image vidéo 16 x 9 est affichée dans une zone de 4 x 3 (boîte de lettres), les zones de boîte de lettres sont affichées avec la couleur d’arrière-plan. La couleur d’arrière-plan s’applique uniquement dans le rectangle cible (TargetRect). Tous les pixels en dehors de TargetRect ne sont pas modifiés.

  • DestFormat décrit l’espace de couleur de la vidéo de sortie, par exemple, si l’UIT-R BT.709 ou BT.601 est utilisé. Ces informations peuvent affecter la façon dont l’image est affichée. Pour plus d’informations, consultez Informations sur les couleurs étendues.

D’autres paramètres sont décrits dans la page de référence de la structure DXVA2_VideoProcessBltParams .

Exemples d’entrée

Le paramètre pSamples de IDirectXVideoProcessor::VideoProcessBlt pointe vers un tableau de structures DXVA2_VideoSample . Chacune de ces structures contient des informations sur un exemple d’entrée et un pointeur vers la surface Direct3D qui contient l’exemple. Chaque exemple est l’un des éléments suivants :

  • Image actuelle du flux principal.
  • Image de référence vers l’avant ou vers l’arrière du flux principal, utilisée pour la déinterlacation.
  • Image de sous-flux.

L’ordre exact dans lequel les exemples doivent apparaître dans le tableau est décrit plus loin, dans la section Input Sample Order.

Jusqu’à 15 images de sous-flux peuvent être fournies, même si la plupart des applications vidéo n’ont besoin que d’un sous-flux, au plus. Le nombre de sous-flux peut changer avec chaque appel à VideoProcessBlt. Les images de sous-flux sont indiquées en définissant le membre SampleFormat.SampleFormat de la structure DXVA2_VideoSample égale à DXVA2_SampleSubStream. Pour le flux vidéo principal, ce membre décrit l’interlacement de la vidéo d’entrée. Pour plus d’informations, consultez DXVA2_SampleFormat énumération.

Pour le flux vidéo principal, les membres début et fin de la structure DXVA2_VideoSample donnent les heures de début et de fin de l’exemple d’entrée. Pour les images de sous-flux, définissez ces valeurs sur zéro, car l’heure de présentation est toujours calculée à partir du flux principal. L’application est responsable du suivi lorsque chaque image de sous-flux doit être présentée et l’envoyer à VideoProcessBlt au moment approprié.

Deux rectangles définissent la façon dont la vidéo source est positionnée pour chaque flux :

  • Le membre SrcRect de la structure DXVA2_VideoSample spécifie le rectangle source, une région rectangulaire de l’image source qui apparaîtra dans le cadre de sortie composite. Pour rogner l’image, définissez-la sur une valeur inférieure à la taille du cadre. Sinon, définissez-le comme égal à la taille du cadre.
  • Le membre DstRect de la même structure spécifie le rectangle de destination, une région rectangulaire de la surface de destination dans laquelle la trame vidéo s’affiche.

Le pilote blit les pixels du rectangle source dans le rectangle de destination. Les deux rectangles peuvent avoir des tailles ou des proportions différentes ; le pilote met à l’échelle l’image en fonction des besoins. De plus, chaque flux d’entrée peut utiliser un facteur de mise à l’échelle différent. En fait, la mise à l’échelle peut être nécessaire pour produire les proportions correctes dans l’image de sortie. Le pilote ne prend pas en compte les proportions de pixels de la source. Par conséquent, si l’image source utilise des pixels non carrés, l’application doit calculer le rectangle de destination correct.

Les formats de sous-flux préférés sont AYUV et AI44. Ce dernier est un format palettené avec 16 couleurs. Les entrées de palette sont spécifiées dans le membre Pal de la structure DXVA2_VideoSample . (Si votre format vidéo source est initialement exprimé en tant que type de média Media Foundation, les entrées de palette sont stockées dans l’attribut MF_MT_PALETTE .) Pour les formats non palettenés, effacez ce tableau sur zéro.

Composition d’image

Chaque opération blit est définie par les trois rectangles suivants :

  • Le rectangle cible (TargetRect) définit la région dans la surface de destination où la sortie s’affiche. L’image de sortie est découpée dans ce rectangle.
  • Le rectangle de destination pour chaque flux (DstRect) définit l’emplacement où le flux d’entrée apparaît dans l’image composite.
  • Le rectangle source pour chaque flux (SrcRect) définit la partie de l’image source qui s’affiche.

Les rectangles cible et de destination sont spécifiés par rapport à la surface de destination. Le rectangle source est spécifié par rapport à l’image source. Tous les rectangles sont spécifiés en pixels.

diagram showing source, destination, and target rectangles

Le périphérique de traitement vidéo alpha fusionne les images d’entrée à l’aide de l’une des sources suivantes de données alpha :

  • Données alpha par pixel à partir de sous-flux.
  • Valeur alpha planaire pour chaque flux vidéo, spécifiée dans le membre PlanarAlpha de la structure DXVA2_VideoSample .
  • Valeur alpha planaire de l’image composite, spécifiée dans le membre Alpha de la structure DXVA2_VideoProcessBltParams . Cette valeur est utilisée pour fusionner l’image composite entière avec la couleur d’arrière-plan.

Cette section fournit une série d’exemples qui montrent comment l’appareil de traitement vidéo crée l’image de sortie.

Exemple 1 : Boîte à lettres

Cet exemple montre comment mettre en forme la boîte de lettres de l’image source en définissant le rectangle de destination comme étant inférieur au rectangle cible. Le flux vidéo principal de cet exemple est une image 720 × 480 et doit être affichée à 16:9 proportions. La surface de destination est de 640 × 480 pixels (4:3 proportions). Pour obtenir les proportions correctes, le rectangle de destination doit être de 640 × 360. Par souci de simplicité, cet exemple n’inclut pas de sous-flux. Le diagramme suivant montre les rectangles source et de destination.

diagram showing letterboxing.

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 640, 480 }

  • Vidéo principale :

    • Rectangle source : { 0, 0, 720, 480 }
    • Rectangle de destination : { 0, 60, 640, 420 }

Le pilote désinterlace la vidéo, réduit l’image déinterlacée à 640 × 360 et blit le cadre dans le rectangle de destination. Le rectangle cible est plus grand que le rectangle de destination. Le pilote utilise donc la couleur d’arrière-plan pour remplir les barres horizontales au-dessus et sous le cadre. La couleur d’arrière-plan est spécifiée dans la structure DXVA2_VideoProcessBltParams .

Exemple 2 : Étirer des images de sous-flux

Les images de sous-flux peuvent s’étendre au-delà de l’image vidéo principale. Dans la vidéo DVD, par exemple, le flux vidéo principal peut avoir un rapport d’aspect de 4:3 alors que le sous-flux est de 16:9. Dans cet exemple, les deux flux vidéo ont les mêmes dimensions sources (720 × 480), mais le sous-flux est destiné à être affiché à un rapport d’aspect de 16:9. Pour atteindre ce rapport d’aspect, l’image de sous-flux est étirée horizontalement. Les rectangles source et de destination sont affichés dans le diagramme suivant.

diagram showing substream image stretching.

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 854, 480 }

  • Vidéo principale :

    • Rectangle source : { 0, 0, 720, 480 }
    • Rectangle de destination : { 0, 107, 474, 480 }
  • Sous-flux:

    • Rectangle source : { 0, 0, 720, 480 }
    • Rectangle de destination : { 0, 0, 854, 480 }

Ces valeurs conservent la hauteur de l’image et mettez à l’échelle les deux images horizontalement. Dans les régions où les deux images apparaissent, elles sont mélangées alpha. Où l’image de sous-flux s’exécute au-delà de la vidéo primay, le sous-flux est fusionné avec la couleur d’arrière-plan. Ce mélange alpha tient compte des couleurs modifiées dans le côté droit du diagramme.

Exemple 3 : Hauteurs de flux incompatibles

Dans l’exemple précédent, le sous-flux et le flux principal sont de la même hauteur. Flux peut également avoir des hauteurs incompatibles, comme illustré dans cet exemple. Zones dans le rectangle cible où aucune vidéo n’apparaît est dessinée à l’aide de la couleur d’arrière-plan ( noir dans cet exemple). Les rectangles source et de destination sont affichés dans le diagramme suivant.

diagram showing mismatched stream heights,

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 150, 85 }
  • Vidéo principale :
    • Rectangle source : { 0, 0, 150, 50 }
    • Rectangle de destination : { 0, 17, 150, 67 }
  • Sous-flux:
    • Rectangle source : { 0, 0, 100, 85 }
    • Rectangle de destination : { 25, 0, 125, 85 }

Exemple 4 : Rectangle cible plus petit que la surface de destination

Cet exemple montre un cas où le rectangle cible est plus petit que la surface de destination.

diagram showing a blit to a destination rectangle.

Le diagramme précédent montre les rectangles suivants :

  • Surface de destination : { 0, 0, 300, 200 }
  • Rectangle cible : { 0, 0, 150, 85 }
  • Vidéo principale :
    • Rectangle source : { 0, 0, 150, 50 }
    • Rectangle de destination : { 0, 17, 150, 67 }
  • Sous-flux:
    • Rectangle source : { 0, 0, 100, 85 }
    • Rectangle de destination : { 25, 0, 125, 85 }

Les pixels en dehors du rectangle cible ne sont pas modifiés. Par conséquent, la couleur d’arrière-plan apparaît uniquement dans le rectangle cible. La zone en pointillé indique des parties de la surface de destination qui ne sont pas affectées par le blit.

Exemple 5 : Rectangles sources

Si vous spécifiez un rectangle source plus petit que l’image source, le pilote blit uniquement cette partie de l’image. Dans cet exemple, les rectangles sources spécifient le quadrant inférieur droit du flux vidéo principal et le quadrant inférieur gauche du sous-flux (indiqué par des marques de hachage dans le diagramme). Les rectangles de destination sont de la même taille que les rectangles sources, de sorte que la vidéo n’est pas étirée. Les rectangles source et de destination sont affichés dans le diagramme suivant.

diagram showing a blit from two source rectangles.

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 720, 576 }
  • Vidéo principale :
    • Taille de la surface source : { 0, 0, 720, 480 }
    • Rectangle source : { 360, 240, 720, 480 }
    • Rectangle de destination : { 0, 0, 360, 240 }
  • Sous-flux:
    • Taille de la surface source : { 0, 0, 640, 576 }
    • Rectangle source : { 0, 288, 320, 576 }
    • Rectangle de destination : { 400, 0, 720, 288 }

Exemple 6 : Intersection des rectangles de destination

Cet exemple est similaire à celui précédent, mais les rectangles de destination se croisent. Les dimensions de surface sont identiques à celles de l’exemple précédent, mais les rectangles source et de destination ne le sont pas. Là encore, la vidéo est rognée, mais pas étirée. Les rectangles source et de destination sont affichés dans le diagramme suivant.

diagram showing intersecting destination rectangles.

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 720, 576 }
  • Vidéo principale :
    • Taille de la surface source : { 0, 0, 720, 480 }
    • Rectangle source : { 260, 92, 720, 480 }
    • Rectangle de destination : { 0, 0, 460, 388 }
  • Sous-flux:
    • Taille de la surface source : { 0, 0, 640, 576 }
    • Rectangle source : { 0, 0, 460, 388 }
    • Rectangle de destination : { 260, 188, 720, 576 }

Exemple 7 : Étirement et rognage vidéo

Dans cet exemple, la vidéo est étirée et rognée. Une région de 180 × 120 de chaque flux est étirée pour couvrir une zone de 360 × 240 dans le rectangle de destination.

diagram showing stretching and cropping.

Le diagramme précédent montre les rectangles suivants :

  • Rectangle cible : { 0, 0, 720, 480 }
  • Vidéo principale :
    • Taille de la surface source : { 0, 0, 360, 240 }
    • Rectangle source : { 180, 120, 360, 240 }
    • Rectangle de destination : { 0, 0, 360, 240 }
  • Sous-flux:
    • Taille de la surface source : { 0, 0, 360, 240 }
    • Rectangle source : { 0, 0, 180, 120 }
    • Rectangle de destination : { 360, 240, 720, 480 }

Exemple d’ordre d’entrée

Le paramètre pSamples de la méthode VideoProcessBlt est un pointeur vers un tableau d’exemples d’entrée. Les exemples du flux vidéo principal s’affichent en premier, suivis des images de sous-flux dans l’ordre Z. Les exemples doivent être placés dans le tableau dans l’ordre suivant :

  • Les exemples du flux vidéo principal apparaissent en premier dans le tableau, dans l’ordre temporel. Selon le mode de déinterlacé, le pilote peut nécessiter un ou plusieurs exemples de référence à partir du flux vidéo principal. Les membres NumForwardRefSamples et NumBackwardRefSamples de la structure DXVA2_VideoProcessorCaps spécifient le nombre d’exemples de référence vers l’avant et vers l’arrière nécessaires. L’appelant doit fournir ces exemples de référence même si le contenu vidéo est progressif et ne nécessite pas de déinterlacation. (Cela peut se produire lorsque des images progressives sont données à un appareil de déinterlacation, par exemple lorsque la source contient un mélange d’images entrelacées et progressives.)
  • Après les exemples du flux vidéo principal, le tableau peut contenir jusqu’à 15 échantillons de sous-flux, organisés dans l’ordre Z, de bas en haut. Les sous-flux sont toujours progressifs et ne nécessitent pas d’images de référence.

À tout moment, le flux vidéo principal peut basculer entre le contenu entrelacé et progressif, et le nombre de sous-flux peut changer.

Le membre SampleFormat.SampleFormat de la structure DXVA2_VideoSample indique le type d’image. Pour les images de sous-flux, définissez cette valeur sur DXVA2_SampleSubStream. Pour les images progressives, la valeur est DXVA2_SampleProgressiveFrame. Pour les images entrelacées, la valeur dépend de la disposition du champ.

Si le pilote a besoin d’échantillons de référence avant et arrière, le nombre total d’échantillons peut ne pas être disponible au début de la séquence vidéo. Dans ce cas, incluez des entrées pour celles-ci dans le tableau pSamples , mais marquez les exemples manquants comme ayant le type DXVA2_SampleUnknown.

Les membres début et fin de la structure DXVA2_VideoSample donnent l’emplacement temporel de chaque échantillon. Ces valeurs sont utilisées uniquement pour les échantillons du flux vidéo principal. Pour les images de sous-flux, définissez les deux membres sur zéro.

Les exemples suivants peuvent aider à clarifier ces exigences.

Exemple 1

Le cas le plus simple se produit lorsqu’il n’existe aucun sous-flux et que l’algorithme de déinterlacation ne nécessite pas d’exemples de référence (NumForwardRefSamples et NumBackwardRefSamples sont tous les deux zéro). Bob deinterlacing est un exemple de tel algorithme. Dans ce cas, le tableau pSamples doit contenir une surface d’entrée unique, comme indiqué dans le tableau suivant.

Index Type surface Emplacement temporel
pSamples[0] Image entrelacée. T

 

La valeur de temps T est supposée être l’heure de début de la trame vidéo actuelle.

Exemple 2

Dans cet exemple, l’application combine deux sous-flux avec le flux principal. L’algorithme de déinterlacation ne nécessite pas d’exemples de référence. Le tableau suivant montre comment ces exemples sont organisés dans le tableau pSamples .

Index Type surface Emplacement temporel Ordre de plan
pSamples[0] Image entrelacée T 0
pSamples[1] Sous-flux 0 1
pSamples[2] Sous-flux 0 2

 

Exemple 3

Supposons maintenant que l’algorithme de déinterlacation nécessite un exemple de référence descendante et un exemple de référence vers l’avant. En outre, deux images de sous-flux sont fournies, pour un total de cinq surfaces. L’ordre correct est indiqué dans le tableau suivant.

Index Type surface Emplacement temporel Ordre de plan
pSamples[0] Image entrelacée (référence) T −1 Non applicable
pSamples[1] Image entrelacée T 0
pSamples[2] Image interlacée (référence) T +1 Non applicable
pSamples[3] Sous-flux 0 1
pSamples[4] Sous-flux 0 2

 

L’heure T −1 est l’heure de début de l’image avant l’image actuelle, et T +1 est l’heure de début de l’image suivante.

Si le flux vidéo bascule vers du contenu progressif, à l’aide du même mode de déinterlacation, l’application doit fournir le même nombre d’exemples, comme illustré dans le tableau suivant.

Index Type surface Emplacement temporel Ordre de plan
pSamples[0] Image progressive (référence) T −1 Non applicable
pSamples[1] Image progressive T 0
pSamples[2] Image progressive (référence) T +1 Non applicable
pSamples[3] Sous-flux 0 1
pSamples[4] Sous-flux 0 2

 

Exemple 4

Au début d’une séquence vidéo, les exemples de référence vers l’avant et vers l’arrière peuvent ne pas être disponibles. Lorsque cela se produit, les entrées pour les exemples manquants sont incluses dans le tableau pSamples , avec le type d’exemple DXVA2_SampleUnknown.

En supposant que le mode de déinterlacation a besoin d’un exemple de référence vers l’avant et d’un exemple de référence descendant, les trois premiers appels à VideoProcessBlt auraient les séquences d’entrées affichées dans les trois tableaux suivants.

Index Type surface Emplacement temporel
pSamples[0] Unknown 0
pSamples[1] Unknown 0
pSamples[2] Image interlacée (référence) T +1

 

Index Type surface Emplacement temporel
pSamples[0] Unknown 0
pSamples[1] Image entrelacée T
pSamples[2] Image interlacée (référence) T +1

 

Index Type surface Emplacement temporel
pSamples[0] Image entrelacée T −1
pSamples[1] Image entrelacée T
pSamples[2] Image interlacée (référence) T +1

 

Accélération vidéo DirectX 2.0

exemple DXVA2_VideoProc