public int InitializeDevice(IntPtr dwUserID, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
int width = 1;
int height = 1;
float fTU = 1.0f;
float fTV = 1.0f;
if (vmrSurfaceAllocatorNotify == null)
{
return(E_FAIL);
}
int hr = 0;
try
{
IntPtr unmanagedDevice = OpenSebJ.eRender.device.GetObjectByValue(DxMagicNumber);
IntPtr hMonitor = OpenSebJ.eRender.getMonitor();
hr = vmrSurfaceAllocatorNotify.SetD3DDevice(unmanagedDevice, hMonitor);
DsError.ThrowExceptionForHR(hr);
if (OpenSebJ.eRender.device.DeviceCaps.TextureCaps.SupportsPower2)
{
while (width < lpAllocInfo.dwWidth)
{
width = width << 1;
}
while (height < lpAllocInfo.dwHeight)
{
height = height << 1;
}
fTU = (float)(lpAllocInfo.dwWidth) / (float)(width);
fTV = (float)(lpAllocInfo.dwHeight) / (float)(height);
//scene.SetSrcRect(fTU, fTV);
lpAllocInfo.dwWidth = width;
lpAllocInfo.dwHeight = height;
}
// NOTE:
// we need to make sure that we create textures because
// surfaces can not be textured onto a primitive.
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
DeleteSurfaces();
unmanagedSurfaces = new IntPtr[lpNumBuffers];
hr = vmrSurfaceAllocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, unmanagedSurfaces);
// If we couldn't create a texture surface and
// the format is not an alpha format,
// then we probably cannot create a texture.
// So what we need to do is create a private texture
// and copy the decoded images onto it.
if (hr < 0)
{
DeleteSurfaces();
FourCC fcc = new FourCC("0000");
// is surface YUV ?
if (lpAllocInfo.Format > fcc.ToInt32())
{
// create the private texture
privateTexture = new Texture(
OpenSebJ.eRender.device,
lpAllocInfo.dwWidth,
lpAllocInfo.dwHeight,
1,
Usage.RenderTarget,
OpenSebJ.eRender.adapterInfo.CurrentDisplayMode.Format,
Pool.Default
);
privateSurface = privateTexture.GetSurfaceLevel(0);
}
lpAllocInfo.dwFlags &= ~VMR9SurfaceAllocationFlags.TextureSurface;
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.OffscreenSurface;
unmanagedSurfaces = new IntPtr[lpNumBuffers];
hr = vmrSurfaceAllocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, unmanagedSurfaces);
if (hr < 0)
{
return(hr);
}
}
else
{
surfaces = new Hashtable(unmanagedSurfaces.Length);
textures = new Hashtable(unmanagedSurfaces.Length);
for (int i = 0; i < lpNumBuffers; i++)
{
Surface surf = new Surface(unmanagedSurfaces[i]);
Texture text = (Texture)surf.GetContainer(new Guid("85C31227-3DE5-4f00-9B3A-F11AC38C18B5"));
surfaces.Add(unmanagedSurfaces[i], surf);
textures.Add(unmanagedSurfaces[i], text);
}
}
//return scene.Init(device);
//System.Windows.Forms.MessageBox.Show(device.ToString());
//VideoRender.eRender.createDevice(device);
return(0);
}
catch (DirectXException e)
{
return(e.ErrorCode);
}
catch
{
return(E_FAIL);
}
}
public int InitializeDevice(IntPtr dwUserID, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
int width = 1;
int height = 1;
float fTU = 1.0f;
float fTV = 1.0f;
if (vmrSurfaceAllocatorNotify == null)
{
return E_FAIL;
}
int hr = 0;
try
{
IntPtr unmanagedDevice = device.GetObjectByValue(DxMagicNumber);
IntPtr hMonitor = Manager.GetAdapterMonitor(adapterInfo.Adapter);
hr = vmrSurfaceAllocatorNotify.SetD3DDevice(unmanagedDevice, hMonitor);
DsError.ThrowExceptionForHR(hr);
if (device.DeviceCaps.TextureCaps.SupportsPower2)
{
while (width < lpAllocInfo.dwWidth)
width = width << 1;
while (height < lpAllocInfo.dwHeight)
height = height << 1;
fTU = (float)(lpAllocInfo.dwWidth) / (float)(width);
fTV = (float)(lpAllocInfo.dwHeight) / (float)(height);
scene.SetSrcRect(fTU, fTV);
lpAllocInfo.dwWidth = width;
lpAllocInfo.dwHeight = height;
}
// NOTE:
// we need to make sure that we create textures because
// surfaces can not be textured onto a primitive.
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
DeleteSurfaces();
unmanagedSurfaces = new IntPtr[lpNumBuffers];
hr = vmrSurfaceAllocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, unmanagedSurfaces);
// If we couldn't create a texture surface and
// the format is not an alpha format,
// then we probably cannot create a texture.
// So what we need to do is create a private texture
// and copy the decoded images onto it.
if (hr < 0)
{
DeleteSurfaces();
FourCC fcc = new FourCC("0000");
// is surface YUV ?
if (lpAllocInfo.Format > fcc.ToInt32())
{
// create the private texture
privateTexture = new Texture(
device,
lpAllocInfo.dwWidth,
lpAllocInfo.dwHeight,
1,
Usage.RenderTarget,
adapterInfo.CurrentDisplayMode.Format,
Pool.Default
);
privateSurface = privateTexture.GetSurfaceLevel(0);
}
lpAllocInfo.dwFlags &= ~VMR9SurfaceAllocationFlags.TextureSurface;
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.OffscreenSurface;
unmanagedSurfaces = new IntPtr[lpNumBuffers];
hr = vmrSurfaceAllocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, unmanagedSurfaces);
if (hr < 0)
return hr;
}
else
{
surfaces = new Hashtable(unmanagedSurfaces.Length);
textures = new Hashtable(unmanagedSurfaces.Length);
for (int i = 0; i < lpNumBuffers; i++)
{
Surface surf = new Surface(unmanagedSurfaces[i]);
Texture text = (Texture) surf.GetContainer(new Guid("85C31227-3DE5-4f00-9B3A-F11AC38C18B5"));
surfaces.Add(unmanagedSurfaces[i], surf);
textures.Add(unmanagedSurfaces[i], text);
}
}
return scene.Init(device);
}
catch(DirectXException e)
{
return e.ErrorCode;
}
catch
{
return E_FAIL;
}
}
public int InitializeDevice(IntPtr dwUserID, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
_surfaces = new Surface[lpNumBuffers];
for (int s = 0; s < lpNumBuffers; s++)
{
_surfaces[s] = Surface.CreateRenderTarget(_d3Device, lpAllocInfo.dwWidth, lpAllocInfo.dwHeight, Format.X8R8G8B8,
MultisampleType.None, 0, true);
}
return 0;
}
/// <summary>
/// The InitializeDevice method is called by the Video Mixing Renderer 9 (VMR-9)
/// when it needs the allocator-presenter to allocate surfaces.
/// </summary>
/// <param name="userId">
/// Application-defined identifier. This value is the same value that the application
/// passed to the IVMRSurfaceAllocatorNotify9.AdviseSurfaceAllocator method in the
/// dwUserID parameter.
/// </param>
/// <param name="lpAllocInfo">
/// Pointer to a VMR9AllocationInfo structure that contains a description of the surfaces to create.
/// </param>
/// <param name="lpNumBuffers">
/// On input, specifies the number of surfaces to create. When the method returns,
/// this parameter contains the number of buffers that were actually allocated.
/// </param>
/// <returns>Returns an HRESULT code</returns>
public int InitializeDevice(IntPtr userId, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
if (m_allocatorNotify == null)
{
return E_FAIL;
}
try
{
int hr;
lock (m_staticLock)
{
/* These two pointers are passed to the the helper
* to create our D3D surfaces */
var pDevice = GetComPointer(m_device);
var pMonitor = GetAdapterMonitor(0);
/* Setup our D3D Device with our renderer */
hr = m_allocatorNotify.SetD3DDevice(pDevice, pMonitor);
DsError.ThrowExceptionForHR(hr);
/* This is only used if the AllocateSurfaceHelper is used */
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
/* Make sure our old surfaces are free'd */
FreeSurfaces();
/* This is an IntPtr array of pointers to D3D surfaces */
DxSurfaces = new IntPtr[lpNumBuffers];
/* This is where the magic happens, surfaces are allocated */
hr = m_allocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, DxSurfaces);
if (hr < 0)
{
FreeSurfaces();
if (lpAllocInfo.Format > 0)
{
hr = m_device.CreateTexture(lpAllocInfo.dwWidth,
lpAllocInfo.dwHeight,
1,
1,
D3DFORMAT.D3DFMT_X8R8G8B8,
0,
out m_privateTexture,
IntPtr.Zero);
DsError.ThrowExceptionForHR(hr);
hr = m_privateTexture.GetSurfaceLevel(0, out m_privateSurface);
DsError.ThrowExceptionForHR(hr);
}
lpAllocInfo.dwFlags &= ~VMR9SurfaceAllocationFlags.TextureSurface;
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.OffscreenSurface;
DxSurfaces = new IntPtr[lpNumBuffers];
hr = m_allocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo,
ref lpNumBuffers,
DxSurfaces);
if (hr < 0)
{
FreeSurfaces();
return hr;
}
}
}
/* Nofity to our listeners we have new surfaces */
InvokeNewSurfaceEvent(m_privateSurface != null ? GetComPointer(m_privateSurface) : DxSurfaces[0]);
return hr;
}
catch
{
return E_FAIL;
}
}
public int InitializeDevice(IntPtr dwUserID, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
int hr = 0;
Debug.WriteLine(string.Format("{0}x{1} : {2} / {3} / 0x{4:x}", lpAllocInfo.dwWidth, lpAllocInfo.dwHeight, FourCCToStr(lpAllocInfo.Format), lpAllocInfo.Pool, lpAllocInfo.dwFlags));
// The allocator sometime call this method with invalid pool value (4 for me). Don't ask me why!
// If the pool is invalid, return an error now to avoid an exception later in the code.
if ((lpAllocInfo.Pool < 0) || (lpAllocInfo.Pool > 3))
return D3DERR_INVALIDCALL;
// if format is YUV ? (note : 0x30303030 = " ")
if (lpAllocInfo.Format > 0x30303030)
{
// Check if the hardware support format conversion from this YUV format to the RGB desktop format
if (!Manager.CheckDeviceFormatConversion(creationParameters.AdapterOrdinal, creationParameters.DeviceType, (Format)lpAllocInfo.Format, adapterInfo.CurrentDisplayMode.Format))
{
// If not, refuse this format!
// The VMR9 will propose other formats supported by the downstream filter output pin.
return D3DERR_INVALIDCALL;
}
}
try
{
IntPtr unmanagedDevice = device.GetObjectByValue(DxMagicNumber);
IntPtr hMonitor = Manager.GetAdapterMonitor(adapterInfo.Adapter);
// Give our Direct3D device to the VMR9 filter
hr = vmrSurfaceAllocatorNotify.SetD3DDevice(unmanagedDevice, hMonitor);
DsError.ThrowExceptionForHR(hr);
videoSize = new Size(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
int width = 1;
int height = 1;
// If hardware require textures to power of two sized
if (device.DeviceCaps.TextureCaps.SupportsPower2)
{
// Compute the ideal size
while (width < lpAllocInfo.dwWidth)
width = width << 1;
while (height < lpAllocInfo.dwHeight)
height = height << 1;
// notify this change to the VMR9 filter
lpAllocInfo.dwWidth = width;
lpAllocInfo.dwHeight = height;
}
textureSize = new Size(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
// Just in case
DeleteSurfaces();
// if format is YUV ?
if (lpAllocInfo.Format > 0x30303030)
{
// An offscreen surface must be created
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.OffscreenSurface;
// Create it
videoSurface = device.CreateOffscreenPlainSurface(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight, (Format)lpAllocInfo.Format, (Pool)lpAllocInfo.Pool);
// And get it unmanaged pointer
unmanagedSurface = videoSurface.GetObjectByValue(DxMagicNumber);
// Then create a private texture for the client application
privateTexture = new Texture(
device,
lpAllocInfo.dwWidth,
lpAllocInfo.dwHeight,
1,
Usage.RenderTarget,
adapterInfo.CurrentDisplayMode.Format,
Pool.Default
);
// Get the MipMap surface 0 for the copy (see PresentImage)
privateSurface = privateTexture.GetSurfaceLevel(0);
// This code path need a surface copy
needCopy = true;
}
else
{
// in RGB pixel format
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
// Simply create a texture
privateTexture = new Texture(
device,
lpAllocInfo.dwWidth,
lpAllocInfo.dwHeight,
1,
Usage.RenderTarget,
adapterInfo.CurrentDisplayMode.Format,
Pool.Default
);
// And get the MipMap surface 0 for the VMR9 filter
privateSurface = privateTexture.GetSurfaceLevel(0);
unmanagedSurface = privateSurface.GetObjectByValue(DxMagicNumber);
// This code path don't need a surface copy.
// The client appllication use the same texture the VMR9 filter use.
needCopy = false;
}
// This allocator only support 1 buffer.
// Notify the VMR9 filter
lpNumBuffers = 1;
}
catch(DirectXException e)
{
// A Direct3D error can occure : Notify it to the VMR9 filter
return e.ErrorCode;
}
catch
{
// Or else, notify a more general error
return E_FAIL;
}
// This allocation is a success
return 0;
}
public int InitializeDevice(IntPtr dwUserID, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
lock (this)
{
log.InfoFormat("DirectShowCodec[{0}]: {1}x{2} : {3} / {4} / {5} / {6} / 0x{7:x}", ID,
lpAllocInfo.dwWidth, lpAllocInfo.dwHeight,
FourCCToStr(lpAllocInfo.Format),
adapterInfo.CurrentDisplayMode.Format,
lpAllocInfo.MinBuffers,
(Pool)lpAllocInfo.Pool,
lpAllocInfo.dwFlags);
Axiom.Media.PixelFormat texFormat = D3DHelper.ConvertEnum(adapterInfo.CurrentDisplayMode.Format);
Format format = (Format)lpAllocInfo.Format;
// if format is YUV ? (note : 0x30303030 = " ")
if (lpAllocInfo.Format > 0x30303030)
{
// NV12 textures appear not to play correctly; when using them with an
// offscreen surface, they only show the first frame or so. Doing this
// should cause it to renegotiate to RGB.
//
// New and improved: YV12 seems to have the same problem.
if (
(lpAllocInfo.Format == StrToFourCC("NV12")) ||
(lpAllocInfo.Format == StrToFourCC("YV12"))
)
{
// XXXMLM - this may cause us to pop an external window
log.WarnFormat("DirectShowCodec[{0}]: Rejecting {1} format", ID, FourCCToStr(lpAllocInfo.Format));
return D3DERR_INVALIDCALL;
}
// Check if the hardware support format conversion from this YUV format to the RGB desktop format
if (!D3D.Manager.CheckDeviceFormatConversion(creationParameters.AdapterOrdinal, creationParameters.DeviceType,
(Format)lpAllocInfo.Format, adapterInfo.CurrentDisplayMode.Format))
{
// If not, refuse this format!
// The VMR9 will propose other formats supported by the downstream filter output pin.
log.WarnFormat("DirectShowCodec[{0}]: Cannot convert between formats", ID);
return D3DERR_INVALIDCALL;
}
}
try
{
IDirect3DDevice9* unmanagedDevice = device.UnmanagedComPointer;
IntPtr hMonitor = D3D.Manager.GetAdapterMonitor(adapterInfo.Adapter);
// Give our Direct3D device to the VMR9 filter
try
{
IVMRSurfaceAllocatorNotify9 notify9 = vmrSurfaceAllocatorNotify;
vmrSurfaceAllocatorNotify.SetD3DDevice((IntPtr)unmanagedDevice, hMonitor);
}
catch (InvalidCastException e)
{
// It turns out that if this function is called from the
// decoder thread, the hr return value of the SetD3DDevice
// call will be E_INVALIDCAST. However, if we've already
// notified the allocator notify interface of the device,
// the rest of this function will happen correctly. So
// only throw the exception if we haven't notified the
// device yet.
if ((IntPtr)unmanagedDevice != notifiedDevice)
{
throw e;
}
}
notifiedDevice = (IntPtr)unmanagedDevice;
videoSize = new Size(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
videoRectangle = new Rectangle(Point.Empty, videoSize);
// Always do power of two sized textures
lpAllocInfo.dwWidth = Manager.NextPowerOfTwo(lpAllocInfo.dwWidth);
lpAllocInfo.dwHeight = Manager.NextPowerOfTwo(lpAllocInfo.dwHeight);
textureSize = new Size(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
// Just in case
DeleteSurfaces();
// if format is YUV ?
if (lpAllocInfo.Format > 0x30303030)
{
log.InfoFormat("DirectShowCodec[{0}]: Creating offscreen surface ({1}x{2})",
ID, lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
// An offscreen surface must be created
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.OffscreenSurface;
// Create it
try
{
// ATI and nVidia both fail this call when created with YUV, so ask for
// an RGB texture first if we can get away with it.
if ((lpAllocInfo.dwFlags & VMR9SurfaceAllocationFlags.RGBDynamicSwitch) != 0)
{
videoSurface = device.CreateOffscreenPlainSurface(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight,
adapterInfo.CurrentDisplayMode.Format, (Pool)lpAllocInfo.Pool);
}
else
{
videoSurface = device.CreateOffscreenPlainSurface(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight,
(Format)lpAllocInfo.Format, (Pool)lpAllocInfo.Pool);
}
}
catch
{
log.WarnFormat("Failed to create {0} surface", (Format)lpAllocInfo.Format);
return D3DERR_INVALIDCALL;
}
// And get it unmanaged pointer
unmanagedSurface = videoSurface.UnmanagedComPointer;
axiomTexture = TextureManager.Instance.GetByName(textureName);
if (axiomTexture != null)
{
log.InfoFormat("DirectShowCodec[{0}]: Removing old texture \"{1}\"",
ID, textureName);
axiomTexture.Unload();
axiomTexture.TextureType = TextureType.TwoD;
axiomTexture.Width = lpAllocInfo.dwWidth;
axiomTexture.Height = lpAllocInfo.dwHeight;
axiomTexture.NumMipMaps = 0;
axiomTexture.Format = texFormat;
axiomTexture.Usage = TextureUsage.RenderTarget;
axiomTexture.CreateInternalResources();
}
else
{
axiomTexture = TextureManager.Instance.CreateManual(
textureName,
TextureType.TwoD,
lpAllocInfo.dwWidth, lpAllocInfo.dwHeight,
0, // no mip maps
texFormat, // from the display
TextureUsage.RenderTarget);
}
if (axiomTexture is D3DTexture)
{
D3DTexture d3t = (D3DTexture)axiomTexture;
if (d3t.DXTexture is D3D.Texture)
{
privateTexture = (D3D.Texture)d3t.DXTexture;
}
else
{
throw new Exception("D3D texture could not get DX texture");
}
}
else
{
throw new Exception("D3D Texture failed to create");
}
// Get the MipMap surface 0 for the copy (see PresentImage)
privateSurface = privateTexture.GetSurfaceLevel(0);
device.ColorFill(privateSurface, new Rectangle(0, 0, lpAllocInfo.dwWidth, lpAllocInfo.dwHeight), Color.Black);
// This code path need a surface copy
needCopy = true;
}
else
{
log.InfoFormat("DirectShowCodec[{0}]: Creating texture surface ({1}x{2})",
ID, lpAllocInfo.dwWidth, lpAllocInfo.dwHeight);
// in RGB pixel format
//lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
//Surface s = device.CreateRenderTarget();
axiomTexture = TextureManager.Instance.GetByName(textureName);
if (axiomTexture != null)
{
log.InfoFormat("DirectShowCodec[{0}]: Removing old texture \"{1}\"",
ID, textureName);
axiomTexture.Unload();
axiomTexture.TextureType = TextureType.TwoD;
axiomTexture.Width = lpAllocInfo.dwWidth;
axiomTexture.Height = lpAllocInfo.dwHeight;
axiomTexture.NumMipMaps = 0;
axiomTexture.Format = texFormat;
axiomTexture.Usage = TextureUsage.RenderTarget;
axiomTexture.CreateInternalResources();
}
else
{
axiomTexture = TextureManager.Instance.CreateManual(
textureName,
TextureType.TwoD,
lpAllocInfo.dwWidth, lpAllocInfo.dwHeight,
0, // no mip maps
texFormat, // from the display
TextureUsage.RenderTarget);
}
if (axiomTexture is D3DTexture)
{
D3DTexture d3t = (D3DTexture)axiomTexture;
if (d3t.DXTexture is D3D.Texture)
{
privateTexture = (D3D.Texture)d3t.DXTexture;
}
}
else
{
throw new Exception("D3D Texture failed to create");
}
// And get the MipMap surface 0 for the VMR9 filter
privateSurface = privateTexture.GetSurfaceLevel(0);
unmanagedSurface = privateSurface.UnmanagedComPointer;
device.ColorFill(privateSurface, new Rectangle(0, 0, lpAllocInfo.dwWidth, lpAllocInfo.dwHeight), Color.Black);
// This code path don't need a surface copy.
// The client appllication use the same texture the VMR9 filter use.
needCopy = false;
}
// This allocator only support 1 buffer.
// Notify the VMR9 filter
lpNumBuffers = 1;
}
catch (DirectXException e)
{
// A Direct3D error can occure : Notify it to the VMR9 filter
LogUtil.ExceptionLog.ErrorFormat("Caught DirectX Exception: {0}", e.ToString());
return e.ErrorCode;
}
catch (Exception e)
{
// Or else, notify a more general error
LogUtil.ExceptionLog.ErrorFormat("Caught Exception: {0}", e.ToString());
return E_FAIL;
}
// This allocation is a success
return 0;
}
}
/// <summary>
/// The InitializeDevice method is called by the Video Mixing Renderer 9 (VMR-9)
/// when it needs the allocator-presenter to allocate surfaces.
/// </summary>
/// <param name="userId">
/// Application-defined identifier. This value is the same value that the application
/// passed to the IVMRSurfaceAllocatorNotify9.AdviseSurfaceAllocator method in the
/// dwUserID parameter.
/// </param>
/// <param name="lpAllocInfo">
/// Pointer to a VMR9AllocationInfo structure that contains a description of the surfaces to create.
/// </param>
/// <param name="lpNumBuffers">
/// On input, specifies the number of surfaces to create. When the method returns,
/// this parameter contains the number of buffers that were actually allocated.
/// </param>
/// <returns>Returns an HRESULT code</returns>
public int InitializeDevice(IntPtr userId, ref VMR9AllocationInfo lpAllocInfo, ref int lpNumBuffers)
{
if (m_allocatorNotify == null)
{
return E_FAIL;
}
try
{
int hr;
lock (m_staticLock)
{
/* These two pointers are passed to the the helper
* to create our D3D surfaces */
var pDevice = GetComPointer(m_device);
var pMonitor = GetAdapterMonitor(0);
/* Setup our D3D Device with our renderer */
hr = m_allocatorNotify.SetD3DDevice(pDevice, pMonitor);
DsError.ThrowExceptionForHR(hr);
/* This is only used if the AllocateSurfaceHelper is used */
lpAllocInfo.dwFlags |= VMR9SurfaceAllocationFlags.TextureSurface;
/* Make sure our old surfaces are free'd */
FreeSurfaces();
/* This is an IntPtr array of pointers to D3D surfaces */
DxSurfaces = new IntPtr[lpNumBuffers];
/* This is where the magic happens, surfaces are allocated */
//hr = m_allocatorNotify.AllocateSurfaceHelper(ref lpAllocInfo, ref lpNumBuffers, DxSurfaces);
//SlimDX.Direct3D9.Device dev = Device.FromPointer(Marshal.GetIUnknownForObject(m_device));
IntPtr sharedHandle;
//Surface s = Surface.CreateRenderTarget(dev,
// lpAllocInfo.dwWidth,
// lpAllocInfo.dwHeight,
// Format.X8B8G8R8,
// MultisampleType.None,
// 0,
// false,
// out sharedHandle);
IntPtr videoSurface;
//
hr = m_device.CreateRenderTarget(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight, D3DFORMAT.D3DFMT_A8R8G8B8, D3DMULTISAMPLE_TYPE.D3DMULTISAMPLE_NONE, 0, false, out videoSurface, out sharedHandle);
//hr = m_device.CreateTexture(lpAllocInfo.dwWidth,
// lpAllocInfo.dwHeight,
// 1,
// 1,
// D3DFORMAT.D3DFMT_A8B8G8R8,
// 0,
// out videoSurface,
// out sharedHandle);
DxSurfaces[0] = videoSurface;
//DxSurfaces[0] = s.ComPointer;
InvokeNewSurfaceEvent(DxSurfaces[0], sharedHandle, new Size(lpAllocInfo.dwWidth, lpAllocInfo.dwHeight));
}
return hr;
}
catch
{
return E_FAIL;
}
}
