/// <summary>Get a human readable implementation description.</summary>
/// <param name="session">The session.</param>
/// <returns></returns>
public static string ImplementationString(mfxSession session)
{
mfxIMPL impl;
var sts = UnsafeNativeMethods.MFXQueryIMPL(session, &impl);
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(UnsafeNativeMethods.MFXQueryIMPL));
return(ImplementationString(impl));
}
/// <summary>Attempts to decode a byte array using codecId as the format indicator.
/// If the array is decodable stream parameters such as width, height, etc... will be returned</summary>
/// <param name="bitstream">The bitstream.</param>
/// <param name="codecId">The codec identifier.</param>
/// <param name="impl">The implementation.</param>
/// <returns>A video parameter structure describing the bitstream.</returns>
public static mfxVideoParam DecodeHeader(byte[] bitstream, CodecId codecId, mfxIMPL impl = mfxIMPL.MFX_IMPL_AUTO)
{
mfxVideoParam mfxDecParam;
mfxStatus sts;
var v = new mfxVersion();
v.Major = 1;
v.Minor = 0;
var session = new mfxSession();
sts = UnsafeNativeMethods.MFXInit(impl, &v, &session);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
try
{
mfxBitstream bs;
mfxDecParam.mfx.CodecId = codecId;
mfxDecParam.IOPattern = IOPattern.MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
fixed(byte *pp = &bitstream[0])
{
// bs.Data_ptr = p;
bs.Data = (IntPtr)pp;
bs.DataLength = (uint)bitstream.Length;
bs.MaxLength = (uint)bitstream.Length;
bs.DataOffset = 0;
sts = UnsafeNativeMethods.MFXVideoDECODE_DecodeHeader(session, &bs, &mfxDecParam);
QuickSyncStatic.ThrowOnBadStatus(sts, "decodeheader");
}
}
finally
{
UnsafeNativeMethods.MFXClose(session);
}
mfxDecParam.IOPattern = (IOPattern)0; // we do not want this to be the source of IOPattern
// must be set it another place so it doesnt default to sysmem
return(mfxDecParam);
}
unsafe public LowLevelEncoderNative(mfxVideoParam mfxEncParams, mfxIMPL impl)
{
mfxStatus sts;
this._session = new mfxSession();
var ver = new mfxVersion()
{
Major = 1, Minor = 3
};
fixed(mfxSession *s = &_session)
sts = UnsafeNativeMethods.MFXInit(impl, &ver, s);
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(UnsafeNativeMethods.MFXInit));
h = NativeLLEncoderUnsafeNativeMethods.NativeEncoder_New();
Trace.Assert(h != IntPtr.Zero);
shared = (EncoderShared *)h;
shared->session = _session;
shared->mfxEncParams = mfxEncParams;
Trace.Assert(shared->safety == sizeof(EncoderShared));
sts = NativeLLEncoderUnsafeNativeMethods.NativeEncoder_Init(h);
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(NativeLLEncoderUnsafeNativeMethods.NativeEncoder_Init));
frameIntPtrs = new IntPtr[shared->nEncSurfNum];
for (int i = 0; i < frameIntPtrs.Length; i++)
{
frameIntPtrs[i] = (IntPtr)shared->pmfxSurfaces[i];
}
GetAndPrintWarnings();
}
/// <summary>This method will determine if:
/// 1. Hardware IGP/GPU support is ready with driver support
/// 2. If the software fallback is available.
/// </summary>
/// <param name="verbose">if set to <c>true</c> [verbose].</param>
unsafe public static void HaltIfNotReady(bool verbose = false)
{
string impltext;
mfxStatus sts;
var v = new mfxVersion();
v.Major = 1;
v.Minor = 0;
var session = new mfxSession();
mfxIMPL impl;
bool readySoftware = false;
bool readyHardware = false;
//https://en.wikipedia.org/wiki/Graphics_processing_unit#Integrated_graphics
sts = UnsafeNativeMethods.MFXInit(mfxIMPL.MFX_IMPL_HARDWARE, &v, &session);
if (sts == mfxStatus.MFX_ERR_UNSUPPORTED)
{
if (verbose)
{
Console.WriteLine("Your computer IS NOT READY for Quick Sync Hardware operations");
Console.WriteLine(" Please check your 1) Drivers 2) Motherboard 3) CPU");
Console.WriteLine(" Please see the LVSDK documentation on system preparation");
}
}
else if (sts == mfxStatus.MFX_ERR_NONE)
{
sts = UnsafeNativeMethods.MFXQueryIMPL(session, &impl);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXQueryIMPL");
sts = UnsafeNativeMethods.MFXQueryVersion(session, &v);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXQueryIMPL");
sts = UnsafeNativeMethods.MFXClose(session);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXClose");
impltext = QuickSyncStatic.ImplementationString(impl);
Console.WriteLine("Your computer IS READY for Quick Sync Hardware operations");
//Console.WriteLine("Implementation = {0}", impltext);
if (verbose)
{
Console.WriteLine(" Version major.minor = {0}.{1}", v.Major, v.Minor);
}
readyHardware = true;
}
else
{
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
}
if (verbose)
{
Console.WriteLine();
}
sts = UnsafeNativeMethods.MFXInit(mfxIMPL.MFX_IMPL_SOFTWARE, &v, &session);
if (sts == mfxStatus.MFX_ERR_UNSUPPORTED)
{
if (verbose)
{
Console.WriteLine("Your software IS NOT READY for software Quick Sync operations");
Console.WriteLine(" You must replace the dummy libmfxsw64.dll with a genuine Intel copy");
Console.WriteLine(" Install either free:\"Media Server Studio\" or \"Intel Media SDK\" to fix this");
Console.WriteLine(" Please see the LVSDK documentation on system preparation");
}
}
else if (sts == mfxStatus.MFX_ERR_NONE)
{
sts = UnsafeNativeMethods.MFXQueryIMPL(session, &impl);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXQueryIMPL");
sts = UnsafeNativeMethods.MFXQueryVersion(session, &v);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXQueryIMPL");
sts = UnsafeNativeMethods.MFXClose(session);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXClose");
impltext = QuickSyncStatic.ImplementationString(impl);
Console.WriteLine("Your software IS READY for software Quick Sync operations");
//Console.WriteLine(" Implementation = {0}", impltext);
if (verbose)
{
Console.WriteLine(" Version major.minor = {0}.{1}", v.Major, v.Minor);
}
readySoftware = true;
}
else
{
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
}
if (verbose)
{
Console.WriteLine();
}
if (!readyHardware && !readySoftware)
{
Console.WriteLine("You are not properly configured for either: A) GPU/IGP Quick Sync B) Software fallback");
Console.WriteLine("You may not continue until you fix one option for Quick Sync coding");
Console.WriteLine("Press a key to exit");
Console.ReadKey();
Environment.Exit(-1);
}
Console.WriteLine();
}
/// <summary>
/// Constructor
/// </summary>
public LowLevelDecoderCSharp(mfxVideoParam mfxDecParamsX,
mfxVideoParam?VPPParamsX = null,
mfxIMPL impl = mfxIMPL.MFX_IMPL_AUTO)
{
mfxStatus sts;
bool enableVPP = VPPParamsX != null;
if (VPPParamsX == null)
{
// Create a default VPPParamsX
var foo = new mfxVideoParam();
foo.AsyncDepth = 1;
foo.IOPattern = IOPattern.MFX_IOPATTERN_OUT_SYSTEM_MEMORY | IOPattern.MFX_IOPATTERN_IN_SYSTEM_MEMORY;
foo.vpp.In = mfxDecParamsX.mfx.FrameInfo;
foo.vpp.Out = mfxDecParamsX.mfx.FrameInfo;
VPPParamsX = foo;
}
mfxVideoParam VPPParams = VPPParamsX != null ? VPPParamsX.Value : new mfxVideoParam();
mfxVideoParam mfxDecParams = mfxDecParamsX;
// NOTE
// IF I am worried about interop issues with stuff moving due to GC,
// just pin ever single blitable here
pinningHandles.Add(GCHandle.Alloc(pmfxSurfaces, GCHandleType.Pinned));
pinningHandles.Add(GCHandle.Alloc(pmfxSurfaces2, GCHandleType.Pinned));
//pinningHandles.Add(GCHandle.Alloc(struct1, GCHandleType.Pinned));
//pinningHandles.Add(GCHandle.Alloc(struct1, GCHandleType.Pinned));
this.videoParam = mfxDecParams;
this.enableVPP = enableVPP;
session = new mfxSession();
var ver = new mfxVersion()
{
Major = 1, Minor = 3
};
fixed(mfxSession *s = &session)
sts = UnsafeNativeMethods.MFXInit(impl, &ver, s);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
bool decVideoMemOut = (mfxDecParams.IOPattern & IOPattern.MFX_IOPATTERN_OUT_VIDEO_MEMORY) != 0;
bool vppVideoMemIn = (VPPParams.IOPattern & IOPattern.MFX_IOPATTERN_IN_VIDEO_MEMORY) != 0;
bool vppVideoMemOut = (VPPParams.IOPattern & IOPattern.MFX_IOPATTERN_OUT_VIDEO_MEMORY) != 0;
Trace.Assert(!enableVPP || decVideoMemOut == vppVideoMemIn, "When the VPP is enabled, the memory type from DEC into VPP must be of same type");
if (vppVideoMemIn || vppVideoMemOut)
{
//if you want to use video memory, you need to have a way to allocate the Direct3D or Vaapi frames
videoAccelerationSupport = new VideoAccelerationSupport(session);
}
fixed(mfxFrameAllocRequest *p = &DecRequest)
sts = UnsafeNativeMethods.MFXVideoDECODE_QueryIOSurf(session, &mfxDecParams, p);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "DECODE_QueryIOSurf");
if (enableVPP)
{
fixed(mfxFrameAllocRequest *p = &VPPRequest[0])
sts = UnsafeNativeMethods.MFXVideoVPP_QueryIOSurf(session, &VPPParams, p);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "VPP_QueryIOSurf");
VPPRequest[1].Type |= FrameMemoryType.WILL_READ;
}
//mfxU16 nSurfNumDecVPP = DecRequest.NumFrameSuggested + VPPRequest[0].NumFrameSuggested;
//mfxU16 nSurfNumVPPOut = VPPRequest[1].NumFrameSuggested;
int nSurfNumVPPOut = 0;
var numSurfaces = DecRequest.NumFrameSuggested + VPPRequest[0].NumFrameSuggested + VPPParams.AsyncDepth;
if (enableVPP)
{
nSurfNumVPPOut = 0 + VPPRequest[1].NumFrameSuggested + VPPParams.AsyncDepth;
}
bitstreamBuffer = Marshal.AllocHGlobal(defaultBitstreamBufferSize);
bitstream.Data = bitstreamBuffer;
bitstream.DataLength = 0;
bitstream.MaxLength = (uint)defaultBitstreamBufferSize;
bitstream.DataOffset = 0;
//mfxFrameAllocRequest DecRequest;
//sts = UnsafeNativeMethods.MFXVideoDECODE_QueryIOSurf(session, &mfxDecParams, &DecRequest);
//if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION) sts = 0;
//Trace.Assert(sts == mfxStatus.MFX_ERR_NONE);
//allocate decoder frames via directx
mfxFrameAllocResponse DecResponse = new mfxFrameAllocResponse();
if (decVideoMemOut)
{
DecRequest.NumFrameMin = DecRequest.NumFrameSuggested = (ushort)numSurfaces;
fixed(mfxFrameAllocRequest *p = &DecRequest)
videoAccelerationSupport.AllocFrames(p, &DecResponse);
}
//allocate vpp frames via directx
mfxFrameAllocResponse EncResponse = new mfxFrameAllocResponse();
if (vppVideoMemOut)
{
VPPRequest[1].NumFrameMin = VPPRequest[1].NumFrameSuggested = (ushort)nSurfNumVPPOut;
fixed(mfxFrameAllocRequest *p = &VPPRequest[1])
videoAccelerationSupport.AllocFrames(p, &EncResponse);
}
// Allocate surfaces for decoder
// - Width and height of buffer must be aligned, a multiple of 32
// - Frame surface array keeps pointers all surface planes and general frame info
UInt16 width = (UInt16)QuickSyncStatic.ALIGN32(DecRequest.Info.Width);
UInt16 height = (UInt16)QuickSyncStatic.ALIGN32(DecRequest.Info.Height);
int bitsPerPixel = VideoUtility.GetBitsPerPixel(mfxDecParams.mfx.FrameInfo.FourCC);
int surfaceSize = width * height * bitsPerPixel / 8;
//byte[] surfaceBuffers = new byte[surfaceSize * numSurfaces]; //XXX
if (!decVideoMemOut)
{
surfaceBuffers = Marshal.AllocHGlobal(surfaceSize * numSurfaces);
}
// // Allocate surface headers (mfxFrameSurface1) for decoder
pmfxSurfaces = new mfxFrameSurface1[numSurfaces];
pinningHandles.Add(GCHandle.Alloc(pmfxSurfaces, GCHandleType.Pinned));
//MSDK_CHECK_POINTER(pmfxSurfaces, MFX_ERR_MEMORY_ALLOC);
for (int i = 0; i < numSurfaces; i++)
{
pmfxSurfaces[i] = new mfxFrameSurface1();
pmfxSurfaces[i].Info = mfxDecParams.mfx.FrameInfo;
if (!decVideoMemOut)
{
switch (mfxDecParams.mfx.FrameInfo.FourCC)
{
case FourCC.NV12:
pmfxSurfaces[i].Data.Y_ptr = (byte *)surfaceBuffers + i * surfaceSize;
pmfxSurfaces[i].Data.U_ptr = pmfxSurfaces[i].Data.Y_ptr + width * height;
pmfxSurfaces[i].Data.V_ptr = pmfxSurfaces[i].Data.U_ptr + 1;
pmfxSurfaces[i].Data.Pitch = width;
break;
case FourCC.YUY2:
pmfxSurfaces[i].Data.Y_ptr = (byte *)surfaceBuffers + i * surfaceSize;
pmfxSurfaces[i].Data.U_ptr = pmfxSurfaces[i].Data.Y_ptr + 1;
pmfxSurfaces[i].Data.V_ptr = pmfxSurfaces[i].Data.U_ptr + 3;
pmfxSurfaces[i].Data.Pitch = (ushort)(width * 2);
break;
default: //find sysmem_allocator.cpp for more help
throw new NotImplementedException();
}
}
else
{
pmfxSurfaces[i].Data.MemId = DecResponse.mids_ptr[i]; // MID (memory id) represent one D3D NV12 surface
}
}
if (enableVPP)
{
UInt16 width2 = (UInt16)QuickSyncStatic.ALIGN32(VPPRequest[1].Info.CropW);
UInt16 height2 = (UInt16)QuickSyncStatic.ALIGN32(VPPRequest[1].Info.CropH);
int bitsPerPixel2 = VideoUtility.GetBitsPerPixel(VPPParams.vpp.Out.FourCC); // NV12 format is a 12 bits per pixel format
int surfaceSize2 = width2 * height2 * bitsPerPixel2 / 8;
int pitch2 = width2 * bitsPerPixel2 / 8;
if (!vppVideoMemOut)
{
surfaceBuffers2 = Marshal.AllocHGlobal(surfaceSize2 * nSurfNumVPPOut);
}
pmfxSurfaces2 = new mfxFrameSurface1[nSurfNumVPPOut];
pinningHandles.Add(GCHandle.Alloc(pmfxSurfaces2, GCHandleType.Pinned));
//MSDK_CHECK_POINTER(pmfxSurfaces, MFX_ERR_MEMORY_ALLOC);
for (int i = 0; i < nSurfNumVPPOut; i++)
{
pmfxSurfaces2[i] = new mfxFrameSurface1();
pmfxSurfaces2[i].Info = VPPParams.vpp.Out;
if (!vppVideoMemOut)
{
pmfxSurfaces2[i].Data.Pitch = (ushort)pitch2;
switch (VPPParams.vpp.Out.FourCC)
{
case FourCC.NV12:
pmfxSurfaces2[i].Data.Y_ptr = (byte *)surfaceBuffers2 + i * surfaceSize2;
pmfxSurfaces2[i].Data.U_ptr = pmfxSurfaces2[i].Data.Y_ptr + width * height;
pmfxSurfaces2[i].Data.V_ptr = pmfxSurfaces2[i].Data.U_ptr + 1;
break;
case FourCC.RGB4:
pmfxSurfaces2[i].Data.B_ptr = (byte *)surfaceBuffers2 + i * surfaceSize2;
pmfxSurfaces2[i].Data.G_ptr = (byte *)surfaceBuffers2 + i * surfaceSize2 + 1;
pmfxSurfaces2[i].Data.R_ptr = (byte *)surfaceBuffers2 + i * surfaceSize2 + 2;
// pmfxSurfaces2[i].Data.A_ptr = (byte*)surfaceBuffers2 + i * surfaceSize2+3;
// pmfxSurfaces2[i].Data. = pmfxSurfaces2[i].Data.Y_ptr + width * height;
// pmfxSurfaces2[i].Data.V_ptr = pmfxSurfaces2[i].Data.U_ptr + 1;
break;
default:
break;
}
}
else
{
pmfxSurfaces2[i].Data.MemId = EncResponse.mids_ptr[i]; // MID (memory id) represent one D3D NV12 surface
}
}
}
sts = UnsafeNativeMethods.MFXVideoDECODE_Init(session, &mfxDecParams);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXVideoDECODE_Init");
if (enableVPP)
{
sts = UnsafeNativeMethods.MFXVideoVPP_Init(session, &VPPParams);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXVideoVPP_Init");
}
}
public unsafe VideoAccelerationSupport(mfxSession session, bool forceSystemMemory = false)
{
mfxStatus sts;
mfxVersion versionMinimum = new mfxVersion()
{
Major = 1, Minor = 3
};
acceleratorHandle = VideoAccelerationSupportPInvoke.VideoAccelerationSupport_New();
Trace.Assert(acceleratorHandle != IntPtr.Zero);
if (sizeof(IntPtr) != 8)
{
throw new Exception("only x64 supported at this time");
}
mfxIMPL ii;
sts = UnsafeNativeMethods.MFXQueryIMPL(session, &ii);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXQueryIMPL");
// if (Environment.OSVersion.Platform == PlatformID.Win32NT)
mfxIMPL viaMask = (mfxIMPL.MFX_IMPL_VIA_D3D9 | mfxIMPL.MFX_IMPL_VIA_D3D11 | mfxIMPL.MFX_IMPL_VIA_VAAPI);
if ((ii & viaMask) == mfxIMPL.MFX_IMPL_VIA_D3D11)
{
isDirectX11 = true;
memType = FrameMemType.D3D11_MEMORY;
}
else if ((ii & viaMask) == mfxIMPL.MFX_IMPL_VIA_D3D9)
{
memType = FrameMemType.D3D9_MEMORY;
}
else if ((ii & viaMask) == mfxIMPL.MFX_IMPL_VIA_VAAPI)
{
memType = FrameMemType.VAAPI_MEMORY;
}
//if (Environment.OSVersion.Platform == PlatformID.Win32NT)
//{
// if (Environment.OSVersion.Version.Major >= 6 && Environment.OSVersion.Version.Minor >= 2)
// memType = MemType.D3D11_MEMORY;
// else
// memType = MemType.D3D9_MEMORY;
//}
//else
//{
// memType = MemType.VAAPI_MEMORY;
//}
if (forceSystemMemory)
{
memType = FrameMemType.SYSTEM_MEMORY;
}
sts = VideoAccelerationSupportPInvoke.VideoAccelerationSupport_Init(acceleratorHandle, session, false, memType);
QuickSyncStatic.ThrowOnBadStatus(sts, "VideoAccelerationSupport_Init");
}
public static extern mfxStatus MFXVideoENCODE_Init(mfxSession session, mfxVideoParam *version);
public static extern mfxStatus MFXQueryVersion(mfxSession session, mfxVersion *version);
public static extern mfxStatus MFXVideoDECODE_DecodeFrameAsync(mfxSession session, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp);
public static extern mfxStatus MFXVideoDECODE_DecodeHeader(mfxSession session, mfxBitstream *bs, mfxVideoParam *par);
public static extern mfxStatus MFXVideoDECODE_Reset(mfxSession session, mfxVideoParam *version);
public static extern mfxStatus MFXVideoUSER_UnLoad(mfxSession session, byte *uid);
public static extern mfxStatus MFXVideoUSER_Load(mfxSession session, byte *uid, UInt32 version);
public LowLevelDecoderNative(mfxVideoParam mfxDecParamsX,
mfxVideoParam?VPPParamsX = null,
mfxIMPL impl = mfxIMPL.MFX_IMPL_AUTO)
{
mfxVideoParam tmpMfxVideoParam;
if (VPPParamsX.HasValue)
{
tmpMfxVideoParam = VPPParamsX.Value;
}
else
{
tmpMfxVideoParam.AsyncDepth = 1;
tmpMfxVideoParam.IOPattern = IOPattern.MFX_IOPATTERN_IN_VIDEO_MEMORY | IOPattern.MFX_IOPATTERN_OUT_VIDEO_MEMORY;
tmpMfxVideoParam.vpp.In = mfxDecParamsX.mfx.FrameInfo;
tmpMfxVideoParam.vpp.Out = mfxDecParamsX.mfx.FrameInfo;
}
mfxStatus sts;
session = new mfxSession();
var ver = new mfxVersion()
{
Major = 1, Minor = 3
};
fixed(mfxSession *s = &session)
sts = UnsafeNativeMethods.MFXInit(impl, &ver, s);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
//deviceSetup = new DeviceSetup(session, false);
h = NativeLLDecoderUnsafeNativeMethods.NativeDecoder_New();
Trace.Assert(h != IntPtr.Zero);
shared = (DecoderShared *)h;
//Console.WriteLine("mfxbs offset in C# {0}", (UInt64)(&(shared->mfxBS)) - (UInt64)shared);
//Console.WriteLine("warningCount offset in C# {0}", (UInt64)(&(shared->warningCount)) - (UInt64)shared);
//Console.WriteLine("sizeof(mfxBitstream) {0}", sizeof(mfxBitstream));
//Console.WriteLine("sizeof(DecoderShared) {0}", sizeof(DecoderShared));
//Console.WriteLine("shared->safety {0}", shared->safety);
Trace.Assert(shared->safety == sizeof(DecoderShared));
shared->mfxBS.MaxLength = 1000000;
shared->mfxBS.Data = Marshal.AllocHGlobal((int)shared->mfxBS.MaxLength);
shared->mfxBS.DataLength = 0;
shared->mfxBS.DataOffset = 0;
sts = NativeLLDecoderUnsafeNativeMethods.NativeDecoder_Init(h, session, &mfxDecParamsX, &tmpMfxVideoParam);
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(NativeLLDecoderUnsafeNativeMethods.NativeDecoder_Init));
//mfxFrameSurface1 aaa = *shared->foo1[0];
//aaa.Data = new mfxFrameData();
//File.WriteAllText("\\x\\a", Newtonsoft.Json.JsonConvert.SerializeObject(aaa,Formatting.Indented));
// aaa = *shared->foo2[0];
//aaa.Data = new mfxFrameData();
//File.WriteAllText("\\x\\b", Newtonsoft.Json.JsonConvert.SerializeObject(aaa, Formatting.Indented));
//aaa = *shared->foo3[0];
//aaa.Data = new mfxFrameData();
//File.WriteAllText("\\x\\c", Newtonsoft.Json.JsonConvert.SerializeObject(aaa, Formatting.Indented));
//aaa = *shared->foo4[0];
//aaa.Data = new mfxFrameData();
//File.WriteAllText("\\x\\d", Newtonsoft.Json.JsonConvert.SerializeObject(aaa, Formatting.Indented));
GetAndPrintWarnings();
}
public static extern mfxStatus MFXVideoCORE_SetFrameAllocator(mfxSession session, mfxFrameAllocator *allocator);
public static extern mfxStatus MFXQueryIMPL(mfxSession session, mfxIMPL *impl);
public static extern mfxStatus MFXVideoCORE_SyncOperation(mfxSession session, mfxSyncPoint syncp, UInt32 wait);
public static extern mfxStatus MFXClose(mfxSession session);
public static extern mfxStatus MFXVideoVPP_RunFrameVPPAsync(mfxSession session, mfxFrameSurface1 *insurf, mfxFrameSurface1 *outsurf, mfxExtVppAuxData *aux, mfxSyncPoint *syncp);
public static extern mfxStatus MFXVideoENCODE_Query(mfxSession session, mfxVideoParam *inin, mfxVideoParam *outout);
public static extern mfxStatus MFXVideoVPP_RunFrameVPPAsyncEx(mfxSession session, mfxFrameSurface1 *insurf, mfxFrameSurface1 *work, mfxFrameSurface1 **outsurf, mfxSyncPoint *syncp);
public static extern mfxStatus MFXVideoENCODE_EncodeFrameAsync(mfxSession session, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp);
public static extern mfxStatus MFXVideoVPP_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
public static extern mfxStatus VideoAccelerationSupport_Init(IntPtr handle, mfxSession s, bool rendering, VideoAccelerationSupport.FrameMemType memType, int linuxLibvaBackend = 0, int linuxMonitorType = 0, bool linuxWaylandPerfMode = false);
public static extern mfxStatus MFXVideoVPP_GetVideoParam(mfxSession session, mfxVideoParam *par);
/// <summary>Initializes a new instance of the <see cref="LowLevelTranscoderCSharp"/> class.</summary>
/// <param name="config">The configuration.</param>
/// <param name="impl">The implementation.</param>
/// <param name="forceSystemMemory">if set to <c>true</c> [force system memory].</param>
public LowLevelTranscoderCSharp(TranscoderConfiguration config, mfxIMPL impl = mfxIMPL.MFX_IMPL_AUTO, bool forceSystemMemory = false)
{
mfxStatus sts;
mfxVideoParam mfxDecParams = config.decParams;
mfxVideoParam mfxVPPParams = config.vppParams;
mfxVideoParam mfxEncParams = config.encParams;
session = new mfxSession();
var ver = new mfxVersion()
{
Major = 1, Minor = 3
};
fixed(mfxSession *s = &session)
sts = UnsafeNativeMethods.MFXInit(impl, &ver, s);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
//deviceSetup = new DeviceSetup(session, forceSystemMemory);
// mfxVideoParam mfxDecParams = new mfxVideoParam();
// mfxDecParams.mfx.CodecId = CodecId.MFX_CODEC_AVC;
int bufsize = (int)1e6;
mfxBS = (mfxBitstream *)MyAllocHGlobalAndZero(sizeof(mfxBitstream));
mfxBS->Data = MyAllocHGlobalAndZero(bufsize);
mfxBS->DataLength = (uint)0;
mfxBS->MaxLength = (uint)bufsize;
mfxBS->DataOffset = 0;
int outwidth = mfxDecParams.mfx.FrameInfo.CropW;
int outheight = mfxDecParams.mfx.FrameInfo.CropH;
// Query number of required surfaces for VPP
//mfxFrameAllocRequest[] VPPRequest = new mfxFrameAllocRequest[2]; // [0] - in, [1] - out
TwoMfxFrameAllocRequest VPPRequest;
sts = UnsafeNativeMethods.MFXVideoVPP_QueryIOSurf(session, &mfxVPPParams, (mfxFrameAllocRequest *)&VPPRequest);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoVPP_QueryIOSurf), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "vpp.queryiosurf");
// Query number required surfaces for dec
mfxFrameAllocRequest DecRequest;
sts = UnsafeNativeMethods.MFXVideoDECODE_QueryIOSurf(session, &mfxDecParams, &DecRequest);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoDECODE_QueryIOSurf), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(UnsafeNativeMethods.MFXVideoDECODE_QueryIOSurf));
// Query number of required surfaces for enc
mfxFrameAllocRequest EncRequest = new mfxFrameAllocRequest();
sts = UnsafeNativeMethods.MFXVideoENCODE_QueryIOSurf(session, &mfxEncParams, &EncRequest);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoENCODE_QueryIOSurf), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, nameof(UnsafeNativeMethods.MFXVideoENCODE_QueryIOSurf));
// Determine the required number of surfaces for decoder output (VPP input) and for VPP output (encoder input)
nSurfNumDecVPP = DecRequest.NumFrameSuggested + VPPRequest.In.NumFrameSuggested + mfxVPPParams.AsyncDepth;
nSurfNumVPPEnc = EncRequest.NumFrameSuggested + VPPRequest.Out.NumFrameSuggested + mfxVPPParams.AsyncDepth;
{
Trace.Assert((mfxEncParams.IOPattern & IOPattern.MFX_IOPATTERN_IN_SYSTEM_MEMORY) != 0);
Trace.Assert((mfxDecParams.IOPattern & IOPattern.MFX_IOPATTERN_OUT_SYSTEM_MEMORY) != 0);
UInt16 width = (UInt16)QuickSyncStatic.ALIGN32(DecRequest.Info.Width);
UInt16 height = (UInt16)QuickSyncStatic.ALIGN32(DecRequest.Info.Height);
int bitsPerPixel = 12;
int surfaceSize = width * height * bitsPerPixel / 8;
var decVppSurfaceBuffers = Marshal.AllocHGlobal(surfaceSize * nSurfNumDecVPP);
var vppEncSurfaceBuffers = Marshal.AllocHGlobal(surfaceSize * nSurfNumVPPEnc);
pSurfaces =
(mfxFrameSurface1 *)MyAllocHGlobalAndZero(sizeof(mfxFrameSurface1) * nSurfNumDecVPP);
pSurfaces2 =
(mfxFrameSurface1 *)MyAllocHGlobalAndZero(sizeof(mfxFrameSurface1) * nSurfNumVPPEnc);
for (int i = 0; i < nSurfNumDecVPP; i++)
{
pSurfaces[i] = new mfxFrameSurface1();
pSurfaces[i].Info = DecRequest.Info;
pSurfaces[i].Data.Y_ptr = (byte *)decVppSurfaceBuffers + i * surfaceSize;
pSurfaces[i].Data.U_ptr = pSurfaces[i].Data.Y_ptr + width * height;
pSurfaces[i].Data.V_ptr = pSurfaces[i].Data.U_ptr + 1;
pSurfaces[i].Data.Pitch = width;
}
for (int i = 0; i < nSurfNumVPPEnc; i++)
{
pSurfaces2[i] = new mfxFrameSurface1();
pSurfaces2[i].Info = EncRequest.Info;
pSurfaces2[i].Data.Y_ptr = (byte *)vppEncSurfaceBuffers + i * surfaceSize;
pSurfaces2[i].Data.U_ptr = pSurfaces2[i].Data.Y_ptr + width * height;
pSurfaces2[i].Data.V_ptr = pSurfaces2[i].Data.U_ptr + 1;
pSurfaces2[i].Data.Pitch = width;
}
}
sts = UnsafeNativeMethods.MFXVideoDECODE_Init(session, &mfxDecParams);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoDECODE_Init), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "decode.init");
sts = UnsafeNativeMethods.MFXVideoENCODE_Init(session, &mfxEncParams);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoENCODE_Init), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "encode.init");
sts = UnsafeNativeMethods.MFXVideoVPP_Init(session, &mfxVPPParams);
if (sts == mfxStatus.MFX_WRN_PARTIAL_ACCELERATION)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoVPP_Init), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "vpp.init");
//mfxExtVPPDoNotUse zz;
//zz.Header.BufferId = BufferId.MFX_EXTBUFF_VPP_DONOTUSE;
//zz.Header.BufferSz = (uint)sizeof(mfxExtVPPDoUse);
//mfxExtBuffer** pExtParamsVPPx = stackalloc mfxExtBuffer*[1];
//pExtParamsVPPx[0] = (mfxExtBuffer*)&zz;
//var t1 = stackalloc uint[100];
//zz.AlgList = t1;
//zz.NumAlg = 100;
//mfxVideoParam par;
//par.ExtParam = pExtParamsVPPx;
//par.NumExtParam = 1;
//sts = UnsafeNativeMethods.MFXVideoVPP_GetVideoParam(session, &par);
//Trace.Assert(sts == mfxStatus.MFX_ERR_NONE);
//Console.WriteLine(zz.NumAlg);
//for (int i = 0; i < 10; i++)
//{
// Console.WriteLine((BufferId)t1[i]);
//}
mfxVideoParam par;
// Retrieve video parameters selected by encoder.
// - BufferSizeInKB parameter is required to set bit stream buffer size
par = new mfxVideoParam();
sts = UnsafeNativeMethods.MFXVideoENCODE_GetVideoParam(session, &par);
QuickSyncStatic.ThrowOnBadStatus(sts, "enc.getvideoparams");
// Create task pool to improve asynchronous performance (greater GPU utilization)
taskPoolSize = mfxEncParams.AsyncDepth; // number of tasks that can be submitted, before synchronizing is required
// Task* pTasks = stackalloc Task[taskPoolSize];
pTasks = (Task *)MyAllocHGlobalAndZero(sizeof(Task) * taskPoolSize);
// GCHandle gch3 = GCHandle.Alloc(pTasks, GCHandleType.Pinned);
for (int i = 0; i < taskPoolSize; i++)
{
// Prepare Media SDK bit stream buffer
pTasks[i].mfxBS.MaxLength = (uint)(par.mfx.BufferSizeInKB * 1000);
pTasks[i].mfxBS.Data = MyAllocHGlobalAndZero((int)pTasks[i].mfxBS.MaxLength);
Trace.Assert(pTasks[i].mfxBS.Data != IntPtr.Zero);
}
// GCHandle gch3 = GCHandle.Alloc(pTasks, GCHandleType.Pinned);
}
public static extern mfxStatus MFXVideoCORE_SetHandle(mfxSession session, mfxHandleType type, IntPtr hdl);
/// <summary>Initializes a new instance of the <see cref="LowLevelEncoderCSharp"/> class.</summary>
/// <param name="mfxEncParams">The encoder parameters.</param>
/// <param name="impl">The implementation.</param>
public LowLevelEncoderCSharp(mfxVideoParam mfxEncParams, mfxIMPL impl = mfxIMPL.MFX_IMPL_AUTO)
{
mfxStatus sts;
session = new mfxSession();
var ver = new mfxVersion()
{
Major = 1, Minor = 3
};
fixed(mfxSession *s = &session)
sts = UnsafeNativeMethods.MFXInit(impl, &ver, s);
QuickSyncStatic.ThrowOnBadStatus(sts, "MFXInit");
//deviceSetup = new DeviceSetup(session, false);
sts = UnsafeNativeMethods.MFXVideoENCODE_Query(session, &mfxEncParams, &mfxEncParams);
if (sts > 0)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoENCODE_Query), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "encodequery");
mfxFrameAllocRequest EncRequest;
sts = UnsafeNativeMethods.MFXVideoENCODE_QueryIOSurf(session, &mfxEncParams, &EncRequest);
QuickSyncStatic.ThrowOnBadStatus(sts, "queryiosurf");
EncRequest.NumFrameSuggested = (ushort)(EncRequest.NumFrameSuggested + mfxEncParams.AsyncDepth);
EncRequest.Type |= (FrameMemoryType)0x2000; // WILL_WRITE; // This line is only required for Windows DirectX11 to ensure that surfaces can be written to by the application
UInt16 numSurfaces = EncRequest.NumFrameSuggested;
// - Width and height of buffer must be aligned, a multiple of 32
// - Frame surface array keeps pointers all surface planes and general frame info
UInt16 width = (UInt16)QuickSyncStatic.ALIGN32(mfxEncParams.mfx.FrameInfo.Width);
UInt16 height = (UInt16)QuickSyncStatic.ALIGN32(mfxEncParams.mfx.FrameInfo.Height);
int bitsPerPixel = VideoUtility.GetBitsPerPixel(mfxEncParams.mfx.FrameInfo.FourCC);
int surfaceSize = width * height * bitsPerPixel / 8;
//byte[] surftaceBuffers = new byte[surfaceSize * numSurfaces]; //XXX
IntPtr surfaceBuffers = Marshal.AllocHGlobal(surfaceSize * numSurfaces);
byte * surfaceBuffersPtr = (byte *)surfaceBuffers;
// // Allocate surface headers (mfxFrameSurface1) for decoder
Frames = new mfxFrameSurface1[numSurfaces];
//MSDK_CHECK_POINTER(pmfxSurfaces, MFX_ERR_MEMORY_ALLOC);
for (int i = 0; i < numSurfaces; i++)
{
Frames[i] = new mfxFrameSurface1();
Frames[i].Info = mfxEncParams.mfx.FrameInfo;
switch (mfxEncParams.mfx.FrameInfo.FourCC)
{
case FourCC.NV12:
Frames[i].Data.Y_ptr = (byte *)surfaceBuffers + i * surfaceSize;
Frames[i].Data.U_ptr = Frames[i].Data.Y_ptr + width * height;
Frames[i].Data.V_ptr = Frames[i].Data.U_ptr + 1;
Frames[i].Data.Pitch = width;
break;
case FourCC.YUY2:
Frames[i].Data.Y_ptr = (byte *)surfaceBuffers + i * surfaceSize;
Frames[i].Data.U_ptr = Frames[i].Data.Y_ptr + 1;
Frames[i].Data.V_ptr = Frames[i].Data.U_ptr + 3;
Frames[i].Data.Pitch = (ushort)(width * 2);
break;
default: //find sysmem_allocator.cpp for more help
throw new NotImplementedException();
}
}
frameIntPtrs = new IntPtr[Frames.Length];
for (int i = 0; i < Frames.Length; i++)
{
fixed(mfxFrameSurface1 *a = &Frames[i])
frameIntPtrs[i] = (IntPtr)a;
}
sts = UnsafeNativeMethods.MFXVideoENCODE_Init(session, &mfxEncParams);
if (sts > 0)
{
warnings.Add(nameof(UnsafeNativeMethods.MFXVideoENCODE_Init), sts);
sts = 0;
}
QuickSyncStatic.ThrowOnBadStatus(sts, "encodeinit");
mfxVideoParam par;
UnsafeNativeMethods.MFXVideoENCODE_GetVideoParam(session, &par);
QuickSyncStatic.ThrowOnBadStatus(sts, "encodegetvideoparam");
// from mediasdkjpeg-man.pdf
// BufferSizeInKB = 4 + (Width * Height * BytesPerPx + 1023) / 1024;
//where Width and Height are weight and height of the picture in pixel, BytesPerPx is number of
//byte for one pixel.It equals to 1 for monochrome picture, 1.5 for NV12 and YV12 color formats,
// 2 for YUY2 color format, and 3 for RGB32 color format(alpha channel is not encoded).
if (par.mfx.BufferSizeInKB == 0 && mfxEncParams.mfx.CodecId == CodecId.MFX_CODEC_JPEG)
{
par.mfx.BufferSizeInKB = (ushort)((4 + (mfxEncParams.mfx.FrameInfo.CropW * mfxEncParams.mfx.FrameInfo.CropH * 3 + 1023)) / 1000);
}
//printf("bufsize %d\n", par.mfx.BufferSizeInKB);
// Create task pool to improve asynchronous performance (greater GPU utilization)
int taskPoolSize = mfxEncParams.AsyncDepth; // number of tasks that can be submitted, before synchronizing is required
//Task* pTasks = stackalloc Task[taskPoolSize];
// GCHandle gch3 = GCHandle.Alloc(pTasks, GCHandleType.Pinned);
pTasks = new Task[taskPoolSize];
for (int i = 0; i < taskPoolSize; i++)
{
// Prepare Media SDK bit stream buffer
pTasks[i].mfxBS.MaxLength = (uint)(par.mfx.BufferSizeInKB * 1000);
pTasks[i].mfxBS.Data = Marshal.AllocHGlobal((int)pTasks[i].mfxBS.MaxLength);
Trace.Assert(pTasks[i].mfxBS.Data != IntPtr.Zero);
}
pinningHandles.Add(GCHandle.Alloc(pTasks, GCHandleType.Pinned));
pinningHandles.Add(GCHandle.Alloc(Frames, GCHandleType.Pinned));
}
public static extern mfxStatus NativeDecoder_Init(IntPtr handle, mfxSession session, mfxVideoParam *mfxDecParamsX,
mfxVideoParam *VPPParamsX);
