/// <summary> /// Add information about dynamically created non-generic native format type /// to the diagnostic stream in form of a NativeFormatType blob. /// </summary> /// <param name="typeBuilder">TypeBuilder is used to query runtime type handle for the type</param> /// <param name="defType">Type to emit to the diagnostic stream</param> /// <param name="state"></param> public static void RegisterDebugDataForNativeFormatType(TypeBuilder typeBuilder, DefType defType, TypeBuilderState state) { #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING NativeFormatType nativeFormatType = defType as NativeFormatType; if (nativeFormatType == null) { return; } NativePrimitiveEncoder encoder = new NativePrimitiveEncoder(); encoder.Init(); byte nativeFormatTypeFlags = 0; SerializeDataBlobTypeAndFlags( ref encoder, SerializedDataBlobKind.NativeFormatType, nativeFormatTypeFlags); TypeManagerHandle moduleHandle = ModuleList.Instance.GetModuleForMetadataReader(nativeFormatType.MetadataReader); encoder.WriteUnsignedLong(unchecked ((ulong)typeBuilder.GetRuntimeTypeHandle(defType).ToIntPtr().ToInt64())); encoder.WriteUnsigned(nativeFormatType.Handle.ToHandle(nativeFormatType.MetadataReader).AsUInt()); encoder.WriteUnsignedLong(unchecked ((ulong)moduleHandle.GetIntPtrUNSAFE().ToInt64())); Instance.ThreadSafeWriteBytes(encoder.GetBytes()); #else return; #endif }
/// <summary> /// Reads a part of the samples as bytes in the specified output format from the sample provider. /// </summary> /// <param name="destination">The destination buffer that decoded samples are written to.</param> /// <param name="format">The destination format that the samples are decoded to.</param> /// <returns>The number of samples that could be read. Will be less than the destination size when the end of the sound is reached.</returns> public int Read(NativeSlice <byte> destination, NativeFormatType format) { CheckValidAndThrow(); // Not doing any format/size checks here. byte is the only valid choice for 8-bits, // 24-bits as well as big-endian float. Users may have reasons to want 16-bit samples // carried via a buffer-of-bytes, so we're being totally flexible here. return(DSPSampleProviderInternal.Internal_ReadUInt8FromSampleProviderById( ProviderHandle, (int)format, destination.GetUnsafePtr(), destination.Length)); }
/// <summary> /// Reads a part of the samples as short integers in the specified output format from the sample provider. /// </summary> /// <param name="destination">The destination buffer that decoded samples are written to.</param> /// <param name="format">The destination format that the samples are decoded to.</param> /// <returns>The number of samples that could be read. Will be less than the destination size when the end of the sound is reached.</returns> public int Read(NativeSlice <short> destination, NativeFormatType format) { CheckValidAndThrow(); if (format != NativeFormatType.PCM16_LE && format != NativeFormatType.PCM16_BE) { throw new ArgumentException("Using buffer of short to capture samples of a different size."); } return(DSPSampleProviderInternal.Internal_ReadSInt16FromSampleProviderById( ProviderHandle, (int)format, destination.GetUnsafePtr(), destination.Length)); }
internal TypeDesc GetTypeDescFromQHandle(QTypeDefinition qTypeDefinition) { #if ECMA_METADATA_SUPPORT if (qTypeDefinition.IsNativeFormatMetadataBased) #endif { MetadataReader nativeFormatMetadataReader = qTypeDefinition.NativeFormatReader; TypeDefinitionHandle typeDefinitionHandle = qTypeDefinition.NativeFormatHandle; NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoForMetadataReader(nativeFormatMetadataReader); NativeFormatMetadataUnit metadataUnit = ResolveMetadataUnit(module); NativeFormatType nativeFormatType = (NativeFormatType)metadataUnit.GetType(typeDefinitionHandle); return(nativeFormatType); } #if ECMA_METADATA_SUPPORT else if (qTypeDefinition.IsEcmaFormatMetadataBased) { EcmaModuleInfo module = ModuleList.Instance.GetModuleInfoForMetadataReader(qTypeDefinition.EcmaFormatReader); Ecma.EcmaModule ecmaModule = ResolveEcmaModule(module); Ecma.EcmaType ecmaType = (Ecma.EcmaType)ecmaModule.GetType(qTypeDefinition.EcmaFormatHandle); return(ecmaType); } #endif return(null); }
public TypeDesc ResolveRuntimeTypeHandle(RuntimeTypeHandle rtth) { TypeDesc returnedType; if (_runtimeTypeHandleResolutionCache.TryGetValue(rtth, out returnedType)) { return(returnedType); } if (rtth.Equals(CanonType.RuntimeTypeHandle)) { returnedType = CanonType; } else if (rtth.Equals(UniversalCanonType.RuntimeTypeHandle)) { returnedType = UniversalCanonType; } else if (RuntimeAugments.IsGenericTypeDefinition(rtth)) { #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING MetadataReader metadataReader; TypeDefinitionHandle typeDefinitionHandle; if (TypeLoaderEnvironment.Instance.TryGetMetadataForNamedType(rtth, out metadataReader, out typeDefinitionHandle)) { IntPtr moduleHandle = ModuleList.Instance.GetModuleForMetadataReader(metadataReader); NativeFormatMetadataUnit metadataUnit = ResolveMetadataUnit(moduleHandle); NativeFormatType nativeFormatType = (NativeFormatType)metadataUnit.GetType(typeDefinitionHandle); returnedType = nativeFormatType; } if (returnedType == null) #endif { unsafe { TypeDesc[] genericParameters = new TypeDesc[rtth.ToEETypePtr()->GenericArgumentCount]; for (int i = 0; i < genericParameters.Length; i++) { genericParameters[i] = GetSignatureVariable(i, false); } returnedType = new NoMetadataType(this, rtth, null, new Instantiation(genericParameters), rtth.GetHashCode()); } } } else if (RuntimeAugments.IsGenericType(rtth)) { RuntimeTypeHandle typeDefRuntimeTypeHandle; RuntimeTypeHandle[] genericArgRuntimeTypeHandles; typeDefRuntimeTypeHandle = RuntimeAugments.GetGenericInstantiation(rtth, out genericArgRuntimeTypeHandles); DefType typeDef = (DefType)ResolveRuntimeTypeHandle(typeDefRuntimeTypeHandle); Instantiation genericArgs = ResolveRuntimeTypeHandles(genericArgRuntimeTypeHandles); returnedType = ResolveGenericInstantiation(typeDef, genericArgs); } else if (RuntimeAugments.IsArrayType(rtth)) { RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc elementType = ResolveRuntimeTypeHandle(elementTypeHandle); unsafe { if (rtth.ToEETypePtr()->IsSzArray) { returnedType = GetArrayType(elementType); } else { returnedType = GetArrayType(elementType, rtth.ToEETypePtr()->ArrayRank); } } } else if (RuntimeAugments.IsUnmanagedPointerType(rtth)) { RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle); returnedType = GetPointerType(targetType); } else { #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING MetadataReader metadataReader; TypeDefinitionHandle typeDefinitionHandle; if (TypeLoaderEnvironment.Instance.TryGetMetadataForNamedType(rtth, out metadataReader, out typeDefinitionHandle)) { IntPtr moduleHandle = ModuleList.Instance.GetModuleForMetadataReader(metadataReader); NativeFormatMetadataUnit metadataUnit = ResolveMetadataUnit(moduleHandle); returnedType = metadataUnit.GetType(typeDefinitionHandle); } else #endif { returnedType = new NoMetadataType(this, rtth, null, Instantiation.Empty, rtth.GetHashCode()); } } // We either retrieved an existing DefType that is already registered with the runtime // or one that is not associated with an EEType yet. If it's not associated, associate it. if (returnedType.RuntimeTypeHandle.IsNull()) { TypeBuilderState state = returnedType.GetTypeBuilderStateIfExist(); bool skipStoringRuntimeTypeHandle = false; // If we've already attempted to lookup and failed to retrieve this type handle, we // may have already decided to create a new one. In that case, do not attempt to abort // that creation process as it may have already begun the process of type creation if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle) { skipStoringRuntimeTypeHandle = true; } if (!skipStoringRuntimeTypeHandle) { returnedType.SetRuntimeTypeHandleUnsafe(rtth); } } _runtimeTypeHandleResolutionCache.Add(rtth, returnedType); return(returnedType.WithDebugName()); }