C# UnmanagedMemoryStream.CopyTo方法代码示例

        public unsafe static void OnFillBuffer(byte * pData, long lDataLen)
        {
            Trace.WriteLine(++i + ": _EncodeInternal: " + lDataLen);

            using (var f = File.Open("dump.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite))
            {
                f.Seek(0, SeekOrigin.End);

                using (var b = new BinaryWriter(f))
                {
                    b.Write((int)lDataLen);

                    using (UnmanagedMemoryStream ms = new UnmanagedMemoryStream(pData, lDataLen))
                    {
                        ms.CopyTo(f);
                    }
                }
            }

            //if (m_Bitmap == null)
            //{
            //    m_Bitmap = new Bitmap(@"D:\Dev\comDemo\Filters\logo.bmp");

            //    Rectangle bounds = new Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height);
            //    var m_BitmapData = m_Bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            //    var RowSizeBytes = m_BitmapData.Stride;

            //    int total_size = m_BitmapData.Stride * m_BitmapData.Height;
            //    if (ImageBytes == null || ImageBytes.Length != total_size)
            //    {
            //        ImageBytes = new byte[total_size];
            //    }
            //    // Copy the data into the ImageBytes array.
            //    Marshal.Copy(m_BitmapData.Scan0, ImageBytes, 0, total_size);

            //    encoder.EncodeRGBtoI420(ImageBytes, m_Bitmap.Width, m_Bitmap.Height, ref yuv, true);
            //}
            //else
            //if(f != null)
            {
                //f.OnFillBuffer(pData, lDataLen);
            }
        }

 public void Update()
 {
     //bool mutexCreated;
     //Mutex mutex = new Mutex(true, "InteractiveSpaceRectifiedTabletopMutex2", out mutexCreated);
     
     using (MemoryMappedViewStream mmfStream = rectifiedTabletopMmf.CreateViewStream())
     {
         unsafe
         {
             ReadLockedWrapperPtr ptr = ResultsDllWrapper.lockFactoryImage(ImageProductType.RectifiedTabletopProduct);
             using (UnmanagedMemoryStream srcStream = new UnmanagedMemoryStream(ptr.BytePtr, imgSize, imgSize, FileAccess.Read))
             {
                 srcStream.CopyTo(mmfStream);
             }
             ResultsDllWrapper.releaseReadLockedWrapperPtr(ptr);
         }
     }
     //mutex.ReleaseMutex();
 }

        /// <summary>
        /// Sends the specified UIImage to the AirPlay device.
        /// </summary>
        /// <param name='service'>
        /// NSNetService (extension method target) representing the AirPlay device.
        /// </param>
        /// <param name='image'>
        /// The UIImage to be send to the device.
        /// </param>
        /// <param name='complete'>
        /// Optional method to be called when the operation is complete. True will be supplied if the action was
        /// successful, false if a problem occured.
        /// </param>
        public static unsafe void SendTo(this NSNetService service, UIImage image, Action<bool> complete)
        {
            if (service == null) {
                if (complete != null)
                    complete (false);
                return;
            }

            // In general I prefer WebClient *Async methods but it does not provide methods to
            // upload Stream and allocating a (not really required) byte[] is a huge waste
            ThreadPool.QueueUserWorkItem (delegate {
                bool ok = true;
                try {
                    string url = String.Format ("http://{0}:{1}/photo", service.HostName, service.Port);
                    var req = (HttpWebRequest) WebRequest.Create (url);
                    using (var data = image.AsJPEG ()) {
                        req.Method = "PUT";
                        req.ContentLength = (int) data.Length;
                        req.UserAgent = "AirPlay/160.4 (Photos)";
                        req.Headers.Add ("X-Apple-AssetKey", Guid.NewGuid ().ToString ());
                        req.Headers.Add ("X-Apple-Session-ID", session.ToString ());
                        var s = req.GetRequestStream ();
                        using (Stream ums = new UnmanagedMemoryStream ((byte *) data.Bytes, (int) data.Length))
                            ums.CopyTo (s);
                    }
                    req.GetResponse ().Dispose ();
                }
                catch {
                    ok = false;
                }
                finally {
                    if (complete != null) {
                        NSRunLoop.Main.InvokeOnMainThread (delegate {
                            complete (ok);
                        });
                    }
                }
            });
        }

 public Sound CreateSound(UnmanagedMemoryStream data, SoundMode mode = SoundMode.Default)
 {
     var stream = new MemoryStream();
     data.CopyTo(stream);
     return CreateSound(stream.ToArray(), mode);
 }

        public unsafe void Compile(ScriptSource source, Stream compiledCodeDestination)
        {
            ClaimContext();

            uint bufferSize = 0;
            Errors.ThrowIfIs(api_.JsSerializeScript(source.SourceText, IntPtr.Zero, ref bufferSize));
            if (bufferSize > int.MaxValue)
                throw new OutOfMemoryException();

            IntPtr mem = Marshal.AllocCoTaskMem(unchecked((int)bufferSize));
            var error = api_.JsSerializeScript(source.SourceText, mem, ref bufferSize);
            if (error != JsErrorCode.JsNoError)
            {
                Marshal.FreeCoTaskMem(mem);
                Errors.ThrowFor(error);
            }

            using (UnmanagedMemoryStream ums = new UnmanagedMemoryStream((byte*)mem.ToPointer(), bufferSize))
            {
                ums.CopyTo(compiledCodeDestination);
            }
            Marshal.FreeCoTaskMem(mem);
        }

        public unsafe void SaveTerrain(string path, string name)
        {
            using (var stream = File.Create(path))
            {
                using (var bw = new BinaryWriter(stream, Encoding.Default, true))
                {
                    bw.Write(name);

                    bw.Write(this.Size.Width);
                    bw.Write(this.Size.Height);
                    bw.Write(this.Size.Depth);
                }

                fixed (TileData* v = this.m_tileGrid)
                {
                    byte* p = (byte*)v;
                    using (var memStream = new UnmanagedMemoryStream(p, this.Size.Volume * sizeof(TileData)))
                        memStream.CopyTo(stream);
                }

                fixed (byte* v = this.m_levelMap)
                {
                    byte* p = (byte*)v;
                    using (var memStream = new UnmanagedMemoryStream(p, this.Width * this.Height * sizeof(byte)))
                        memStream.CopyTo(stream);
                }
            }
        }

		unsafe void WriteMesh (Mesh mesh, BinaryWriter writer) {
			var boneSlotCount = this.GetBoneSlotCount(mesh);

			VertexFlags flags;
			int stride;
			this.GetVertexFormat(mesh, boneSlotCount, out flags, out stride);
			var count = mesh.VertexCount;

			writer.Write(mesh.Name);
			writer.Write((uint)flags);
			writer.Write(boneSlotCount);
			writer.Write(mesh.MaterialIndex);
			var vertices = new float[stride * count];
			int idx = 0, offset = 0;
			foreach (var pos in mesh.Vertices) {
				vertices[idx] = pos.X;
				vertices[idx + 1] = pos.Y;
				vertices[idx + 2] = pos.Z;
				idx += stride;
			}
			offset = idx = 3;
			if (mesh.HasNormals) {
				foreach (var norm in mesh.Normals) {
					vertices[idx] = norm.X;
					vertices[idx + 1] = norm.Y;
					vertices[idx + 2] = norm.Z;
					idx += stride;
				}
				offset += 3;
				idx = offset;
			}
			for (var i = 0; i < 4; i++) {
				if (mesh.HasTextureCoords(i)) {
					if (mesh.UVComponentCount[i] != 2)
						Console.WriteLine("WARNING: texture coordinates should have 2 components, but this channel has " + mesh.UVComponentCount[i]);
					foreach (var uv in mesh.TextureCoordinateChannels[i]) {
						vertices[idx] = uv.X;
						vertices[idx + 1] = uv.Y;
						idx += stride;
					}
					offset += 2;
					idx = offset;
				}
			}
			for (var i = 0; i < 4; i++) {
				if (mesh.HasVertexColors(i)) {
					foreach (var c in mesh.VertexColorChannels[i]) {
						vertices[idx] = c.R;
						vertices[idx + 1] = c.G;
						vertices[idx + 2] = c.B;
						vertices[idx + 3] = c.A;
						idx += stride;
					}
					offset += 4;
					idx = offset;
				}
			}
			// add bone information to every vertex
			for(var i = 0; i < mesh.BoneCount; i++) {
				foreach (var weight in mesh.Bones[i].VertexWeights) {
					if (weight.Weight > 0f) {
						idx = (stride * weight.VertexID) + offset;
						while (vertices[idx] != 0f)
							idx++;
						vertices[idx] = weight.Weight;
						vertices[idx + boneSlotCount] = i;
					}
				}
			}
			writer.Write(vertices.Length);
			writer.Flush();
			fixed(float *fp = &vertices[0]) {
				byte* bp = (byte*)fp;
				using (var ms = new UnmanagedMemoryStream(bp, vertices.Length * sizeof(float))) {
					ms.CopyTo(writer.BaseStream);
				}
			}

			count = mesh.FaceCount;
			var indices = new int[count * 3];
			idx = 0;
			for (var i = 0; i < count; i++) {
				var face = mesh.Faces[i];
				var faceIndices = face.Indices;
				if (face.IndexCount != 3)
					throw new InvalidOperationException("Polygonal faces are not supported, faces must be triangles.");
				indices[idx++] = faceIndices[0];
				indices[idx++] = faceIndices[1];
				indices[idx++] = faceIndices[2];
			}
			writer.Write(indices.Length);
			writer.Flush();
			fixed(int *ip = &indices[0]) {
				byte* bp = (byte*)ip;
				using (var ms = new UnmanagedMemoryStream(bp, indices.Length * sizeof(float))) {
					ms.CopyTo(writer.BaseStream);
				}
			}

			count = mesh.BoneCount;
//.........这里部分代码省略.........