文章目录
- 概述
- 关系
- 参考
- 接口介绍
- 显示方式
- 纹理方式
- 使用shader的纹理方式
- 不使用shader的纹理方式
- 表面(Surface)方式
- 纹理方式
- 显示方式
概述
备注：本文主要针对DirectX 9.0版本来讨论的。
在开始这篇文章之前，我们先阐述一下一些名词：DX、DDraw、DirectShow、D3D、DirectX、DirectDraw等。
关系
首先我们理一理他们之间的关系，这些关键词统称DirectX，简称DX，它有一下成员：
- DirectX Graphics： 集成了以前的
DirectDraw(简称DDraw) 和Direct3D(简称D3D)技术。DirectDraw主要负责2D加速，以实现对显卡内存和系统内存的直接操作；Direct3D主要提供三维绘图硬件接口，它是开发三维DirectX游戏的基础。
- DirectInput： 主要支持输入服务（包括鼠标、键盘、游戏杆等），同时支持输出设备。
- DirectPlay： 主要提供多人网络游戏的通信、组织功能。
- DirectSetup： 主要提供自动安装
DirectX组件的API功能。 - DirectMusic： 主要支持MIDI音乐合成和播放功能。
- DirectSound： 主要提供音频捕捉、回放、音效处理、硬件加速、直接设备访问等功能。
- DirectShow： 为Windows平台上处理各种格式的媒体文件的回放、音视频采集等高性能要求的多媒体应用，提供了完整的解决方案。
- DirectX Media Objects：
DirectShow Filter的简化模型，提供更方便的流数据处理方案。
参考
链接DirectX和DirectShow介绍和区别
链接DirectShow和DirectX有什么区别
接口介绍
显示方式
D3D显示YUV方式有两种：纹理(Texture)方式和表面(Surface)方式。而Texture方式又可以包含使用Shader及不使用Shader方式。
纹理方式
使用shader的纹理方式
这部分代码参考的前辈的项目，现在把连接发出来：D3D三层Texture纹理经像素着色器实现渲染YUV420P 第二版
直接上代码：头文件d3dUtility.h
//
//
// File: d3dUtility.h
//
// Author: Frank Luna (C) All Rights Reserved
//
// System: AMD Athlon 1800+ XP, 512 DDR, Geforce 3, Windows XP, MSVC++ 7.0
//
// Desc: Provides utility functions for simplifying common tasks.
//
//
#ifndef __d3dUtilityH__
#define __d3dUtilityH__
#include cpp文件：d3dUtility.cpp
//
//
// File: d3dUtility.cpp
//
// Author: Frank Luna (C) All Rights Reserved
//
// System: AMD Athlon 1800+ XP, 512 DDR, Geforce 3, Windows XP, MSVC++ 7.0
//
// Desc: Provides utility functions for simplifying common tasks.
//
//
#include "d3dUtility.h"
// vertex formats
const DWORD d3d::Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;
bool d3d::InitD3D(
HINSTANCE hInstance,
int width, int height,
bool windowed,
D3DDEVTYPE deviceType,
IDirect3DDevice9** device)
{
//
// Create the main application window.
//
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)d3d::WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(0, IDI_APPLICATION);
wc.hCursor = LoadCursor(0, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
wc.lpszMenuName = 0;
wc.lpszClassName = "Direct3D9App";
if( !RegisterClass(&wc) )
{
::MessageBox(0, "RegisterClass() - FAILED", 0, 0);
return false;
}
HWND hwnd = 0;
hwnd = ::CreateWindow("Direct3D9App", "Direct3D9App",
WS_EX_TOPMOST,
0, 0, 1024, 768,
0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/);
if( !hwnd )
{
::MessageBox(0, "CreateWindow() - FAILED", 0, 0);
return false;
}
::ShowWindow(hwnd, SW_SHOW);
::UpdateWindow(hwnd);
//
// Init D3D:
//
HRESULT hr = 0;
// Step 1: Create the IDirect3D9 object.
IDirect3D9* d3d9 = 0;
d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
if( !d3d9 )
{
::MessageBox(0, "Direct3DCreate9() - FAILED", 0, 0);
return false;
}
// Step 2: Check for hardware vp.
D3DCAPS9 caps;
d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);
int vp = 0;
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
else
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
// Step 3: Fill out the D3DPRESENT_PARAMETERS structure.
D3DDISPLAYMODE d3ddm;
UINT adapter = D3DADAPTER_DEFAULT;
IDirect3D9_GetAdapterDisplayMode(d3d9, adapter, &d3ddm);
// 默认不使用多采样
D3DMULTISAMPLE_TYPE multiType = D3DMULTISAMPLE_NONE;
if(d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, D3DFMT_A8R8G8B8, !windowed,
D3DMULTISAMPLE_4_SAMPLES,
NULL) == D3D_OK)
{
// 保存多采样类型
multiType = D3DMULTISAMPLE_4_SAMPLES;
}
D3DPRESENT_PARAMETERS d3dpp;
d3dpp.BackBufferWidth = width;
d3dpp.BackBufferHeight = height;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = multiType;
d3dpp.MultiSampleQuality = 0;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hwnd;
d3dpp.Windowed = windowed;
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.Flags = 0;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
// Step 4: Create the device.
hr = d3d9->CreateDevice(
D3DADAPTER_DEFAULT, // primary adapter
deviceType, // device type
hwnd, // window associated with device
vp, // vertex processing
&d3dpp, // present parameters
device); // return created device
if( FAILED(hr) )
{
// try again using a 16-bit depth buffer
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
hr = d3d9->CreateDevice(
D3DADAPTER_DEFAULT,
deviceType,
hwnd,
vp,
&d3dpp,
device);
if( FAILED(hr) )
{
d3d9->Release(); // done with d3d9 object
::MessageBox(0, "CreateDevice() - FAILED", 0, 0);
return false;
}
}
d3d9->Release(); // done with d3d9 object
return true;
}
int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )
{
MSG msg;
::ZeroMemory(&msg, sizeof(MSG));
//static float lastTime = (float)timeGetTime();
DWORD lastTime = GetTickCount();
while(msg.message != WM_QUIT)
{
if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
else
{
//float currTime = (float)timeGetTime();
DWORD currTime = GetTickCount();
float timeDelta = (currTime - lastTime)*0.001f;
ptr_display(timeDelta);
lastTime = currTime;
}
}
return msg.wParam;
}
D3DLIGHT9 d3d::InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color)
{
D3DLIGHT9 light;
::ZeroMemory(&light, sizeof(light));
light.Type = D3DLIGHT_DIRECTIONAL;
light.Ambient = *color * 0.4f;
light.Diffuse = *color;
light.Specular = *color * 0.6f;
light.Direction = *direction;
return light;
}
D3DLIGHT9 d3d::InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color)
{
D3DLIGHT9 light;
::ZeroMemory(&light, sizeof(light));
light.Type = D3DLIGHT_POINT;
light.Ambient = *color * 0.4f;
light.Diffuse = *color;
light.Specular = *color * 0.6f;
light.Position = *position;
light.Range = 1000.0f;
light.Falloff = 1.0f;
light.Attenuation0 = 1.0f;
light.Attenuation1 = 0.0f;
light.Attenuation2 = 0.0f;
return light;
}
D3DLIGHT9 d3d::InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color)
{
D3DLIGHT9 light;
::ZeroMemory(&light, sizeof(light));
light.Type = D3DLIGHT_SPOT;
light.Ambient = *color * 0.4f;
light.Diffuse = *color;
light.Specular = *color * 0.6f;
light.Position = *position;
light.Direction = *direction;
light.Range = 1000.0f;
light.Falloff = 1.0f;
light.Attenuation0 = 1.0f;
light.Attenuation1 = 0.0f;
light.Attenuation2 = 0.0f;
light.Theta = 0.5f;
light.Phi = 0.7f;
return light;
}
D3DMATERIAL9 d3d::InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p)
{
D3DMATERIAL9 mtrl;
mtrl.Ambient = a;
mtrl.Diffuse = d;
mtrl.Specular = s;
mtrl.Emissive = e;
mtrl.Power = p;
return mtrl;
}
d3d::BoundingBox::BoundingBox()
{
// infinite small
_min.x = d3d::INFINITY0;
_min.y = d3d::INFINITY0;
_min.z = d3d::INFINITY0;
_max.x = -d3d::INFINITY0;
_max.y = -d3d::INFINITY0;
_max.z = -d3d::INFINITY0;
}
bool d3d::BoundingBox::isPointInside(D3DXVECTOR3& p)
{
if( p.x >= _min.x && p.y >= _min.y && p.z >= _min.z &&
p.x <= _max.x && p.y <= _max.y && p.z <= _max.z )
{
return true;
}
else
{
return false;
}
}
d3d::BoundingSphere::BoundingSphere()
{
_radius = 0.0f;
}
bool d3d::DrawBasicScene(IDirect3DDevice9* device, float scale)
{
static IDirect3DVertexBuffer9* floor = 0;
static IDirect3DTexture9* tex = 0;
static ID3DXMesh* pillar = 0;
HRESULT hr = 0;
if( device == 0 )
{
if( floor && tex && pillar )
{
// they already exist, destroy them
d3d::Release<IDirect3DVertexBuffer9*>(floor);
d3d::Release<IDirect3DTexture9*>(tex);
d3d::Release<ID3DXMesh*>(pillar);
}
}
else if( !floor && !tex && !pillar )
{
// they don't exist, create them
device->CreateVertexBuffer(
6 * sizeof(d3d::Vertex),
0,
d3d::Vertex::FVF,
D3DPOOL_MANAGED,
&floor,
0);
Vertex* v = 0;
floor->Lock(0, 0, (void**)&v, 0);
v[0] = Vertex(-20.0f, -2.5f, -20.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
v[1] = Vertex(-20.0f, -2.5f, 20.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
v[2] = Vertex( 20.0f, -2.5f, 20.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
v[3] = Vertex(-20.0f, -2.5f, -20.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
v[4] = Vertex( 20.0f, -2.5f, 20.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
v[5] = Vertex( 20.0f, -2.5f, -20.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f);
floor->Unlock();
D3DXCreateCylinder(device, 0.5f, 0.5f, 5.0f, 20, 20, &pillar, 0);
D3DXCreateTextureFromFile(
device,
"desert.bmp",
&tex);
}
else
{
//
// Pre-Render Setup
//
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
D3DXVECTOR3 dir(0.707f, -0.707f, 0.707f);
D3DXCOLOR col(1.0f, 1.0f, 1.0f, 1.0f);
D3DLIGHT9 light = d3d::InitDirectionalLight(&dir, &col);
device->SetLight(0, &light);
device->LightEnable(0, true);
device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
device->SetRenderState(D3DRS_SPECULARENABLE, true);
//
// Render
//
D3DXMATRIX T, R, P, S;
D3DXMatrixScaling(&S, scale, scale, scale);
// used to rotate cylinders to be parallel with world's y-axis
D3DXMatrixRotationX(&R, -D3DX_PI * 0.5f);
// draw floor
D3DXMatrixIdentity(&T);
T = T * S;
device->SetTransform(D3DTS_WORLD, &T);
device->SetMaterial(&d3d::WHITE_MTRL);
device->SetTexture(0, tex);
device->SetStreamSource(0, floor, 0, sizeof(Vertex));
device->SetFVF(Vertex::FVF);
device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
// draw pillars
device->SetMaterial(&d3d::BLUE_MTRL);
device->SetTexture(0, 0);
for(int i = 0; i < 5; i++)
{
D3DXMatrixTranslation(&T, -5.0f, 0.0f, -15.0f + (i * 7.5f));
P = R * T * S;
device->SetTransform(D3DTS_WORLD, &P);
pillar->DrawSubset(0);
D3DXMatrixTranslation(&T, 5.0f, 0.0f, -15.0f + (i * 7.5f));
P = R * T * S;
device->SetTransform(D3DTS_WORLD, &P);
pillar->DrawSubset(0);
}
}
return true;
}
float d3d::GetRandomFloat(float lowBound, float highBound)
{
if( lowBound >= highBound ) // bad input
return lowBound;
// get random float in [0, 1] interval
float f = (rand() % 10000) * 0.0001f;
// return float in [lowBound, highBound] interval.
return (f * (highBound - lowBound)) + lowBound;
}
void d3d::GetRandomVector(
D3DXVECTOR3* out,
D3DXVECTOR3* min,
D3DXVECTOR3* max)
{
out->x = GetRandomFloat(min->x, max->x);
out->y = GetRandomFloat(min->y, max->y);
out->z = GetRandomFloat(min->z, max->z);
}
DWORD d3d::FtoDw(float f)
{
return *((DWORD*)&f);
}
调用：
//
//
// File: ps_multitex.cpp
//
// Author: Frank Luna (C) All Rights Reserved
//
// System: AMD Athlon 1800+ XP, 512 DDR, Geforce 3, Windows XP, MSVC++ 7.0
//
// Desc: Deomstrates multi-texturing using a pixel shader. You will have
// to switch to the REF device to run this sample if your hardware
// doesn't support pixel shaders.
//
//
#include "d3dUtility.h"
//
// Globals
//
IDirect3DDevice9* Device = 0;
const int Width = 320;
const int Height = 180;
IDirect3DPixelShader9* MultiTexPS = 0;
ID3DXConstantTable* MultiTexCT = 0;
IDirect3DVertexBuffer9* QuadVB = 0;
IDirect3DTexture9* YTex = 0;
IDirect3DTexture9* UTex = 0;
IDirect3DTexture9* VTex = 0;
D3DXHANDLE YTexHandle = 0;
D3DXHANDLE UTexHandle = 0;
D3DXHANDLE VTexHandle = 0;
D3DXCONSTANT_DESC YTexDesc;
D3DXCONSTANT_DESC UTexDesc;
D3DXCONSTANT_DESC VTexDesc;
//YUV file
FILE *infile = NULL;
unsigned char buf[Width*Height*3/2];
unsigned char *plane[3];
//
// Structs
//
struct MultiTexVertex
{
MultiTexVertex(float x, float y, float z,
float u0, float v0,
float u1, float v1,
float u2, float v2)
{
_x = x; _y = y; _z = z;
_u0 = u0; _v0 = v0;
_u1 = u1; _v1 = v1;
_u2 = u2, _v2 = v2;
}
float _x, _y, _z;
float _u0, _v0;
float _u1, _v1;
float _u2, _v2;
static const DWORD FVF;
};
const DWORD MultiTexVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX3;
//
// Framework functions
//
bool Setup()
{
HRESULT hr = 0;
//
// Create geometry.
//
Device->CreateVertexBuffer(
6 * sizeof(MultiTexVertex),
D3DUSAGE_WRITEONLY,
MultiTexVertex::FVF,
D3DPOOL_MANAGED,
&QuadVB,
0);
MultiTexVertex* v = 0;
QuadVB->Lock(0, 0, (void**)&v, 0);
v[0] = MultiTexVertex(-10.0f, -10.0f, 5.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
v[1] = MultiTexVertex(-10.0f, 10.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
v[2] = MultiTexVertex( 10.0f, 10.0f, 5.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
v[3] = MultiTexVertex(-10.0f, -10.0f, 5.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
v[4] = MultiTexVertex( 10.0f, 10.0f, 5.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
v[5] = MultiTexVertex( 10.0f, -10.0f, 5.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
QuadVB->Unlock();
//
// Compile shader
//
ID3DXBuffer* shader = 0;
ID3DXBuffer* errorBuffer = 0;
hr = D3DXCompileShaderFromFile(
"ps_multitex.txt",
0,
0,
"Main", // entry point function name
"ps_2_0",
D3DXSHADER_DEBUG | D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY,
&shader,
&errorBuffer,
&MultiTexCT);
// output any error messages
if( errorBuffer )
{
::MessageBox(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
d3d::Release<ID3DXBuffer*>(errorBuffer);
}
if(FAILED(hr))
{
::MessageBox(0, "D3DXCompileShaderFromFile() - FAILED", 0, 0);
return false;
}
//
// Create Pixel Shader
//
hr = Device->CreatePixelShader(
(DWORD*)shader->GetBufferPointer(),
&MultiTexPS);
if(FAILED(hr))
{
::MessageBox(0, "CreateVertexShader - FAILED", 0, 0);
return false;
}
d3d::Release<ID3DXBuffer*>(shader);
//
// Create textures.
//
Device->CreateTexture ( Width, Height, 1, D3DUSAGE_DYNAMIC, D3DFMT_L8, D3DPOOL_DEFAULT, &YTex, NULL ) ;
Device->CreateTexture ( Width / 2, Height / 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_L8, D3DPOOL_DEFAULT, &UTex, NULL ) ;
Device->CreateTexture ( Width / 2, Height / 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_L8, D3DPOOL_DEFAULT, &VTex, NULL ) ;
if((infile=fopen("test_yuv420p_320x180.yuv", "rb"))==NULL){
printf("cannot open this file\n");
return false;
}
//
// Set Projection Matrix
//
D3DXMATRIX P;
D3DXMatrixPerspectiveFovLH(
&P, D3DX_PI * 0.25f,
(float)Width / (float)Height, 1.0f, 1000.0f);
Device->SetTransform(D3DTS_PROJECTION, &P);
//
// Disable lighting.
//
Device->SetRenderState(D3DRS_LIGHTING, false);
//
// Get Handles
//
YTexHandle = MultiTexCT->GetConstantByName(0, "YTex");
UTexHandle = MultiTexCT->GetConstantByName(0, "UTex");
VTexHandle = MultiTexCT->GetConstantByName(0, "VTex");
//
// Set constant descriptions:
//
UINT count;
MultiTexCT->GetConstantDesc(YTexHandle, &YTexDesc, &count);
MultiTexCT->GetConstantDesc(UTexHandle, &UTexDesc, &count);
MultiTexCT->GetConstantDesc(VTexHandle, &VTexDesc, &count);
MultiTexCT->SetDefaults(Device);
return true;
}
void Cleanup()
{
d3d::Release<IDirect3DVertexBuffer9*>(QuadVB);
d3d::Release<IDirect3DTexture9*>(YTex);
d3d::Release<IDirect3DTexture9*>(UTex);
d3d::Release<IDirect3DTexture9*>(VTex);
d3d::Release<IDirect3DPixelShader9*>(MultiTexPS);
d3d::Release<ID3DXConstantTable*>(MultiTexCT);
}
bool Display(float timeDelta)
{
if (fread(buf, 1, Width*Height*3/2, infile) != Width*Height*3/2){
// Loop
fseek(infile, 0, SEEK_SET);
fread(buf, 1, Width*Height*3/2, infile);
}
if( buf != NULL && Device )
{
//
// Update the scene: Allow user to rotate around scene.
//
static float angle = (3.0f * D3DX_PI) / 2.0f;
static float radius = 20.0f;
if( ::GetAsyncKeyState(VK_LEFT) & 0x8000f )
angle -= 0.5f * timeDelta;
if( ::GetAsyncKeyState(VK_RIGHT) & 0x8000f )
angle += 0.5f * timeDelta;
if( ::GetAsyncKeyState(VK_UP) & 0x8000f )
radius -= 2.0f * timeDelta;
if( ::GetAsyncKeyState(VK_DOWN) & 0x8000f )
radius += 2.0f * timeDelta;
D3DXVECTOR3 position( cosf(angle) * radius, 0.0f, sinf(angle) * radius );
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX V;
D3DXMatrixLookAtLH(&V, &position, &target, &up);
Device->SetTransform(D3DTS_VIEW, &V);
//
// Render
//
Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
plane[0] = buf;
plane[1] = plane[0] + Width*Height;
plane[2] = plane[1] + Width*Height/4;
D3DLOCKED_RECT d3d_rect;
byte *pSrc = buf;
//Locks a rectangle on a texture resource.
//And then we can manipulate pixel data in it.
LRESULT lRet = YTex->LockRect(0, &d3d_rect, 0, 0);
if (FAILED(lRet)){
return false;
}
// Copy pixel data to texture
byte *pDest = (byte *)d3d_rect.pBits;
int stride = d3d_rect.Pitch;
for(int i = 0;i < Height;i ++){
memcpy(pDest + i * stride,plane[0] + i * Width, Width);
}
YTex->UnlockRect(0);
D3DLOCKED_RECT d3d_rect1;
lRet = UTex->LockRect(0, &d3d_rect1, 0, 0);
if (FAILED(lRet)){
return false;
}
// Copy pixel data to texture
byte *pDest1 = (byte *)d3d_rect1.pBits;
int stride1 = d3d_rect1.Pitch;
for(int i = 0;i < Height/2;i ++){
memcpy(pDest1 + i * stride1,plane[1] + i * Width / 2, Width / 2);
}
UTex->UnlockRect(0);
D3DLOCKED_RECT d3d_rect2;
lRet = VTex->LockRect(0, &d3d_rect2, 0, 0);
if (FAILED(lRet)){
return false;
}
// Copy pixel data to texture
byte *pDest2 = (byte *)d3d_rect2.pBits;
int stride2 = d3d_rect2.Pitch;
for(int i = 0;i < Height/2;i ++){
memcpy(pDest2 + i * stride2,plane[2] + i * Width / 2, Width / 2);
}
VTex->UnlockRect(0);
Device->BeginScene();
Device->SetPixelShader(MultiTexPS);
Device->SetFVF(MultiTexVertex::FVF);
Device->SetStreamSource(0, QuadVB, 0, sizeof(MultiTexVertex));
// Y tex
Device->SetTexture( YTexDesc.RegisterIndex, YTex);
Device->SetSamplerState(YTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(YTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(YTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(YTexDesc.RegisterIndex, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
Device->SetSamplerState(YTexDesc.RegisterIndex, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
// U tex
Device->SetTexture( UTexDesc.RegisterIndex, UTex);
Device->SetSamplerState(UTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(UTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(UTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(UTexDesc.RegisterIndex, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
Device->SetSamplerState(UTexDesc.RegisterIndex, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
// string tex
Device->SetTexture( VTexDesc.RegisterIndex, VTex);
Device->SetSamplerState(VTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(VTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(VTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(VTexDesc.RegisterIndex, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
Device->SetSamplerState(VTexDesc.RegisterIndex, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
Device->EndScene();
Device->Present(0, 0, 0, 0);
}
return true;
}
//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch( msg )
{
case WM_DESTROY:
::PostQuitMessage(0);
break;
case WM_KEYDOWN:
if( wParam == VK_ESCAPE )
::DestroyWindow(hwnd);
break;
}
return ::DefWindowProc(hwnd, msg, wParam, lParam);
}
//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
HINSTANCE prevInstance,
PSTR cmdLine,
int showCmd)
{
if(!d3d::InitD3D(hinstance,
Width, Height, true, D3DDEVTYPE_HAL, &Device))
{
::MessageBox(0, "InitD3D() - FAILED", 0, 0);
return 0;
}
if(!Setup())
{
::MessageBox(0, "Setup() - FAILED", 0, 0);
return 0;
}
d3d::EnterMsgLoop( Display );
Cleanup();
Device->Release();
return 0;
}
这里我提示一下：在运行项目时，D3DXCompileShaderFromFile会返回失败，甚至会崩溃报错，这里大家注意一下它的第一个参数ps_multitex.txt的目录，你可以先把它写成绝对目录试试。
这里还有一个问题是：显示没有拉伸，我没找到拉伸的方式。
不使用shader的纹理方式
这里代码参考雷神的代码：
最简单的视音频播放示例4：Direct3D播放RGB（通过Texture）
/**
* 最简单的Direct3D播放视频的例子(Direct3D播放RGB)[Texture]
* Simplest Video Play Direct3D (Direct3D play RGB)[Texture]
*
* 雷霄骅 Lei Xiaohua
* [email protected]
* 中国传媒大学/数字电视技术
* Communication University of China / Digital TV Technology
* http://blog.csdn.net/leixiaohua1020
*
* 本程序使用Direct3D播放RGB/YUV视频像素数据。使用D3D中的Texture渲染数据。
* 相对于使用Surface渲染视频数据来说，使用Texture渲染视频数据功能更加灵活，
* 但是学习起来也会相对复杂一些。
*
* 函数调用步骤如下：
*
* [初始化]
* Direct3DCreate9()：获得IDirect3D9
* IDirect3D9->CreateDevice()：通过IDirect3D9创建Device（设备）
* IDirect3DDevice9->CreateTexture()：通过Device创建一个Texture（纹理）。
* IDirect3DDevice9->CreateVertexBuffer()：通过Device创建一个VertexBuffer（顶点缓存）。
* IDirect3DVertexBuffer9->Lock()：锁定顶点缓存。
* memcpy()：填充顶点缓存。
* IDirect3DVertexBuffer9->Unlock()：解锁顶点缓存。
*
* [循环渲染数据]
* IDirect3DTexture9->LockRect()：锁定纹理。
* memcpy()：填充纹理数据
* IDirect3DTexture9->UnLockRect()：解锁纹理。
* IDirect3DDevice9->BeginScene()：开始绘制。
* IDirect3DDevice9->SetTexture()：设置当前要渲染的纹理。
* IDirect3DDevice9->SetStreamSource()：绑定VertexBuffer。
* IDirect3DDevice9->SetFVF()：设置Vertex格式。
* IDirect3DDevice9->DrawPrimitive()：渲染。
* IDirect3DDevice9->EndScene()：结束绘制。
* IDirect3DDevice9->Present()：显示出来。
*
* This software plays RGB/YUV raw video data using Direct3D.
* It uses Texture in D3D to render the pixel data.
* Compared to another method (use Surface), it's more flexible
* but a little difficult.
*
* The process is shown as follows:
*
* [Init]
* Direct3DCreate9()：Get IDirect3D9.
* IDirect3D9->CreateDevice()：Create a Device.
* IDirect3DDevice9->CreateTexture()：Create a Texture.
* IDirect3DDevice9->CreateVertexBuffer()：Create a VertexBuffer.
* IDirect3DVertexBuffer9->Lock()：Lock VertexBuffer.
* memcpy()：Fill VertexBuffer.
* IDirect3DVertexBuffer9->Unlock()：UnLock VertexBuffer.
*
* [Loop to Render data]
* IDirect3DTexture9->LockRect()：Lock Texture.
* memcpy()：Fill pixel data...
* IDirect3DTexture9->UnLockRect()：UnLock Texture.
* IDirect3DDevice9->BeginScene()：Begin to draw.
* IDirect3DDevice9->SetTexture()：Set current Texture.
* IDirect3DDevice9->SetStreamSource()：Bind VertexBuffer.
* IDirect3DDevice9->SetFVF()：Set Vertex Format.
* IDirect3DDevice9->DrawPrimitive()：Render.
* IDirect3DDevice9->EndScene()：End drawing.
* IDirect3DDevice9->Present()：Show on the screen.
*/
#include 表面(Surface)方式
首先我们看看网上的方式：参考链接使用D3D渲染YUV_RGB
这里就不贴代码了，这里主要有一个问题就是，在播放窗口变大后，图片拉伸是模糊的，没有按照分辨率去拉伸，我下面贴出我的代码：头文件d3dDispaly.h
#pragma once
#include cpp文件：d3dDispaly.cpp
//#include "stdafx.h"
#include "d3dDispaly.h"
d3dDispaly::d3dDispaly() :
m_nImgWidth(0), m_nImgHeight(0), m_pD3D(NULL),
m_pd3dDevice(NULL), m_pd3dSurface(NULL), m_hwnd(NULL),
m_pBackBuffer(NULL)
{
}
d3dDispaly::~d3dDispaly()
{
}
bool d3dDispaly::init(HWND hwnd)
{
m_hwnd = hwnd;
m_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
if (m_pD3D == NULL)
{
OutputDebugStringA("D3D****************Direct3DCreate9 Fail*******\n");
return false;
}
D3DDISPLAYMODE d3dDisplayMode;
m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3dDisplayMode);
D3DCAPS9 d3dcaps;
m_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dcaps);
int hal_vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
if (d3dcaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
hal_vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3dDisplayMode.Format;//D3DFMT_UNKNOWN;
d3dpp.BackBufferWidth = d3dDisplayMode.Width;
d3dpp.BackBufferHeight = d3dDisplayMode.Height;
d3dpp.Flags = D3DPRESENTFLAG_VIDEO;
d3dpp.hDeviceWindow = m_hwnd;
HRESULT result = m_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hwnd, hal_vp, &d3dpp, &m_pd3dDevice);
if (FAILED(result))
{
D3DERR_OUTOFVIDEOMEMORY;
char buf[100] = {
0 };
sprintf_s(buf, 100, "D3D****************CreateDevice-1 Fail[%d]*******\n", result);
OutputDebugStringA(buf);
if (FAILED(m_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, m_hwnd, hal_vp, &d3dpp, &m_pd3dDevice)))
{
OutputDebugStringA("D3D****************CreateDevice-2 Fail*******\n");
return false;
}
}
m_rtViewport.left = 0;
m_rtViewport.right = d3dDisplayMode.Width;
m_rtViewport.top = 0;
m_rtViewport.bottom = d3dDisplayMode.Height;
return 0;
}
void d3dDispaly::uninit()
{
if (m_pD3D != NULL)
{
m_pD3D->Release();
m_pD3D = NULL;
}
if (m_pd3dDevice != NULL)
{
m_pd3dDevice->Release();
m_pd3dDevice = NULL;
}
if (m_pd3dSurface != NULL)
{
m_pd3dSurface->Release();
m_pd3dSurface = NULL;
}
if (m_pBackBuffer != NULL)
{
m_pBackBuffer->Release();
m_pBackBuffer = NULL;
}
m_nImgWidth = 0;
m_nImgHeight = 0;
}
bool d3dDispaly::inputYUVData(LPBYTE pBuffer, long nwidth, long nheight)
{
if (NULL == m_pd3dDevice)
{
return false;
}
if (m_nImgWidth != nwidth || m_nImgHeight != nheight)
{
if (!__setVideoSize(nwidth, nheight))
return false;
}
if (m_pd3dSurface == NULL) return false;
D3DLOCKED_RECT d3d_rect;
if (FAILED(m_pd3dSurface->LockRect(&d3d_rect, NULL, D3DLOCK_DONOTWAIT)))
{
//OutputDebugStringA("D3D****************LockRect Fail*******\n");
return false;
}
const int w = m_nImgWidth, h = m_nImgHeight;
BYTE* const p = (BYTE *)d3d_rect.pBits;
const int stride = d3d_rect.Pitch;
int i = 0;
for (i = 0; i < h; i++)
memcpy(p + i * stride, pBuffer + i * w, w);
for (i = 0; i < h / 2; i++)
memcpy(p + stride * h + i * stride / 2, pBuffer + w * h + w * h / 4 + i * w / 2, w / 2);
for (i = 0; i < h / 2; i++)
memcpy(p + stride * h + stride * h / 4 + i * stride / 2, pBuffer + w * h + i * w / 2, w / 2);
if (FAILED(m_pd3dSurface->UnlockRect()))
{
//OutputDebugStringA("D3D****************UnlockRect Fail*******\n");
return false;
}
__drawImage();
return true;
}
bool d3dDispaly::__setVideoSize(long lWidth, long lHeight)
{
if (FAILED(m_pd3dDevice->CreateOffscreenPlainSurface(lWidth, lHeight, (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2'), D3DPOOL_DEFAULT, &m_pd3dSurface, NULL)))
{
OutputDebugStringA("D3D****************CreateOffscreenPlainSurface Fail*******\n");
return false;
}
m_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackBuffer);
if (!m_pBackBuffer)
{
OutputDebugStringA("D3D****************GetBackBuffer Fail*******\n");
return false;
}
m_nImgWidth = lWidth;
m_nImgHeight = lHeight;
return true;
}
void d3dDispaly::__drawImage()
{
if (m_pd3dDevice != NULL)
{
//m_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0);
if (SUCCEEDED(m_pd3dDevice->BeginScene()))
{
m_pd3dDevice->StretchRect(m_pd3dSurface/*NULL*/, NULL, m_pBackBuffer, &m_rtViewport, D3DTEXF_LINEAR);
m_pd3dDevice->EndScene();
}
m_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}
}
这里需要指出的是init函数中的代码，不能放在__setVideoSize函数中，因为D3D初始化较耗性能，如果在初始化的同时就压数据，很容易引起卡顿问题。