/// <summary>
/// Rounds height upto value divisible by 16,
/// or 32 in the case where picstruct is MFX_PICSTRUCT_PROGRESSIVE
/// </summary>
/// <param name="height"></param>
/// <param name="picstruct">Used to decide 16 or 32 for rounding up</param>
/// <returns></returns>
public static ushort AlignHeightTo32or16(int height, PicStruct picstruct)
{
ushort v =
(PicStruct.MFX_PICSTRUCT_PROGRESSIVE == picstruct) ?
(ushort)QuickSyncStatic.ALIGN16(height) :
(ushort)QuickSyncStatic.ALIGN32(height);
return(v);
}
/// <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));
}
/// <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");
}
}
/// <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);
}