public VideoFrame(DateTime timeStamp, byte[] rawData, Resolution resolution, FrameFormat frameFormat)
{
RawData = rawData;
FrameFormat = frameFormat;
TimeStamp = timeStamp;
Resolution = new Resolution(resolution);
}
private void buttonSendDNFUCode_Click(object sender, EventArgs e)
{
buttonSendDNFUCode.Enabled = false;
FrameFormat frameFormat = new FrameFormat();
frameFormat.Command = (ushort)FrameCmd.FRAME_WRITE_MAKER_CODE;
frameFormat.MessageType = (byte)MessageType_e.REQUEST;
frameFormat.DataLength = (byte)sizeof(UInt32);
UInt32 DNFUCode = Convert.ToUInt32("0x" + maskedTextBoxDNFUCode.Text, 16);
byte[] bytesDNFUCode = BitConverter.GetBytes(DNFUCode);
if (BitConverter.IsLittleEndian == true)
{
bytesDNFUCode = (byte[])bytesDNFUCode.Reverse().ToArray();
}
for (int i = 0; i < frameFormat.DataLength; i++)
{
frameFormat.OptionalData[i] = bytesDNFUCode[i];
}
serialManager.SendCommand(uART_MsgComposer.GetBytesStream(frameFormat));
Thread thread1 = new Thread(WaitDNFUSet);
thread1.Start();
}
public StreamControl GetStreamControlFormatSize(FrameFormat format, int width, int height, int fps)
{
StreamControl control;
GetStreamControlFormatSize(format, width, height, fps, out control);
return(control);
}
private static Format ConvertToD3D(FrameFormat format)
{
switch (format)
{
case FrameFormat.YV12:
return(D3DFormatYV12);
case FrameFormat.NV12:
return(D3DFormatNV12);
case FrameFormat.YUY2:
return(Format.Yuy2);
case FrameFormat.UYVY:
return(Format.Uyvy);
case FrameFormat.RGB15:
return(Format.X1R5G5B5);
case FrameFormat.RGB16:
return(Format.R5G6B5);
case FrameFormat.RGB32:
return(Format.X8R8G8B8);
case FrameFormat.ARGB32:
return(Format.A8R8G8B8);
case FrameFormat.RGB24:
return(Format.R8G8B8);
default:
throw new ArgumentException("Unknown pixel format", "format");
}
}
private static PixelAlignmentType ConvertToPixelFormat(FrameFormat format)
{
switch (format)
{
case FrameFormat.YV12:
return(PixelAlignmentType.YV12);
case FrameFormat.NV12:
return(PixelAlignmentType.NV12);
case FrameFormat.YUY2:
return(PixelAlignmentType.YUY2);
case FrameFormat.UYVY:
return(PixelAlignmentType.UYVY);
case FrameFormat.RGB32:
return(PixelAlignmentType.BGRA);
case FrameFormat.ARGB32:
return(PixelAlignmentType.ABGR);
case FrameFormat.RGB24:
return(PixelAlignmentType.RGB24);
case FrameFormat.RGB15:
case FrameFormat.RGB16:
default:
return(PixelAlignmentType.NotSupported);
}
}
public async Task InitializeAsync()
{
var callStatus = await _callChannel.GetCallStatusAsync();
if (callStatus != null)
{
await CallStatusUpdate(callStatus);
}
if (CallState != CallState.Idle)
{
FrameFormat localFrameFormat = await _callChannel.GetFrameFormatAsync(true);
if (localFrameFormat != null)
{
OnFrameFormatUpdate(localFrameFormat);
}
FrameFormat remoteFrameFormat = await _callChannel.GetFrameFormatAsync(false);
if (remoteFrameFormat != null)
{
OnFrameFormatUpdate(remoteFrameFormat);
}
}
// Get stored relay messages
OnRelayMessagesUpdated();
_cameras = await _settingsChannel.GetVideoCaptureDevicesAsync();
}
// 解析 帧类型和数据项类型
public static string GetFrameTypeAndDataType(FrameFormat frame)
{
string type = "无法识别";
foreach (CmdExplain cmd in FrameExplainTbl)
{
if (cmd.Cmd == (byte)frame.CtrlWord.CmdType)
{
type = cmd.CmdName;
if (frame.CtrlWord.IsAckFrame)
{
type += "-应答";
}
if (frame.CtrlWord.CmdType == CommandType.ReadData ||
frame.CtrlWord.CmdType == CommandType.WriteData
)
{
type += " [" + GetDataType(frame) + "]";
}
}
}
return(type);
}
private void OnFrameFormatUpdate(FrameFormat obj)
{
if (CallState == CallState.Idle)
{
return;
}
#if WIN10
if (obj.ForegroundProcessId != ChatterBoxClient.Universal.BackgroundRenderer.Renderer.GetProcessId())
{
// Ignore this update because it's for an old foreground process
return;
}
#endif
if (obj.IsLocal)
{
#if WIN10
// Only Windows 10 client uses SwapChainPanel for rendering the video
LocalSwapChainPanelHandle = obj.SwapChainHandle;
#endif
LocalNativeVideoSize = new Size(obj.Width, obj.Height);
}
else
{
#if WIN10
// Only Windows 10 client uses SwapChainPanel for rendering the video
RemoteSwapChainPanelHandle = obj.SwapChainHandle;
#endif
RemoteNativeVideoSize = new Size(obj.Width, obj.Height);
}
}
public void OnUpdateFrameFormat(FrameFormat frameFormat)
{
if (_foregroundChannel == null)
{
_foregroundChannel = _container.Resolve<IForegroundChannel>();
}
_foregroundChannel.OnUpdateFrameFormat(frameFormat);
}
/// <summary>
/// Создаёт объект CAN-порта конкретного типа на основе
/// строки с параметрами CAN-порта и возвращает инферфейс
/// </summary>
/// <param name="configPort">Описатель порта, полученный при
/// вызове метода ToString() конкретного класса порта</param>
/// <returns></returns>
public static ICanPort Create(string configPort)
{
string[] pair;
Dictionary <string, string> settings = new Dictionary <string, string>();
// Получаем из строки пары: [параметр:значение]
string[] parameters = configPort.Split(';');
// Преобразуем пары в словарь
foreach (string param in parameters)
{
pair = param.Split(':');
if (pair.Length != 2)
{
throw new InvalidCastException();
}
settings.Add(pair[0].Trim(), pair[1].Trim());
}
// Проверяем наличие всех необходимых ключей
if (!(settings.ContainsKey("Manufacturer") && settings.ContainsKey("HardwareType") &&
settings.ContainsKey("PortName") && settings.ContainsKey("BitRate") &&
settings.ContainsKey("Mode") && settings.ContainsKey("FrameFormat")))
{
throw new InvalidCastException();
}
BaudRate bitRate = (BaudRate)Enum.Parse(typeof(BaudRate), settings["BitRate"]);
FrameFormat frameFormat = (FrameFormat)Enum.Parse(typeof(FrameFormat), settings["FrameFormat"]);
PortMode mode = (PortMode)Enum.Parse(typeof(PortMode), settings["Mode"]);
// На основе полученных данных строим объект порта
switch (settings["Manufacturer"].ToUpper())
{
case "FASTWEL":
{
switch (settings["HardwareType"].ToUpper())
{
case "NIM-351":
{
return((ICanPort) new Fastwel.NIM351.CanPort(settings["PortName"],
bitRate, frameFormat, mode));
}
default:
{ throw new NotSupportedException(""); }
}
//break;
}
case "IXXAT":
{
return((ICanPort) new IXXAT.CanPort(settings["PortName"],
bitRate, frameFormat, mode));
}
default:
{ throw new NotSupportedException(""); }
}
}
private void SendInternal(string title, byte[] contentBytes, byte stateCode, int messageId, TcpSendMode sendMode)
{
if (_state != 1)
{
throw new Exception();
}
if (title == null)
{
title = string.Empty;
}
if (title.Length >= 65535)
{
throw new Exception();
}
if (contentBytes == null)
{
contentBytes = FrameFormat.EmptyBytes;
}
var titleBytes = FrameFormat.GetTitleBytes(title);
var messageByteCount = FrameFormat.ComputeFrameByteCount(titleBytes, contentBytes);
var sendBuffer = GetSendBuffer(messageByteCount);
FrameFormat.FillFrameHeader(sendBuffer, titleBytes, contentBytes, stateCode, messageId);
if (title.Length + contentBytes.Length > 0)
{
FrameFormat.FillFrameBody(sendBuffer, titleBytes, contentBytes);
}
if (sendMode == TcpSendMode.Async)
{
try
{
_socket.BeginSend(sendBuffer, 0, messageByteCount, SocketFlags.None, SendCallback, this);
}
catch
{
Close();
throw;
}
}
else
{
try
{
_socket.Send(sendBuffer, messageByteCount, SocketFlags.None);
}
catch
{
Close();
throw;
}
}
}
//-----------------------------------------------------------------------------------------
/// <summary>
/// Строит и возвращает структуру режима работы порта NIM351
/// </summary>
/// <param name="mode">Режим работы порта</param>
/// <param name="frameFormat">Формат кадра</param>
/// <param name="errorFrameEnable">Разрешает/запрещает передачу информационных сообщений</param>
/// <returns></returns>
public static CAN_OPMODE OpModeBuilder(PortMode mode,
FrameFormat frameFormat, Boolean errorFrameEnable)
{
CAN_OPMODE result;
String msg;
result = CAN_OPMODE.CAN_OPMODE_INIT;
switch (mode)
{
case PortMode.NORMAL:
{ break; }
case PortMode.LISTEN_ONLY:
{ result |= CAN_OPMODE.CAN_OPMODE_LSTNONLY; break; }
case PortMode.SELFTEST:
{ result |= CAN_OPMODE.CAN_OPMODE_SELFTEST; break; }
case PortMode.SELFRECV:
{ result |= CAN_OPMODE.CAN_OPMODE_SELFRECV; break; }
default:
{
msg = String.Format(Properties.ErrorMessages.NotSupportedValue, mode);
throw new InvalidCastException(msg);
}
}
switch (frameFormat)
{
case FrameFormat.StandardFrame:
{ result |= CAN_OPMODE.CAN_OPMODE_STANDARD; break; }
case FrameFormat.ExtendedFrame:
{ result |= CAN_OPMODE.CAN_OPMODE_EXTENDED; break; }
case FrameFormat.MixedFrame:
{ result |= (CAN_OPMODE.CAN_OPMODE_STANDARD | CAN_OPMODE.CAN_OPMODE_EXTENDED); break; }
default:
{
msg = String.Format(Properties.ErrorMessages.NotSupportedValue, frameFormat);
throw new InvalidCastException(msg);
}
}
if (errorFrameEnable)
{
result |= CAN_OPMODE.CAN_OPMODE_ERRFRAME;
}
return(result);
}
protected override void SerializeToStream(CitpBinaryWriter writer)
{
base.SerializeToStream(writer);
writer.Write(SourceIdentifier);
writer.Write(FrameFormat.GetCustomAttribute <CitpId>().Id);
writer.Write(FrameWidth);
writer.Write(FrameHeight);
writer.Write(Fps);
writer.Write(Timeout);
}
//private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
//{
// try
// {
// var message = serialPort.ReadTo("~") + "~";
// Debug.WriteLine(message);
// logger.Trace("Received : {0}", message);
// incommingQueue.Add(message);
// }
// catch (TimeoutException ex)
// {
// Debug.WriteLine(ex.Message);
// logger.Warn(ex, "Time out exeption");
// }
// catch (IOException ex)
// {
// Debug.WriteLine(ex.Message);
// logger.Error(ex, "IO Expetion");
// }
//}
public void HandleParsing(string message)
{
try
{
string syncedMessage = SyncMessage(message);
Debug.WriteLine("Synced msg = " + syncedMessage);
if (string.IsNullOrWhiteSpace(syncedMessage))
{
logger.Info("no synced message ");
return;
}
FrameFormat frame = GenericParser.GenericParser.Parse <FrameFormat>(syncedMessage);
if (null == frame)
{
return;
}
var subStr = syncedMessage.TrimStart(new char[] { FrameFormat.SOI }).TrimEnd(new char[] { FrameFormat.EOI });
subStr = subStr.Substring(0, subStr.Length - 2);
var CRCResultStr = FrameFormat.CalculateCRC(subStr);
byte CalculatedCRC = byte.Parse(CRCResultStr, System.Globalization.NumberStyles.HexNumber);
if (CalculatedCRC != frame.CRC)
{
logger.Error("CRC not compatible, original message = " + message);
return;
}
logger.Trace(frame.ToStringWithAtt <ParserDefinitionAttribute>());
switch (frame.Version)
{
case (byte)GenericParser.Version.Version82:
ParseCommand(frame);
break;
default:
break;
}
}
catch (Exception ex)
{
//evAgg.PublishOnUIThread(new MessageBoxMessage() { Title = "Error", Message = ex.Message });
//MessageBox.Show(this, ex.Message, "Error");
logger.Error(ex, "Error parsing incomming message");
}
}
public static ImageFormat AsImageFormat(this FrameFormat frameFormat)
{
return(frameFormat switch
{
FrameFormat.Bmp => ImageFormat.Bmp,
FrameFormat.Gif => ImageFormat.Gif,
FrameFormat.Jpeg => ImageFormat.Jpeg,
FrameFormat.Png => ImageFormat.Png,
FrameFormat.Rgba => throw new NotSupportedException($"Unexpected '{frameFormat}' frame format specified."),
FrameFormat.Unspecified => throw new NotSupportedException($"Unexpected '{frameFormat}' frame format specified."),
_ => throw new NotSupportedException($"'{frameFormat}' frame format is not currently supported.")
});
public void SetupSurface(int width, int height, FrameFormat format)
{
if (!this.Dispatcher.CheckAccess())
{
this.Dispatcher.Invoke((Action)(() => this.SetupSurface(width, height, format)));
return;
}
this.CreateRenderer();
this.render.SetupSurface(width, height, format);
this.image.Source = this.render.ImageSource;
}
public void SetupSurface(int width, int height, FrameFormat format)
{
if (!this.Dispatcher.CheckAccess())
{
this.Dispatcher.Invoke((Action)(() => this.SetupSurface(width, height, format)));
return;
}
this.CreateRenderer();
this.render.SetupSurface(width, height, format);
this.image.Source = this.render.ImageSource;
}
// 写地址
private static TreeNode ExplainWriteDevAddr(FrameFormat frame)
{
TreeNode payloadNode = new TreeNode("数据载荷");
byte[] buf = frame.DataBuf;
string strTmp = "";
int index = 0;
if (!frame.CtrlWord.IsAckFrame)
{
// 请求
if (buf.Length < index + 3)
{
return(payloadNode);
}
string strDataType = GetDataType(frame);
strTmp = "数据标识：" + strDataType + " (" + buf[index].ToString("X2") + buf[index + 1].ToString("X2") + ")";
payloadNode.Nodes.Add(strTmp);
index += 2;
strTmp = "帧序号 ：" + buf[index].ToString("X2");
payloadNode.Nodes.Add(strTmp);
index += 1;
if (buf.Length < index + 7)
{
return(payloadNode);
}
strTmp = "新地址 ：" + Util.GetStringHexFromBytes(buf, index, 7, "", true);
payloadNode.Nodes.Add(strTmp);
index += 7;
}
else
{
// 应答
if (buf.Length < index + 3)
{
return(payloadNode);
}
string strDataType = GetDataType(frame);
strTmp = "数据标识：" + strDataType + " (" + buf[index].ToString("X2") + buf[index + 1].ToString("X2") + ")";
payloadNode.Nodes.Add(strTmp);
index += 2;
strTmp = "帧序号 ：" + buf[index].ToString("X2");
payloadNode.Nodes.Add(strTmp);
index += 1;
}
return(payloadNode);
}
public void Display(IntPtr yPtr, IntPtr uPtr, IntPtr vPtr, int frameWidth, int frameHeight, FrameFormat format)
{
if (this.srcFormat != format || this.srcWidth != frameWidth || this.srcHeight != frameHeight)
{
this.render.SetupSurface(frameWidth, frameHeight, format); // 重建offscreen surface
this.srcFormat = format;
this.srcWidth = frameWidth;
this.srcHeight = frameHeight;
}
this.render.Render(yPtr, uPtr, vPtr);
}
public static bool IsInterlaced(this FrameFormat frameFormat)
{
switch (frameFormat)
{
case FrameFormat.InterlacedTopFieldFirst:
case FrameFormat.InterlacedBottomFieldFirst:
case FrameFormat.SubPicInterlacedTopFieldFirst:
case FrameFormat.SubPicInterlacedBottomFieldFirst:
return(true);
}
return(false);
}
public void Display(IntPtr yPtr, IntPtr uPtr, IntPtr vPtr, int frameWidth, int frameHeight, FrameFormat format)
{
if (this.srcFormat != format || this.srcWidth != frameWidth || this.srcHeight != frameHeight)
{
this.render.SetupSurface(frameWidth, frameHeight, format); // 重建offscreen surface
this.srcFormat = format;
this.srcWidth = frameWidth;
this.srcHeight = frameHeight;
}
this.render.Render(yPtr, uPtr, vPtr);
}
public bool SetupSurface(RenderType renderType, int width, int height, FrameFormat format)
{
if (!this.Dispatcher.CheckAccess())
{
return((bool)this.Dispatcher.Invoke((Action)(() => this.SetupSurface(renderType, width, height, format))));
}
this.CreateRenderer(renderType);
var ret = this.render.SetupSurface(width, height, format);
this.image.Source = this.render.ImageSource;
return(ret);
}
public static ColorMode FrameFormatToColorMode(FrameFormat format)
{
if (format == FrameFormat.Bgra32)
{
return ColorMode.Bgra8888;
}
else if (format == FrameFormat.Gray8)
{
return ColorMode.Gray8;
}
throw new ArgumentException();
}
private static ZXing.RGBLuminanceSource.BitmapFormat FrameFormatToBitmapFormat(FrameFormat format)
{
if (format == FrameFormat.Bgra32)
{
return ZXing.RGBLuminanceSource.BitmapFormat.BGRA32;
}
else if (format == FrameFormat.Gray8)
{
return ZXing.RGBLuminanceSource.BitmapFormat.Gray8;
}
throw new ArgumentException();
}
public static ColorMode FrameFormatToColorMode(FrameFormat format)
{
if (format == FrameFormat.Bgra32)
{
return(ColorMode.Bgra8888);
}
else if (format == FrameFormat.Gray8)
{
return(ColorMode.Gray8);
}
throw new ArgumentException();
}
public async Task <FrameData> QueryAsyncInternal(byte[] titleBytes, byte[] contentBytes, byte[] extentionBytes = null, bool throwIfErrorResponseCode = false)
{
if (titleBytes == null)
{
throw new ArgumentNullException("titleBytes");
}
if (titleBytes.Length > 65535)
{
throw new ArgumentOutOfRangeException("titleBytes");
}
_isSyncQuery = false;
int messageId = GetMessageId();
var messageByteCount = FrameFormat.ComputeFrameByteCount(extentionBytes, titleBytes, contentBytes);
var sendBuffer = _transport.SendBufferCache.Get(messageByteCount);
FrameFormat.FillFrame(sendBuffer, extentionBytes, titleBytes, contentBytes, 0, messageId);
_asyncQueryContext.Reset(messageId);
CheckConnection();
//if (NetworkSettings.ServerTcpSendMode == TcpSendMode.Async)
// _transport.SendAsync(sendBuffer, messageByteCount);
//else
_transport.Send(sendBuffer, messageByteCount);
_transport.SendBufferCache.Cache(sendBuffer);
var receiveData = await _asyncQueryContext.WaitForResult(messageId, NetworkSettings.ReceiveTimeout);
if (receiveData == null)
{
_transport.Close();
throw new Exception("queryAsync failed, time is out");
}
if (throwIfErrorResponseCode)
{
var stateCode = receiveData.StateCode;
if (stateCode != (byte)ResponseCode.OK)
{
throw new Exception("queryAsync failed,error code:" + stateCode);
}
}
return(receiveData);
}
internal void ConstructCurrentMessage(byte[] titleBytes, byte[] contentBytes, byte[] extentionBytes = null, bool throwIfErrorResponseCode = true)
{
MessageId++;
if (MessageId >= 100000000)
{
MessageId = 1;
}
MessageByteCount = FrameFormat.ComputeFrameByteCount(extentionBytes, titleBytes, contentBytes);
SendBuffer = _sendBufferCache.Get(MessageByteCount);
FrameFormat.FillFrame(SendBuffer, extentionBytes, titleBytes, contentBytes, 0, MessageId);
ThrowIfErrorResponseCode = throwIfErrorResponseCode;
}
// 解析 帧颜色
public static Color GetFrameColor(FrameFormat frame)
{
Color frameColor = Color.Black;
foreach (CmdExplain cmd in FrameExplainTbl)
{
if (cmd.Cmd == (byte)frame.CtrlWord.CmdType)
{
frameColor = cmd.CmdColor;
}
}
return(frameColor);
}
// 解析 帧数据部分
public static TreeNode ExplainFrameData(FrameFormat frame)
{
TreeNode node = null;
foreach (CmdExplain cmd in FrameExplainTbl)
{
if (cmd.Cmd == (byte)frame.CtrlWord.CmdType)
{
node = cmd.CmdExplainFunc(frame);
}
}
return(node);
}
public NALUnit(DateTime timeStamp, byte[] rawData, Resolution resolution, FrameFormat frameFormat) : base(timeStamp, rawData, resolution, frameFormat)
{
if (RawData[0] == 0x00 && RawData[1] == 0x00 && RawData[2] == 0x00 && RawData[3] == 0x01)
{
PrefixLength = 4;
}
else if (RawData[0] == 0x00 && RawData[1] == 0x00 && RawData[2] == 0x01)
{
PrefixLength = 3;
}
else
{
throw new ArgumentException("NAL Unit prefix error");
}
}
private void HandleRealTimeData(FrameFormat frame, RealtimeDataMap_V82 realTimeData)
{
try
{
BatteryStatViewModel vm;
if (SharedData.Default.BatteryPackContainer.TryGetValue(frame.Address.ToString(), out vm))
{
UpdateViewModel(realTimeData, vm);
}
}
catch (Exception e)
{
logger.Error(e, "Error updateing view model");
}
}
/// <summary>
/// Конструктор для десериализации
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
public CanPort(SerializationInfo info, StreamingContext context)
{
this._InputBufferMessages = new Queue <Frame>(100);
// Инициализируем дескриптор устройства
this._DeviceHandle = new SafeFileHandle(IntPtr.Zero, true);
this._DeviceHandle.Close();
this._PortName = info.GetString("PortName");
this._BitRate = (BaudRate)info.GetValue("BitRate", typeof(BaudRate));
this._OpMode = (PortMode)info.GetValue("Mode", typeof(PortMode));
this._ErrorFrameEnable = info.GetBoolean("ErrorFrameEnable");
this._FrameFormat = (FrameFormat)info.GetValue("FrameFormat", typeof(FrameFormat));
this._Timeouts = (F_CAN_TIMEOUTS)info.GetValue("Timeouts", typeof(F_CAN_TIMEOUTS));
}
public bool SetupSurface(int videoWidth, int videoHeight, FrameFormat format)
{
this.pixelType = ConvertToPixelFormat(format);
if (pixelType == PixelAlignmentType.NotSupported)
{
return(false);
}
this.width = videoWidth;
this.height = videoHeight;
switch (format)
{
case FrameFormat.YV12:
case FrameFormat.NV12:
this.frameSize = this.width * this.height * 3 / 2;
break;
case FrameFormat.YUY2:
case FrameFormat.UYVY:
case FrameFormat.RGB15: // rgb555
case FrameFormat.RGB16: // rgb565
this.frameSize = this.width * this.height * 2; // 每个像素2字节
break;
case FrameFormat.RGB24:
this.frameSize = this.width * this.height * 3; // 每个像素3字节
break;
case FrameFormat.RGB32:
case FrameFormat.ARGB32:
this.frameSize = this.width * this.height * 4; // 每个像素4字节
break;
default:
return(false);
}
this.imageSource = new WriteableBitmap(videoWidth, videoHeight, DPI_X, DPI_Y, System.Windows.Media.PixelFormats.Bgr32, null);
this.imageSourceRect = new Int32Rect(0, 0, videoWidth, videoHeight);
System.Drawing.Size size = new System.Drawing.Size(videoWidth, videoHeight);
this.converter = new ConverterResizer(size, pixelType, size, PixelAlignmentType.BGRA);
this.NotifyImageSourceChanged();
return(true);
}
// 解析 帧数据项
public static TreeNode ExplainDataItem(FrameFormat frame)
{
TreeNode node = null;
foreach (DataExplain dat in DataExplainTbl)
{
if (dat.DI0 == frame.DataBuf[0] &&
dat.DI1 == frame.DataBuf[1]
)
{
node = dat.DataExplainFunc(frame);
}
}
return(node);
}
public bool SetupSurface(int videoWidth, int videoHeight, FrameFormat format)
{
this.pixelType = ConvertToPixelFormat(format);
if (pixelType == PixelAlignmentType.NotSupported)
{
return false;
}
this.width = videoWidth;
this.height = videoHeight;
switch (format)
{
case FrameFormat.YV12:
case FrameFormat.NV12:
this.frameSize = this.width * this.height * 3 / 2;
break;
case FrameFormat.YUY2:
case FrameFormat.UYVY:
case FrameFormat.RGB15: // rgb555
case FrameFormat.RGB16: // rgb565
this.frameSize = this.width * this.height * 2; // 每个像素2字节
break;
case FrameFormat.RGB32:
case FrameFormat.ARGB32:
this.frameSize = this.width * this.height * 4; // 每个像素4字节
break;
default:
return false;
}
this.imageSource = new WriteableBitmap(videoWidth, videoHeight, DPI_X, DPI_Y, System.Windows.Media.PixelFormats.Bgr32, null);
this.imageSourceRect = new Int32Rect(0, 0, videoWidth, videoHeight);
System.Drawing.Size size = new System.Drawing.Size(videoWidth, videoHeight);
this.converter = new ConverterResizer(size, pixelType, size, PixelAlignmentType.BGRA);
this.NotifyImageSourceChanged();
return true;
}
private static PixelAlignmentType ConvertToPixelFormat(FrameFormat format)
{
switch (format)
{
case FrameFormat.YV12:
return PixelAlignmentType.YV12;
case FrameFormat.NV12:
return PixelAlignmentType.NV12;
case FrameFormat.YUY2:
return PixelAlignmentType.YUY2;
case FrameFormat.UYVY:
return PixelAlignmentType.UYVY;
case FrameFormat.RGB32:
return PixelAlignmentType.BGRA;
case FrameFormat.ARGB32:
return PixelAlignmentType.ABGR;
case FrameFormat.RGB24:
return PixelAlignmentType.RGB24;
case FrameFormat.RGB15:
case FrameFormat.RGB16:
default:
return PixelAlignmentType.NotSupported;
}
}
public bool CheckFormat(FrameFormat format)
{
return ConvertToPixelFormat(format) != PixelAlignmentType.NotSupported;
}
/// <summary>
/// Возвращает максимальное значение идентификатора сообщения
/// для указанного формата кадра сообщения
/// </summary>
/// <param name="format">Формат кадра CAN-сообщения</param>
/// <returns>Максимальное значение идентификатора</returns>
public static UInt32 GetIdMaxValue(FrameFormat format)
{
//UInt32 id;
switch (format)
{
case FrameFormat.StandardFrame:
{ return 0x7FFF; }
case FrameFormat.ExtendedFrame:
{ return 0x1FFFFFFF; }
default:
{
throw new InvalidOperationException(
"Невозможно вернуть значение свойства. Установлен недупустимый формат фрейма сообщения");
}
}
}
public abstract void WriteMessage(uint identifier, FrameType frameType,
FrameFormat frameFormat, byte[] data);
//--------------------------------------------------------------------------------
#endregion
//--------------------------------------------------------------------------------
#region Constructors
//--------------------------------------------------------------------------------
/// <summary>
/// Конструктор
/// </summary>
public FilterIds()
{
_Format = FrameFormat.StandardFrame;
}
/// <summary>
/// Записывает в порт сообщение (кадр)
/// </summary>
/// <param name="identifier">Идентификатор сообщения</param>
/// <param name="frameType">Тип сообщения</param>
/// <param name="frameFormat">Формат сообщения</param>
/// <param name="data">Данные сообщения (0...8 байт)</param>
public override void WriteMessage(UInt32 identifier, FrameType frameType,
FrameFormat frameFormat, Byte[] data)
{
String msg;
lock (_SyncRoot)
{
CanMessage canMsg = new CanMessage();
canMsg.TimeStamp = 0;
canMsg.Identifier = identifier;
switch (frameType)
{
case FrameType.DATAFRAME:
{
canMsg.FrameType = CanMsgFrameType.Data;
canMsg.RemoteTransmissionRequest = false;
break;
}
case FrameType.REMOTEFRAME:
{
canMsg.FrameType = CanMsgFrameType.Data;
canMsg.RemoteTransmissionRequest = true;
break;
}
default:
{
msg = String.Format("{0}: class CanPort.WriteMessage: Невозможно записать в порт сообщение данного типа: {1}",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), frameFormat.ToString());
Trace.TraceError(msg);
throw new ArgumentException(msg, FrameType.DATAFRAME.ToString());
}
}
if (data.Length > 8)
{
msg = String.Format(
"{0}: class CanPort: Невозмоно записать в порт сообщение. Поле данных в сообщении не может быть больше 8 байт, передано: {1}",
DateTime.Now.ToString(new System.Globalization.CultureInfo("ru-Ru", false)), data.Length.ToString());
Trace.TraceError(msg);
throw new ArgumentException(msg, "data.Length");
}
else
{
canMsg.DataLength = System.Convert.ToByte(data.Length);
}
switch (frameFormat)
{
case FrameFormat.ExtendedFrame:
{
canMsg.ExtendedFrameFormat = true;
break;
}
case FrameFormat.StandardFrame:
{
canMsg.ExtendedFrameFormat = false;
break;
}
default:
{
msg = String.Format(
"{0}: class CanPort: Невозможно записать в порт сообщение с форматом кадра: {1}",
frameFormat.ToString());
Trace.TraceError(msg);
throw new ArgumentException(msg, "frameFormat");
}
}
// Эхо!!!
canMsg.SelfReceptionRequest = true; // show this message in the console window
for (Byte i = 0; i < data.Length; i++)
{
canMsg[i] = data[i];
}
//#if DEBUG
//StringBuilder sb = new StringBuilder();
//sb.Append("OUT: ");
//sb.Append("Type: " + frameType.ToString() + " ");
//sb.Append("Format: " + frameFormat.ToString() + " ");
//sb.Append("Id:" + identifier.ToString() + " ");
//foreach (Byte item in data)
//{
// sb.Append("0x" + item.ToString("X2") + " ");
//}
//WindowsDebugging.WriteLine(sb.ToString(), Category.Information);
//#endif
// Write the CAN message into the transmit FIFO
this._Writer.SendMessage(canMsg);
}
return;
}
/// <summary>
/// Строит сообщение
/// </summary>
/// <param name="identifier">Идентификатор сообщения</param>
/// <param name="frameType">Тип сообщения</param>
/// <param name="frameFormat">Формат сообщения</param>
/// <param name="data">Данные сообщения</param>
/// <returns></returns>
public static F_CAN_MSG MessageBuilder(uint identifier, FrameType frameType,
FrameFormat frameFormat, byte[] data)
{
F_CAN_MSG result;
String msg;
// Разбираем сообщение и подготавливаем его для отправки
result.can_dlc = (Byte)data.Length;
result.data = new Byte[8];
Array.Copy(data, result.data, data.Length);
result.can_id = identifier;
//buffer.msg.can_id &= (CAN_MSG_MASK.CAN_SFF_MASK | CAN_MSG_MASK.CAN_EFF_MASK);
if (frameFormat == FrameFormat.ExtendedFrame)
{
result.can_id |= CAN_MSG_FLAG.CAN_EFF_FLAG;
}
if (frameType == FrameType.REMOTEFRAME)
{
if (data.Length != 0)
{
// При отправке сообщения возникла ошибка, при
// устанавленном бите RTR, длина DLC данных должна быть равна 0
msg = "Не удалось отправить сообщение. DLC должно быть равно 0 при установленном бите RTR";
throw new Exception(msg);
}
result.can_id |= CAN_MSG_FLAG.CAN_RTR_FLAG;
}
return result;
}
//-----------------------------------------------------------------------------------------
/// <summary>
/// Строит и возвращает структуру режима работы порта NIM351
/// </summary>
/// <param name="mode">Режим работы порта</param>
/// <param name="frameFormat">Формат кадра</param>
/// <param name="errorFrameEnable">Разрешает/запрещает передачу информационных сообщений</param>
/// <returns></returns>
public static CAN_OPMODE OpModeBuilder(PortMode mode,
FrameFormat frameFormat, Boolean errorFrameEnable)
{
CAN_OPMODE result;
String msg;
result = CAN_OPMODE.CAN_OPMODE_INIT;
switch (mode)
{
case PortMode.NORMAL:
{ break; }
case PortMode.LISTEN_ONLY:
{ result |= CAN_OPMODE.CAN_OPMODE_LSTNONLY; break; }
case PortMode.SELFTEST:
{ result |= CAN_OPMODE.CAN_OPMODE_SELFTEST; break; }
case PortMode.SELFRECV:
{ result |= CAN_OPMODE.CAN_OPMODE_SELFRECV; break; }
default:
{
msg = String.Format(Properties.ErrorMessages.NotSupportedValue, mode);
throw new InvalidCastException(msg);
}
}
switch (frameFormat)
{
case FrameFormat.StandardFrame:
{ result |= CAN_OPMODE.CAN_OPMODE_STANDARD; break; }
case FrameFormat.ExtendedFrame:
{ result |= CAN_OPMODE.CAN_OPMODE_EXTENDED; break; }
case FrameFormat.MixedFrame:
{ result |= (CAN_OPMODE.CAN_OPMODE_STANDARD | CAN_OPMODE.CAN_OPMODE_EXTENDED); break; }
default:
{
msg = String.Format(Properties.ErrorMessages.NotSupportedValue, frameFormat);
throw new InvalidCastException(msg);
}
}
if (errorFrameEnable)
{ result |= CAN_OPMODE.CAN_OPMODE_ERRFRAME; }
return result;
}
/// <summary>
/// Записывает сообщение в порт
/// </summary>
/// <param name="identifier"></param>
/// <param name="frameType"></param>
/// <param name="frameFormat"></param>
/// <param name="data"></param>
public override void WriteMessage(uint identifier, FrameType frameType,
FrameFormat frameFormat, byte[] data)
{
Frame frame = new Frame();
frame.Identifier = identifier;
frame.FrameType = frameType;
frame.FrameFormat = FrameFormat;
if (data != null)
{ frame.Data = data; }
else
{ frame.Data = new byte[0]; }
this.Write(frame);
return;
}
/// <summary>
///
/// </summary>
/// <param name="portName"></param>
/// <param name="bitRate"></param>
/// <param name="frameFormat"></param>
/// <param name="mode"></param>
public CanPort(String portName, BaudRate bitRate, FrameFormat frameFormat,
PortMode mode)
{
// Инициализируем буфер входящих сообщений
this._InputBufferMessages = new Queue<Frame>(100);
// Инициализируем дескриптор устройства
this._DeviceHandle = new SafeFileHandle(IntPtr.Zero, true);
this._DeviceHandle.Close();
// Номер порта
PortName = portName;
_BitRate = bitRate;
_FrameFormat = frameFormat;
_OpMode = mode;
// Структура таймаутов
_Timeouts = new F_CAN_TIMEOUTS();
}
/// <summary>
/// Конструктор для десериализации
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
public CanPort(SerializationInfo info, StreamingContext context)
{
this.PortName = info.GetString("PortName");
this._InputBufferMessages = new Queue<Frame>(100);
this._FrameFormat = (FrameFormat)info.GetValue("FrameFormat", typeof(FrameFormat));
this._ErrorFrameEnable = info.GetBoolean("ErrorFrameEnable");
this._ListenOnlyMode = info.GetBoolean("ListenOlnyMode");
this._CanBitRate = (BaudRate)info.GetValue("BitRate", typeof(BaudRate));
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="portName">Наименование порта (серийный номер порта)</param>
public CanPort(String portName, BaudRate bitRate, FrameFormat frameFormat,
PortMode mode)
{
IVciDeviceList deviceList;
String serialNumber;
Object pack;
// Настраиваем поля
this.PortName = portName;
// Инициализируем входной буфер сообщений
this._InputBufferMessages = new Queue<Frame>(100);
// Инициализируем свойства порта
this._FrameFormat = frameFormat;
this._ErrorFrameEnable = true;
((ICanPort)this).Mode = mode;
this._LowSpeedModeEnable = false;
// Устанавливаем скорость по умолчанию
this._CanBitRate = bitRate;
// Получаем список доступных устройств
deviceList = GetDeviceList();
// Находим нужное нам устройство и открываем его
foreach (IVciDevice item in deviceList)
{
pack = (Object)item.UniqueHardwareId;
serialNumber = GetSerialNumber(ref pack);
if (serialNumber == this._SerialNumber)
{
// Устройство найдено
this._CanDevice = item;
break;
}
}
}
//--------------------------------------------------------------------------------
/// <summary>
/// Конструктор
/// </summary>
public CanPort()
{
//#if DEBUG
//WindowsDebugging = new OutputWindow(String.Format("CAN-Port {0}", this.PortName));
//WindowsDebugging.Show();
//#endif
// Настраиваем поля
// Инициализируем входной буфер сообщений
this._InputBufferMessages = new Queue<Frame>(100);
// Инициализируем свойства порта
this._FrameFormat = FrameFormat.StandardFrame;
this._ErrorFrameEnable = true;
this._ListenOnlyMode = false;
this._LowSpeedModeEnable = false;
// Устанавливаем скорость по умолчанию
this._CanBitRate = BaudRate.BR10;
}
public bool SetupSurface(int videoWidth, int videoHeight, FrameFormat format)
{
Format d3dFormat = ConvertToD3D(format);
if (!this.CheckFormat(d3dFormat))
{
// 显卡不支持该格式
return false;
}
#region 初始化尺寸参数
this.frameFormat = format;
switch (format)
{
case FrameFormat.YV12:
this.yStride = videoWidth;
this.yHeight = videoHeight;
this.ySize = videoWidth * videoHeight;
this.uvStride = this.yStride >> 1;
this.uvHeight = this.yHeight >> 1;
this.uvSize = this.ySize >> 2;
break;
case FrameFormat.NV12:
this.yStride = videoWidth;
this.yHeight = videoHeight;
this.ySize = videoWidth * videoHeight;
this.uvStride = this.yStride;
this.uvHeight = this.yHeight >> 1;
this.uvSize = this.ySize >> 1;
break;
case FrameFormat.YUY2:
case FrameFormat.UYVY:
case FrameFormat.RGB15: // rgb555
case FrameFormat.RGB16: // rgb565
this.yStride = videoWidth << 1;
this.yHeight = videoHeight;
this.ySize = this.yStride * this.yHeight;
this.uvStride = this.uvHeight = this.uvSize = 0;
break;
case FrameFormat.RGB32:
case FrameFormat.ARGB32:
this.yStride = videoWidth << 2;
this.yHeight = videoHeight;
this.ySize = this.yStride * this.yHeight;
this.uvStride = this.uvHeight = this.uvSize = 0;
break;
default:
return false;
}
#endregion
this.ReleaseResource();
this.CreateResource(d3dFormat, videoWidth, videoHeight);
return true;
}
public bool CheckFormat(FrameFormat format)
{
return this.CheckFormat(ConvertToD3D(format));
}
private static Format ConvertToD3D(FrameFormat format)
{
switch (format)
{
case FrameFormat.YV12:
return D3DFormatYV12;
case FrameFormat.NV12:
return D3DFormatNV12;
case FrameFormat.YUY2:
return Format.Yuy2;
case FrameFormat.UYVY:
return Format.Uyvy;
case FrameFormat.RGB15:
return Format.X1R5G5B5;
case FrameFormat.RGB16:
return Format.R5G6B5;
case FrameFormat.RGB32:
return Format.X8R8G8B8;
case FrameFormat.ARGB32:
return Format.A8R8G8B8;
case FrameFormat.RGB24:
return Format.R8G8B8;
default:
throw new ArgumentException("Unknown pixel format", "format");
}
}
/// <summary>
/// Конструктор для десериализации
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
public CanPort(SerializationInfo info, StreamingContext context)
{
this._InputBufferMessages = new Queue<Frame>(100);
// Инициализируем дескриптор устройства
this._DeviceHandle = new SafeFileHandle(IntPtr.Zero, true);
this._DeviceHandle.Close();
this._PortName = info.GetString("PortName");
this._BitRate = (BaudRate)info.GetValue("BitRate", typeof(BaudRate));
this._OpMode = (PortMode)info.GetValue("Mode", typeof(PortMode));
this._ErrorFrameEnable = info.GetBoolean("ErrorFrameEnable");
this._FrameFormat = (FrameFormat)info.GetValue("FrameFormat", typeof(FrameFormat));
this._Timeouts = (F_CAN_TIMEOUTS)info.GetValue("Timeouts", typeof(F_CAN_TIMEOUTS));
}
