static int Main()
{
if (GetCommandLine())
{
// load the multimedia API
MM_LOAD load = new MM_LOAD();
if (MMHelper.MMLoad(ref load, Environment.CurrentDirectory))
{
MMHelper.InitClientParms(1, _parmsDecode);
_parmsDecode.Open.UserName = "";
_parmsDecode.Open.PassWord = "";
string basicAuth = CommandLine._url;
if (!string.IsNullOrEmpty(_parmsDecode.Open.UserName))
{
var index = CommandLine._url.IndexOf("://");
if (index != -1)
{
basicAuth = basicAuth.Insert(index + 3, _parmsDecode.Open.UserName + ":" + _parmsDecode.Open.PassWord + "@");
}
}
// account for UTF8 encoded data
int len = Encoding.UTF8.GetByteCount(basicAuth);
byte[] utf8Bytes = new byte[len + 1];
Encoding.UTF8.GetBytes(basicAuth, 0, basicAuth.Length, utf8Bytes, 0);
IntPtr nativeUtf8 = Marshal.AllocHGlobal(utf8Bytes.Length);
Marshal.Copy(utf8Bytes, 0, nativeUtf8, utf8Bytes.Length);
_parmsDecode.Open.OpenParms.PURL = nativeUtf8;
_parmsDecode.Open.OpenParms.BNetTCP = 1;
_parmsDecode.Open.OpenParms.PDataCBKFN = _dataCBKFN;
_parmsDecode.Open.OpenParms.PStatusCBKFN = _statusCBKFN;
_parmsDecode.Open.OpenParms.OpenFlags = MM_CLIENT_REQUEST.MM_CLIENT_REQUEST_VIDEO_SOURCE |
MM_CLIENT_REQUEST.MM_CLIENT_REQUEST_VIDEO_DECODED;
_sts = mmMethods.mmClientOpen(out _hSession, ref _parmsDecode.Open.OpenParms);
if (_sts == mmStatus.MM_STS_NONE)
{
_sts = mmMethods.mmClientPlay(_hSession, ref _parmsDecode.Play.PlayParms);
if (_sts == mmStatus.MM_STS_NONE)
{
do
{
System.Threading.Thread.Sleep(1000);
} while (_play);
}
mmMethods.mmClose(_hSession);
}
Marshal.FreeHGlobal(_parmsDecode.Open.OpenParms.PURL);
mmMethods.mmRelease(load.HInterface);
}
if (_sts != mmStatus.MM_STS_NONE)
{
Console.WriteLine($"ERROR - Status 0x{_sts:X}");
}
}
return((int)_sts);
}
public static bool MMLoad(ref MM_LOAD load, string baseDirectory)
{
string mmLibPath = GetMultiMediaPath(baseDirectory);
if (!string.IsNullOrEmpty(mmLibPath))
{
try
{
if (!MMInterop.SetDllDirectory(mmLibPath))
{
Exception e = new System.ComponentModel.Win32Exception();
throw new DllNotFoundException("Error, Unable to load library: " + mmLibPath, e);
}
else
{
load.Size = (uint)Marshal.SizeOf(typeof(MM_LOAD));
mmStatus sts = mmMethods.mmLoad(ref load);
if (sts == mmStatus.MM_STS_NONE)
{
return(true);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
Console.WriteLine($"Error, failed to Load mmAPI from {baseDirectory}");
return(false);
}
private void executeTask(MM_TASK task)
{
mmStatus sts = mmStatus.MM_STS_NONE;
switch (task._item)
{
case MM_TASK_ITEM.MM_STOP:
_run = false;
goto case MM_TASK_ITEM.MM_CLOSE;
case MM_TASK_ITEM.MM_CLOSE:
sts = closeSession(task._dictKey, task._lpData);
_state = MM_TASK_ITEM.MM_CLOSE;
break;
case MM_TASK_ITEM.MM_OPEN:
sts = openSesssion(task._dictKey, task._lpData);
_state = MM_TASK_ITEM.MM_OPEN;
break;
case MM_TASK_ITEM.MM_PLAY:
sts = playSesssion(task._dictKey, task._lpData);
_state = MM_TASK_ITEM.MM_PLAY;
break;
case MM_TASK_ITEM.MM_PAUSE:
sts = pauseSesssion(task._dictKey, task._lpData);
_state = MM_TASK_ITEM.MM_PAUSE;
break;
case MM_TASK_ITEM.MM_DICT:
sts = dictSession(task._dictKey, task._lpData);
break;
default:
Debug.Assert(false);
break;
}
}
public static mmStatus mmDictionarySet(IntPtr hSession, mmSessionDictionaryKeys key, IntPtr pValue)
{
IntPtr pKey = Marshal.StringToHGlobalAnsi(key.ToString());
mmStatus sts = NativeMethods.mmDictionarySet(hSession, pKey, pValue);
Marshal.FreeHGlobal(pKey);
return(sts);
}
private mmStatus closeSession(mmSessionDictionaryKeys flags, IntPtr lpData)
{
mmStatus sts = mmStatus.MM_STS_NONE;
if (_hSession == IntPtr.Zero)
sts = mmStatus.MM_STS_LIB_ERROR_INVALID_STATE;
else
{
sts = mmMethods.mmClose(_hSession);
_hSession = IntPtr.Zero;
}
return sts;
}
public static bool MMLoad(ref MM_LOAD load, string baseDirectory)
{
string mmLibPath = GetMultiMediaPath(baseDirectory);
if (!string.IsNullOrEmpty(mmLibPath))
{
try
{
if (!MMInterop.SetDllDirectory(mmLibPath))
{
Exception e = new System.ComponentModel.Win32Exception();
throw new DllNotFoundException("Error, Unable to load library: " + mmLibPath, e);
}
else
{
load.Size = (uint)Marshal.SizeOf(typeof(MM_LOAD));
mmStatus sts = mmMethods.mmLoad(ref load);
if (sts == mmStatus.MM_STS_NONE)
{
bool activated = false;
if ((load.OutFlags & MM_LOAD_CONTEXT.MM_LOAD_CONTEXT_ACTIVATED) == MM_LOAD_CONTEXT.MM_LOAD_CONTEXT_ACTIVATED)
{
activated = true;
}
String loadString = String.Format("mmAPI v{0}.{1}.{2} activated={3} flags={4}",
load.Version.Major.ToString().PadLeft(2, '0'), load.Version.Minor.ToString().PadLeft(2, '0'), load.Version.Micro.ToString().PadLeft(2, '0'),
activated, load.OutFlags);
Console.WriteLine(loadString);
return(true);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
Console.WriteLine($"Error, failed to Load mmAPI from {baseDirectory}");
return(false);
}
public static bool MMLoadEx(ref MM_LOAD load, string path)
{
try
{
if (MMInterop.SetDllDirectory(path))
{
load.Size = (uint)Marshal.SizeOf(typeof(MM_LOAD));
mmStatus sts = mmMethods.mmLoad(ref load);
if (sts == mmStatus.MM_STS_NONE)
{
return(true);
}
}
}
catch (Exception e)
{
//Console.WriteLine(e.ToString());
}
return(false);
}
private mmStatus playSesssion(mmSessionDictionaryKeys flags, IntPtr lpData)
{
if (_hSession == IntPtr.Zero)
return mmStatus.MM_STS_LIB_ERROR_INVALID_STATE;
if (lpData != IntPtr.Zero) // else a re-connect on error case using existing params
{
_parms.Play.PlayParms = (MM_CLIENT_PLAY)Marshal.PtrToStructure(lpData, typeof(MM_CLIENT_PLAY));
if (_parms.Play.PlayParms.Size == (Marshal.SizeOf(typeof(MM_CLIENT_PLAY))))
{
_parms.Play.StartTime = MMInterop.PtrToString(lpData + Marshal.SizeOf(typeof(MM_CLIENT_PLAY)));
_parms.Play.EndTime = MMInterop.PtrToString(lpData + Marshal.SizeOf(typeof(MM_CLIENT_PLAY)) + (2 * (_parms.Play.StartTime.Length + 1)));
}
else
return mmStatus.MM_STS_SRC_ERROR_INCOMPATIBLE_API;
}
if (string.IsNullOrEmpty(_parms.Play.StartTime))
_parms.Play.PlayParms.PStartTime = IntPtr.Zero;
else
_parms.Play.PlayParms.PStartTime = (IntPtr)Marshal.StringToHGlobalAnsi(_parms.Play.StartTime);
if (string.IsNullOrEmpty(_parms.Play.EndTime))
_parms.Play.PlayParms.PEndTime = IntPtr.Zero;
else
_parms.Play.PlayParms.PEndTime = (IntPtr)Marshal.StringToHGlobalAnsi(_parms.Play.EndTime);
mmStatus sts = mmMethods.mmClientPlay(_hSession, ref _parms.Play.PlayParms);
if (_parms.Play.PlayParms.PStartTime != IntPtr.Zero)
Marshal.FreeHGlobal(_parms.Play.PlayParms.PStartTime);
if (_parms.Play.PlayParms.PEndTime != IntPtr.Zero)
Marshal.FreeHGlobal(_parms.Play.PlayParms.PEndTime);
return sts; // any play error makes its way back via the callback
}
private static mmStatus DataCallbackFN(IntPtr hSession, IntPtr pMediaSample, IntPtr pUserData)
{
try
{
MM_DATA mediaSample = (MM_DATA)Marshal.PtrToStructure(pMediaSample, typeof(MM_DATA));
// ignore uncompressed frames and corrupt compressed frames
if (((mediaSample.ContextFlag & (uint)MM_DATA_CONTEXT.MM_DATA_CONTEXT_UNCOMPRESSED_VIDEO) == 0) ||
((mediaSample.ContextFlag & (uint)MM_DATA_CONTEXT.MM_DATA_CONTEXT_UNCOMPRESSED_VIDEO_CORRUPTION) == (uint)MM_DATA_CONTEXT.MM_DATA_CONTEXT_UNCOMPRESSED_VIDEO_CORRUPTION))
{
return(mmStatus.MM_STS_NONE);
}
Console.WriteLine($"MM_DATA - Session 0x{hSession:X} FourCC {mediaSample.FourCC}");
_samples++;
if (_samples % CommandLine._interval != 0)
{
return(mmStatus.MM_STS_NONE);
}
_sampled++;
if (_sampled > CommandLine._count)
{
_play = false;
return(mmStatus.MM_STS_NONE);
}
uint managedSize = mediaSample.Width * mediaSample.Height * 3 / 2;
byte[] managed = new byte[managedSize];
int dIndex = 0;
int sIndex = 0;
if ((MAKEFOURCC('n', 'v', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('N', 'V', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('n', 'v', '2', '1') == mediaSample.FourCC) ||
(MAKEFOURCC('N', 'V', '2', '1') == mediaSample.FourCC))
{
for (uint y = 0; y < mediaSample.Height; y++) // y plane
{
Marshal.Copy(mediaSample.PData[0] + sIndex, managed, dIndex, (int)mediaSample.Width);
dIndex += (int)mediaSample.Width;
sIndex += (int)mediaSample.Pitch[0];
}
sIndex = 0;
for (uint y = 0; y < mediaSample.Height / 2; y++) // uv plane (interleaved)
{
Marshal.Copy(mediaSample.PData[1] + sIndex, managed, dIndex, (int)mediaSample.Width);
dIndex += (int)mediaSample.Width;
sIndex += (int)mediaSample.Pitch[1];
}
}
else if ((MAKEFOURCC('y', 'v', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('Y', 'V', '1', '2') == mediaSample.FourCC))
{
for (uint y = 0; y < mediaSample.Height; y++) // y plane
{
Marshal.Copy(mediaSample.PData[0] + sIndex, managed, dIndex, (int)mediaSample.Width);
dIndex += (int)mediaSample.Width;
sIndex += (int)mediaSample.Pitch[0];
}
sIndex = 0;
for (uint y = 0; y < mediaSample.Height / 2; y++) // v plane
{
Marshal.Copy(mediaSample.PData[2] + sIndex, managed, dIndex, (int)mediaSample.Width / 2);
dIndex += (int)mediaSample.Width / 2;
sIndex += (int)mediaSample.Pitch[2];
}
sIndex = 0;
for (uint y = 0; y < mediaSample.Height / 2; y++) // u plane
{
Marshal.Copy(mediaSample.PData[1] + sIndex, managed, dIndex, (int)mediaSample.Width / 2);
dIndex += (int)mediaSample.Width / 2;
sIndex += (int)mediaSample.Pitch[1];
}
}
else if ((MAKEFOURCC('i', '4', '2', '0') == mediaSample.FourCC) ||
(MAKEFOURCC('I', '4', '2', '0') == mediaSample.FourCC) ||
(MAKEFOURCC('i', 'y', 'u', 'v') == mediaSample.FourCC) ||
(MAKEFOURCC('I', 'Y', 'U', 'V') == mediaSample.FourCC))
{
for (uint y = 0; y < mediaSample.Height; y++) // y plane
{
Marshal.Copy(mediaSample.PData[0] + sIndex, managed, dIndex, (int)mediaSample.Width);
dIndex += (int)mediaSample.Width;
sIndex += (int)mediaSample.Pitch[0];
}
sIndex = 0;
for (uint y = 0; y < mediaSample.Height / 2; y++) // u plane
{
Marshal.Copy(mediaSample.PData[1] + sIndex, managed, dIndex, (int)mediaSample.Width / 2);
dIndex += (int)mediaSample.Width / 2;
sIndex += (int)mediaSample.Pitch[1];
}
sIndex = 0;
for (uint y = 0; y < mediaSample.Height / 2; y++) // v plane
{
Marshal.Copy(mediaSample.PData[2] + sIndex, managed, dIndex, (int)mediaSample.Width / 2);
dIndex += (int)mediaSample.Width / 2;
sIndex += (int)mediaSample.Pitch[2];
}
}
else
{
_sts = mmStatus.MM_STS_SRC_ERROR_INVALID_DATA;
Console.WriteLine($"MM_DATA - Session 0x{hSession:X} {mediaSample.FourCC} Not Processed");
_play = false;
}
#if USING_OPEN_CV
ColorConversionCodes cs;
if ((MAKEFOURCC('n', 'v', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('N', 'V', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('n', 'v', '2', '1') == mediaSample.FourCC) ||
(MAKEFOURCC('N', 'V', '2', '1') == mediaSample.FourCC))
{
cs = ColorConversionCodes.YUV2BGR_NV12;
}
else if ((MAKEFOURCC('y', 'v', '1', '2') == mediaSample.FourCC) ||
(MAKEFOURCC('Y', 'V', '1', '2') == mediaSample.FourCC))
{
cs = ColorConversionCodes.YUV2BGR_YV12;
}
else if ((MAKEFOURCC('i', '4', '2', '0') == mediaSample.FourCC) ||
(MAKEFOURCC('I', '4', '2', '0') == mediaSample.FourCC) ||
(MAKEFOURCC('i', 'y', 'u', 'v') == mediaSample.FourCC) ||
(MAKEFOURCC('I', 'Y', 'U', 'V') == mediaSample.FourCC))
{
cs = ColorConversionCodes.YUV2BGR_I420;
}
else
{
return(mmStatus.MM_STS_NONE);
}
string samplePath = $"{CommandLine._path}_{_sampled}.bmp";
Mat picYV12 = new Mat((int)((mediaSample.Height * 3) / 2), (int)mediaSample.Width, MatType.CV_8UC1, managed);
Mat picBGR = new Mat();
Cv2.CvtColor(picYV12, picBGR, cs);
Cv2.ImWrite(samplePath, picBGR);
#endif
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
return(mmStatus.MM_STS_NONE);
}
static void Main()
{
mmStatus sts = 0;
MM_LOAD load = new MM_LOAD();
var currentDirectory = System.Environment.CurrentDirectory;
// colour theme
int argbTheme = 0x00FFFF;
int timeoutMS = 10000;
IntPtr logPath = IntPtr.Zero;
MMParameters _Parms = new MMParameters();
MMHelper.InitClientParms(1, _Parms);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
string[] args = Environment.GetCommandLineArgs();
try
{
// simple cmd line parser
Dictionary <string, string> retval = args.ToDictionary(
k => k.Split(new char[] { '=' }, 2)[0].ToLower(),
v => v.Split(new char[] { '=' }, 2).Count() > 1
? v.Split(new char[] { '=' }, 2)[1]
: null);
int tmp;
float tmpf;
foreach (var arg in retval)
{
if (arg.Key == "-url")
{
_Parms.Open.URL = arg.Value;
}
else if (arg.Key == "-user")
{
_Parms.Open.UserName = arg.Value;
}
else if (arg.Key == "-pass")
{
_Parms.Open.PassWord = arg.Value;
}
else if (arg.Key == "-x")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Window.WindowParms.Placement.Left = tmp;
}
}
else if (arg.Key == "-y")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Window.WindowParms.Placement.Top = tmp;
}
}
else if (arg.Key == "-w")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Window.WindowParms.Placement.Right = tmp;
}
}
else if (arg.Key == "-h")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Window.WindowParms.Placement.Bottom = tmp;
}
}
else if (arg.Key == "-tcp")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Open.OpenParms.BNetTCP = (uint)tmp;
}
}
else if (arg.Key == "-start_time")
{
_Parms.Play.StartTime = arg.Value;
}
else if (arg.Key == "-end_time")
{
_Parms.Play.EndTime = arg.Value;
}
else if (arg.Key == "-cache_video")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Open.OpenParms.CacheVideo = (uint)tmp;
}
}
else if (arg.Key == "-speed")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Play.PlayParms.Speed = (MM_CLIENT_SPEED)tmp;
}
}
else if (arg.Key == "-repeat")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Open.OpenParms.BRepeat = (uint)tmp;
}
}
else if (arg.Key == "-reverse")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Play.PlayParms.BReverse = (uint)tmp;
}
}
else if (arg.Key == "-borders")
{
if (int.TryParse(arg.Value, out tmp))
{
if (tmp != 0)
{
_Parms.Window.WindowParms.BorderAndTitleBar = true;
}
}
}
else if (arg.Key == "-window")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Window.WindowParms.ShowState = (SHOWSTATE)tmp;
}
}
else if (arg.Key == "-net_tcp")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Open.OpenParms.BNetTCP = (uint)tmp;
}
}
else if (arg.Key == "-aspect_ratio")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Source.SourceParms.BEnforceAR = (uint)tmp;
_Parms.Source.SourceParms.Flags |= MM_CLIENT_SOURCE_REQUEST.MM_CLIENT_SOURCE_ASPECT_RATIO;
}
}
else if (arg.Key == "-argb")
{
if (int.TryParse(arg.Value, out tmp))
{
argbTheme = tmp;
}
}
else if (arg.Key == "-timeout")
{
if (int.TryParse(arg.Value, out tmp))
{
timeoutMS = tmp;
}
}
else if (arg.Key == "-logpath")
{
// account for UTF8 encoded data
int len = Encoding.UTF8.GetByteCount(arg.Value);
byte[] utf8Bytes = new byte[len + 1];
Encoding.UTF8.GetBytes(arg.Value, 0, arg.Value.Length, utf8Bytes, 0);
load.PLogPath = Marshal.AllocHGlobal(utf8Bytes.Length);
Marshal.Copy(utf8Bytes, 0, load.PLogPath, utf8Bytes.Length);
}
else if (arg.Key == "-se")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Dewarp.DewarpParms.BSessionEnabled = (uint)tmp;
}
}
else if (arg.Key == "-pf")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Dewarp.DewarpParms.PanoFactor = (uint)tmp;
}
}
else if (arg.Key == "-fov")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.FOV = tmpf;
}
}
else if (arg.Key == "-xa")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.XAngle = tmpf;
}
}
else if (arg.Key == "-ya")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.YAngle = tmpf;
}
}
else if (arg.Key == "-xab")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.XAngleB = tmpf;
}
}
else if (arg.Key == "-hv")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Dewarp.DewarpParms.BHorViewMode = (uint)tmp;
}
}
else if (arg.Key == "-fovr")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.FOVRot = tmpf;
}
}
else if (arg.Key == "-xc")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.XCenter = tmpf;
}
}
else if (arg.Key == "-yc")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.YCenter = tmpf;
}
}
else if (arg.Key == "-ra")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.Radius = tmpf;
}
}
else if (arg.Key == "-hs")
{
if (float.TryParse(arg.Value, out tmpf))
{
_Parms.Dewarp.DewarpParms.HStretch = tmpf;
}
}
else if (arg.Key == "-zt")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Zoom.ZoomParms.Top = tmp;
}
}
else if (arg.Key == "-zl")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Zoom.ZoomParms.Left = tmp;
}
}
else if (arg.Key == "-zr")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Zoom.ZoomParms.Right = tmp;
}
}
else if (arg.Key == "-zb")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Zoom.ZoomParms.Bottom = tmp;
}
}
else if (arg.Key == "-reserved")
{
if (int.TryParse(arg.Value, out tmp))
{
_Parms.Open.Reserved = (uint)tmp;
}
}
}
if (_Parms.Open.URL == null)
{
throw new System.ArgumentException("You must provide -url=[url]");
}
}
catch
{
string msg = "usage: -url=[url] | -user[username] | -pass[password] | -x=[x] | -y=[y] | -w=[w] | -h=[h] \nExample: -url=stream:rtsp:\\\\127.0.0.1:554\\\\rsc";
Debug.WriteLine(msg);
return;
}
load.TimeoutMS = (uint)timeoutMS;
if (MMHelper.MMLoad(ref load, Environment.CurrentDirectory))
{
// Create our window
WindowParent window = new WindowParent(argbTheme);
// Specify the default call back functions found within the Window class
GCHandle _GCHandle = GCHandle.Alloc(window);
_Parms.Open.OpenParms.PStatusUserData = GCHandle.ToIntPtr(_GCHandle);
_Parms.Open.OpenParms.PStatusCBKFN = new MM_STATUS_CBKFN(StatusCallbackFN);
// Interested in..
_Parms.Open.OpenParms.OpenFlags = MM_CLIENT_REQUEST.MM_CLIENT_REQUEST_VIDEO_SOURCE | MM_CLIENT_REQUEST.MM_CLIENT_REQUEST_VIDEO_TO_DISPLAY;
// Create a synchronized interface for the window to use
MMInterface _interface = new MMInterface(_Parms, window);
window.SetInterface(_interface);
// Execute - NOTE [STAThread] above Main..
Application.Run(window);
mmMethods.mmRelease(load.HInterface);
if (_GCHandle.IsAllocated)
{
_GCHandle.Free();
}
}
else
{
string msg = "Load Failed: 0x" + sts.ToString("X");
Debug.WriteLine(msg);
}
}
private mmStatus openSesssion(mmSessionDictionaryKeys flags, IntPtr lpData)
{
if (_hSession != IntPtr.Zero)
return mmStatus.MM_STS_LIB_ERROR_INVALID_STATE;
if (lpData != IntPtr.Zero) // else a re-connect on error case using existing params
{
_parms.Open.OpenParms = (MM_CLIENT_OPEN)Marshal.PtrToStructure(lpData, typeof(MM_CLIENT_OPEN));
if (_parms.Open.OpenParms.Size == (Marshal.SizeOf(typeof(MM_CLIENT_OPEN))))
{
_parms.Open.URL = MMInterop.PtrToString(lpData + Marshal.SizeOf(typeof(MM_CLIENT_OPEN)));
_parms.Open.UserName = MMInterop.PtrToString(lpData + Marshal.SizeOf(typeof(MM_CLIENT_OPEN)) + (2 * (_parms.Open.URL.Length + 1)));
_parms.Open.PassWord = MMInterop.PtrToString(lpData + Marshal.SizeOf(typeof(MM_CLIENT_OPEN)) + (2 * ((_parms.Open.URL.Length + 1) + (_parms.Open.UserName.Length + 1))));
}
else
return mmStatus.MM_STS_SRC_ERROR_INCOMPATIBLE_API;
}
string basicAuth = _parms.Open.URL;
if( (uint)flags != 0x80000000) // playlist case
_windowParent.LockPaintSessionStatus("Opening URL: " + _parms.Open.URL);
_windowParent.LockSetSessionWindowText(_parms.Open.URL);
if (!string.IsNullOrEmpty(_parms.Open.UserName))
{
var index = _parms.Open.URL.IndexOf("://");
if (index != -1)
basicAuth = basicAuth.Insert(index + 3, _parms.Open.UserName + ":" + _parms.Open.PassWord + "@");
}
_parms.Open.OpenParms.HWnd = _windowParent.GetHWND();
// account for UTF8 encoded data
int len = Encoding.UTF8.GetByteCount(basicAuth);
byte[] utf8Bytes = new byte[len + 1];
Encoding.UTF8.GetBytes(basicAuth, 0, basicAuth.Length, utf8Bytes, 0);
_parms.Open.OpenParms.PURL = Marshal.AllocHGlobal(utf8Bytes.Length);
Marshal.Copy(utf8Bytes, 0, _parms.Open.OpenParms.PURL, utf8Bytes.Length);
if (_parms.Open.Reserved != 0)
{
_parms.Open.OpenParms.PReserved = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)));
Marshal.WriteInt32(_parms.Open.OpenParms.PReserved, 0, ((int)_parms.Open.Reserved));
}
else
_parms.Open.OpenParms.PReserved = IntPtr.Zero;
mmStatus sts = mmMethods.mmClientOpen(out _hSession, ref _parms.Open.OpenParms);
if (sts != mmStatus.MM_STS_NONE)
{
_windowParent.LockPaintSessionStatus($"STATUS 0x{sts:X} Opening URL: " + _parms.Open.URL);
_windowParent._watchDog.Enabled = true;
// start a fresh
_parms.Play.StartTime = null;
_parms.Play.EndTime = null;
}
else
_windowParent.LockPaintSessionStatus("");
if (_parms.Open.OpenParms.PReserved != IntPtr.Zero)
Marshal.FreeHGlobal(_parms.Open.OpenParms.PReserved);
Marshal.FreeHGlobal(_parms.Open.OpenParms.PURL);
return sts;
}
private mmStatus dictSession(mmSessionDictionaryKeys flags, IntPtr lpData)
{
mmStatus sts = mmStatus.MM_STS_NONE;
if (_hSession == IntPtr.Zero)
return mmStatus.MM_STS_LIB_ERROR_INVALID_STATE;
try
{
// use either local structure (startup) or lpData from synchronized SendMessage
switch ((mmSessionDictionaryKeys)flags)
{
case mmSessionDictionaryKeys.CLI_DEWARP:
if (lpData != IntPtr.Zero)
_parms.Dewarp.DewarpParms = (MM_CLIENT_DEWARP)Marshal.PtrToStructure(lpData, typeof(MM_CLIENT_DEWARP));
else
{
lpData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MM_CLIENT_DEWARP)));
Marshal.StructureToPtr(_parms.Dewarp.DewarpParms, lpData, false);
}
break;
case mmSessionDictionaryKeys.CLI_SOURCE:
if (lpData != IntPtr.Zero)
{
MM_CLIENT_SOURCE source = (MM_CLIENT_SOURCE)Marshal.PtrToStructure(lpData, typeof(MM_CLIENT_SOURCE));
if ((source.Size == (uint)Marshal.SizeOf(typeof(MM_CLIENT_SOURCE))))
{
if ((source.Flags & MM_CLIENT_SOURCE_REQUEST.MM_CLIENT_SOURCE_RENDER) == MM_CLIENT_SOURCE_REQUEST.MM_CLIENT_SOURCE_RENDER)
_parms.Source.SourceParms.BRender = source.BRender;
if ((source.Flags & MM_CLIENT_SOURCE_REQUEST.MM_CLIENT_SOURCE_ASPECT_RATIO) == MM_CLIENT_SOURCE_REQUEST.MM_CLIENT_SOURCE_ASPECT_RATIO)
_parms.Source.SourceParms.BEnforceAR = source.BEnforceAR;
_parms.Source.SourceParms.Flags |= source.Flags;
}
else
return mmStatus.MM_STS_SRC_ERROR_INCOMPATIBLE_API;
}
else
{
lpData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MM_CLIENT_SOURCE)));
Marshal.StructureToPtr(_parms.Source.SourceParms, lpData, false);
}
break;
case mmSessionDictionaryKeys.CLI_ZOOM:
if (lpData != IntPtr.Zero)
_parms.Zoom.ZoomParms = (MM_RECT)Marshal.PtrToStructure(lpData, typeof(MM_RECT));
else
{
lpData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MM_RECT)));
Marshal.StructureToPtr(_parms.Zoom.ZoomParms, lpData, false);
}
break;
case mmSessionDictionaryKeys.CLI_CHILD:
if (lpData == IntPtr.Zero)
Debug.Assert(false);
break;
case mmSessionDictionaryKeys.CLI_RESET:
break;
default:
break;
}
sts = mmMethods.mmDictionarySet(_hSession, (mmSessionDictionaryKeys)flags, lpData);
}
catch { Debug.Assert(false); }
return sts;
}
