public FileIndex(string idxFile, string mulFile, int file) { string idxPath = null; MulPath = null; if (Files.MulPath == null) { Files.LoadMulPath(); } if (Files.MulPath.Count > 0) { idxPath = Files.MulPath[idxFile.ToLower()]; MulPath = Files.MulPath[mulFile.ToLower()]; if (String.IsNullOrEmpty(idxPath)) { idxPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(idxPath))) { idxPath = Path.Combine(Files.RootDir, idxPath); } if (!File.Exists(idxPath)) { idxPath = null; } } if (String.IsNullOrEmpty(MulPath)) { MulPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(MulPath))) { MulPath = Path.Combine(Files.RootDir, MulPath); } if (!File.Exists(MulPath)) { MulPath = null; } } } if ((idxPath != null) && (MulPath != null)) { using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read); int count = (int)(index.Length / 12); IdxLength = index.Length; Index = new Entry3D[count]; GCHandle gc = GCHandle.Alloc(Index, GCHandleType.Pinned); byte[] buffer = new byte[index.Length]; index.Read(buffer, 0, (int)index.Length); Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int)index.Length); gc.Free(); } } else { Stream = null; Index = new Entry3D[1]; return; } Entry5D[] patches = Verdata.Patches; if (file > -1) { for (int i = 0; i < patches.Length; ++i) { Entry5D patch = patches[i]; if (patch.file == file && patch.index >= 0 && patch.index < Index.Length) { Index[patch.index].lookup = patch.lookup; Index[patch.index].length = patch.length | (1 << 31); Index[patch.index].extra = patch.extra; } } } }
/// <summary> /// For derived classes only. /// </summary> protected MidiPort() { _status = MidiPortStatus.Closed; _instanceHandle = GCHandle.Alloc(this, GCHandleType.Weak); AutoReturnBuffers = true; }
void Init(byte[] bios) { bool GL = SyncSettings.UseGL; if (AttachedCore != null) { AttachedCore.Dispose(); AttachedCore = null; } VideoHandle = GCHandle.Alloc(VideoBuffer, GCHandleType.Pinned); SoundHandle = GCHandle.Alloc(SoundBuffer, GCHandleType.Pinned); LibYabause.CDInterface CDInt = new LibYabause.CDInterface(); CDInt.InitFunc = InitH = new LibYabause.CDInterface.Init(CD_Init); CDInt.DeInitFunc = DeInitH = new LibYabause.CDInterface.DeInit(CD_DeInit); CDInt.GetStatusFunc = GetStatusH = new LibYabause.CDInterface.GetStatus(CD_GetStatus); CDInt.ReadTOCFunc = ReadTOCH = new LibYabause.CDInterface.ReadTOC(CD_ReadTOC); CDInt.ReadSectorFADFunc = ReadSectorFADH = new LibYabause.CDInterface.ReadSectorFAD(CD_ReadSectorFAD); CDInt.ReadAheadFADFunc = ReadAheadFADH = new LibYabause.CDInterface.ReadAheadFAD(CD_ReadAheadFAD); var fp = new FilePiping(); string BiosPipe = fp.GetPipeNameNative(); fp.Offer(bios); int basetime; if (SyncSettings.RealTimeRTC) { basetime = 0; } else { basetime = (int)((SyncSettings.RTCInitialTime - new DateTime(1970, 1, 1).ToLocalTime()).TotalSeconds); } if (!LibYabause.libyabause_init ( ref CDInt, BiosPipe, GL, SyncSettings.CartType, SyncSettings.SkipBios, !SyncSettings.RealTimeRTC, basetime )) { throw new Exception("libyabause_init() failed!"); } fp.Finish(); LibYabause.libyabause_setvidbuff(VideoHandle.AddrOfPinnedObject()); LibYabause.libyabause_setsndbuff(SoundHandle.AddrOfPinnedObject()); AttachedCore = this; // with or without GL, this is the guaranteed frame -1 size; (unless you do a gl resize) BufferWidth = 320; BufferHeight = 224; InitMemoryDomains(); GLMode = GL; // if in GL mode, this will trigger the initial GL resize PutSyncSettings(this.SyncSettings); }
internal Watcher(LibEvLoop loop) : base(loop) { Loop = loop; gc_handle = GCHandle.Alloc(this); }
public T Read <T>(IntPtr address) where T : struct { object ret = default(T); var buffer = new byte[0]; if (typeof(T) == typeof(string)) { return((T)(object)ReadCString(address)); } buffer = ReadBytes(address, (uint)Marshal.SizeOf(typeof(T))); switch (Type.GetTypeCode(typeof(T))) { case TypeCode.Object: GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned); Marshal.PtrToStructure(handle.AddrOfPinnedObject(), ret); handle.Free(); break; case TypeCode.Boolean: ret = BitConverter.ToBoolean(buffer, 0); break; case TypeCode.Char: ret = BitConverter.ToChar(buffer, 0); break; case TypeCode.Byte: ret = buffer[0]; break; case TypeCode.Int16: ret = BitConverter.ToInt16(buffer, 0); break; case TypeCode.UInt16: ret = BitConverter.ToUInt16(buffer, 0); break; case TypeCode.Int32: ret = BitConverter.ToInt32(buffer, 0); break; case TypeCode.UInt32: ret = BitConverter.ToUInt32(buffer, 0); break; case TypeCode.Int64: ret = BitConverter.ToInt64(buffer, 0); break; case TypeCode.UInt64: ret = BitConverter.ToUInt64(buffer, 0); break; case TypeCode.Single: ret = BitConverter.ToSingle(buffer, 0); break; case TypeCode.Double: ret = BitConverter.ToDouble(buffer, 0); break; default: throw new NotSupportedException($"Unknown type {typeof(T).Name}."); } return((T)ret); }
public HandleTracked(T item) { _gcHandle = GCHandle.Alloc(item); }
internal ECDsaCng CreateECDsa(string algorithm, bool usePrivateKey) { if (Crv == null) throw LogHelper.LogArgumentNullException(nameof(Crv)); if (X == null) throw LogHelper.LogArgumentNullException(nameof(X)); if (Y == null) throw LogHelper.LogArgumentNullException(nameof(Y)); GCHandle keyBlobHandle = new GCHandle(); try { uint dwMagic = GetMagicValue(Crv, usePrivateKey); uint cbKey = GetKeyByteCount(Crv); byte[] keyBlob; #if NET45 if (usePrivateKey) keyBlob = new byte[3 * cbKey + 2 * Marshal.SizeOf(typeof(uint))]; else keyBlob = new byte[2 * cbKey + 2 * Marshal.SizeOf(typeof(uint))]; #else if (usePrivateKey) keyBlob = new byte[3 * cbKey + 2 * Marshal.SizeOf<uint>()]; else keyBlob = new byte[2 * cbKey + 2 * Marshal.SizeOf<uint>()]; #endif keyBlobHandle = GCHandle.Alloc(keyBlob, GCHandleType.Pinned); IntPtr keyBlobPtr = keyBlobHandle.AddrOfPinnedObject(); byte[] x = Base64UrlEncoder.DecodeBytes(X); byte[] y = Base64UrlEncoder.DecodeBytes(Y); Marshal.WriteInt64(keyBlobPtr, 0, dwMagic); Marshal.WriteInt64(keyBlobPtr, 4, cbKey); int index = 8; foreach (byte b in x) Marshal.WriteByte(keyBlobPtr, index++, b); foreach (byte b in y) Marshal.WriteByte(keyBlobPtr, index++, b); if (usePrivateKey) { if (D == null) throw LogHelper.LogArgumentNullException(nameof(D)); byte[] d = Base64UrlEncoder.DecodeBytes(D); foreach (byte b in d) Marshal.WriteByte(keyBlobPtr, index++, b); Marshal.Copy(keyBlobPtr, keyBlob, 0, keyBlob.Length); using (CngKey cngKey = CngKey.Import(keyBlob, CngKeyBlobFormat.EccPrivateBlob)) { if (Utility.ValidateECDSAKeySize(cngKey.KeySize, algorithm)) return new ECDsaCng(cngKey); else throw LogHelper.LogExceptionMessage(new ArgumentOutOfRangeException("key.KeySize", String.Format(CultureInfo.InvariantCulture, LogMessages.IDX10671, cngKey, ECDsaAlgorithm.DefaultECDsaKeySizeInBitsMap[algorithm], cngKey.KeySize))); } } else { Marshal.Copy(keyBlobPtr, keyBlob, 0, keyBlob.Length); using (CngKey cngKey = CngKey.Import(keyBlob, CngKeyBlobFormat.EccPublicBlob)) { if (Utility.ValidateECDSAKeySize(cngKey.KeySize, algorithm)) return new ECDsaCng(cngKey); else throw LogHelper.LogExceptionMessage(new ArgumentOutOfRangeException("key.KeySize", String.Format(CultureInfo.InvariantCulture, LogMessages.IDX10671, cngKey, ECDsaAlgorithm.DefaultECDsaKeySizeInBitsMap[algorithm], cngKey.KeySize))); } } } finally { if (keyBlobHandle != null) keyBlobHandle.Free(); } }
internal unsafe void SendError(ulong requestId, int httpStatusCode, IList <string> authChallenges = null) { HttpApiTypes.HTTP_RESPONSE_V2 httpResponse = new HttpApiTypes.HTTP_RESPONSE_V2(); httpResponse.Response_V1.Version = new HttpApiTypes.HTTP_VERSION(); httpResponse.Response_V1.Version.MajorVersion = (ushort)1; httpResponse.Response_V1.Version.MinorVersion = (ushort)1; List <GCHandle> pinnedHeaders = null; GCHandle gcHandle; try { // Copied from the multi-value headers section of SerializeHeaders if (authChallenges != null && authChallenges.Count > 0) { pinnedHeaders = new List <GCHandle>(authChallenges.Count + 3); HttpApiTypes.HTTP_RESPONSE_INFO[] knownHeaderInfo = null; knownHeaderInfo = new HttpApiTypes.HTTP_RESPONSE_INFO[1]; gcHandle = GCHandle.Alloc(knownHeaderInfo, GCHandleType.Pinned); pinnedHeaders.Add(gcHandle); httpResponse.pResponseInfo = (HttpApiTypes.HTTP_RESPONSE_INFO *)gcHandle.AddrOfPinnedObject(); knownHeaderInfo[httpResponse.ResponseInfoCount].Type = HttpApiTypes.HTTP_RESPONSE_INFO_TYPE.HttpResponseInfoTypeMultipleKnownHeaders; knownHeaderInfo[httpResponse.ResponseInfoCount].Length = (uint)Marshal.SizeOf <HttpApiTypes.HTTP_MULTIPLE_KNOWN_HEADERS>(); HttpApiTypes.HTTP_MULTIPLE_KNOWN_HEADERS header = new HttpApiTypes.HTTP_MULTIPLE_KNOWN_HEADERS(); header.HeaderId = HttpApiTypes.HTTP_RESPONSE_HEADER_ID.Enum.HttpHeaderWwwAuthenticate; header.Flags = HttpApiTypes.HTTP_RESPONSE_INFO_FLAGS.PreserveOrder; // The docs say this is for www-auth only. HttpApiTypes.HTTP_KNOWN_HEADER[] nativeHeaderValues = new HttpApiTypes.HTTP_KNOWN_HEADER[authChallenges.Count]; gcHandle = GCHandle.Alloc(nativeHeaderValues, GCHandleType.Pinned); pinnedHeaders.Add(gcHandle); header.KnownHeaders = (HttpApiTypes.HTTP_KNOWN_HEADER *)gcHandle.AddrOfPinnedObject(); for (int headerValueIndex = 0; headerValueIndex < authChallenges.Count; headerValueIndex++) { // Add Value string headerValue = authChallenges[headerValueIndex]; byte[] bytes = HeaderEncoding.GetBytes(headerValue); nativeHeaderValues[header.KnownHeaderCount].RawValueLength = (ushort)bytes.Length; gcHandle = GCHandle.Alloc(bytes, GCHandleType.Pinned); pinnedHeaders.Add(gcHandle); nativeHeaderValues[header.KnownHeaderCount].pRawValue = (byte *)gcHandle.AddrOfPinnedObject(); header.KnownHeaderCount++; } // This type is a struct, not an object, so pinning it causes a boxed copy to be created. We can't do that until after all the fields are set. gcHandle = GCHandle.Alloc(header, GCHandleType.Pinned); pinnedHeaders.Add(gcHandle); knownHeaderInfo[0].pInfo = (HttpApiTypes.HTTP_MULTIPLE_KNOWN_HEADERS *)gcHandle.AddrOfPinnedObject(); httpResponse.ResponseInfoCount = 1; } httpResponse.Response_V1.StatusCode = (ushort)httpStatusCode; string statusDescription = HttpReasonPhrase.Get(httpStatusCode); uint dataWritten = 0; uint statusCode; byte[] byteReason = HeaderEncoding.GetBytes(statusDescription); fixed(byte *pReason = byteReason) { httpResponse.Response_V1.pReason = (byte *)pReason; httpResponse.Response_V1.ReasonLength = (ushort)byteReason.Length; byte[] byteContentLength = new byte[] { (byte)'0' }; fixed(byte *pContentLength = byteContentLength) { (&httpResponse.Response_V1.Headers.KnownHeaders)[(int)HttpSysResponseHeader.ContentLength].pRawValue = (byte *)pContentLength; (&httpResponse.Response_V1.Headers.KnownHeaders)[(int)HttpSysResponseHeader.ContentLength].RawValueLength = (ushort)byteContentLength.Length; httpResponse.Response_V1.Headers.UnknownHeaderCount = 0; statusCode = HttpApi.HttpSendHttpResponse( _requestQueue.Handle, requestId, 0, &httpResponse, null, &dataWritten, IntPtr.Zero, 0, SafeNativeOverlapped.Zero, IntPtr.Zero); } } if (statusCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS) { // if we fail to send a 401 something's seriously wrong, abort the request HttpApi.HttpCancelHttpRequest(_requestQueue.Handle, requestId, IntPtr.Zero); } } finally { if (pinnedHeaders != null) { foreach (GCHandle handle in pinnedHeaders) { if (handle.IsAllocated) { handle.Free(); } } } } }
/// <summary> /// Enumerates computers on the local network. /// </summary> private void OnEnumerate(object state) { IntPtr pInfo; int entriesRead = 0; int totalEntries = 0; int resumeHandle = 0; int result = ERROR_MORE_DATA; GCHandle dwResumeHandle = GCHandle.Alloc(resumeHandle, GCHandleType.Pinned); try { while (m_stopped == 0 && result == ERROR_MORE_DATA) { // enumerate the first batch of servers. result = NetServerEnum( IntPtr.Zero, LEVEL_SERVER_INFO_100, out pInfo, MAX_PREFERRED_LENGTH, out entriesRead, out totalEntries, SV_TYPE_WORKSTATION | SV_TYPE_SERVER, m_domain, dwResumeHandle.AddrOfPinnedObject()); // check for fatal error. if ((result != NERR_Success) && (result != ERROR_MORE_DATA)) { Utils.Trace("Could not enumerate hosts on network. Error = {0}", result); return; } // copy host names from the returned structures. string[] hostnames = new string[entriesRead]; IntPtr pos = pInfo; for (int ii = 0; ii < entriesRead; ii++) { SERVER_INFO_100 info = (SERVER_INFO_100)Marshal.PtrToStructure(pos, typeof(SERVER_INFO_100)); hostnames[ii] = info.sv100_name; pos = (IntPtr)(pos.ToInt64() + Marshal.SizeOf(typeof(SERVER_INFO_100))); } NetApiBufferFree(pInfo); // raise an event. if (m_stopped == 0 && m_HostsDiscovered != null) { try { m_HostsDiscovered(this, new HostEnumeratorEventArgs(hostnames)); } catch (Exception e) { Utils.Trace(e, "Unexpected exception raising HostsDiscovered event."); } } } } catch (Exception e) { Utils.Trace(e, "Unexpected exception calling NetServerEnum."); } finally { if (dwResumeHandle.IsAllocated) { dwResumeHandle.Free(); } } }
public static List <bioapi_unit_schema> EnumerateDevices() { uint res; List <bioapi_unit_schema> result = new List <bioapi_unit_schema>(); bioapi_unit_schema unitinfo; GCHandle gch = GCHandle.Alloc(_bspinfo.BSPUuid, GCHandleType.Pinned); try { res = BioAPI.OK; if (BSPLoaded) { try { res = BioAPI.BSPUnload(gch.AddrOfPinnedObject(), (BioAPI.EventHandler)null, IntPtr.Zero); } catch (Exception ex) { _log.Error(ex); } } if (res == BioAPI.OK) { BSPLoaded = false; res = BioAPI.BSPLoad(gch.AddrOfPinnedObject(), (BioAPI.EventHandler)null, IntPtr.Zero); if (res == BioAPI.OK) { BSPLoaded = true; res = BioAPI.QueryUnits(gch.AddrOfPinnedObject(), ref DeviceArray, ref deviceCount); if (res == BioAPI.OK) { for (int i = 0; i < deviceCount; i++) { int size = Marshal.SizeOf(typeof(bioapi_unit_schema)); unitinfo = (bioapi_unit_schema)Marshal.PtrToStructure(DeviceArray + size * i, typeof(bioapi_unit_schema)); result.Add(unitinfo); } } else { throw new Exception("QueryUnits " + res.ToString()); } } else { throw new Exception("BSPLoad " + res.ToString()); } } else { throw new Exception("BSPUnload " + res.ToString()); } } catch (Exception ex) { _log.Error(ex); } finally { gch.Free(); } return(result); }
public void CreateDeploymentData(BackgroundWorker backgroundWorker, DoWorkEventArgs doWorkEventArgs) { MFDevice device = doWorkEventArgs.Argument as MFDevice; _DBG.Engine eng = device.DbgEngine; Commands.Monitor_FlashSectorMap.Reply flashMap = eng.GetFlashSectorMap(); //find deployment sectors. MemoryStream deploymentStream = new MemoryStream(); //this duplicates LoadDeploymentAssemblies logic, as how to find assemblies in the deployment sectors int iSectorStart = -1, iSectorEnd = 0; uint address, addressAssemblyStart, addressStart = 0, addressEnd = 0; int iSector; //First, find out where the deployment sectors are for (iSector = 0; iSector < flashMap.m_map.Length; iSector++) { Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData = flashMap.m_map[iSector]; if ((flashSectorData.m_flags & Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK) == Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT) { if (iSectorStart < 0) { iSectorStart = iSector; addressStart = flashSectorData.m_address; } iSectorEnd = iSector; addressEnd = flashSectorData.m_address + flashSectorData.m_size; } } if (iSectorStart < 0) { throw new ApplicationException("Could not find deployment sectors"); } address = addressStart; iSector = iSectorStart; while (true) { if (backgroundWorker.WorkerReportsProgress) { int progress = (int)(100.0 * (double)address / (double)addressEnd); backgroundWorker.ReportProgress(progress); } //read assembly header uint assemblyHeaderSize = (uint)Marshal.SizeOf(typeof(CLR_RECORD_ASSEMBLY)); byte[] assemblyHeaderBytes = null; byte[] assemblyDataBytes = null; if (address + assemblyHeaderSize >= addressEnd) { break; } addressAssemblyStart = address; if (!CreateDeploymentReadHelper(backgroundWorker, doWorkEventArgs, eng, ref address, addressStart, addressEnd, assemblyHeaderSize, out assemblyHeaderBytes)) { return; } GCHandle gch = GCHandle.Alloc(assemblyHeaderBytes, GCHandleType.Pinned); CLR_RECORD_ASSEMBLY assemblyHeader = (CLR_RECORD_ASSEMBLY)Marshal.PtrToStructure(gch.AddrOfPinnedObject(), typeof(CLR_RECORD_ASSEMBLY)); gch.Free(); //check if valid header //check marker bool fValidAssembly = assemblyHeader.marker == CLR_RECORD_ASSEMBLY.MARKER_ASSEMBLY_V1; if (fValidAssembly) { //check header crc uint crcHeader = assemblyHeader.headerCRC; //clear headerCRC int headerCRCOffset = 8; int headerCRCSize = 4; Array.Clear(assemblyHeaderBytes, headerCRCOffset, headerCRCSize); uint crc = _DBG.CRC.ComputeCRC(assemblyHeaderBytes, 0); //Reset headerCRC Array.Copy(BitConverter.GetBytes(crcHeader), 0, assemblyHeaderBytes, headerCRCOffset, headerCRCSize); fValidAssembly = (crcHeader == crc); } if (fValidAssembly) { uint assemblyTotalSize = assemblyHeader.startOfTables[CLR_RECORD_ASSEMBLY.TBL_EndOfAssembly]; uint assemblyDataSize = assemblyTotalSize - assemblyHeaderSize; if (address + assemblyDataSize >= addressEnd) { break; } //read body if (!CreateDeploymentReadHelper(backgroundWorker, doWorkEventArgs, eng, ref address, addressStart, addressEnd, assemblyDataSize, out assemblyDataBytes)) { return; } //check if valid body (crc) uint crc = _DBG.CRC.ComputeCRC(assemblyDataBytes, 0); fValidAssembly = (crc == assemblyHeader.assemblyCRC); } if (fValidAssembly) { // add to compact stream deploymentStream.Write(assemblyHeaderBytes, 0, assemblyHeaderBytes.Length); deploymentStream.Write(assemblyDataBytes, 0, assemblyDataBytes.Length); // make sure we are on 4 byte boundary if (0 != (address % sizeof(UInt32))) { byte[] buff = new byte[sizeof(UInt32) - (address % sizeof(UInt32))]; deploymentStream.Write(buff, 0, buff.Length); address += sizeof(UInt32) - (address % sizeof(UInt32)); } } else { //if no, clear assemblyData, jump to next sector (if in middle of sector), or finish (if at beginning of sector) while (iSector < iSectorEnd) { Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData = flashMap.m_map[iSector]; if (addressAssemblyStart >= flashSectorData.m_address && addressAssemblyStart < flashSectorData.m_address + flashSectorData.m_size) { // jump to next sector address = flashSectorData.m_address + flashSectorData.m_size; System.Diagnostics.Debug.Assert(address == flashMap.m_map[iSector + 1].m_address); break; } iSector++; } } } //Finished reading //convert to srec MFApplicationDeploymentData data = new MFApplicationDeploymentData(); long deploymentLength = deploymentStream.Seek(0, SeekOrigin.Current); MemoryStream streamSrec = new MemoryStream(); deploymentStream.Seek(0, SeekOrigin.Begin); data.BinaryData = new byte[(int)deploymentLength]; deploymentStream.Read(data.BinaryData, 0, (int)deploymentLength); deploymentStream.Seek(0, SeekOrigin.Begin); new BinToSrec().DoConversion(deploymentStream, streamSrec, flashMap.m_map[iSectorStart].m_address); //add zero bytes to all other deployment sectors? //Get bytes long pos = streamSrec.Seek(0, SeekOrigin.Current); data.HexData = new byte[pos]; streamSrec.Seek(0, SeekOrigin.Begin); streamSrec.Read(data.HexData, 0, (int)pos); doWorkEventArgs.Result = data; }
private void Switch_1(int row, int col) { sight_row = row; sight_col = col; block_row = null; block_col = null; int BigWidth = 64; byte[] bytes = new byte[49152]; paint.Children.Clear(); for (int i = 0; i < 128; i++) { for (int j = 0; j < 128; j++) { /* * System.Windows.Shapes.Rectangle pixel = new System.Windows.Shapes.Rectangle(); * pixel.Fill = new SolidColorBrush(this.colors[col * 128 + i, row * 128 + j]); * pixel.Stroke = new SolidColorBrush(this.colors[col * 128 + i, row * 128 + j]); * pixel.Width = width; * pixel.Height = width; * pixel.SetValue(Canvas.LeftProperty, j * width + 0.0); * pixel.SetValue(Canvas.TopProperty, i * width + 0.0); * paint.Children.Add(pixel); */ bytes[49151 - (i * 128 + (127 - j)) * 3] = this.colors[row * 128 + i, col * 128 + j].R; bytes[49150 - (i * 128 + (127 - j)) * 3] = this.colors[row * 128 + i, col * 128 + j].G; bytes[49149 - (i * 128 + (127 - j)) * 3] = this.colors[row * 128 + i, col * 128 + j].B; } } int stride = 384; GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned); int scan0 = (int)handle.AddrOfPinnedObject(); scan0 += 127 * stride; Bitmap bitmap = new Bitmap(128, 128, -stride, System.Drawing.Imaging.PixelFormat.Format24bppRgb, (IntPtr)scan0); handle.Free(); System.Windows.Controls.Image img = new System.Windows.Controls.Image(); MemoryStream Ms = new MemoryStream(); bitmap.Save(Ms, System.Drawing.Imaging.ImageFormat.Bmp); Ms.Position = 0; BitmapImage ObjBitmapImage = new BitmapImage(); ObjBitmapImage.BeginInit(); ObjBitmapImage.StreamSource = Ms; ObjBitmapImage.EndInit(); img.Source = ObjBitmapImage; img.Width = 512; img.Height = 512; img.Stretch = Stretch.Uniform; paint.Children.Add(img); for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { System.Windows.Shapes.Rectangle pixel = new System.Windows.Shapes.Rectangle(); pixel.Fill = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 255, 255, 255)); pixel.Width = BigWidth; pixel.Height = BigWidth; pixel.SetValue(Canvas.LeftProperty, j * BigWidth + 0.0); pixel.SetValue(Canvas.TopProperty, i * BigWidth + 0.0); pixel.SetValue(Panel.ZIndexProperty, 1); pixel.MouseEnter += RectangleEnter; pixel.MouseMove += RectangleEnter; pixel.MouseLeave += RectangleLeave; pixel.MouseLeftButtonUp += RectanglePress; paint.Children.Add(pixel); } } this.mode = 1; }
private void Switch_0() { sight_row = null; sight_col = null; block_row = null; block_col = null; int row_adjust = row * 128; int col_adjust = colume * 128; double top = row_adjust > col_adjust ? 512.0 * (row_adjust - col_adjust) / row_adjust / 2 : 0; double left = col_adjust > row_adjust ? 512.0 * (col_adjust - row_adjust) / col_adjust / 2 : 0; double width = row_adjust > col_adjust ? 512.0 / (double)row_adjust : 512.0 / (double)col_adjust; double BigWidth = width * 128.0; byte[] bytes = new byte[3 * row_adjust * col_adjust]; paint.Children.Clear(); for (int i = 0; i < col_adjust; i++) { for (int j = 0; j < row_adjust; j++) { bytes[3 * row_adjust * col_adjust - (i * row_adjust + (row_adjust - j - 1)) * 3 - 1] = this.colors[i, j].R; bytes[3 * row_adjust * col_adjust - (i * row_adjust + (row_adjust - j - 1)) * 3 - 2] = this.colors[i, j].G; bytes[3 * row_adjust * col_adjust - (i * row_adjust + (row_adjust - j - 1)) * 3 - 3] = this.colors[i, j].B; } } int stride = row_adjust * 3; GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned); int scan0 = (int)handle.AddrOfPinnedObject(); scan0 += (col_adjust - 1) * stride; Bitmap bitmap = new Bitmap(row_adjust, col_adjust, -stride, System.Drawing.Imaging.PixelFormat.Format24bppRgb, (IntPtr)scan0); handle.Free(); System.Windows.Controls.Image img = new System.Windows.Controls.Image(); MemoryStream Ms = new MemoryStream(); bitmap.Save(Ms, System.Drawing.Imaging.ImageFormat.Bmp); Ms.Position = 0; BitmapImage ObjBitmapImage = new BitmapImage(); ObjBitmapImage.BeginInit(); ObjBitmapImage.StreamSource = Ms; ObjBitmapImage.EndInit(); img.Source = ObjBitmapImage; img.Width = 512; img.Height = 512; img.Stretch = Stretch.Uniform; paint.Children.Add(img); for (int i = 0; i < colume; i++) { for (int j = 0; j < row; j++) { System.Windows.Shapes.Rectangle pixel = new System.Windows.Shapes.Rectangle(); pixel.Fill = new SolidColorBrush(System.Windows.Media.Color.FromArgb(0, 255, 255, 255)); pixel.Width = BigWidth; pixel.Height = BigWidth; pixel.SetValue(Canvas.LeftProperty, left + j * BigWidth); pixel.SetValue(Canvas.TopProperty, top + i * BigWidth); pixel.SetValue(Panel.ZIndexProperty, 1); pixel.MouseEnter += RectangleEnter; pixel.MouseMove += RectangleEnter; pixel.MouseLeave += RectangleLeave; pixel.MouseLeftButtonUp += RectanglePress; paint.Children.Add(pixel); } } this.mode = 0; }
public CpProxyUpnpOrgContentDirectory1(CpDevice aDevice) { iHandle = CpProxyUpnpOrgContentDirectory1Create(aDevice.Handle()); iGch = GCHandle.Alloc(this); }
internal void Initialize() { adapter = DeviceEnumerator.GetAdapter(int.Parse(Settings.Model.AdapterId)); output = adapter.GetOutput1(Settings.Model.DisplayId); var scale = Settings.Model.Scale; var bounds = output.Description.DesktopBounds; var outputWidth = bounds.Right - bounds.Left; var outputHeight = bounds.Bottom - bounds.Top; renderBounds = new Rectangle(0, 0, outputWidth / scale, outputHeight / scale); fpsLocation = new RectangleF(renderBounds.Width - 92, renderBounds.Height - 19, renderBounds.Width, renderBounds.Height); device = new Device(adapter, DeviceCreationFlags.PreventAlteringLayerSettingsFromRegistry | DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.BgraSupport); gpuTexture = new Texture2D(device, new TextureDescription() { CpuAccessFlags = CpuAccessFlags.None, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, Format = Format.B8G8R8A8_UNorm, Width = outputWidth, Height = outputHeight, OptionFlags = ResourceOptionFlags.GenerateMipMaps, MipLevels = (int)Math.Log2(scale) + 1, ArraySize = 1, SampleDescription = { Count = 1, Quality = 0 }, Usage = ResourceUsage.Default }); cpuTexture = new Texture2D(device, new TextureDescription() { CpuAccessFlags = CpuAccessFlags.Read, BindFlags = BindFlags.None, Format = Format.B8G8R8A8_UNorm, Width = renderBounds.Width, Height = renderBounds.Height, OptionFlags = ResourceOptionFlags.None, MipLevels = 1, ArraySize = 1, SampleDescription = { Count = 1, Quality = 0 }, Usage = ResourceUsage.Staging }); renderDescription = new SwapChainDescription1() { BufferCount = 1, Width = renderBounds.Width, Stereo = false, Height = renderBounds.Height, Format = Format.B8G8R8A8_UNorm, SampleDescription = new SampleDescription(1, 0), Usage = Usage.BackBuffer | Usage.RenderTargetOutput, Scaling = Scaling.Stretch, SwapEffect = SwapEffect.Discard }; memBuffer = new byte[renderBounds.Height * renderBounds.Width * 4]; pinnedMemBuffer = GCHandle.Alloc(memBuffer, GCHandleType.Pinned); ptrMemBuffer = pinnedMemBuffer.AddrOfPinnedObject(); generateRecPoints(); Settings.Model.PropertyChanged += LedsChanged; duplicator = output.DuplicateOutput(device); scaler = new ShaderResourceView(device, gpuTexture); }
/// <summary> /// Create the writer indicating Metadata information /// </summary> /// <param name="output"><see cref="System.IO.Stream"/> Where resulting WMA string will be written</param> /// <param name="format">PCM format of input data received in <see cref="WmaWriter.Write"/> method</param> /// <param name="profile">IWMProfile that describe the resulting compressed stream</param> /// <param name="MetadataAttributes">Array of <see cref="Yeti.WMFSdk.WM_Attr"/> structures describing the metadata information that will be in the result stream</param> public WmaWriter(Stream output, WaveFormat format, IWMProfile profile, WM_Attr[] MetadataAttributes) : base(output, format) { m_Writer = WM.CreateWriter(); IWMWriterAdvanced wa = (IWMWriterAdvanced)m_Writer; wa.AddSink((IWMWriterSink)this); m_Writer.SetProfile(profile); uint inputs; m_Writer.GetInputCount(out inputs); if (inputs == 1) { IWMInputMediaProps InpProps; Guid type; m_Writer.GetInputProps(0, out InpProps); InpProps.GetType(out type); if (type == MediaTypes.WMMEDIATYPE_Audio) { WM_MEDIA_TYPE mt; mt.majortype = MediaTypes.WMMEDIATYPE_Audio; mt.subtype = MediaTypes.WMMEDIASUBTYPE_PCM; mt.bFixedSizeSamples = true; mt.bTemporalCompression = false; mt.lSampleSize = (uint)m_InputDataFormat.nBlockAlign; mt.formattype = MediaTypes.WMFORMAT_WaveFormatEx; mt.pUnk = IntPtr.Zero; mt.cbFormat = (uint)Marshal.SizeOf(m_InputDataFormat); GCHandle h = GCHandle.Alloc(m_InputDataFormat, GCHandleType.Pinned); try { mt.pbFormat = h.AddrOfPinnedObject(); InpProps.SetMediaType(ref mt); } finally { h.Free(); } m_Writer.SetInputProps(0, InpProps); if (MetadataAttributes != null) { WMHeaderInfo info = new WMHeaderInfo((IWMHeaderInfo)m_Writer); foreach (WM_Attr attr in MetadataAttributes) { info.SetAttribute(attr); } info = null; } m_Writer.BeginWriting(); m_Profile = profile; } else { throw new ArgumentException("Invalid profile", "profile"); } } else { throw new ArgumentException("Invalid profile", "profile"); } }
public Hv_bubbles_Context(double sampleRate, int poolKb=10) { gch = GCHandle.Alloc(msgQueue); _context = hv_bubbles_new_with_options(sampleRate, poolKb); hv_setPrintHook(_context, new PrintHook(OnPrint)); hv_setUserData(_context, GCHandle.ToIntPtr(gch)); }
internal ControlChangeNotify(Part parent) { _Parent = parent; rcwHandle = GCHandle.Alloc(this, GCHandleType.Normal); }
/// <summary> /// Submit a log entry to the journal. /// </summary> public static unsafe LogResult Log(LogFlags flags, JournalMessage message) { Socket socket = GetJournalSocket(); if (socket == null) { if (s_isSupported.Value) { return(LogResult.NotAvailable); } else { return(LogResult.NotSupported); } } if (message.IsEmpty) { return(LogResult.Success); } int priority = (int)flags & 0xf; if (priority != 0) { message.Append(JournalFieldName.Priority, priority - 1); } if (((flags & LogFlags.DontAppendSyslogIdentifier) == LogFlags.None) && SyslogIdentifier != null) { message.Append(JournalFieldName.SyslogIdentifier, SyslogIdentifier); } List <ArraySegment <byte> > data = message.GetData(); int dataLength = data.Count; if (dataLength > MaxIovs) { // We should handle this the same way as EMSGSIZE, which we don't handle atm. ErrorWhileLogging("size exceeded"); return(LogResult.Size); } Span <IOVector> iovs = stackalloc IOVector[dataLength]; Span <GCHandle> handles = stackalloc GCHandle[dataLength]; for (int i = 0; i < data.Count; i++) { handles[i] = GCHandle.Alloc(data[i].Array, GCHandleType.Pinned); iovs[i].Base = handles[i].AddrOfPinnedObject(); iovs[i].Length = new IntPtr(data[i].Count); } int sendmsgFlags = 0; if ((flags & LogFlags.DropWhenBusy) != 0) { sendmsgFlags |= MSG_DONTWAIT; } LogResult result = LogResult.Success; fixed(IOVector *pIovs = &MemoryMarshal.GetReference(iovs)) { bool loop; do { loop = false; msghdr msg; msg.msg_iov = pIovs; msg.msg_iovlen = (SizeT)dataLength; int rv = sendmsg(socket.Handle.ToInt32(), &msg, sendmsgFlags).ToInt32(); if (rv < 0) { int errno = Marshal.GetLastWin32Error(); if (errno == EINTR) { loop = true; } else if (errno == EAGAIN) { result = LogResult.Busy; } else { result = LogResult.UnknownError; ErrorWhileLogging($"errno={errno}"); } } } while (loop); } for (int i = 0; i < handles.Length; i++) { handles[i].Free(); } return(result); }
private unsafe static int EncryptDecryptHelper(OP op, SSPIInterface secModule, SafeDeleteContext context, SecurityBuffer[] input, uint sequenceNumber) { Interop.SspiCli.SecurityBufferDescriptor sdcInOut = new Interop.SspiCli.SecurityBufferDescriptor(input.Length); var unmanagedBuffer = new Interop.SspiCli.SecurityBufferStruct[input.Length]; fixed(Interop.SspiCli.SecurityBufferStruct *unmanagedBufferPtr = unmanagedBuffer) { sdcInOut.UnmanagedPointer = unmanagedBufferPtr; GCHandle[] pinnedBuffers = new GCHandle[input.Length]; byte[][] buffers = new byte[input.Length][]; try { for (int i = 0; i < input.Length; i++) { SecurityBuffer iBuffer = input[i]; unmanagedBuffer[i].count = iBuffer.size; unmanagedBuffer[i].type = iBuffer.type; if (iBuffer.token == null || iBuffer.token.Length == 0) { unmanagedBuffer[i].token = IntPtr.Zero; } else { pinnedBuffers[i] = GCHandle.Alloc(iBuffer.token, GCHandleType.Pinned); unmanagedBuffer[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(iBuffer.token, iBuffer.offset); buffers[i] = iBuffer.token; } } // The result is written in the input Buffer passed as type=BufferType.Data. int errorCode; switch (op) { case OP.Encrypt: errorCode = secModule.EncryptMessage(context, sdcInOut, sequenceNumber); break; case OP.Decrypt: errorCode = secModule.DecryptMessage(context, sdcInOut, sequenceNumber); break; case OP.MakeSignature: errorCode = secModule.MakeSignature(context, sdcInOut, sequenceNumber); break; case OP.VerifySignature: errorCode = secModule.VerifySignature(context, sdcInOut, sequenceNumber); break; default: if (GlobalLog.IsEnabled) { GlobalLog.Assert("SSPIWrapper::EncryptDecryptHelper", "Unknown OP: " + op); } Debug.Fail("SSPIWrapper::EncryptDecryptHelper", "Unknown OP: " + op); throw NotImplemented.ByDesignWithMessage(SR.net_MethodNotImplementedException); } // Marshalling back returned sizes / data. for (int i = 0; i < input.Length; i++) { SecurityBuffer iBuffer = input[i]; iBuffer.size = unmanagedBuffer[i].count; iBuffer.type = unmanagedBuffer[i].type; if (iBuffer.size == 0) { iBuffer.offset = 0; iBuffer.token = null; } else { checked { // Find the buffer this is inside of. Usually they all point inside buffer 0. int j; for (j = 0; j < input.Length; j++) { if (buffers[j] == null) { continue; } byte *bufferAddress = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(buffers[j], 0); if ((byte *)unmanagedBuffer[i].token >= bufferAddress && (byte *)unmanagedBuffer[i].token + iBuffer.size <= bufferAddress + buffers[j].Length) { iBuffer.offset = (int)((byte *)unmanagedBuffer[i].token - bufferAddress); iBuffer.token = buffers[j]; break; } } if (j >= input.Length) { if (GlobalLog.IsEnabled) { GlobalLog.Assert("SSPIWrapper::EncryptDecryptHelper", "Output buffer out of range."); } Debug.Fail("SSPIWrapper::EncryptDecryptHelper", "Output buffer out of range."); iBuffer.size = 0; iBuffer.offset = 0; iBuffer.token = null; } } } // Backup validate the new sizes. if (iBuffer.offset < 0 || iBuffer.offset > (iBuffer.token == null ? 0 : iBuffer.token.Length)) { if (GlobalLog.IsEnabled) { GlobalLog.AssertFormat("SSPIWrapper::EncryptDecryptHelper|'offset' out of range. [{0}]", iBuffer.offset); } Debug.Fail("SSPIWrapper::EncryptDecryptHelper|'offset' out of range. [" + iBuffer.offset + "]"); } if (iBuffer.size < 0 || iBuffer.size > (iBuffer.token == null ? 0 : iBuffer.token.Length - iBuffer.offset)) { if (GlobalLog.IsEnabled) { GlobalLog.AssertFormat("SSPIWrapper::EncryptDecryptHelper|'size' out of range. [{0}]", iBuffer.size); } Debug.Fail("SSPIWrapper::EncryptDecryptHelper|'size' out of range. [" + iBuffer.size + "]"); } } if (errorCode != 0 && NetEventSource.Log.IsEnabled()) { if (errorCode == Interop.SspiCli.SEC_I_RENEGOTIATE) { NetEventSource.PrintError(NetEventSource.ComponentType.Security, SR.Format(SR.event_OperationReturnedSomething, op, "SEC_I_RENEGOTIATE")); } else { NetEventSource.PrintError(NetEventSource.ComponentType.Security, SR.Format(SR.net_log_operation_failed_with_error, op, String.Format(CultureInfo.CurrentCulture, "0X{0:X}", errorCode))); } } return(errorCode); } finally { for (int i = 0; i < pinnedBuffers.Length; ++i) { if (pinnedBuffers[i].IsAllocated) { pinnedBuffers[i].Free(); } } } } }
internal static unsafe byte[] DownloadAsset(string uri, ref TimeSpan remainingDownloadTime) { if (remainingDownloadTime <= TimeSpan.Zero) { return(null); } List <byte[]> dataPieces = new List <byte[]>(); using (Interop.libcurl.SafeCurlHandle curlHandle = Interop.libcurl.curl_easy_init()) { GCHandle gcHandle = GCHandle.Alloc(dataPieces); try { IntPtr dataHandlePtr = GCHandle.ToIntPtr(gcHandle); Interop.libcurl.curl_easy_setopt(curlHandle, Interop.libcurl.CURLoption.CURLOPT_URL, uri); Interop.libcurl.curl_easy_setopt(curlHandle, Interop.libcurl.CURLoption.CURLOPT_WRITEDATA, dataHandlePtr); Interop.libcurl.curl_easy_setopt(curlHandle, Interop.libcurl.CURLoption.CURLOPT_WRITEFUNCTION, s_writeCallback); Interop.libcurl.curl_easy_setopt(curlHandle, Interop.libcurl.CURLoption.CURLOPT_FOLLOWLOCATION, 1L); Stopwatch stopwatch = Stopwatch.StartNew(); int res = Interop.libcurl.curl_easy_perform(curlHandle); stopwatch.Stop(); // TimeSpan.Zero isn't a worrisome value on the subtraction, it only // means "no limit" on the original input. remainingDownloadTime -= stopwatch.Elapsed; if (res != Interop.libcurl.CURLcode.CURLE_OK) { return(null); } } finally { gcHandle.Free(); } } if (dataPieces.Count == 0) { return(null); } if (dataPieces.Count == 1) { return(dataPieces[0]); } int dataLen = 0; for (int i = 0; i < dataPieces.Count; i++) { dataLen += dataPieces[i].Length; } byte[] data = new byte[dataLen]; int offset = 0; for (int i = 0; i < dataPieces.Count; i++) { byte[] piece = dataPieces[i]; Buffer.BlockCopy(piece, 0, data, offset, piece.Length); offset += piece.Length; } return(data); }
// Convert the raw data in the frame's buffer into the bitmap's data. This method doesn't support // the following Pixel formats: eFmtRgb48, eFmtYuv411 and eFmtYuv444. static unsafe bool Frame2Data(ref BitmapData Data) { switch (GCamera.Frame.Format) { case tImageFormat.eFmtMono8: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; while (lOffset < GCamera.Frame.ImageBufferSize) { lDst[lPos] = GCamera.Buffer[lOffset]; lDst[lPos + 1] = GCamera.Buffer[lOffset]; lDst[lPos + 2] = GCamera.Buffer[lOffset]; lOffset++; lPos += 3; // Take care of the padding in the destination bitmap. if ((lOffset % GCamera.Frame.Width) == 0) { lPos += (UInt32)Data.Stride - (GCamera.Frame.Width * 3); } } return(true); } case tImageFormat.eFmtMono16: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; byte bitshift = (byte)((int)GCamera.Frame.BitDepth - 8); UInt16 *lSrc = (UInt16 *)GCamera.Frame.ImageBuffer; while (lOffset < GCamera.Frame.Width * GCamera.Frame.Height) { lDst[lPos] = (byte)(lSrc[lOffset] >> bitshift); lDst[lPos + 1] = lDst[lPos]; lDst[lPos + 2] = lDst[lPos]; lOffset++; lPos += 3; // Take care of the padding in the destination bitmap. if ((lOffset % GCamera.Frame.Width) == 0) { lPos += (UInt32)Data.Stride - (GCamera.Frame.Width * 3); } } return(true); } case tImageFormat.eFmtBayer8: { UInt32 WidthSize = GCamera.Frame.Width * 3; GCHandle pFrame = GCHandle.Alloc(GCamera.Frame, GCHandleType.Pinned); UInt32 remainder = (((WidthSize + 3U) & ~3U) - WidthSize); // Interpolate the colors. IntPtr pRed = (IntPtr)((byte *)Data.Scan0 + 2); IntPtr pGreen = (IntPtr)((byte *)Data.Scan0 + 1); IntPtr pBlue = (IntPtr)((byte *)Data.Scan0); Pv.ColorInterpolate(pFrame.AddrOfPinnedObject(), pRed, pGreen, pBlue, 2, remainder); pFrame.Free(); return(true); } case tImageFormat.eFmtBayer16: { UInt32 WidthSize = GCamera.Frame.Width * 3; UInt32 lOffset = 0; byte bitshift = (byte)((int)GCamera.Frame.BitDepth - 8); UInt16 * lSrc = (UInt16 *)GCamera.Frame.ImageBuffer; byte * lDst = (byte *)GCamera.Frame.ImageBuffer; UInt32 remainder = (((WidthSize + 3U) & ~3U) - WidthSize); GCHandle pFrame; GCamera.Frame.Format = tImageFormat.eFmtBayer8; pFrame = GCHandle.Alloc(GCamera.Frame, GCHandleType.Pinned); // Shift the pixel. while (lOffset < GCamera.Frame.Width * GCamera.Frame.Height) { lDst[lOffset] = (byte)(lSrc[lOffset++] >> bitshift); } // Interpolate the colors. IntPtr pRed = (IntPtr)((byte *)Data.Scan0 + 2); IntPtr pGreen = (IntPtr)((byte *)Data.Scan0 + 1); IntPtr pBlue = (IntPtr)((byte *)Data.Scan0); Pv.ColorInterpolate(pFrame.AddrOfPinnedObject(), pRed, pGreen, pBlue, 2, remainder); pFrame.Free(); return(true); } case tImageFormat.eFmtRgb24: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; while (lOffset < GCamera.Frame.ImageBufferSize) { // Copy the data. lDst[lPos] = GCamera.Buffer[lOffset + 2]; lDst[lPos + 1] = GCamera.Buffer[lOffset + 1]; lDst[lPos + 2] = GCamera.Buffer[lOffset]; lOffset += 3; lPos += 3; // Take care of the padding in the destination bitmap. if ((lOffset % (GCamera.Frame.Width * 3)) == 0) { lPos += (UInt32)Data.Stride - (GCamera.Frame.Width * 3); } } return(true); } case tImageFormat.eFmtRgb48: { UInt32 lOffset = 0; UInt32 lPos = 0; UInt32 lLength = GCamera.Frame.ImageBufferSize / sizeof(UInt16); UInt16 *lSrc = (UInt16 *)GCamera.Frame.ImageBuffer; byte * lDst = (byte *)Data.Scan0; byte bitshift = (byte)((int)GCamera.Frame.BitDepth - 8); while (lOffset < lLength) { // Copy the data. lDst[lPos] = (byte)(lSrc[lOffset + 2] >> bitshift); lDst[lPos + 1] = (byte)(lSrc[lOffset + 1] >> bitshift); lDst[lPos + 2] = (byte)(lSrc[lOffset] >> bitshift); lOffset += 3; lPos += 3; // Take care of the padding in the destination bitmap. if ((lOffset % (GCamera.Frame.Width * 3)) == 0) { lPos += (UInt32)Data.Stride - (GCamera.Frame.Width * 3); } } return(true); } case tImageFormat.eFmtYuv411: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; int y1, y2, y3, y4, u, v; int r, g, b; r = g = b = 0; while (lOffset < GCamera.Frame.ImageBufferSize) { u = GCamera.Buffer[lOffset++]; y1 = GCamera.Buffer[lOffset++]; y2 = GCamera.Buffer[lOffset++]; v = GCamera.Buffer[lOffset++]; y3 = GCamera.Buffer[lOffset++]; y4 = GCamera.Buffer[lOffset++]; YUV2RGB(y1, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; YUV2RGB(y2, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; YUV2RGB(y3, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; YUV2RGB(y4, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; } return(true); } case tImageFormat.eFmtYuv422: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; int y1, y2, u, v; int r, g, b; r = g = b = 0; while (lOffset < GCamera.Frame.ImageBufferSize) { u = GCamera.Buffer[lOffset++]; y1 = GCamera.Buffer[lOffset++]; v = GCamera.Buffer[lOffset++]; y2 = GCamera.Buffer[lOffset++]; YUV2RGB(y1, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; YUV2RGB(y2, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; } return(true); } case tImageFormat.eFmtYuv444: { UInt32 lOffset = 0; UInt32 lPos = 0; byte * lDst = (byte *)Data.Scan0; int y1, y2, u, v; int r, g, b; r = g = b = 0; while (lOffset < GCamera.Frame.ImageBufferSize) { u = GCamera.Buffer[lOffset++]; y1 = GCamera.Buffer[lOffset++]; v = GCamera.Buffer[lOffset++]; lOffset++; y2 = GCamera.Buffer[lOffset++]; lOffset++; YUV2RGB(y1, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; YUV2RGB(y2, u, v, ref r, ref g, ref b); lDst[lPos++] = (byte)b; lDst[lPos++] = (byte)g; lDst[lPos++] = (byte)r; } return(true); } default: return(false); } }
public static IntPtr Pin(UInt32 size, eLeapAllocatorType typeHint, IntPtr state) { try { //Construct a key to identify the desired allocation PoolKey key = new PoolKey() { type = typeHint, size = size }; //Attempt to find the pool that holds this type of allocation Queue <object> pool; if (!_pooledMemory.TryGetValue(key, out pool)) { //Construct a new pool if none exists yet pool = new Queue <object>(); _pooledMemory[key] = pool; } //Attempt to get an object from the pool object memory; if (EnablePooling && pool.Count > MinPoolSize) { memory = pool.Dequeue(); } else { //If the pool is empty, we need to construct a new object switch (typeHint) { default: case eLeapAllocatorType.eLeapAllocatorType_Uint8: memory = new byte[size]; break; case eLeapAllocatorType.eLeapAllocatorType_Float: memory = new float[(size + sizeof(float) - 1) / sizeof(float)]; break; } } //Pin the object so its address will not change GCHandle handle = GCHandle.Alloc(memory, GCHandleType.Pinned); IntPtr ptr = handle.AddrOfPinnedObject(); //Put the information about the newly pinned allocation into the //active memory map so it can be retrieved and freed layer. _activeMemory.TryAdd(ptr, new ActiveMemoryInfo() { handle = handle, key = key }); return(ptr); } catch (Exception e) { UnityEngine.Debug.LogException(e); } return(IntPtr.Zero); }
public InputStream(SoundIO.Device device) { _self = GCHandle.Alloc(this); _device = device; OpenStream(); }
/// <summary>Actually sends the data to mIRC.</summary> private Task <string> dispatchMessageAsync(uint message, string command, short eventID, CancellationToken token) { var taskSource = new TaskCompletionSource <string>(); var buffer = new byte[FileSize]; prepareMappedFile(message, command, buffer); // Send the command to mIRC. currentDelegate = this.commandCallback; SendMessageCallbackW(this.targetWindow, message, new IntPtr(24 | eventID << 16), this.fileNumber, currentDelegate, (IntPtr)GCHandle.Alloc(taskSource)); token.Register(() => this.cancelled(taskSource)); return(taskSource.Task); }
/// Starts a service in the machine specified. public void Start(string[] args) { if (args == null) { throw new ArgumentNullException("args"); } IntPtr serviceHandle = GetServiceHandle(Interop.mincore.ServiceOptions.SERVICE_START); try { IntPtr[] argPtrs = new IntPtr[args.Length]; int i = 0; try { for (i = 0; i < args.Length; i++) { if (args[i] == null) { throw new ArgumentNullException(SR.ArgsCantBeNull, "args"); } argPtrs[i] = Marshal.StringToHGlobalUni(args[i]); } } catch { for (int j = 0; j < i; j++) { Marshal.FreeHGlobal(argPtrs[i]); } throw; } GCHandle argPtrsHandle = new GCHandle(); try { argPtrsHandle = GCHandle.Alloc(argPtrs, GCHandleType.Pinned); bool result = Interop.mincore.StartService(serviceHandle, args.Length, (IntPtr)argPtrsHandle.AddrOfPinnedObject()); if (!result) { Exception inner = new Win32Exception(Marshal.GetLastWin32Error()); throw new InvalidOperationException(SR.Format(SR.CannotStart, ServiceName, _machineName), inner); } } finally { for (i = 0; i < args.Length; i++) { Marshal.FreeHGlobal(argPtrs[i]); } if (argPtrsHandle.IsAllocated) { argPtrsHandle.Free(); } } } finally { Interop.mincore.CloseServiceHandle(serviceHandle); } }
// This essentially wraps SSL* SSL_new() internal static SafeSslHandle AllocateSslHandle(SafeFreeSslCredentials credential, SslAuthenticationOptions sslAuthenticationOptions) { SafeSslHandle? sslHandle = null; SafeSslContextHandle?sslCtxHandle = null; SafeSslContextHandle?newCtxHandle = null; SslProtocols protocols = CalculateEffectiveProtocols(sslAuthenticationOptions); bool hasAlpn = sslAuthenticationOptions.ApplicationProtocols != null && sslAuthenticationOptions.ApplicationProtocols.Count != 0; bool cacheSslContext = !DisableTlsResume && sslAuthenticationOptions.EncryptionPolicy == EncryptionPolicy.RequireEncryption && sslAuthenticationOptions.CipherSuitesPolicy == null; if (cacheSslContext) { if (sslAuthenticationOptions.IsClient) { // We don't support client resume on old OpenSSL versions. // We don't want to try on empty TargetName since that is our key. // And we don't want to mess up with client authentication. It may be possible // but it seems safe to get full new session. if (!Interop.Ssl.Capabilities.Tls13Supported || string.IsNullOrEmpty(sslAuthenticationOptions.TargetHost) || sslAuthenticationOptions.CertificateContext != null || sslAuthenticationOptions.CertSelectionDelegate != null) { cacheSslContext = false; } } else { // Server should always have certificate Debug.Assert(sslAuthenticationOptions.CertificateContext != null); if (sslAuthenticationOptions.CertificateContext == null || sslAuthenticationOptions.CertificateContext.SslContexts == null) { cacheSslContext = false; } } } if (cacheSslContext) { if (sslAuthenticationOptions.IsServer) { sslAuthenticationOptions.CertificateContext !.SslContexts !.TryGetValue(protocols | (hasAlpn ? FakeAlpnSslProtocol : SslProtocols.None), out sslCtxHandle); } else { s_clientSslContexts.TryGetValue(protocols, out sslCtxHandle); } } if (sslCtxHandle == null) { // We did not get SslContext from cache sslCtxHandle = newCtxHandle = AllocateSslContext(credential, sslAuthenticationOptions, protocols, cacheSslContext); if (cacheSslContext) { bool added = sslAuthenticationOptions.IsServer ? sslAuthenticationOptions.CertificateContext !.SslContexts !.TryAdd(protocols | (SslProtocols)(hasAlpn ? 1 : 0), newCtxHandle) : s_clientSslContexts.TryAdd(protocols, newCtxHandle); if (added) { newCtxHandle = null; } } } GCHandle alpnHandle = default; try { sslHandle = SafeSslHandle.Create(sslCtxHandle, sslAuthenticationOptions.IsServer); Debug.Assert(sslHandle != null, "Expected non-null return value from SafeSslHandle.Create"); if (sslHandle.IsInvalid) { sslHandle.Dispose(); throw CreateSslException(SR.net_allocate_ssl_context_failed); } if (sslAuthenticationOptions.ApplicationProtocols != null && sslAuthenticationOptions.ApplicationProtocols.Count != 0) { if (sslAuthenticationOptions.IsServer) { Debug.Assert(Interop.Ssl.SslGetData(sslHandle) == IntPtr.Zero); alpnHandle = GCHandle.Alloc(sslAuthenticationOptions.ApplicationProtocols); Interop.Ssl.SslSetData(sslHandle, GCHandle.ToIntPtr(alpnHandle)); sslHandle.AlpnHandle = alpnHandle; } else { if (Interop.Ssl.SslSetAlpnProtos(sslHandle, sslAuthenticationOptions.ApplicationProtocols) != 0) { throw CreateSslException(SR.net_alpn_config_failed); } } } if (sslAuthenticationOptions.IsClient) { // The IdnMapping converts unicode input into the IDNA punycode sequence. string punyCode = string.IsNullOrEmpty(sslAuthenticationOptions.TargetHost) ? string.Empty : s_idnMapping.GetAscii(sslAuthenticationOptions.TargetHost !); // Similar to windows behavior, set SNI on openssl by default for client context, ignore errors. if (!Ssl.SslSetTlsExtHostName(sslHandle, punyCode)) { Crypto.ErrClearError(); } if (cacheSslContext && !string.IsNullOrEmpty(punyCode)) { sslCtxHandle.TrySetSession(sslHandle, punyCode); } // relevant to TLS 1.3 only: if user supplied a client cert or cert callback, // advertise that we are willing to send the certificate post-handshake. if (sslAuthenticationOptions.ClientCertificates?.Count > 0 || sslAuthenticationOptions.CertSelectionDelegate != null) { Ssl.SslSetPostHandshakeAuth(sslHandle, 1); } // Set client cert callback, this will interrupt the handshake with SecurityStatusPalErrorCode.CredentialsNeeded // if server actually requests a certificate. Ssl.SslSetClientCertCallback(sslHandle, 1); } else // sslAuthenticationOptions.IsServer { if (sslAuthenticationOptions.RemoteCertRequired) { Ssl.SslSetVerifyPeer(sslHandle); } if (sslAuthenticationOptions.CertificateContext?.Trust?._sendTrustInHandshake == true) { SslCertificateTrust trust = sslAuthenticationOptions.CertificateContext !.Trust !; X509Certificate2Collection certList = (trust._trustList ?? trust._store !.Certificates); Debug.Assert(certList != null, "certList != null"); Span <IntPtr> handles = certList.Count <= 256 ? stackalloc IntPtr[256] : new IntPtr[certList.Count]; for (int i = 0; i < certList.Count; i++) { handles[i] = certList[i].Handle; } if (!Ssl.SslAddClientCAs(sslHandle, handles.Slice(0, certList.Count))) { // The method can fail only when the number of cert names exceeds the maximum capacity // supported by STACK_OF(X509_NAME) structure, which should not happen under normal // operation. Debug.Fail("Failed to add issuer to trusted CA list."); } } } } catch { if (alpnHandle.IsAllocated) { alpnHandle.Free(); } throw; } finally { newCtxHandle?.Dispose(); } return(sslHandle); }
// // How do we support "null" values, should the caller take care of that? // // The caller is responsible for calling value_free_value on the returned Value public static Value FromObject(object v, bool box_value_types) { Value value = new Value(); unsafe { if (box_value_types && (v is ValueType || v is string)) { value.boxed_valuetype = GCHandle.Alloc(v); } if (v is IEasingFunction && !(v is EasingFunctionBase)) { v = new EasingFunctionWrapper(v as IEasingFunction); } if (v is INativeEventObjectWrapper) { INativeEventObjectWrapper dov = (INativeEventObjectWrapper)v; if (dov.NativeHandle == IntPtr.Zero) { throw new Exception(String.Format( "Object {0} has not set its native property", dov.GetType())); } NativeMethods.event_object_ref(dov.NativeHandle); value.Kind = dov.GetKind(); value.u.p = dov.NativeHandle; } else if (v is DependencyProperty) { value.Kind = Kind.DEPENDENCYPROPERTY; value.u.p = ((DependencyProperty)v).Native; } else if (v is int || (v.GetType().IsEnum&& Enum.GetUnderlyingType(v.GetType()) == typeof(int))) { value.Kind = Deployment.Current.Types.TypeToKind(v.GetType()); value.u.i32 = (int)v; } else if (v is byte || (v.GetType().IsEnum&& Enum.GetUnderlyingType(v.GetType()) == typeof(byte))) { value.Kind = Deployment.Current.Types.TypeToKind(v.GetType()); value.u.i32 = (byte)v; } else if (v is bool) { value.Kind = Kind.BOOL; value.u.i32 = ((bool)v) ? 1 : 0; } else if (v is double) { value.Kind = Kind.DOUBLE; value.u.d = (double)v; } else if (v is float) { value.Kind = Kind.FLOAT; value.u.f = (float)v; } else if (v is long) { value.Kind = Kind.INT64; value.u.i64 = (long)v; } else if (v is TimeSpan) { TimeSpan ts = (TimeSpan)v; value.Kind = Kind.TIMESPAN; value.u.i64 = ts.Ticks; } else if (v is ulong) { value.Kind = Kind.UINT64; value.u.ui64 = (ulong)v; } else if (v is uint) { value.Kind = Kind.UINT32; value.u.ui32 = (uint)v; } else if (v is char) { value.Kind = Kind.CHAR; value.u.ui32 = (uint)(char)v; } else if (v is string) { value.Kind = Kind.STRING; value.u.p = StringToIntPtr((string)v); } else if (v is Rect) { Rect rect = (Rect)v; value.Kind = Kind.RECT; value.u.p = Marshal.AllocHGlobal(sizeof(Rect)); Marshal.StructureToPtr(rect, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is Size) { Size size = (Size)v; value.Kind = Kind.SIZE; value.u.p = Marshal.AllocHGlobal(sizeof(Size)); Marshal.StructureToPtr(size, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is CornerRadius) { CornerRadius corner = (CornerRadius)v; value.Kind = Kind.CORNERRADIUS; value.u.p = Marshal.AllocHGlobal(sizeof(CornerRadius)); Marshal.StructureToPtr(corner, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is AudioFormat) { AudioFormat f = (AudioFormat)v; value.Kind = Kind.AUDIOFORMAT; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedAudioFormat)); UnmanagedAudioFormat *format = (UnmanagedAudioFormat *)value.u.p; format->bitsPerSample = f.BitsPerSample; format->channels = f.Channels; format->samplesPerSecond = f.SamplesPerSecond; format->waveFormat = f.WaveFormat; } else if (v is VideoFormat) { VideoFormat f = (VideoFormat)v; value.Kind = Kind.VIDEOFORMAT; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedVideoFormat)); UnmanagedVideoFormat *format = (UnmanagedVideoFormat *)value.u.p; format->framesPerSecond = f.FramesPerSecond; format->height = f.PixelHeight; format->width = f.PixelWidth; format->stride = f.Stride; format->pixelFormat = f.PixelFormat; } else if (v is Point) { Point pnt = (Point)v; value.Kind = Kind.POINT; value.u.p = Marshal.AllocHGlobal(sizeof(Point)); Marshal.StructureToPtr(pnt, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is Thickness) { Thickness thickness = (Thickness)v; value.Kind = Kind.THICKNESS; value.u.p = Marshal.AllocHGlobal(sizeof(Thickness)); Marshal.StructureToPtr(thickness, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is Color) { Color c = (Color)v; value.Kind = Kind.COLOR; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedColor)); UnmanagedColor *color = (UnmanagedColor *)value.u.p; color->r = c.R / 255.0f; color->g = c.G / 255.0f; color->b = c.B / 255.0f; color->a = c.A / 255.0f; } else if (v is Matrix) { // hack around the fact that managed Matrix is a struct while unmanaged Matrix is a DO // i.e. the unmanaged and managed structure layouts ARE NOT equal return(FromObject(new UnmanagedMatrix((Matrix)v), box_value_types)); } else if (v is StylusPoint) { return(FromObject(new UnmanagedStylusPoint((StylusPoint)v), box_value_types)); } else if (v is Matrix3D) { // hack around the fact that managed Matrix3D is a struct while unmanaged Matrix3D is a DO // i.e. the unmanaged and managed structure layouts ARE NOT equal return(FromObject(new UnmanagedMatrix3D((Matrix3D)v), box_value_types)); } else if (v is Duration) { Duration d = (Duration)v; value.Kind = Kind.DURATION; value.u.p = Marshal.AllocHGlobal(sizeof(Duration)); Marshal.StructureToPtr(d, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is KeyTime) { KeyTime k = (KeyTime)v; value.Kind = Kind.KEYTIME; value.u.p = Marshal.AllocHGlobal(sizeof(KeyTime)); Marshal.StructureToPtr(k, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is RepeatBehavior) { RepeatBehavior d = (RepeatBehavior)v; value.Kind = Kind.REPEATBEHAVIOR; value.u.p = Marshal.AllocHGlobal(sizeof(RepeatBehavior)); Marshal.StructureToPtr(d, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is FontFamily) { FontFamily family = (FontFamily)v; value.Kind = Kind.FONTFAMILY; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedFontFamily)); Marshal.StructureToPtr(family, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is FontSource) { FontSource source = (FontSource)v; value.Kind = Kind.FONTSOURCE; if (source.wrapper != null || source.typeface != null) { value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedFontSource)); UnmanagedFontSource *ufs = (UnmanagedFontSource *)value.u.p; ufs->type = source.type; switch (source.type) { case FontSourceType.ManagedStream: ManagedStreamCallbacks callbacks = source.wrapper.GetCallbacks(); ufs->source.stream = Marshal.AllocHGlobal(sizeof(UnmanagedStreamCallbacks)); Marshal.StructureToPtr(callbacks, ufs->source.stream, false); break; case FontSourceType.GlyphTypeface: ufs->source.typeface = source.typeface.Native; break; } } else { value.IsNull = true; } } else if (v is PropertyPath) { PropertyPath propertypath = (PropertyPath)v; value.Kind = Kind.PROPERTYPATH; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedPropertyPath)); UnmanagedPropertyPath *upp = (UnmanagedPropertyPath *)value.u.p; upp->property = propertypath.NativeDP; if (upp->property == IntPtr.Zero) { upp->pathString = StringToIntPtr(propertypath.Path); upp->expandedPathString = StringToIntPtr(propertypath.ExpandedPath); } else { upp->pathString = IntPtr.Zero; upp->expandedPathString = IntPtr.Zero; } } else if (v is Uri) { Uri uri = (Uri)v; value.Kind = Kind.URI; value.u.p = UriHelper.ToNativeUri(uri); } else if (v is XmlLanguage) { XmlLanguage lang = (XmlLanguage)v; value.Kind = Kind.XMLLANGUAGE; value.u.p = StringToIntPtr(lang.IetfLanguageTag); } else if (v is Cursor) { Cursor c = (Cursor)v; value.Kind = Kind.CURSORTYPE; value.u.i32 = (int)c.cursor; } else if (v is GridLength) { GridLength gl = (GridLength)v; value.Kind = Kind.GRIDLENGTH; value.u.p = Marshal.AllocHGlobal(sizeof(GridLength)); Marshal.StructureToPtr(gl, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is FontStretch) { FontStretch stretch = (FontStretch)v; value.Kind = Kind.FONTSTRETCH; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedFontStretch)); Marshal.StructureToPtr(stretch, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is FontStyle) { FontStyle style = (FontStyle)v; value.Kind = Kind.FONTSTYLE; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedFontStyle)); Marshal.StructureToPtr(style, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is FontWeight) { FontWeight weight = (FontWeight)v; value.Kind = Kind.FONTWEIGHT; value.u.p = Marshal.AllocHGlobal(sizeof(UnmanagedFontWeight)); Marshal.StructureToPtr(weight, value.u.p, false); // Unmanaged and managed structure layout is equal. } else if (v is TextDecorationCollection) { value.Kind = Kind.TEXTDECORATIONS; value.u.i32 = (int)(v as TextDecorationCollection).Kind; } else if (v is Type) { Type t = v as Type; value.Kind = Kind.MANAGEDTYPEINFO; value.u.p = NativeMethods.managed_type_info_new(Deployment.Current.Types.TypeToKind(t)); } else if (v is Value) { throw new InvalidOperationException("You can not create a Mono.Value from a Mono.Value."); } else { //Console.WriteLine ("Do not know how to encode {0} yet, boxing it", v.GetType ()); // TODO: We probably need to marshal types that can animate as the // corresponding type (Point, Double, Color, etc). // TODO: We need to store the GCHandle somewhere so that we can free it, // or register a callback on the surface for the unmanaged code to call. GCHandle handle = GCHandle.Alloc(v); value.IsGCHandle = true; value.Kind = Deployment.Current.Types.TypeToKind(v.GetType()); value.u.p = GCHandle.ToIntPtr(handle); } } return(value); }
public void PersistUntilCalled() { release_on_call = true; gch = GCHandle.Alloc(this); }
private _AudioConverter() { _handle = GCHandle.Alloc(this); _audioConverter = new IntPtr(); }