Added property:
public virtual AVAssetTrackGroupOutputHandling AudioTrackGroupHandling { get; set; }
Added properties:
public virtual AVAssetImageGeneratorDynamicRangePolicy DynamicRangePolicy { get; set; }
public Foundation.NSString WeakDynamicRangePolicy { get; set; }
Added property:
public virtual bool SendsCommonMediaClientDataAsHttpHeaders { get; set; }
Added property:
public virtual bool EntireLengthAvailableOnDemand { get; set; }
Added property:
public virtual bool CanProvideSampleCursors { get; }
Added methods:
public virtual AVSampleCursor MakeSampleCursor (CoreMedia.CMTime presentationTimeStamp);
public virtual AVSampleCursor MakeSampleCursorAtFirstSampleInDecodeOrder ();
public virtual AVSampleCursor MakeSampleCursorAtLastSampleInDecodeOrder ();
Added properties:
public virtual bool Binaural { get; }
public virtual bool Downmix { get; }
public virtual bool Immersive { get; }
Added methods:
public static Foundation.NSPredicate GetPredicateForAudioSampleRate (double sampleRate, AVMediaSelectionOption mediaSelectionOption, Foundation.NSPredicateOperatorType operatorType);
public static Foundation.NSPredicate GetPredicateForBinauralAudio (bool isBinauralAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForDownmixAudio (bool isDownmixAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForImmersiveAudio (bool isImmersiveAudio, AVMediaSelectionOption mediaSelectionOption);
Added property:
public virtual AVAssetVariantVideoLayoutAttributes[] VideoLayoutAttributes { get; }
Added property:
public virtual CoreMedia.CMTime InitialMovieFragmentInterval { get; set; }
Added properties:
public static Foundation.NSString InputMuteStateChangeNotification { get; }
public static Foundation.NSString MuteStateKey { get; }
Added method:
public virtual bool SetMutedSpeechActivityEventListener (AVAudioInputNodeMutedSpeechEventListener listenerAction);
Obsoleted constructors:
[Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
public AVAudioPlayer (Foundation.NSData data, string fileTypeHint, out Foundation.NSError outError);
[Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
public AVAudioPlayer (Foundation.NSUrl url, string fileTypeHint, out Foundation.NSError outError);
Added methods:
public static AVAudioPlayer FromData (Foundation.NSData data, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromData (Foundation.NSData data, Foundation.NSString fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, Foundation.NSString fileTypeHint, out Foundation.NSError error);
Added methods:
public virtual AVMusicTrack CreateAndAppendTrack ();
public virtual bool RemoveTrack (AVMusicTrack track);
public virtual void ReverseEvents ();
public virtual void SetUserCallback (AVAudioSequencerUserCallback userCallback);
Added properties:
public static Foundation.NSString PortContinuityMicrophone { get; }
public virtual bool PrefersInterruptionOnRouteDisconnect { get; }
Added method:
public virtual bool SetPrefersInterruptionOnRouteDisconnect (bool value, out Foundation.NSError outError);
Added value:
LongFormAudio = 1,
Added properties:
public virtual UIKit.UIImage Icon { get; }
public virtual bool PassesAUVal { get; }
Modified properties:
-public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; set; }
+public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; }
Added values:
ContinuityCamera = 13,
DeskViewCamera = 14,
Microphone = 12,
Added properties:
public virtual bool ConfiguresApplicationAudioSessionToMixWithOthers { get; set; }
public virtual AVCaptureConnection[] Connections { get; }
public virtual AVCaptureControl[] Controls { get; }
public IAVCaptureSessionControlsDelegate ControlsDelegate { get; }
public virtual CoreFoundation.DispatchQueue ControlsDelegateCallbackQueue { get; }
public virtual float HardwareCost { get; }
public virtual IntPtr MaxControlsCount { get; }
public virtual bool MultitaskingCameraAccessEnabled { get; set; }
public virtual bool MultitaskingCameraAccessSupported { get; }
public virtual bool SupportsControls { get; }
public virtual Foundation.NSObject WeakControlsDelegate { get; }
Added methods:
public virtual void AddControl (AVCaptureControl control);
public virtual bool CanAddControl (AVCaptureControl control);
public virtual void RemoveControl (AVCaptureControl control);
public virtual void SetControlsDelegate (IAVCaptureSessionControlsDelegate controlsDelegate, CoreFoundation.DispatchQueue controlsDelegateCallbackQueue);
Added property:
public virtual bool Previewing { get; }
Added methods:
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (string[] bestMatchingPreferredLanguages);
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (Foundation.NSLocale titleLocale, string[] commonKeys);
public virtual AVMediaSelectionGroup GetMediaSelectionGroup (string mediaCharacteristic);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual int GetUnusedTrackId ();
Added methods:
public virtual AVAssetTrack[] GetAssociatedTracks (string trackAssociationType);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual CoreMedia.CMTime GetSamplePresentationTime (CoreMedia.CMTime trackTime);
public virtual bool HasMediaCharacteristic (string mediaCharacteristic);
Added property:
public virtual AVExternalContentProtectionStatus ExternalContentProtectionStatus { get; }
Added method:
public virtual void Revoke ();
Added method:
public virtual bool RespondByRequestingPersistableContentKeyRequest (out Foundation.NSError error);
Added methods:
public virtual void InvalidateAllPersistableContentKeys (Foundation.NSData appIdentifier, Foundation.NSDictionary options, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> InvalidateAllPersistableContentKeysAsync (Foundation.NSData appIdentifier, Foundation.NSDictionary options);
public virtual void InvalidatePersistableContentKey (Foundation.NSData persistableContentKeyData, Foundation.NSDictionary options, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> InvalidatePersistableContentKeyAsync (Foundation.NSData persistableContentKeyData, Foundation.NSDictionary options);
public virtual void MakeSecureToken (Foundation.NSData persistableContentKeyData, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> MakeSecureTokenAsync (Foundation.NSData persistableContentKeyData);
Added methods:
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void DidUpdate (AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);
Added methods:
public static void DidProvideContentKeyRequests (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public static void DidUpdate (this IAVContentKeySessionDelegate This, AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public static void ExternalProtectionStatusDidChange (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKey contentKey);
Added constructor:
public AVDisplayCriteria (float refreshRate, CoreMedia.CMFormatDescription formatDescription);
Added values:
AirPlayReceiverTemporarilyUnavailable = -11882,
EncodeFailed = -11883,
FailedToLoadSampleData = -11881,
InvalidSampleCursor = -11880,
MediaExtensionConflict = -11887,
MediaExtensionDisabled = -11886,
SandboxExtensionDenied = -11884,
ToneMappingFailed = -11885,
Added value:
Ahap = 23,
Added values:
CarriesVideoStereoMetadata = 18,
ContainsStereoMultiviewVideo = 19,
EnhancesSpeechIntelligibility = 20,
IndicatesHorizontalFieldOfView = 21,
TactileMinimal = 22,
Added values:
AuxiliaryPicture = 11,
Haptic = 12,
Added properties:
public static Foundation.NSString QuickTimeMetadataFullFrameRatePlaybackIntent { get; }
public static Foundation.NSString QuickTimeMetadataKeyFullFrameRatePlaybackIntent { get; }
Added value:
HumanFullBody = 16777216,
Added property:
public virtual bool UsesAutomatedParameters { get; set; }
Added methods:
public virtual void AddEvent (AVMusicEvent event, double beat);
public virtual void ClearEvents (AVBeatRange range);
public virtual void CopyAndMergeEvents (AVBeatRange range, AVMusicTrack sourceTrack, double mergeStartBeat);
public virtual void CopyEvents (AVBeatRange range, AVMusicTrack sourceTrack, double insertStartBeat);
public virtual void CutEvents (AVBeatRange range);
public virtual void EnumerateEvents (AVBeatRange range, AVMusicEventEnumerationBlock block);
public virtual void MoveEvents (AVBeatRange range, double beatAmount);
Added methods:
public virtual void Insert (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime, AVMutableCompositionInsertHandler completionHandler);
public virtual System.Threading.Tasks.Task InsertAsync (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime);
Added methods:
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateApplier applier, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction, AVMutableVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVMutableVideoCompositionCreateApplier applier);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction);
Added values:
PresetMvHevc1440x1440 = 17,
PresetMvHevc960x960 = 16,
Added properties:
public virtual float DefaultRate { get; set; }
public virtual AVPlayerVideoOutput VideoOutput { get; set; }
Added method:
protected override void Dispose (bool disposing);
Added interfaces:
Foundation.INSCopying
ObjCRuntime.INativeObject
System.IDisposable
Modified properties:
-public virtual Foundation.NSDate Date { get; set; }
+public virtual Foundation.NSDate Date { get; }
-public virtual string Identifier { get; set; }
+public virtual string Identifier { get; }
-public virtual CoreMedia.CMTime PlayoutLimit { get; set; }
+public virtual CoreMedia.CMTime PlayoutLimit { get; }
-public virtual AVPlayerItem PrimaryItem { get; set; }
+public virtual AVPlayerItem PrimaryItem { get; }
-public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; set; }
+public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; }
-public virtual CoreMedia.CMTime ResumptionOffset { get; set; }
+public virtual CoreMedia.CMTime ResumptionOffset { get; }
-public virtual AVPlayerItem[] TemplateItems { get; set; }
+public virtual AVPlayerItem[] TemplateItems { get; }
-public virtual CoreMedia.CMTime Time { get; set; }
+public virtual CoreMedia.CMTime Time { get; }
-public virtual Foundation.NSDictionary UserDefinedAttributes { get; set; }
+public virtual Foundation.NSDictionary UserDefinedAttributes { get; }
Added properties:
public virtual bool AlignsResumptionWithPrimarySegmentBoundary { get; set; }
public virtual bool AlignsStartWithPrimarySegmentBoundary { get; set; }
public virtual Foundation.NSDictionary AssetListResponse { get; }
public virtual bool ContentMayVary { get; set; }
public virtual string Cue { get; set; }
public virtual CoreMedia.CMTime PlannedDuration { get; set; }
public virtual bool SupplementsPrimaryContent { get; set; }
public virtual AVPlayerInterstitialEventTimelineOccupancy TimelineOccupancy { get; set; }
public virtual bool WillPlayOnce { get; set; }
Added methods:
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, CoreMedia.CMTime time);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, Foundation.NSDate date);
Added properties:
public static Foundation.NSString AssetListResponseStatusDidChangeErrorKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeEventKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeNotification { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeStatusKey { get; }
Added methods:
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
Added interface:
IAVMetricEventStreamPublisher
Added property:
public virtual AVPlayerItemIntegratedTimeline IntegratedTimeline { get; }
Added method:
public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();
Added constructor:
public AVPlayerLooper (AVQueuePlayer player, AVPlayerItem itemToLoop, CoreMedia.CMTimeRange loopRange, AVPlayerLooperItemOrdering itemOrdering);
Added properties:
public static Foundation.NSString DisplayLayerReadyForDisplayDidChangeNotification { get; }
public virtual bool ReadyForDisplay { get; }
public virtual AVSampleBufferVideoRenderer SampleBufferRenderer { get; }
Added methods:
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
Added properties:
public static Foundation.NSString AvailableVoicesDidChangeNotification { get; }
public virtual AVSpeechSynthesisVoiceTraits VoiceTraits { get; }
Added value:
Premium = 3,
Added property:
public static AVSpeechSynthesisPersonalVoiceAuthorizationStatus PersonalVoiceAuthorizationStatus { get; }
Added event:
public event System.EventHandler<AVSpeechSynthesizerWillSpeakMarkerEventArgs> WillSpeakMarker;
Added methods:
public static void RequestPersonalVoiceAuthorization (AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback handler);
public static System.Threading.Tasks.Task<AVSpeechSynthesisPersonalVoiceAuthorizationStatus> RequestPersonalVoiceAuthorizationAsync ();
public virtual void WriteUtterance (AVSpeechUtterance utterance, AVSpeechSynthesizerBufferCallback bufferCallback, AVSpeechSynthesizerMarkerCallback markerCallback);
Added method:
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
Added method:
public static void WillSpeakMarker (this IAVSpeechSynthesizerDelegate This, AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
Added constructor:
public AVSpeechUtterance (string string, AVSpeechUtteranceInitializationOption option);
Added method:
public static AVSpeechUtterance FromSsmlRepresentation (string string);
Added properties:
public virtual Foundation.NSUuid HttpSessionIdentifier { get; }
public static Foundation.NSString HttpUserAgentKey { get; }
public static Foundation.NSString OverrideMimeTypeKey { get; }
public static Foundation.NSString PrimarySessionIdentifierKey { get; }
Added values:
AppleProRes4444XQ = 10,
JpegXl = 11,
Added methods:
public static void Create (AVAsset asset, AVVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionCreateApplier applier, AVVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionCreateApplier applier);
public virtual void DetermineValidity (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate, AVVideoCompositionDetermineValidityCallback completionHandler);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DetermineValidityAsync (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);
public virtual bool IsValid (AVAssetTrack[] tracks, CoreMedia.CMTime duration, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);
Obsoleted properties:
[Obsolete ("Use 'Itu_R_709_2' instead.")]
public static Foundation.NSString AVVideoTransferFunction_Itu_R_709_2 { get; }
Added properties:
public static Foundation.NSString Iec_sRgb { get; }
public static Foundation.NSString Itu_R_2100_Hlg { get; }
public static Foundation.NSString Itu_R_709_2 { get; }
public static Foundation.NSString Linear { get; }
public static Foundation.NSString Smpte_St_2084_Pq { get; }
Added methods:
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void DidUpdate (AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);
Added method:
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
public class AVAUPresetEvent : AVFoundation.AVMusicEvent {
// constructors
public AVAUPresetEvent ();
protected AVAUPresetEvent (Foundation.NSObjectFlag t);
protected AVAUPresetEvent (ObjCRuntime.NativeHandle handle);
public AVAUPresetEvent (uint scope, uint element, Foundation.NSDictionary presetDictionary);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Element { get; set; }
public virtual Foundation.NSDictionary PresetDictionary { get; }
public virtual uint Scope { get; set; }
}
[Serializable]
public enum AVAssetImageGeneratorDynamicRangePolicy {
DynamicRangePolicyForceSdr = 0,
DynamicRangePolicyMatchSource = 1,
}
public static class AVAssetImageGeneratorDynamicRangePolicyExtensions {
// methods
public static Foundation.NSString GetConstant (this AVAssetImageGeneratorDynamicRangePolicy self);
public static AVAssetImageGeneratorDynamicRangePolicy GetValue (Foundation.NSString constant);
}
public class AVAssetPlaybackAssistant : Foundation.NSObject {
// constructors
protected AVAssetPlaybackAssistant (Foundation.NSObjectFlag t);
protected AVAssetPlaybackAssistant (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public static AVAssetPlaybackAssistant Create (AVAsset asset);
public virtual void LoadPlaybackConfigurationOptions (AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler completionHandler);
public virtual System.Threading.Tasks.Task<System.String[]> LoadPlaybackConfigurationOptionsAsync ();
}
public sealed delegate AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler : System.MulticastDelegate {
// constructors
public AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (string[] playbackConfigurationOptions, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (string[] playbackConfigurationOptions);
}
[Serializable]
public enum AVAssetPlaybackConfigurationOption {
SpatialVideo = 2,
StereoMultiviewVideo = 1,
StereoVideo = 0,
}
public static class AVAssetPlaybackConfigurationOptionExtensions {
// methods
public static Foundation.NSString GetConstant (this AVAssetPlaybackConfigurationOption self);
public static AVAssetPlaybackConfigurationOption GetValue (Foundation.NSString constant);
}
[Serializable]
[Flags]
public enum AVAssetTrackGroupOutputHandling {
DefaultPolicy = 0,
None = 0,
PreserveAlternateTracks = 1,
}
public class AVAssetVariantVideoLayoutAttributes : Foundation.NSObject {
// constructors
protected AVAssetVariantVideoLayoutAttributes (Foundation.NSObjectFlag t);
protected AVAssetVariantVideoLayoutAttributes (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMStereoViewComponents StereoViewComponents { get; }
}
[Serializable]
public enum AVAudioApplicationMicrophoneInjectionPermission {
Denied = 1684369017,
Granted = 1735552628,
ServiceDisabled = 1936876659,
Undetermined = 1970168948,
}
public sealed delegate AVAudioInputNodeMutedSpeechEventListener : System.MulticastDelegate {
// constructors
public AVAudioInputNodeMutedSpeechEventListener (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAudioVoiceProcessingSpeechActivityEvent event, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAudioVoiceProcessingSpeechActivityEvent event);
}
public class AVAudioRecorder : Foundation.NSObject {
// constructors
public AVAudioRecorder ();
protected AVAudioRecorder (Foundation.NSObjectFlag t);
protected AVAudioRecorder (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVAudioSessionChannelDescription[] ChannelAssignments { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double CurrentTime { get; }
public IAVAudioRecorderDelegate Delegate { get; set; }
public virtual double DeviceCurrentTime { get; }
public virtual AVAudioFormat Format { get; }
public virtual bool MeteringEnabled { get; set; }
public virtual bool Recording { get; }
public AudioSettings Settings { get; }
public virtual Foundation.NSUrl Url { get; }
public virtual Foundation.NSObject WeakDelegate { get; set; }
public virtual Foundation.NSDictionary WeakSettings { get; }
[Obsolete ("Use the 'CurrentTime' property instead.")]
public virtual double currentTime { get; }
// methods
public virtual float AveragePower (UIntPtr channelNumber);
public virtual bool DeleteRecording ();
protected override void Dispose (bool disposing);
public virtual void Pause ();
public virtual float PeakPower (UIntPtr channelNumber);
public virtual bool PrepareToRecord ();
public virtual bool Record ();
public virtual bool RecordAt (double time);
public virtual bool RecordAt (double time, double duration);
public virtual bool RecordFor (double duration);
public virtual void Stop ();
public virtual void UpdateMeters ();
}
public class AVAudioRecorderDelegate : Foundation.NSObject, IAVAudioRecorderDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVAudioRecorderDelegate ();
protected AVAudioRecorderDelegate (Foundation.NSObjectFlag t);
protected AVAudioRecorderDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void EncoderError (AVAudioRecorder recorder, Foundation.NSError error);
public virtual void FinishedRecording (AVAudioRecorder recorder, bool flag);
}
public static class AVAudioRecorderDelegate_Extensions {
// methods
public static void EncoderError (this IAVAudioRecorderDelegate This, AVAudioRecorder recorder, Foundation.NSError error);
public static void FinishedRecording (this IAVAudioRecorderDelegate This, AVAudioRecorder recorder, bool flag);
}
public class AVAudioSequencerInfoDictionary : Foundation.DictionaryContainer {
// constructors
public AVAudioSequencerInfoDictionary ();
public AVAudioSequencerInfoDictionary (Foundation.NSDictionary dictionary);
// properties
public string Album { get; set; }
public double? ApproximateDurationInSeconds { get; set; }
public string Artist { get; set; }
public Foundation.NSObject ChannelLayout { get; set; }
public string Comments { get; set; }
public string Composer { get; set; }
public string Copyright { get; set; }
public string EncodingApplication { get; set; }
public string Genre { get; set; }
public Foundation.NSObject Isrc { get; set; }
public string KeySignature { get; set; }
public string Lyricist { get; set; }
public double? NominalBitRate { get; set; }
public Foundation.NSObject RecordedDate { get; set; }
public double? SourceBitDepth { get; set; }
public string SourceEncoder { get; set; }
public string SubTitle { get; set; }
public double? Tempo { get; set; }
public string TimeSignature { get; set; }
public string Title { get; set; }
public int? TrackNumber { get; set; }
public string Year { get; set; }
}
public sealed delegate AVAudioSequencerUserCallback : System.MulticastDelegate {
// constructors
public AVAudioSequencerUserCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp);
}
[Serializable]
public enum AVAudioSessionMicrophoneInjectionMode {
None = 0,
SpokenAudio = 1,
}
[Serializable]
public enum AVAudioVoiceProcessingSpeechActivityEvent {
Ended = 1,
Started = 0,
}
[Serializable]
public enum AVAuthorizationMediaType {
Audio = 1,
Video = 0,
}
[Serializable]
public enum AVAuthorizationStatus {
Authorized = 3,
Denied = 2,
NotDetermined = 0,
Restricted = 1,
}
public class AVCaptureAudioDataOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCaptureAudioDataOutput ();
protected AVCaptureAudioDataOutput (Foundation.NSObjectFlag t);
protected AVCaptureAudioDataOutput (ObjCRuntime.NativeHandle handle);
// properties
public AudioSettings AudioSettings { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreFoundation.DispatchQueue SampleBufferCallbackQueue { get; }
public virtual IAVCaptureAudioDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
public virtual Foundation.NSDictionary WeakAudioSettings { get; set; }
// methods
public virtual Foundation.NSDictionary GetRecommendedAudioSettingsForAssetWriter (string outputFileType);
public virtual void SetSampleBufferDelegate (IAVCaptureAudioDataOutputSampleBufferDelegate sampleBufferDelegate, CoreFoundation.DispatchQueue sampleBufferCallbackDispatchQueue);
}
public class AVCaptureAudioDataOutputSampleBufferDelegate : Foundation.NSObject, IAVCaptureAudioDataOutputSampleBufferDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCaptureAudioDataOutputSampleBufferDelegate ();
protected AVCaptureAudioDataOutputSampleBufferDelegate (Foundation.NSObjectFlag t);
protected AVCaptureAudioDataOutputSampleBufferDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
public static class AVCaptureAudioDataOutputSampleBufferDelegate_Extensions {
// methods
public static void DidOutputSampleBuffer (this IAVCaptureAudioDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
public class AVCaptureAutoExposureBracketedStillImageSettings : AVFoundation.AVCaptureBracketedStillImageSettings {
// constructors
protected AVCaptureAutoExposureBracketedStillImageSettings (Foundation.NSObjectFlag t);
protected AVCaptureAutoExposureBracketedStillImageSettings (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual float ExposureTargetBias { get; }
// methods
public static AVCaptureAutoExposureBracketedStillImageSettings Create (float exposureTargetBias);
}
[Serializable]
public enum AVCaptureAutoFocusRangeRestriction {
Far = 2,
Near = 1,
None = 0,
}
[Serializable]
public enum AVCaptureAutoFocusSystem {
ContrastDetection = 1,
None = 0,
PhaseDetection = 2,
}
public class AVCaptureBracketedStillImageSettings : Foundation.NSObject {
// constructors
protected AVCaptureBracketedStillImageSettings (Foundation.NSObjectFlag t);
protected AVCaptureBracketedStillImageSettings (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
[Serializable]
public enum AVCaptureCenterStageControlMode {
App = 1,
Cooperative = 2,
User = 0,
}
[Serializable]
public enum AVCaptureColorSpace {
AppleLog = 3,
HlgBT2020 = 2,
P3D65 = 1,
Srgb = 0,
}
public class AVCaptureControl : Foundation.NSObject {
// constructors
protected AVCaptureControl (Foundation.NSObjectFlag t);
protected AVCaptureControl (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool Enabled { get; set; }
}
public class AVCaptureDataOutputSynchronizer : Foundation.NSObject {
// constructors
public AVCaptureDataOutputSynchronizer (AVCaptureOutput[] dataOutputs);
protected AVCaptureDataOutputSynchronizer (Foundation.NSObjectFlag t);
protected AVCaptureDataOutputSynchronizer (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureOutput[] DataOutputs { get; }
public IAVCaptureDataOutputSynchronizerDelegate Delegate { get; }
public virtual CoreFoundation.DispatchQueue DelegateCallbackQueue { get; }
public virtual Foundation.NSObject WeakDelegate { get; }
// methods
public virtual void SetDelegate (IAVCaptureDataOutputSynchronizerDelegate del, CoreFoundation.DispatchQueue delegateCallbackQueue);
}
public abstract class AVCaptureDataOutputSynchronizerDelegate : Foundation.NSObject, IAVCaptureDataOutputSynchronizerDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVCaptureDataOutputSynchronizerDelegate ();
protected AVCaptureDataOutputSynchronizerDelegate (Foundation.NSObjectFlag t);
protected AVCaptureDataOutputSynchronizerDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidOutputSynchronizedDataCollection (AVCaptureDataOutputSynchronizer synchronizer, AVCaptureSynchronizedDataCollection synchronizedDataCollection);
}
public class AVCaptureDepthDataOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCaptureDepthDataOutput ();
protected AVCaptureDepthDataOutput (Foundation.NSObjectFlag t);
protected AVCaptureDepthDataOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual bool AlwaysDiscardsLateDepthData { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public IAVCaptureDepthDataOutputDelegate Delegate { get; }
public virtual CoreFoundation.DispatchQueue DelegateCallbackQueue { get; }
public virtual bool FilteringEnabled { get; set; }
public virtual Foundation.NSObject WeakDelegate { get; }
// methods
public virtual void SetDelegate (IAVCaptureDepthDataOutputDelegate del, CoreFoundation.DispatchQueue callbackQueue);
}
public class AVCaptureDepthDataOutputDelegate : Foundation.NSObject, IAVCaptureDepthDataOutputDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCaptureDepthDataOutputDelegate ();
protected AVCaptureDepthDataOutputDelegate (Foundation.NSObjectFlag t);
protected AVCaptureDepthDataOutputDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidDropDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
public virtual void DidOutputDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
public static class AVCaptureDepthDataOutputDelegate_Extensions {
// methods
public static void DidDropDepthData (this IAVCaptureDepthDataOutputDelegate This, AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
public static void DidOutputDepthData (this IAVCaptureDepthDataOutputDelegate This, AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
public class AVCaptureDevice : Foundation.NSObject {
// constructors
protected AVCaptureDevice (Foundation.NSObjectFlag t);
protected AVCaptureDevice (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCaptureColorSpace ActiveColorSpace { get; set; }
public virtual AVCaptureDeviceFormat ActiveDepthDataFormat { get; set; }
public virtual CoreMedia.CMTime ActiveDepthDataMinFrameDuration { get; set; }
public virtual AVCaptureDeviceFormat ActiveFormat { get; set; }
public virtual CoreMedia.CMTime ActiveMaxExposureDuration { get; set; }
public static AVCaptureMicrophoneMode ActiveMicrophoneMode { get; }
public virtual AVCaptureDevice ActivePrimaryConstituentDevice { get; }
public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions ActivePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions { get; }
public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior ActivePrimaryConstituentDeviceSwitchingBehavior { get; }
public virtual CoreMedia.CMTime ActiveVideoMaxFrameDuration { get; set; }
public virtual CoreMedia.CMTime ActiveVideoMinFrameDuration { get; set; }
public virtual bool AdjustingExposure { get; }
public virtual bool AdjustingFocus { get; }
public virtual bool AdjustingWhiteBalance { get; }
public virtual AVCaptureAutoFocusRangeRestriction AutoFocusRangeRestriction { get; set; }
public virtual bool AutoFocusRangeRestrictionSupported { get; }
public virtual bool AutoVideoFrameRateEnabled { get; set; }
public virtual bool AutomaticallyAdjustsFaceDrivenAutoExposureEnabled { get; set; }
public virtual bool AutomaticallyAdjustsFaceDrivenAutoFocusEnabled { get; set; }
public virtual bool AutomaticallyAdjustsVideoHdrEnabled { get; set; }
public virtual bool AutomaticallyEnablesLowLightBoostWhenAvailable { get; set; }
public virtual Foundation.NSSet<Foundation.NSString> AvailableReactionTypes { get; }
public virtual bool BackgroundReplacementActive { get; }
public static bool BackgroundReplacementEnabled { get; }
public virtual bool CanPerformReactionEffects { get; }
public virtual bool CenterStageActive { get; }
public static AVCaptureCenterStageControlMode CenterStageControlMode { get; set; }
public static bool CenterStageEnabled { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureDevice CompanionDeskViewCamera { get; }
public virtual bool Connected { get; }
public virtual AVCaptureDevice[] ConstituentDevices { get; }
public virtual bool ContinuityCamera { get; }
public AVCaptureDeviceType DeviceType { get; }
public virtual AVCaptureWhiteBalanceGains DeviceWhiteBalanceGains { get; }
public static AVCaptureDevice[] Devices { get; }
public virtual System.Runtime.InteropServices.NFloat DisplayVideoZoomFactorMultiplier { get; }
public virtual System.Runtime.InteropServices.NFloat DualCameraSwitchOverVideoZoomFactor { get; }
public virtual CoreMedia.CMTime ExposureDuration { get; }
public static CoreMedia.CMTime ExposureDurationCurrent { get; }
public virtual AVCaptureExposureMode ExposureMode { get; set; }
public virtual CoreGraphics.CGPoint ExposurePointOfInterest { get; set; }
public virtual bool ExposurePointOfInterestSupported { get; }
public virtual float ExposureTargetBias { get; }
public static float ExposureTargetBiasCurrent { get; }
public virtual float ExposureTargetOffset { get; }
public virtual bool FaceDrivenAutoExposureEnabled { get; set; }
public virtual bool FaceDrivenAutoFocusEnabled { get; set; }
public virtual AVCaptureDevice[] FallbackPrimaryConstituentDevices { get; set; }
public virtual bool FlashActive { get; }
public virtual bool FlashAvailable { get; }
public virtual AVCaptureFocusMode FocusMode { get; set; }
public static float FocusModeLensPositionCurrent { get; }
public virtual CoreGraphics.CGPoint FocusPointOfInterest { get; set; }
public virtual bool FocusPointOfInterestSupported { get; }
public virtual AVCaptureDeviceFormat[] Formats { get; }
public virtual bool GeometricDistortionCorrectionEnabled { get; set; }
public virtual bool GeometricDistortionCorrectionSupported { get; }
public virtual bool GlobalToneMappingEnabled { get; set; }
public virtual AVCaptureWhiteBalanceGains GrayWorldDeviceWhiteBalanceGains { get; }
public virtual bool HasFlash { get; }
public virtual bool HasTorch { get; }
public virtual float ISO { get; }
public static float ISOCurrent { get; }
public virtual bool InUseByAnotherApplication { get; }
public virtual float LensAperture { get; }
public virtual float LensPosition { get; }
public static float LensPositionCurrent { get; }
public virtual AVCaptureDevice[] LinkedDevices { get; }
public virtual string LocalizedName { get; }
public virtual bool LockingFocusWithCustomLensPositionSupported { get; }
public virtual bool LockingWhiteBalanceWithCustomDeviceGainsSupported { get; }
public virtual bool LowLightBoostEnabled { get; }
public virtual bool LowLightBoostSupported { get; }
public virtual string Manufacturer { get; }
public static float MaxAvailableTorchLevel { get; }
public virtual System.Runtime.InteropServices.NFloat MaxAvailableVideoZoomFactor { get; }
public virtual float MaxExposureTargetBias { get; }
public virtual float MaxWhiteBalanceGain { get; }
public virtual System.Runtime.InteropServices.NFloat MinAvailableVideoZoomFactor { get; }
public virtual float MinExposureTargetBias { get; }
public virtual IntPtr MinimumFocusDistance { get; }
public virtual string ModelID { get; }
public virtual bool PortraitEffectActive { get; }
public static bool PortraitEffectEnabled { get; }
public virtual AVCaptureDevicePosition Position { get; }
public static AVCaptureMicrophoneMode PreferredMicrophoneMode { get; }
public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions PrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions { get; }
public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior PrimaryConstituentDeviceSwitchingBehavior { get; }
public virtual bool RampingVideoZoom { get; }
public static bool ReactionEffectGesturesEnabled { get; }
public static bool ReactionEffectsEnabled { get; }
public virtual AVCaptureReactionEffectState[] ReactionEffectsInProgress { get; }
public virtual bool SmoothAutoFocusEnabled { get; set; }
public virtual bool SmoothAutoFocusSupported { get; }
public virtual Foundation.NSSet<Foundation.NSString> SpatialCaptureDiscomfortReasons { get; }
public virtual bool StudioLightActive { get; }
public static bool StudioLightEnabled { get; }
public virtual bool SubjectAreaChangeMonitoringEnabled { get; set; }
public static Foundation.NSString SubjectAreaDidChangeNotification { get; }
public virtual AVCaptureDevice[] SupportedFallbackPrimaryConstituentDevices { get; }
public virtual bool Suspended { get; }
public static AVCaptureDevice SystemPreferredCamera { get; }
public virtual AVCaptureSystemPressureState SystemPressureState { get; }
public virtual bool TorchActive { get; }
public virtual bool TorchAvailable { get; }
public virtual float TorchLevel { get; }
public virtual AVCaptureTorchMode TorchMode { get; set; }
public virtual string UniqueID { get; }
public static AVCaptureDevice UserPreferredCamera { get; set; }
public virtual bool VideoHdrEnabled { get; set; }
public virtual System.Runtime.InteropServices.NFloat VideoZoomFactor { get; set; }
public virtual bool VirtualDevice { get; }
public virtual Foundation.NSNumber[] VirtualDeviceSwitchOverVideoZoomFactors { get; }
public static Foundation.NSString WasConnectedNotification { get; }
public static Foundation.NSString WasDisconnectedNotification { get; }
public virtual int WeakTransportType { get; }
public static AVCaptureWhiteBalanceGains WhiteBalanceGainsCurrent { get; }
public virtual AVCaptureWhiteBalanceMode WhiteBalanceMode { get; set; }
// methods
public virtual void CancelVideoZoomRamp ();
public static AVCaptureDevice DeviceWithUniqueID (string deviceUniqueID);
public static AVCaptureDevice[] DevicesWithMediaType (string mediaType);
protected override void Dispose (bool disposing);
public static AVAuthorizationStatus GetAuthorizationStatus (AVAuthorizationMediaType mediaType);
public static AVAuthorizationStatus GetAuthorizationStatus (Foundation.NSString avMediaTypeToken);
public virtual AVCaptureWhiteBalanceChromaticityValues GetChromaticityValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
public static AVCaptureDevice GetDefaultDevice (AVMediaTypes mediaType);
public static AVCaptureDevice GetDefaultDevice (Foundation.NSString mediaType);
public static AVCaptureDevice GetDefaultDevice (AVCaptureDeviceType deviceType, string mediaType, AVCaptureDevicePosition position);
public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceChromaticityValues chromaticityValues);
public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceTemperatureAndTintValues tempAndTintValues);
public static Foundation.NSData GetExtrinsicMatrix (AVCaptureDevice fromDevice, AVCaptureDevice toDevice);
public virtual AVCaptureWhiteBalanceTemperatureAndTintValues GetTemperatureAndTintValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
public bool HasMediaType (AVMediaTypes mediaType);
public virtual bool HasMediaType (string mediaType);
public virtual bool IsExposureModeSupported (AVCaptureExposureMode exposureMode);
public virtual bool IsFocusModeSupported (AVCaptureFocusMode focusMode);
public virtual bool IsTorchModeSupported (AVCaptureTorchMode torchMode);
public virtual bool IsWhiteBalanceModeSupported (AVCaptureWhiteBalanceMode whiteBalanceMode);
public virtual void LockExposure (CoreMedia.CMTime duration, float ISO, System.Action<CoreMedia.CMTime> completionHandler);
public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> LockExposureAsync (CoreMedia.CMTime duration, float ISO);
public virtual bool LockForConfiguration (out Foundation.NSError error);
public virtual void PerformEffect (string reactionType);
public virtual void RampToVideoZoom (System.Runtime.InteropServices.NFloat factor, float rate);
public static void RequestAccessForMediaType (AVAuthorizationMediaType mediaType, AVRequestAccessStatus completion);
public static void RequestAccessForMediaType (Foundation.NSString avMediaTypeToken, AVRequestAccessStatus completion);
public static System.Threading.Tasks.Task<bool> RequestAccessForMediaTypeAsync (AVAuthorizationMediaType mediaType);
public static System.Threading.Tasks.Task<bool> RequestAccessForMediaTypeAsync (Foundation.NSString avMediaTypeToken);
public virtual void SetExposureTargetBias (float bias, System.Action<CoreMedia.CMTime> completionHandler);
public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetExposureTargetBiasAsync (float bias);
public virtual void SetFocusModeLocked (float lensPosition, System.Action<CoreMedia.CMTime> completionHandler);
public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetFocusModeLockedAsync (float lensPosition);
public virtual void SetPrimaryConstituentDeviceSwitchingBehavior (AVCapturePrimaryConstituentDeviceSwitchingBehavior switchingBehavior, AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions restrictedSwitchingBehaviorConditions);
public virtual bool SetTorchModeLevel (float torchLevel, out Foundation.NSError outError);
public virtual void SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains (AVCaptureWhiteBalanceGains whiteBalanceGains, System.Action<CoreMedia.CMTime> completionHandler);
public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGainsAsync (AVCaptureWhiteBalanceGains whiteBalanceGains);
public static void ShowSystemUserInterface (AVCaptureSystemUserInterface systemUserInterface);
public virtual bool SupportsAVCaptureSessionPreset (string preset);
public virtual void UnlockForConfiguration ();
// inner types
public static class Notifications {
// methods
public static Foundation.NSObject ObserveSubjectAreaDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSubjectAreaDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveWasConnected (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveWasConnected (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveWasDisconnected (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveWasDisconnected (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
}
}
public class AVCaptureDeviceDiscoverySession : Foundation.NSObject {
// constructors
protected AVCaptureDeviceDiscoverySession (Foundation.NSObjectFlag t);
protected AVCaptureDeviceDiscoverySession (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureDevice[] Devices { get; }
public virtual Foundation.NSSet<AVCaptureDevice>[] SupportedMultiCamDeviceSets { get; }
// methods
public static AVCaptureDeviceDiscoverySession Create (AVCaptureDeviceType[] deviceTypes, AVMediaTypes mediaType, AVCaptureDevicePosition position);
}
public class AVCaptureDeviceFormat : Foundation.NSObject {
// constructors
protected AVCaptureDeviceFormat (Foundation.NSObjectFlag t);
protected AVCaptureDeviceFormat (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCaptureAutoFocusSystem AutoFocusSystem { get; }
public virtual bool AutoVideoFrameRateSupported { get; }
public virtual bool BackgroundReplacementSupported { get; }
public virtual bool CenterStageSupported { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMFormatDescription FormatDescription { get; }
public virtual float GeometricDistortionCorrectedVideoFieldOfView { get; }
public virtual bool GlobalToneMappingSupported { get; }
public virtual bool HighPhotoQualitySupported { get; }
public virtual CoreMedia.CMVideoDimensions HighResolutionStillImageDimensions { get; }
public virtual bool HighestPhotoQualitySupported { get; }
public virtual bool IsVideoHdrSupported { get; }
public virtual CoreMedia.CMTime MaxExposureDuration { get; }
public virtual float MaxISO { get; }
public virtual Foundation.NSString MediaType { get; }
public virtual CoreMedia.CMTime MinExposureDuration { get; }
public virtual float MinISO { get; }
public virtual bool MultiCamSupported { get; }
public virtual bool PortraitEffectSupported { get; }
public virtual bool PortraitEffectsMatteStillImageDeliverySupported { get; }
public virtual bool ReactionEffectsSupported { get; }
public virtual System.Runtime.InteropServices.NFloat[] SecondaryNativeResolutionZoomFactors { get; }
public virtual bool SpatialVideoCaptureSupported { get; }
public virtual bool StudioLightSupported { get; }
public virtual AVCaptureColorSpace[] SupportedColorSpaces { get; }
public virtual AVCaptureDeviceFormat[] SupportedDepthDataFormats { get; }
public virtual CoreMedia.CMVideoDimensions[] SupportedMaxPhotoDimensions { get; }
public virtual System.Runtime.InteropServices.NFloat[] SupportedVideoZoomFactorsForDepthDataDelivery { get; }
public virtual AVZoomRange[] SupportedVideoZoomRangesForDepthDataDelivery { get; }
public virtual AVExposureBiasRange SystemRecommendedExposureBiasRange { get; }
public virtual AVZoomRange SystemRecommendedVideoZoomRange { get; }
public virtual ObjCRuntime.Class[] UnsupportedCaptureOutputClasses { get; }
public virtual bool VideoBinned { get; }
public virtual float VideoFieldOfView { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForBackgroundReplacement { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForCenterStage { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForPortraitEffect { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForReactionEffectsInProgress { get; }
public virtual AVFrameRateRange VideoFrameRateRangeForStudioLight { get; }
public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactor { get; }
public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactorForCenterStage { get; }
public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactorForDepthDataDelivery { get; }
public virtual System.Runtime.InteropServices.NFloat VideoMinZoomFactorForCenterStage { get; }
public virtual System.Runtime.InteropServices.NFloat VideoMinZoomFactorForDepthDataDelivery { get; }
public virtual bool VideoStabilizationSupported { get; }
public virtual AVFrameRateRange[] VideoSupportedFrameRateRanges { get; }
public virtual System.Runtime.InteropServices.NFloat VideoZoomFactorUpscaleThreshold { get; }
public virtual bool ZoomFactorsOutsideOfVideoZoomRangesForDepthDeliverySupported { get; }
[Obsolete ("Use the 'IsVideoHdrSupported' property instead.")]
public virtual bool videoHDRSupportedVideoHDREnabled { get; }
// methods
public virtual bool IsVideoStabilizationModeSupported (AVCaptureVideoStabilizationMode mode);
}
public class AVCaptureDeviceInput : AVFoundation.AVCaptureInput {
// constructors
protected AVCaptureDeviceInput (Foundation.NSObjectFlag t);
protected AVCaptureDeviceInput (ObjCRuntime.NativeHandle handle);
public AVCaptureDeviceInput (AVCaptureDevice device, out Foundation.NSError error);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureDevice Device { get; }
public virtual AVCaptureMultichannelAudioMode MultichannelAudioMode { get; set; }
public virtual bool UnifiedAutoExposureDefaultsEnabled { get; set; }
public virtual CoreMedia.CMTime VideoMinFrameDurationOverride { get; set; }
public virtual bool WindNoiseRemovalEnabled { get; set; }
public virtual bool WindNoiseRemovalSupported { get; }
// methods
public static AVCaptureDeviceInput FromDevice (AVCaptureDevice device, out Foundation.NSError error);
public virtual AVCaptureInputPort[] GetPorts (AVMediaTypes mediaType, AVCaptureDeviceType sourceDeviceType, AVCaptureDevicePosition sourceDevicePosition);
public virtual bool IsMultichannelAudioModeSupported (AVCaptureMultichannelAudioMode multichannelAudioMode);
}
public class AVCaptureDeviceRotationCoordinator : Foundation.NSObject {
// constructors
protected AVCaptureDeviceRotationCoordinator (Foundation.NSObjectFlag t);
protected AVCaptureDeviceRotationCoordinator (ObjCRuntime.NativeHandle handle);
public AVCaptureDeviceRotationCoordinator (AVCaptureDevice device, CoreAnimation.CALayer previewLayer);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureDevice Device { get; }
public virtual CoreAnimation.CALayer PreviewLayer { get; }
public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelCapture { get; }
public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelPreview { get; }
// methods
protected override void Dispose (bool disposing);
}
[Serializable]
public enum AVCaptureExposureMode {
AutoExpose = 1,
ContinuousAutoExposure = 2,
Custom = 3,
Locked = 0,
}
[Serializable]
public enum AVCaptureFlashMode {
Auto = 2,
Off = 0,
On = 1,
}
[Serializable]
public enum AVCaptureFocusMode {
AutoFocus = 1,
ContinuousAutoFocus = 2,
Locked = 0,
}
public class AVCaptureIndexPicker : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureIndexPicker ();
protected AVCaptureIndexPicker (Foundation.NSObjectFlag t);
protected AVCaptureIndexPicker (ObjCRuntime.NativeHandle handle);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, string[] localizedIndexTitles);
public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes, AVCaptureIndexPickerTitleTransform localizedTitleTransform);
// properties
public virtual string AccessibilityIdentifier { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string[] LocalizedIndexTitles { get; }
public virtual string LocalizedTitle { get; }
public virtual IntPtr NumberOfIndexes { get; }
public virtual IntPtr SelectedIndex { get; set; }
public virtual string SymbolName { get; }
// methods
public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureIndexPickerCallback action);
}
public sealed delegate AVCaptureIndexPickerCallback : System.MulticastDelegate {
// constructors
public AVCaptureIndexPickerCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (IntPtr newValue, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (IntPtr newValue);
}
public sealed delegate AVCaptureIndexPickerTitleTransform : System.MulticastDelegate {
// constructors
public AVCaptureIndexPickerTitleTransform (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (IntPtr index, System.AsyncCallback callback, object object);
public virtual string EndInvoke (System.IAsyncResult result);
public virtual string Invoke (IntPtr index);
}
[Serializable]
public enum AVCaptureLensStabilizationStatus {
Active = 2,
Off = 1,
OutOfRange = 3,
Unavailable = 4,
Unsupported = 0,
}
public class AVCaptureManualExposureBracketedStillImageSettings : AVFoundation.AVCaptureBracketedStillImageSettings {
// constructors
protected AVCaptureManualExposureBracketedStillImageSettings (Foundation.NSObjectFlag t);
protected AVCaptureManualExposureBracketedStillImageSettings (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTime ExposureDuration { get; }
public virtual float ISO { get; }
// methods
public static AVCaptureManualExposureBracketedStillImageSettings Create (CoreMedia.CMTime duration, float ISO);
}
public class AVCaptureMetadataInput : AVFoundation.AVCaptureInput {
// constructors
protected AVCaptureMetadataInput (Foundation.NSObjectFlag t);
protected AVCaptureMetadataInput (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual bool AppendTimedMetadataGroup (AVTimedMetadataGroup metadata, out Foundation.NSError outError);
}
public class AVCaptureMetadataOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCaptureMetadataOutput ();
protected AVCaptureMetadataOutput (Foundation.NSObjectFlag t);
protected AVCaptureMetadataOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual CoreFoundation.DispatchQueue CallbackQueue { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual IAVCaptureMetadataOutputObjectsDelegate Delegate { get; }
public virtual CoreGraphics.CGRect RectOfInterest { get; set; }
public virtual Foundation.NSString[] WeakAvailableMetadataObjectTypes { get; }
public virtual Foundation.NSString[] WeakMetadataObjectTypes { get; set; }
// methods
public virtual void SetDelegate (IAVCaptureMetadataOutputObjectsDelegate objectsDelegate, CoreFoundation.DispatchQueue objectsCallbackQueue);
}
public class AVCaptureMetadataOutputObjectsDelegate : Foundation.NSObject, IAVCaptureMetadataOutputObjectsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCaptureMetadataOutputObjectsDelegate ();
protected AVCaptureMetadataOutputObjectsDelegate (Foundation.NSObjectFlag t);
protected AVCaptureMetadataOutputObjectsDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
public static class AVCaptureMetadataOutputObjectsDelegate_Extensions {
// methods
public static void DidOutputMetadataObjects (this IAVCaptureMetadataOutputObjectsDelegate This, AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
[Serializable]
public enum AVCaptureMicrophoneMode {
Standard = 0,
VoiceIsolation = 2,
WideSpectrum = 1,
}
public class AVCaptureMovieFileOutput : AVFoundation.AVCaptureFileOutput {
// constructors
public AVCaptureMovieFileOutput ();
protected AVCaptureMovieFileOutput (Foundation.NSObjectFlag t);
protected AVCaptureMovieFileOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual Foundation.NSString[] AvailableVideoCodecTypes { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetadataItem[] Metadata { get; set; }
public virtual CoreMedia.CMTime MovieFragmentInterval { get; set; }
public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions PrimaryConstituentDeviceRestrictedSwitchingBehaviorConditionsForRecording { get; }
public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior PrimaryConstituentDeviceSwitchingBehaviorForRecording { get; }
public virtual bool PrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled { get; set; }
public virtual bool SpatialVideoCaptureEnabled { get; set; }
public virtual bool SpatialVideoCaptureSupported { get; }
// methods
public virtual Foundation.NSDictionary GetOutputSettings (AVCaptureConnection connection);
public virtual string[] GetSupportedOutputSettingsKeys (AVCaptureConnection connection);
public virtual bool RecordsVideoOrientationAndMirroringChangesAsMetadataTrack (AVCaptureConnection connection);
public virtual void SetOutputSettings (Foundation.NSDictionary outputSettings, AVCaptureConnection connection);
public virtual void SetPrimaryConstituentDeviceSwitchingBehaviorForRecording (AVCapturePrimaryConstituentDeviceSwitchingBehavior switchingBehavior, AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions restrictedSwitchingBehaviorConditions);
public virtual void SetRecordsVideoOrientationAndMirroringChanges (bool doRecordChanges, AVCaptureConnection connection);
}
public class AVCaptureMultiCamSession : AVFoundation.AVCaptureSession {
// constructors
public AVCaptureMultiCamSession ();
protected AVCaptureMultiCamSession (Foundation.NSObjectFlag t);
protected AVCaptureMultiCamSession (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual float HardwareCost { get; }
public static bool MultiCamSupported { get; }
public virtual float SystemPressureCost { get; }
}
[Serializable]
public enum AVCaptureMultichannelAudioMode {
FirstOrderAmbisonics = 2,
None = 0,
Stereo = 1,
}
public class AVCapturePhoto : Foundation.NSObject {
// constructors
protected AVCapturePhoto (Foundation.NSObjectFlag t);
protected AVCapturePhoto (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCaptureBracketedStillImageSettings BracketSettings { get; }
public virtual CoreGraphics.CGImage CGImageRepresentation { get; }
public virtual AVCameraCalibrationData CameraCalibrationData { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual float ConstantColorCenterWeightedMeanConfidenceLevel { get; }
public virtual CoreVideo.CVPixelBuffer ConstantColorConfidenceMap { get; }
public virtual bool ConstantColorFallbackPhoto { get; }
public virtual AVDepthData DepthData { get; }
public AVVideoSettingsCompressed EmbeddedThumbnailPhotoFormat { get; }
public virtual Foundation.NSData FileDataRepresentation { get; }
public virtual AVCaptureLensStabilizationStatus LensStabilizationStatus { get; }
public virtual IntPtr PhotoCount { get; }
public virtual CoreVideo.CVPixelBuffer PixelBuffer { get; }
public virtual AVPortraitEffectsMatte PortraitEffectsMatte { get; }
public virtual CoreGraphics.CGImage PreviewCGImageRepresentation { get; }
public virtual CoreVideo.CVPixelBuffer PreviewPixelBuffer { get; }
public CoreGraphics.CGImageProperties Properties { get; }
public virtual bool RawPhoto { get; }
public virtual AVCaptureResolvedPhotoSettings ResolvedSettings { get; }
public virtual IntPtr SequenceCount { get; }
public AVCaptureDeviceType SourceDeviceType { get; }
public virtual CoreMedia.CMTime Timestamp { get; }
public virtual Foundation.NSDictionary WeakEmbeddedThumbnailPhotoFormat { get; }
public virtual Foundation.NSDictionary WeakMetadata { get; }
public virtual Foundation.NSString WeakSourceDeviceType { get; }
// methods
public virtual Foundation.NSData GetFileDataRepresentation (IAVCapturePhotoFileDataRepresentationCustomizer customizer);
public virtual Foundation.NSData GetFileDataRepresentation (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementMetadata, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormat, CoreVideo.CVPixelBuffer replacementEmbeddedThumbnailPixelBuffer, AVDepthData replacementDepthData);
public virtual AVSemanticSegmentationMatte GetSemanticSegmentationMatte (AVSemanticSegmentationMatteType semanticSegmentationMatteType);
}
public class AVCapturePhotoBracketSettings : AVFoundation.AVCapturePhotoSettings {
// constructors
protected AVCapturePhotoBracketSettings (Foundation.NSObjectFlag t);
protected AVCapturePhotoBracketSettings (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCaptureBracketedStillImageSettings[] BracketedSettings { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool IsLensStabilizationEnabled { get; set; }
// methods
public static AVCapturePhotoBracketSettings FromPhotoBracketSettings (uint rawPixelFormatType, string rawFileType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat, string processedFileType, AVCaptureBracketedStillImageSettings[] bracketedSettings);
public static AVCapturePhotoBracketSettings FromRawPixelFormatType (uint rawPixelFormatType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> format, AVCaptureBracketedStillImageSettings[] bracketedSettings);
}
public class AVCapturePhotoCaptureDelegate : Foundation.NSObject, IAVCapturePhotoCaptureDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCapturePhotoCaptureDelegate ();
protected AVCapturePhotoCaptureDelegate (Foundation.NSObjectFlag t);
protected AVCapturePhotoCaptureDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void DidFinishCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public virtual void DidFinishProcessingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public virtual void DidFinishProcessingPhoto (AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
public virtual void DidFinishRecordingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void WillBeginCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void WillCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
public static class AVCapturePhotoCaptureDelegate_Extensions {
// methods
public static void DidCapturePhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public static void DidFinishCapture (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public static void DidFinishProcessingLivePhotoMovie (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public static void DidFinishProcessingPhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
public static void DidFinishRecordingLivePhotoMovie (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
public static void WillBeginCapture (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public static void WillCapturePhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
public static class AVCapturePhotoFileDataRepresentationCustomizer_Extensions {
// methods
public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementAppleProRawCompressionSettings (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> defaultSettings, IntPtr maximumBitDepth);
public static AVDepthData GetReplacementDepthData (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
public static CoreVideo.CVPixelBuffer GetReplacementEmbeddedThumbnail (this IAVCapturePhotoFileDataRepresentationCustomizer This, out Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormatOut, AVCapturePhoto photo);
public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementMetadata (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
public static AVPortraitEffectsMatte GetReplacementPortraitEffectsMatte (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
public static AVSemanticSegmentationMatte GetReplacementSemanticSegmentationMatte (this IAVCapturePhotoFileDataRepresentationCustomizer This, Foundation.NSString semanticSegmentationMatteType, AVCapturePhoto photo);
}
public class AVCapturePhotoOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCapturePhotoOutput ();
protected AVCapturePhotoOutput (Foundation.NSObjectFlag t);
protected AVCapturePhotoOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual bool AppleProRawEnabled { get; set; }
public virtual bool AppleProRawSupported { get; }
public virtual bool AutoRedEyeReductionSupported { get; }
public virtual string[] AvailableLivePhotoVideoCodecTypes { get; }
public virtual string[] AvailablePhotoCodecTypes { get; }
public virtual Foundation.NSNumber[] AvailablePhotoPixelFormatTypes { get; }
public virtual AVVideoCodecType[] AvailableRawPhotoCodecTypes { get; }
public virtual Foundation.NSNumber[] AvailableRawPhotoPixelFormatTypes { get; }
public virtual AVSemanticSegmentationMatteType[] AvailableSemanticSegmentationMatteTypes { get; }
public virtual bool CameraCalibrationDataDeliverySupported { get; }
public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool ConstantColorEnabled { get; set; }
public virtual bool ConstantColorSupported { get; }
public virtual bool ContentAwareDistortionCorrectionEnabled { get; set; }
public virtual bool ContentAwareDistortionCorrectionSupported { get; }
public virtual bool DepthDataDeliveryEnabled { get; set; }
public virtual bool DepthDataDeliverySupported { get; }
public virtual bool DualCameraDualPhotoDeliveryEnabled { get; set; }
public virtual bool DualCameraDualPhotoDeliverySupported { get; }
public virtual bool DualCameraFusionSupported { get; }
public virtual AVSemanticSegmentationMatteType[] EnabledSemanticSegmentationMatteTypes { get; set; }
public virtual bool FastCapturePrioritizationEnabled { get; set; }
public virtual bool FastCapturePrioritizationSupported { get; set; }
public AVFileTypes[] GetAvailablePhotoFileTypes { get; }
public AVFileTypes[] GetAvailableRawPhotoFileTypes { get; }
public virtual bool IsFlashScene { get; }
public virtual bool IsHighResolutionCaptureEnabled { get; set; }
public virtual bool IsLensStabilizationDuringBracketedCaptureSupported { get; }
public virtual bool IsLivePhotoAutoTrimmingEnabled { get; set; }
public virtual bool IsLivePhotoCaptureEnabled { get; set; }
public virtual bool IsLivePhotoCaptureSupported { get; }
public virtual bool IsLivePhotoCaptureSuspended { get; set; }
public virtual bool IsStillImageStabilizationScene { get; }
public virtual bool IsStillImageStabilizationSupported { get; }
public virtual UIntPtr MaxBracketedCapturePhotoCount { get; }
public virtual CoreMedia.CMVideoDimensions MaxPhotoDimensions { get; set; }
public virtual AVCapturePhotoQualityPrioritization MaxPhotoQualityPrioritization { get; set; }
public virtual AVCapturePhotoSettings PhotoSettingsForSceneMonitoring { get; set; }
public virtual bool PortraitEffectsMatteDeliveryEnabled { get; set; }
public virtual bool PortraitEffectsMatteDeliverySupported { get; }
public virtual AVCapturePhotoSettings[] PreparedPhotoSettings { get; }
public virtual bool PreservesLivePhotoCaptureSuspendedOnSessionStop { get; set; }
public virtual bool ResponsiveCaptureEnabled { get; set; }
public virtual bool ResponsiveCaptureSupported { get; }
public virtual bool ShutterSoundSuppressionSupported { get; }
public virtual AVCaptureFlashMode[] SupportedFlashModes { get; }
public virtual bool VirtualDeviceConstituentPhotoDeliveryEnabled { get; set; }
public virtual bool VirtualDeviceConstituentPhotoDeliverySupported { get; }
public virtual bool VirtualDeviceFusionSupported { get; }
public virtual bool ZeroShutterLagEnabled { get; set; }
public virtual bool ZeroShutterLagSupported { get; }
// methods
public virtual void CapturePhoto (AVCapturePhotoSettings settings, IAVCapturePhotoCaptureDelegate cb);
protected override void Dispose (bool disposing);
public static Foundation.NSData GetDngPhotoDataRepresentation (CoreMedia.CMSampleBuffer rawSampleBuffer, CoreMedia.CMSampleBuffer previewPhotoSampleBuffer);
public static Foundation.NSData GetJpegPhotoDataRepresentation (CoreMedia.CMSampleBuffer JPEGSampleBuffer, CoreMedia.CMSampleBuffer previewPhotoSampleBuffer);
public AVVideoCodecType[] GetSupportedPhotoCodecTypesForFileType (string fileType);
public virtual Foundation.NSNumber[] GetSupportedPhotoPixelFormatTypesForFileType (string fileType);
public virtual AVVideoCodecType[] GetSupportedRawPhotoCodecTypes (CoreVideo.CVPixelFormatType rawPixelFormatType, AVFileTypes fileType);
public virtual Foundation.NSNumber[] GetSupportedRawPhotoPixelFormatTypesForFileType (string fileType);
public static bool IsAppleProRawPixelFormat (CoreVideo.CVPixelFormatType pixelFormat);
public static bool IsBayerRawPixelFormat (CoreVideo.CVPixelFormatType pixelFormat);
public virtual void SetPreparedPhotoSettings (AVCapturePhotoSettings[] preparedPhotoSettingsArray, System.Action<System.Boolean,Foundation.NSError> completionHandler);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> SetPreparedPhotoSettingsAsync (AVCapturePhotoSettings[] preparedPhotoSettingsArray);
}
[Serializable]
public enum AVCapturePhotoOutputCaptureReadiness {
NotReadyMomentarily = 2,
NotReadyWaitingForCapture = 3,
NotReadyWaitingForProcessing = 4,
Ready = 1,
SessionNotRunning = 0,
}
public class AVCapturePhotoOutputReadinessCoordinator : Foundation.NSObject {
// constructors
public AVCapturePhotoOutputReadinessCoordinator (AVCapturePhotoOutput photoOutput);
protected AVCapturePhotoOutputReadinessCoordinator (Foundation.NSObjectFlag t);
protected AVCapturePhotoOutputReadinessCoordinator (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public IAVCapturePhotoOutputReadinessCoordinatorDelegate Delegate { get; set; }
public virtual Foundation.NSObject WeakDelegate { get; set; }
// methods
protected override void Dispose (bool disposing);
public virtual void StartTrackingCaptureRequest (AVCapturePhotoSettings settings);
public virtual void StopTrackingCaptureRequest (long settingsUniqueId);
}
public class AVCapturePhotoOutputReadinessCoordinatorDelegate : Foundation.NSObject, IAVCapturePhotoOutputReadinessCoordinatorDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCapturePhotoOutputReadinessCoordinatorDelegate ();
protected AVCapturePhotoOutputReadinessCoordinatorDelegate (Foundation.NSObjectFlag t);
protected AVCapturePhotoOutputReadinessCoordinatorDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}
[Serializable]
public enum AVCapturePhotoQualityPrioritization {
Balanced = 2,
Quality = 3,
Speed = 1,
}
public class AVCapturePhotoSettings : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVCapturePhotoSettings (Foundation.NSObjectFlag t);
protected AVCapturePhotoSettings (ObjCRuntime.NativeHandle handle);
// properties
public virtual bool AutoContentAwareDistortionCorrectionEnabled { get; set; }
public virtual bool AutoDualCameraFusionEnabled { get; set; }
public virtual bool AutoRedEyeReductionEnabled { get; set; }
public virtual bool AutoVirtualDeviceFusionEnabled { get; set; }
public virtual AVVideoCodecType[] AvailableEmbeddedThumbnailPhotoCodecTypes { get; }
public virtual Foundation.NSNumber[] AvailablePreviewPhotoPixelFormatTypes { get; }
public virtual AVVideoCodecType[] AvailableRawEmbeddedThumbnailPhotoCodecTypes { get; }
public virtual bool CameraCalibrationDataDeliveryEnabled { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool ConstantColorEnabled { get; set; }
public virtual bool ConstantColorFallbackPhotoDeliveryEnabled { get; set; }
public virtual bool DepthDataDeliveryEnabled { get; set; }
public virtual bool DepthDataFiltered { get; set; }
public virtual bool DualCameraDualPhotoDeliveryEnabled { get; set; }
public AVCapturePhotoSettingsThumbnailFormat EmbeddedThumbnailPhotoFormat { get; set; }
public virtual bool EmbedsDepthDataInPhoto { get; set; }
public virtual bool EmbedsPortraitEffectsMatteInPhoto { get; set; }
public virtual bool EmbedsSemanticSegmentationMattesInPhoto { get; set; }
public virtual AVSemanticSegmentationMatteType[] EnabledSemanticSegmentationMatteTypes { get; set; }
public virtual AVCaptureFlashMode FlashMode { get; set; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> Format { get; }
public virtual bool IsAutoStillImageStabilizationEnabled { get; set; }
public virtual bool IsHighResolutionPhotoEnabled { get; set; }
public virtual Foundation.NSUrl LivePhotoMovieFileUrl { get; set; }
public virtual AVMetadataItem[] LivePhotoMovieMetadata { get; set; }
public virtual string LivePhotoVideoCodecType { get; set; }
public virtual CoreMedia.CMVideoDimensions MaxPhotoDimensions { get; set; }
public virtual Foundation.NSDictionary Metadata { get; set; }
public virtual AVCapturePhotoQualityPrioritization PhotoQualityPrioritization { get; set; }
public virtual bool PortraitEffectsMatteDeliveryEnabled { get; set; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> PreviewPhotoFormat { get; set; }
public virtual string ProcessedFileType { get; }
public AVCapturePhotoSettingsThumbnailFormat RawEmbeddedThumbnailPhotoFormat { get; set; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> RawFileFormat { get; set; }
public virtual string RawFileType { get; }
public virtual uint RawPhotoPixelFormatType { get; }
public virtual bool ShutterSoundSuppressionEnabled { get; set; }
public virtual long UniqueID { get; }
public virtual AVCaptureDevice[] VirtualDeviceConstituentPhotoDeliveryEnabledDevices { get; set; }
public virtual Foundation.NSDictionary WeakEmbeddedThumbnailPhotoFormat { get; set; }
public virtual Foundation.NSDictionary WeakRawEmbeddedThumbnailPhotoFormat { get; set; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public static AVCapturePhotoSettings Create ();
protected override void Dispose (bool disposing);
public static AVCapturePhotoSettings FromFormat (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> format);
public static AVCapturePhotoSettings FromPhotoSettings (AVCapturePhotoSettings photoSettings);
public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType);
public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat);
public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType, string rawFileType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat, string processedFileType);
}
public class AVCapturePhotoSettingsThumbnailFormat : Foundation.DictionaryContainer {
// constructors
public AVCapturePhotoSettingsThumbnailFormat ();
public AVCapturePhotoSettingsThumbnailFormat (Foundation.NSDictionary dictionary);
// properties
public Foundation.NSString Codec { get; set; }
public Foundation.NSNumber Height { get; set; }
public Foundation.NSNumber Width { get; set; }
}
[Serializable]
[Flags]
public enum AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions {
ExposureModeChanged = 4,
FocusModeChanged = 2,
None = 0,
VideoZoomChanged = 1,
}
[Serializable]
public enum AVCapturePrimaryConstituentDeviceSwitchingBehavior {
Auto = 1,
Locked = 3,
Restricted = 2,
Unsupported = 0,
}
public class AVCaptureReactionEffectState : Foundation.NSObject {
// constructors
public AVCaptureReactionEffectState ();
protected AVCaptureReactionEffectState (Foundation.NSObjectFlag t);
protected AVCaptureReactionEffectState (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTime EndTime { get; }
public virtual string ReactionType { get; }
public virtual CoreMedia.CMTime StartTime { get; }
}
public static class AVCaptureReactionType_Extensions {
// methods
public static string GetSystemImage (this AVCaptureReactionType reactionType);
}
public class AVCaptureResolvedPhotoSettings : Foundation.NSObject {
// constructors
protected AVCaptureResolvedPhotoSettings (Foundation.NSObjectFlag t);
protected AVCaptureResolvedPhotoSettings (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool ContentAwareDistortionCorrectionEnabled { get; }
public virtual bool DualCameraFusionEnabled { get; }
public virtual CoreMedia.CMVideoDimensions EmbeddedThumbnailDimensions { get; }
public virtual UIntPtr ExpectedPhotoCount { get; }
public virtual bool FastCapturePrioritizationEnabled { get; }
public virtual bool IsFlashEnabled { get; }
public virtual CoreMedia.CMVideoDimensions LivePhotoMovieDimensions { get; }
public virtual CoreMedia.CMVideoDimensions PhotoDimensions { get; }
public virtual CoreMedia.CMTimeRange PhotoProcessingTimeRange { get; }
public virtual CoreMedia.CMVideoDimensions PortraitEffectsMatteDimensions { get; }
public virtual CoreMedia.CMVideoDimensions PreviewDimensions { get; }
public virtual CoreMedia.CMVideoDimensions RawEmbeddedThumbnailDimensions { get; }
public virtual CoreMedia.CMVideoDimensions RawPhotoDimensions { get; }
public virtual bool RedEyeReductionEnabled { get; }
public virtual long UniqueID { get; }
public virtual bool VirtualDeviceFusionEnabled { get; }
// methods
public virtual CoreMedia.CMVideoDimensions GetDimensions (AVSemanticSegmentationMatteType semanticSegmentationMatteType);
}
public abstract class AVCaptureSessionControlsDelegate : Foundation.NSObject, IAVCaptureSessionControlsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVCaptureSessionControlsDelegate ();
protected AVCaptureSessionControlsDelegate (Foundation.NSObjectFlag t);
protected AVCaptureSessionControlsDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidBecomeActive (AVCaptureSession session);
public virtual void DidBecomeInactive (AVCaptureSession session);
public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}
[Serializable]
public enum AVCaptureSessionInterruptionReason {
AudioDeviceInUseByAnotherClient = 2,
VideoDeviceInUseByAnotherClient = 3,
VideoDeviceNotAvailableDueToSystemPressure = 5,
VideoDeviceNotAvailableInBackground = 1,
VideoDeviceNotAvailableWithMultipleForegroundApps = 4,
}
public class AVCaptureSlider : AVFoundation.AVCaptureControl {
// constructors
protected AVCaptureSlider (Foundation.NSObjectFlag t);
protected AVCaptureSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSlider (string localizedTitle, string symbolName, float[] values);
public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue);
public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue, float step);
// properties
public virtual string AccessibilityIdentifier { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string LocalizedTitle { get; }
public virtual string LocalizedValueFormat { get; set; }
public virtual float[] ProminentValues { get; set; }
public virtual string SymbolName { get; }
public virtual float Value { get; set; }
// methods
public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureSliderCallback action);
}
public sealed delegate AVCaptureSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (float newValue, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (float newValue);
}
public class AVCaptureSynchronizedData : Foundation.NSObject {
// constructors
protected AVCaptureSynchronizedData (Foundation.NSObjectFlag t);
protected AVCaptureSynchronizedData (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTime Timestamp { get; }
}
public class AVCaptureSynchronizedDataCollection : Foundation.NSObject {
// constructors
protected AVCaptureSynchronizedDataCollection (Foundation.NSObjectFlag t);
protected AVCaptureSynchronizedDataCollection (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual UIntPtr Count { get; }
// methods
public virtual AVCaptureSynchronizedData GetSynchronizedData (AVCaptureOutput captureOutput);
}
public class AVCaptureSynchronizedDepthData : AVFoundation.AVCaptureSynchronizedData {
// constructors
protected AVCaptureSynchronizedDepthData (Foundation.NSObjectFlag t);
protected AVCaptureSynchronizedDepthData (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVDepthData DepthData { get; }
public virtual bool DepthDataWasDropped { get; }
public virtual AVCaptureOutputDataDroppedReason DroppedReason { get; }
}
public class AVCaptureSynchronizedMetadataObjectData : AVFoundation.AVCaptureSynchronizedData {
// constructors
public AVCaptureSynchronizedMetadataObjectData ();
protected AVCaptureSynchronizedMetadataObjectData (Foundation.NSObjectFlag t);
protected AVCaptureSynchronizedMetadataObjectData (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetadataObject[] MetadataObjects { get; }
}
public class AVCaptureSynchronizedSampleBufferData : AVFoundation.AVCaptureSynchronizedData {
// constructors
public AVCaptureSynchronizedSampleBufferData ();
protected AVCaptureSynchronizedSampleBufferData (Foundation.NSObjectFlag t);
protected AVCaptureSynchronizedSampleBufferData (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureOutputDataDroppedReason DroppedReason { get; }
public virtual CoreMedia.CMSampleBuffer SampleBuffer { get; }
public virtual bool SampleBufferWasDropped { get; }
}
public class AVCaptureSystemExposureBiasSlider : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device);
protected AVCaptureSystemExposureBiasSlider (Foundation.NSObjectFlag t);
protected AVCaptureSystemExposureBiasSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device, AVCaptureSystemExposureBiasSliderCallback action);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public sealed delegate AVCaptureSystemExposureBiasSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSystemExposureBiasSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat exposureTargetBias, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (System.Runtime.InteropServices.NFloat exposureTargetBias);
}
[Serializable]
[Flags]
public enum AVCaptureSystemPressureFactors {
CameraTemperature = 8,
DepthModuleTemperature = 4,
None = 0,
PeakPower = 2,
SystemTemperature = 1,
}
[Serializable]
public enum AVCaptureSystemPressureLevel {
Critical = 3,
Fair = 1,
Nominal = 0,
Serious = 2,
Shutdown = 4,
}
public static class AVCaptureSystemPressureLevelExtensions {
// methods
public static Foundation.NSString GetConstant (this AVCaptureSystemPressureLevel self);
public static AVCaptureSystemPressureLevel GetValue (Foundation.NSString constant);
}
public class AVCaptureSystemPressureState : Foundation.NSObject {
// constructors
protected AVCaptureSystemPressureState (Foundation.NSObjectFlag t);
protected AVCaptureSystemPressureState (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVCaptureSystemPressureFactors Factors { get; }
public AVCaptureSystemPressureLevel Level { get; }
}
[Serializable]
public enum AVCaptureSystemUserInterface {
MicrophoneModes = 2,
VideoEffects = 1,
}
public class AVCaptureSystemZoomSlider : AVFoundation.AVCaptureControl {
// constructors
public AVCaptureSystemZoomSlider (AVCaptureDevice device);
protected AVCaptureSystemZoomSlider (Foundation.NSObjectFlag t);
protected AVCaptureSystemZoomSlider (ObjCRuntime.NativeHandle handle);
public AVCaptureSystemZoomSlider (AVCaptureDevice device, AVCaptureSystemZoomSliderCallback action);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public sealed delegate AVCaptureSystemZoomSliderCallback : System.MulticastDelegate {
// constructors
public AVCaptureSystemZoomSliderCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat videoZoomFactor, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (System.Runtime.InteropServices.NFloat videoZoomFactor);
}
[Serializable]
public enum AVCaptureTorchMode {
Auto = 2,
Off = 0,
On = 1,
}
public class AVCaptureVideoDataOutput : AVFoundation.AVCaptureOutput {
// constructors
public AVCaptureVideoDataOutput ();
protected AVCaptureVideoDataOutput (Foundation.NSObjectFlag t);
protected AVCaptureVideoDataOutput (ObjCRuntime.NativeHandle handle);
// properties
public virtual bool AlwaysDiscardsLateVideoFrames { get; set; }
public virtual bool AutomaticallyConfiguresOutputBufferDimensions { get; set; }
public virtual CoreVideo.CVPixelFormatType[] AvailableVideoCVPixelFormatTypes { get; }
public virtual Foundation.NSString[] AvailableVideoCodecTypes { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public AVVideoSettingsCompressed CompressedVideoSetting { get; set; }
public virtual bool DeliversPreviewSizedOutputBuffers { get; set; }
public virtual CoreMedia.CMTime MinFrameDuration { get; set; }
public virtual CoreFoundation.DispatchQueue SampleBufferCallbackQueue { get; }
public virtual IAVCaptureVideoDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
public AVVideoSettingsUncompressed UncompressedVideoSetting { get; set; }
public virtual Foundation.NSDictionary WeakVideoSettings { get; set; }
// methods
public virtual string[] GetAvailableVideoCodecTypes (string outputFileType);
public AVPlayerItemVideoOutputSettings GetRecommendedVideoSettings (string videoCodecType, string outputFileType);
public AVPlayerItemVideoOutputSettings GetRecommendedVideoSettings (AVVideoCodecType videoCodecType, AVFileTypes outputFileType, Foundation.NSUrl outputFileUrl);
public virtual Foundation.NSDictionary GetRecommendedVideoSettings (string videoCodecType, string outputFileType, Foundation.NSUrl outputFileUrl);
public virtual Foundation.NSDictionary GetRecommendedVideoSettingsForAssetWriter (string outputFileType);
public virtual void SetSampleBufferDelegate (IAVCaptureVideoDataOutputSampleBufferDelegate sampleBufferDelegate, CoreFoundation.DispatchQueue sampleBufferCallbackQueue);
}
public class AVCaptureVideoDataOutputSampleBufferDelegate : Foundation.NSObject, IAVCaptureVideoDataOutputSampleBufferDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVCaptureVideoDataOutputSampleBufferDelegate ();
protected AVCaptureVideoDataOutputSampleBufferDelegate (Foundation.NSObjectFlag t);
protected AVCaptureVideoDataOutputSampleBufferDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidDropSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
public static class AVCaptureVideoDataOutputSampleBufferDelegate_Extensions {
// methods
public static void DidDropSampleBuffer (this IAVCaptureVideoDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
public static void DidOutputSampleBuffer (this IAVCaptureVideoDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
[Serializable]
public enum AVCaptureWhiteBalanceMode {
AutoWhiteBalance = 1,
ContinuousAutoWhiteBalance = 2,
Locked = 0,
}
public class AVContinuityDevice : Foundation.NSObject {
// constructors
protected AVContinuityDevice (Foundation.NSObjectFlag t);
protected AVContinuityDevice (ObjCRuntime.NativeHandle handle);
// properties
public virtual AVAudioSessionPortDescription[] AudioSessionInputs { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool Connected { get; }
public virtual Foundation.NSUuid ConnectionId { get; }
public virtual AVCaptureDevice[] VideoDevices { get; }
}
public class AVExposureBiasRange : Foundation.NSObject {
// constructors
protected AVExposureBiasRange (Foundation.NSObjectFlag t);
protected AVExposureBiasRange (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual float MaxExposureBias { get; }
public virtual float MinExposureBias { get; }
// methods
public virtual bool ContainsExposureBias (float exposureBias);
}
public class AVExtendedNoteOnEvent : AVFoundation.AVMusicEvent {
// constructors
public AVExtendedNoteOnEvent ();
protected AVExtendedNoteOnEvent (Foundation.NSObjectFlag t);
protected AVExtendedNoteOnEvent (ObjCRuntime.NativeHandle handle);
public AVExtendedNoteOnEvent (float midiNote, float velocity, uint groupId, double duration);
public AVExtendedNoteOnEvent (float midiNote, float velocity, uint instrumentId, uint groupId, double duration);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public static uint DefaultInstrument { get; }
public virtual double Duration { get; set; }
public virtual uint GroupId { get; set; }
public virtual uint InstrumentId { get; set; }
public virtual float MidiNote { get; set; }
public virtual float Velocity { get; set; }
}
public class AVExtendedTempoEvent : AVFoundation.AVMusicEvent {
// constructors
public AVExtendedTempoEvent ();
protected AVExtendedTempoEvent (Foundation.NSObjectFlag t);
protected AVExtendedTempoEvent (ObjCRuntime.NativeHandle handle);
public AVExtendedTempoEvent (double tempo);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Tempo { get; set; }
}
[Serializable]
public enum AVExternalContentProtectionStatus {
Insufficient = 2,
Pending = 0,
Sufficient = 1,
}
public class AVExternalStorageDevice : Foundation.NSObject {
// constructors
protected AVExternalStorageDevice (Foundation.NSObjectFlag t);
protected AVExternalStorageDevice (ObjCRuntime.NativeHandle handle);
// properties
public static AVAuthorizationStatus AuthorizationStatus { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool Connected { get; }
public virtual string DisplayName { get; }
public virtual IntPtr FreeSize { get; }
public virtual bool NotRecommendedForCaptureUse { get; }
public virtual IntPtr TotalSize { get; }
public virtual Foundation.NSUuid Uuid { get; }
// methods
public virtual Foundation.NSUrl[] GetNextAvailableUrls (string[] extensionArray, out Foundation.NSError outError);
public static void RequestAccess (AVExternalStorageDeviceRequestAccessCallback handler);
public static System.Threading.Tasks.Task<bool> RequestAccessAsync ();
}
public class AVExternalStorageDeviceDiscoverySession : Foundation.NSObject {
// constructors
protected AVExternalStorageDeviceDiscoverySession (Foundation.NSObjectFlag t);
protected AVExternalStorageDeviceDiscoverySession (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVExternalStorageDevice[] ExternalStorageDevices { get; }
public static AVExternalStorageDeviceDiscoverySession SharedSession { get; }
public static bool Supported { get; }
}
public sealed delegate AVExternalStorageDeviceRequestAccessCallback : System.MulticastDelegate {
// constructors
public AVExternalStorageDeviceRequestAccessCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool granted, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool granted);
}
public class AVFrameRateRange : Foundation.NSObject {
// constructors
protected AVFrameRateRange (Foundation.NSObjectFlag t);
protected AVFrameRateRange (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTime MaxFrameDuration { get; }
public virtual double MaxFrameRate { get; }
public virtual CoreMedia.CMTime MinFrameDuration { get; }
public virtual double MinFrameRate { get; }
}
public class AVMetadataBodyObject : AVFoundation.AVMetadataObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMetadataBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public virtual IntPtr BodyId { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetadataCatBodyObject : AVFoundation.AVMetadataBodyObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMetadataCatBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataCatBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetadataDogBodyObject : AVFoundation.AVMetadataBodyObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMetadataDogBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataDogBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetadataHumanBodyObject : AVFoundation.AVMetadataBodyObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMetadataHumanBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataHumanBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetadataHumanFullBodyObject : AVFoundation.AVMetadataBodyObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVMetadataHumanFullBodyObject ();
protected AVMetadataHumanFullBodyObject (Foundation.NSObjectFlag t);
protected AVMetadataHumanFullBodyObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetadataSalientObject : AVFoundation.AVMetadataObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVMetadataSalientObject (Foundation.NSObjectFlag t);
protected AVMetadataSalientObject (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual IntPtr ObjectId { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
public class AVMetricContentKeyRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricContentKeyRequestEvent (Foundation.NSCoder coder);
protected AVMetricContentKeyRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricContentKeyRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVContentKeySpecifier ContentKeySpecifier { get; }
public virtual bool IsClientInitiated { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
}
public class AVMetricErrorEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricErrorEvent (Foundation.NSCoder coder);
protected AVMetricErrorEvent (Foundation.NSObjectFlag t);
protected AVMetricErrorEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidRecover { get; }
public virtual Foundation.NSError Error { get; }
}
public class AVMetricEvent : Foundation.NSObject, Foundation.INSCoding, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVMetricEvent (Foundation.NSCoder coder);
protected AVMetricEvent (Foundation.NSObjectFlag t);
protected AVMetricEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate Date { get; }
public virtual CoreMedia.CMTime MediaTime { get; }
public virtual string SessionId { get; }
// methods
public virtual void EncodeTo (Foundation.NSCoder encoder);
}
public class AVMetricEventStream : Foundation.NSObject {
// constructors
protected AVMetricEventStream (Foundation.NSObjectFlag t);
protected AVMetricEventStream (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual bool AddPublisher (IAVMetricEventStreamPublisher publisher);
public static AVMetricEventStream Create ();
public virtual bool SetSubscriber (IAVMetricEventStreamSubscriber subscriber, CoreFoundation.DispatchQueue queue);
public virtual void SubscribeTo (ObjCRuntime.Class metricEventClass);
public virtual void SubscribeTo (ObjCRuntime.Class[] metricEventsClasses);
public void SubscribeTo (System.Type metricEventType);
public void SubscribeTo (System.Type[] metricEventsTypes);
public virtual void SubscribeToAll ();
}
public class AVMetricHlsMediaSegmentRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricHlsMediaSegmentRequestEvent (Foundation.NSCoder coder);
protected AVMetricHlsMediaSegmentRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricHlsMediaSegmentRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual Foundation.NSRange ByteRange { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSUrl IndexFileUrl { get; }
public virtual bool IsMapSegment { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
public virtual Foundation.NSUrl Url { get; }
}
public class AVMetricHlsPlaylistRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricHlsPlaylistRequestEvent (Foundation.NSCoder coder);
protected AVMetricHlsPlaylistRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricHlsPlaylistRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool IsMultivariantPlaylist { get; }
public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
public virtual string MediaType { get; }
public virtual Foundation.NSUrl Url { get; }
}
public class AVMetricMediaResourceRequestEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricMediaResourceRequestEvent (Foundation.NSCoder coder);
protected AVMetricMediaResourceRequestEvent (Foundation.NSObjectFlag t);
protected AVMetricMediaResourceRequestEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual Foundation.NSRange ByteRange { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricErrorEvent ErrorEvent { get; }
public virtual Foundation.NSUrlSessionTaskMetrics NetworkTransactionMetrics { get; }
public virtual bool ReadFromCache { get; }
public virtual Foundation.NSDate RequestEndTime { get; }
public virtual Foundation.NSDate RequestStartTime { get; }
public virtual Foundation.NSDate ResponseEndTime { get; }
public virtual Foundation.NSDate ResponseStartTime { get; }
public virtual string ServerAddress { get; }
public virtual Foundation.NSUrl Url { get; }
}
public class AVMetricPlayerItemInitialLikelyToKeepUpEvent : AVFoundation.AVMetricPlayerItemLikelyToKeepUpEvent {
// constructors
public AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricContentKeyRequestEvent[] ContentKeyRequestEvents { get; }
public virtual AVMetricHlsMediaSegmentRequestEvent[] MediaSegmentRequestEvents { get; }
public virtual AVMetricHlsPlaylistRequestEvent[] PlaylistRequestEvents { get; }
}
public class AVMetricPlayerItemLikelyToKeepUpEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual double TimeTaken { get; }
public virtual AVAssetVariant Variant { get; }
}
public class AVMetricPlayerItemPlaybackSummaryEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemPlaybackSummaryEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMetricErrorEvent ErrorEvent { get; }
public virtual IntPtr MediaResourceRequestCount { get; }
public virtual IntPtr PlaybackDuration { get; }
public virtual IntPtr RecoverableErrorCount { get; }
public virtual IntPtr StallCount { get; }
public virtual double TimeSpentInInitialStartup { get; }
public virtual double TimeSpentRecoveringFromStall { get; }
public virtual IntPtr TimeWeightedAverageBitrate { get; }
public virtual IntPtr TimeWeightedPeakBitrate { get; }
public virtual IntPtr VariantSwitchCount { get; }
}
public class AVMetricPlayerItemRateChangeEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemRateChangeEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemRateChangeEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemRateChangeEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double PreviousRate { get; }
public virtual double Rate { get; }
public virtual AVAssetVariant Variant { get; }
}
public class AVMetricPlayerItemSeekDidCompleteEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemSeekDidCompleteEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidSeekInBuffer { get; }
}
public class AVMetricPlayerItemSeekEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemSeekEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemSeekEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemSeekEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public class AVMetricPlayerItemStallEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
// constructors
public AVMetricPlayerItemStallEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemStallEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemStallEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public class AVMetricPlayerItemVariantSwitchEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemVariantSwitchEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemVariantSwitchEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemVariantSwitchEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual bool DidSucceed { get; }
public virtual AVAssetVariant FromVariant { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVAssetVariant ToVariant { get; }
}
public class AVMetricPlayerItemVariantSwitchStartEvent : AVFoundation.AVMetricEvent {
// constructors
public AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSCoder coder);
protected AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSObjectFlag t);
protected AVMetricPlayerItemVariantSwitchStartEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVAssetVariant FromVariant { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVAssetVariant ToVariant { get; }
}
public class AVMidiChannelEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiChannelEvent ();
protected AVMidiChannelEvent (Foundation.NSObjectFlag t);
protected AVMidiChannelEvent (ObjCRuntime.NativeHandle handle);
// properties
public virtual uint Channel { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public class AVMidiChannelPressureEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiChannelPressureEvent ();
protected AVMidiChannelPressureEvent (Foundation.NSObjectFlag t);
protected AVMidiChannelPressureEvent (ObjCRuntime.NativeHandle handle);
public AVMidiChannelPressureEvent (uint channel, uint pressure);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Pressure { get; set; }
}
public class AVMidiControlChangeEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiControlChangeEvent ();
protected AVMidiControlChangeEvent (Foundation.NSObjectFlag t);
protected AVMidiControlChangeEvent (ObjCRuntime.NativeHandle handle);
public AVMidiControlChangeEvent (uint channel, AVMidiControlChangeMessageType messageType, uint value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMidiControlChangeMessageType MessageType { get; }
public virtual uint Value { get; }
}
[Serializable]
public enum AVMidiControlChangeMessageType {
AllNotesOff = 123,
AllSoundOff = 120,
AttackTime = 73,
Balance = 8,
BankSelect = 0,
Breath = 2,
Brightness = 74,
ChorusLevel = 93,
DataEntry = 6,
DecayTime = 75,
Expression = 11,
FilterResonance = 71,
Foot = 4,
Hold2Pedal = 69,
LegatoPedal = 68,
ModWheel = 1,
MonoModeOff = 127,
MonoModeOn = 126,
OmniModeOff = 124,
OmniModeOn = 125,
Pan = 10,
Portamento = 65,
PortamentoTime = 5,
ReleaseTime = 72,
ResetAllControllers = 121,
ReverbLevel = 91,
RpnLsb = 100,
RpnMsb = 101,
Soft = 67,
Sostenuto = 66,
Sustain = 64,
VibratoDelay = 78,
VibratoDepth = 77,
VibratoRate = 76,
Volume = 7,
}
public class AVMidiMetaEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiMetaEvent ();
protected AVMidiMetaEvent (Foundation.NSObjectFlag t);
protected AVMidiMetaEvent (ObjCRuntime.NativeHandle handle);
public AVMidiMetaEvent (AVMidiMetaEventType type, Foundation.NSData data);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVMidiMetaEventType Type { get; }
}
[Serializable]
public enum AVMidiMetaEventType {
Copyright = 2,
CuePoint = 7,
EndOfTrack = 47,
Instrument = 4,
KeySignature = 89,
Lyric = 5,
Marker = 6,
MidiChannel = 32,
MidiPort = 33,
ProprietaryEvent = 127,
SequenceNumber = 0,
SmpteOffset = 84,
Tempo = 81,
Text = 1,
TimeSignature = 88,
TrackName = 3,
}
public class AVMidiNoteEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiNoteEvent ();
protected AVMidiNoteEvent (Foundation.NSObjectFlag t);
protected AVMidiNoteEvent (ObjCRuntime.NativeHandle handle);
public AVMidiNoteEvent (uint channel, uint keyNum, uint velocity, double duration);
// properties
public virtual uint Channel { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual double Duration { get; set; }
public virtual uint Key { get; set; }
public virtual uint Velocity { get; set; }
}
public class AVMidiPitchBendEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiPitchBendEvent ();
protected AVMidiPitchBendEvent (Foundation.NSObjectFlag t);
protected AVMidiPitchBendEvent (ObjCRuntime.NativeHandle handle);
public AVMidiPitchBendEvent (uint channel, uint value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Value { get; set; }
}
public class AVMidiPolyPressureEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiPolyPressureEvent ();
protected AVMidiPolyPressureEvent (Foundation.NSObjectFlag t);
protected AVMidiPolyPressureEvent (ObjCRuntime.NativeHandle handle);
public AVMidiPolyPressureEvent (uint channel, uint key, uint pressure);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Key { get; set; }
public virtual uint Pressure { get; set; }
}
public class AVMidiProgramChangeEvent : AVFoundation.AVMidiChannelEvent {
// constructors
public AVMidiProgramChangeEvent ();
protected AVMidiProgramChangeEvent (Foundation.NSObjectFlag t);
protected AVMidiProgramChangeEvent (ObjCRuntime.NativeHandle handle);
public AVMidiProgramChangeEvent (uint channel, uint programNumber);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint ProgramNumber { get; set; }
}
public class AVMidiSysexEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMidiSysexEvent ();
public AVMidiSysexEvent (Foundation.NSData data);
protected AVMidiSysexEvent (Foundation.NSObjectFlag t);
protected AVMidiSysexEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint SizeInBytes { get; }
}
public class AVMusicEvent : Foundation.NSObject {
// constructors
public AVMusicEvent ();
protected AVMusicEvent (Foundation.NSObjectFlag t);
protected AVMusicEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
public sealed delegate AVMusicEventEnumerationBlock : System.MulticastDelegate {
// constructors
public AVMusicEventEnumerationBlock (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMusicEvent event, out double timeStamp, out bool removeEvent, System.AsyncCallback callback, object object);
public virtual void EndInvoke (out double timeStamp, out bool removeEvent, System.IAsyncResult result);
public virtual void Invoke (AVMusicEvent event, out double timeStamp, out bool removeEvent);
}
public class AVMusicUserEvent : AVFoundation.AVMusicEvent {
// constructors
public AVMusicUserEvent ();
public AVMusicUserEvent (Foundation.NSData data);
protected AVMusicUserEvent (Foundation.NSObjectFlag t);
protected AVMusicUserEvent (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint SizeInBytes { get; }
}
public sealed delegate AVMutableCompositionInsertHandler : System.MulticastDelegate {
// constructors
public AVMutableCompositionInsertHandler (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (Foundation.NSError error);
}
public sealed delegate AVMutableVideoCompositionCreateApplier : System.MulticastDelegate {
// constructors
public AVMutableVideoCompositionCreateApplier (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAsynchronousCIImageFilteringRequest request, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAsynchronousCIImageFilteringRequest request);
}
public sealed delegate AVMutableVideoCompositionCreateCallback : System.MulticastDelegate {
// constructors
public AVMutableVideoCompositionCreateCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVMutableVideoComposition videoComposition, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVMutableVideoComposition videoComposition, Foundation.NSError error);
}
public class AVParameterEvent : AVFoundation.AVMusicEvent {
// constructors
public AVParameterEvent ();
protected AVParameterEvent (Foundation.NSObjectFlag t);
protected AVParameterEvent (ObjCRuntime.NativeHandle handle);
public AVParameterEvent (uint parameterId, uint scope, uint element, float value);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual uint Element { get; set; }
public virtual uint ParameterId { get; set; }
public virtual uint Scope { get; set; }
public virtual float Value { get; set; }
}
[Serializable]
public enum AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason {
CurrentSegmentChanged = 1,
LoadedTimeRangesChanged = 2,
SegmentsChanged = 0,
}
public static class AVPlayerIntegratedTimelineSnapshotsOutOfSyncReasonExtensions {
// methods
public static Foundation.NSString GetConstant (this AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason self);
public static AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason GetValue (Foundation.NSString constant);
}
[Serializable]
public enum AVPlayerInterstitialEventAssetListResponseStatus {
Available = 0,
Cleared = 1,
Unavailable = 2,
}
[Serializable]
public enum AVPlayerInterstitialEventCue {
JoinCue = 1,
LeaveCue = 2,
NoCue = 0,
}
public static class AVPlayerInterstitialEventCueExtensions {
// methods
public static Foundation.NSString GetConstant (this AVPlayerInterstitialEventCue self);
public static AVPlayerInterstitialEventCue GetValue (Foundation.NSString constant);
}
[Serializable]
public enum AVPlayerInterstitialEventTimelineOccupancy {
Fill = 1,
SinglePoint = 0,
}
public class AVPlayerItemIntegratedTimeline : Foundation.NSObject {
// constructors
protected AVPlayerItemIntegratedTimeline (Foundation.NSObjectFlag t);
protected AVPlayerItemIntegratedTimeline (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate CurrentDate { get; }
public virtual AVPlayerItemIntegratedTimelineSnapshot CurrentSnapshot { get; }
public virtual CoreMedia.CMTime CurrentTime { get; }
// methods
public virtual IAVPlayerItemIntegratedTimelineObserver AddBoundaryTimeObserver (AVPlayerItemSegment segment, CoreMedia.CMTime[] offsetsIntoSegment, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback callback);
public virtual IAVPlayerItemIntegratedTimelineObserver AddPeriodicTimeObserver (CoreMedia.CMTime interval, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback callback);
public virtual void RemoveTimeObserver (IAVPlayerItemIntegratedTimelineObserver observer);
public virtual void SeekToDate (Foundation.NSDate date, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
public virtual System.Threading.Tasks.Task<bool> SeekToDateAsync (Foundation.NSDate date);
public virtual void SeekToTime (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
public virtual System.Threading.Tasks.Task<bool> SeekToTimeAsync (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter);
}
public sealed delegate AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool success, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool success);
}
public sealed delegate AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CoreMedia.CMTime time, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (CoreMedia.CMTime time);
}
public sealed delegate AVPlayerItemIntegratedTimelineSeekCallback : System.MulticastDelegate {
// constructors
public AVPlayerItemIntegratedTimelineSeekCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool success, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool success);
}
public class AVPlayerItemIntegratedTimelineSnapshot : Foundation.NSObject {
// constructors
protected AVPlayerItemIntegratedTimelineSnapshot (Foundation.NSObjectFlag t);
protected AVPlayerItemIntegratedTimelineSnapshot (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDate CurrentDate { get; }
public virtual AVPlayerItemSegment CurrentSegment { get; }
public virtual CoreMedia.CMTime CurrentTime { get; }
public virtual CoreMedia.CMTime Duration { get; }
public virtual AVPlayerItemSegment[] Segments { get; }
public static Foundation.NSString SnapshotsOutOfSyncNotification { get; }
public static Foundation.NSString SnapshotsOutOfSyncReasonKey { get; }
// methods
public virtual void Map (CoreMedia.CMTime time, out AVPlayerItemSegment timeSegment, out CoreMedia.CMTime segmentOffset);
// inner types
public static class Notifications {
// methods
public static Foundation.NSObject ObserveSnapshotsOutOfSync (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSnapshotsOutOfSync (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
}
}
public class AVPlayerItemSegment : Foundation.NSObject {
// constructors
protected AVPlayerItemSegment (Foundation.NSObjectFlag t);
protected AVPlayerItemSegment (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVPlayerInterstitialEvent InterstitialEvent { get; }
public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
public virtual AVPlayerItemSegmentType SegmentType { get; }
public virtual Foundation.NSDate StartDate { get; }
public virtual CoreMedia.CMTimeMapping TimeMapping { get; }
}
[Serializable]
public enum AVPlayerItemSegmentType {
Interstitial = 1,
Primary = 0,
}
[Serializable]
public enum AVPlayerLooperItemOrdering {
FollowExistingItems = 1,
PrecedeExistingItems = 0,
}
public class AVPlayerVideoOutput : Foundation.NSObject {
// constructors
public AVPlayerVideoOutput (AVVideoOutputSpecification specification);
protected AVPlayerVideoOutput (Foundation.NSObjectFlag t);
protected AVPlayerVideoOutput (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual CoreMedia.CMTaggedBufferGroup CopyTaggedBufferGroup (CoreMedia.CMTime hostTime, out CoreMedia.CMTime presentationTimeStamp, out AVPlayerVideoOutputConfiguration activeConfiguration);
}
public class AVPlayerVideoOutputConfiguration : Foundation.NSObject {
// constructors
protected AVPlayerVideoOutputConfiguration (Foundation.NSObjectFlag t);
protected AVPlayerVideoOutputConfiguration (ObjCRuntime.NativeHandle handle);
// properties
public virtual CoreMedia.CMTime ActivationTime { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSObject[] DataChannelDescriptions { get; }
public virtual CoreGraphics.CGAffineTransform PreferredTransform { get; }
public virtual AVPlayerItem SourcePlayerItem { get; }
// methods
protected override void Dispose (bool disposing);
}
public sealed delegate AVRequestAccessStatus : System.MulticastDelegate {
// constructors
public AVRequestAccessStatus (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool accessGranted, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool accessGranted);
}
public class AVSampleBufferGenerator : Foundation.NSObject {
// constructors
protected AVSampleBufferGenerator (Foundation.NSObjectFlag t);
protected AVSampleBufferGenerator (ObjCRuntime.NativeHandle handle);
public AVSampleBufferGenerator (AVAsset asset, CoreMedia.CMTimebase timebase);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, out Foundation.NSError outError);
public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, AVSampleBufferGeneratorBatch batch, out Foundation.NSError outError);
public virtual AVSampleBufferGeneratorBatch MakeBatch ();
public static void NotifyOfDataReady (CoreMedia.CMSampleBuffer sbuf, System.Action<System.Boolean,Foundation.NSError> completionHandler);
public static System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> NotifyOfDataReadyAsync (CoreMedia.CMSampleBuffer sbuf);
}
public class AVSampleBufferGeneratorBatch : Foundation.NSObject {
// constructors
protected AVSampleBufferGeneratorBatch (Foundation.NSObjectFlag t);
protected AVSampleBufferGeneratorBatch (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
// methods
public virtual void Cancel ();
public virtual void MakeDataReady (AVSampleBufferGeneratorBatchMakeReadyCallback completionHandler);
public virtual System.Threading.Tasks.Task MakeDataReadyAsync ();
}
public sealed delegate AVSampleBufferGeneratorBatchMakeReadyCallback : System.MulticastDelegate {
// constructors
public AVSampleBufferGeneratorBatchMakeReadyCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (Foundation.NSError error);
}
public class AVSampleBufferRequest : Foundation.NSObject {
// constructors
public AVSampleBufferRequest (AVSampleCursor startCursor);
protected AVSampleBufferRequest (Foundation.NSObjectFlag t);
protected AVSampleBufferRequest (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSampleBufferRequestDirection Direction { get; set; }
public virtual AVSampleCursor LimitCursor { get; set; }
public virtual IntPtr MaxSampleCount { get; set; }
public virtual AVSampleBufferRequestMode Mode { get; set; }
public virtual CoreMedia.CMTime OverrideTime { get; set; }
public virtual IntPtr PreferredMinSampleCount { get; set; }
public virtual AVSampleCursor StartCursor { get; }
}
public class AVSampleBufferVideoRenderer : Foundation.NSObject, IAVQueuedSampleBufferRendering, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSampleBufferVideoRenderer ();
protected AVSampleBufferVideoRenderer (Foundation.NSObjectFlag t);
protected AVSampleBufferVideoRenderer (ObjCRuntime.NativeHandle handle);
// properties
public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotification { get; }
public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotificationErrorKey { get; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSError Error { get; }
public virtual bool HasSufficientMediaDataForReliablePlaybackStart { get; }
public virtual bool ReadyForMoreMediaData { get; }
public virtual bool RequiresFlushToResumeDecoding { get; }
public static Foundation.NSString RequiresFlushToResumeDecodingDidChangeNotification { get; }
public virtual AVQueuedSampleBufferRenderingStatus Status { get; }
public virtual CoreMedia.CMTimebase Timebase { get; }
// methods
public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();
public virtual void Enqueue (CoreMedia.CMSampleBuffer sampleBuffer);
public virtual void ExpectMinimumUpcomingSampleBufferPresentationTime (CoreMedia.CMTime minimumUpcomingPresentationTime);
public virtual void ExpectMonotonicallyIncreasingUpcomingSampleBufferPresentationTimes ();
public virtual void Flush ();
public virtual void FlushWithRemovalOfDisplayedImage (bool removeDisplayedImage, System.Action handler);
public virtual void LoadVideoPerformanceMetrics (AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback completionHandler);
public virtual System.Threading.Tasks.Task<AVVideoPerformanceMetrics> LoadVideoPerformanceMetricsAsync ();
public virtual void RequestMediaData (CoreFoundation.DispatchQueue queue, System.Action handler);
public virtual void ResetUpcomingSampleBufferPresentationTimeExpectations ();
public virtual void StopRequestingMediaData ();
// inner types
public static class Notifications {
// methods
public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
}
}
public sealed delegate AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback : System.MulticastDelegate {
// constructors
public AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVVideoPerformanceMetrics videoPerformanceMetrics, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVVideoPerformanceMetrics videoPerformanceMetrics);
}
[Serializable]
public enum AVSpatialCaptureDiscomfortReason {
NotEnoughLight = 0,
SubjectTooClose = 1,
}
public static class AVSpatialCaptureDiscomfortReasonExtensions {
// methods
public static Foundation.NSString GetConstant (this AVSpatialCaptureDiscomfortReason self);
public static AVSpatialCaptureDiscomfortReason GetValue (Foundation.NSString constant);
}
public class AVSpeechSynthesisMarker : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisMarker ();
public AVSpeechSynthesisMarker (Foundation.NSCoder coder);
protected AVSpeechSynthesisMarker (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisMarker (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisMarker (AVSpeechSynthesisMarkerMark type, Foundation.NSRange range, UIntPtr byteSampleOffset);
public AVSpeechSynthesisMarker (Foundation.NSRange range, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerRangeOption option);
public AVSpeechSynthesisMarker (string value, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerStringOption option);
// properties
public virtual string BookmarkName { get; set; }
public virtual UIntPtr ByteSampleOffset { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisMarkerMark Mark { get; set; }
public virtual string Phoneme { get; set; }
public virtual Foundation.NSRange TextRange { get; set; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
}
[Serializable]
public enum AVSpeechSynthesisMarkerMark {
Bookmark = 4,
Paragraph = 3,
Phoneme = 0,
Sentence = 2,
Word = 1,
}
[Serializable]
public enum AVSpeechSynthesisMarkerRangeOption {
Paragraph = 2,
Sentence = 1,
Word = 0,
}
[Serializable]
public enum AVSpeechSynthesisMarkerStringOption {
Bookmark = 1,
Phoneme = 0,
}
[Serializable]
public enum AVSpeechSynthesisPersonalVoiceAuthorizationStatus {
Authorized = 3,
Denied = 1,
NotDetermined = 0,
Unsupported = 2,
}
public class AVSpeechSynthesisProviderAudioUnit : AudioUnit.AUAudioUnit {
// constructors
protected AVSpeechSynthesisProviderAudioUnit (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderAudioUnit (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisProviderOutputBlock SpeechSynthesisOutputMetadataBlock { get; set; }
public virtual AVSpeechSynthesisProviderVoice[] SpeechVoices { get; set; }
// methods
public virtual void CancelSpeechRequest ();
public static AVSpeechSynthesisProviderAudioUnit Create (AudioUnit.AudioComponentDescription componentDescription, AudioUnit.AudioComponentInstantiationOptions options, out Foundation.NSError error);
public virtual void SynthesizeSpeechRequest (AVSpeechSynthesisProviderRequest speechRequest);
}
public sealed delegate AVSpeechSynthesisProviderOutputBlock : System.MulticastDelegate {
// constructors
public AVSpeechSynthesisProviderOutputBlock (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request);
}
public class AVSpeechSynthesisProviderRequest : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisProviderRequest (Foundation.NSCoder coder);
protected AVSpeechSynthesisProviderRequest (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderRequest (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisProviderRequest (string ssmlRepresentation, AVSpeechSynthesisProviderVoice voice);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual string SsmlRepresentation { get; }
public virtual AVSpeechSynthesisProviderVoice Voice { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
}
public class AVSpeechSynthesisProviderVoice : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVSpeechSynthesisProviderVoice (Foundation.NSCoder coder);
protected AVSpeechSynthesisProviderVoice (Foundation.NSObjectFlag t);
protected AVSpeechSynthesisProviderVoice (ObjCRuntime.NativeHandle handle);
public AVSpeechSynthesisProviderVoice (string name, string identifier, string[] primaryLanguages, string[] supportedLanguages);
// properties
public virtual IntPtr Age { get; set; }
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual AVSpeechSynthesisVoiceGender Gender { get; set; }
public virtual string Identifier { get; }
public virtual string Name { get; }
public virtual string[] PrimaryLanguages { get; }
public virtual string[] SupportedLanguages { get; }
public virtual string Version { get; set; }
public virtual long VoiceSize { get; set; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void EncodeTo (Foundation.NSCoder encoder);
public static void UpdateSpeechVoices ();
}
[Serializable]
public enum AVSpeechSynthesisVoiceTraits {
IsNoveltyVoice = 1,
IsPersonalVoice = 2,
None = 0,
}
public sealed delegate AVSpeechSynthesizerBufferCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerBufferCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAudioBuffer buffer, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAudioBuffer buffer);
}
public sealed delegate AVSpeechSynthesizerMarkerCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerMarkerCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisMarker[] markers);
}
public sealed delegate AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback : System.MulticastDelegate {
// constructors
public AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisPersonalVoiceAuthorizationStatus status, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVSpeechSynthesisPersonalVoiceAuthorizationStatus status);
}
public class AVSpeechSynthesizerWillSpeakMarkerEventArgs : System.EventArgs {
// constructors
public AVSpeechSynthesizerWillSpeakMarkerEventArgs (AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
// properties
public AVSpeechSynthesisMarker Marker { get; set; }
public AVSpeechUtterance Utterance { get; set; }
}
[Serializable]
public enum AVSpeechUtteranceInitializationOption {
PlainText = 0,
SsmlRepresentation = 1,
}
public sealed delegate AVVideoCompositionCreateApplier : System.MulticastDelegate {
// constructors
public AVVideoCompositionCreateApplier (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVAsynchronousCIImageFilteringRequest applier, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVAsynchronousCIImageFilteringRequest applier);
}
public sealed delegate AVVideoCompositionCreateCallback : System.MulticastDelegate {
// constructors
public AVVideoCompositionCreateCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (AVVideoComposition videoComposition, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (AVVideoComposition videoComposition, Foundation.NSError error);
}
public sealed delegate AVVideoCompositionDetermineValidityCallback : System.MulticastDelegate {
// constructors
public AVVideoCompositionDetermineValidityCallback (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (bool isValid, Foundation.NSError error, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (bool isValid, Foundation.NSError error);
}
public class AVVideoOutputSpecification : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
protected AVVideoOutputSpecification (Foundation.NSObjectFlag t);
public AVVideoOutputSpecification (Foundation.NSObject[] tagCollections);
protected AVVideoOutputSpecification (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultOutputSettings { get; set; }
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultPixelBufferAttributes { get; set; }
public virtual Foundation.NSObject[] PreferredTagCollections { get; }
// methods
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public virtual void SetOutputSettings (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> outputSettings, CoreMedia.CMTagCollection tagCollection);
}
public class AVVideoPerformanceMetrics : Foundation.NSObject {
// constructors
protected AVVideoPerformanceMetrics (Foundation.NSObjectFlag t);
protected AVVideoPerformanceMetrics (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual IntPtr NumberOfCorruptedFrames { get; }
public virtual IntPtr NumberOfDroppedFrames { get; }
public virtual IntPtr NumberOfFramesDisplayedUsingOptimizedCompositing { get; }
public virtual double TotalAccumulatedFrameDelay { get; }
public virtual IntPtr TotalNumberOfFrames { get; }
}
public class AVZoomRange : Foundation.NSObject {
// constructors
protected AVZoomRange (Foundation.NSObjectFlag t);
protected AVZoomRange (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public virtual System.Runtime.InteropServices.NFloat MaxZoomFactor { get; }
public virtual System.Runtime.InteropServices.NFloat MinZoomFactor { get; }
// methods
public virtual bool ContainsZoomFactor (System.Runtime.InteropServices.NFloat zoomFactor);
}
[Serializable]
public enum CMTagCollectionVideoOutputPreset {
Monoscopic = 0,
Stereoscopic = 1,
}
public static class CMTagCollectionVideoOutputPreset_Extensions {
// methods
public static CoreMedia.CMTagCollection Create (this CMTagCollectionVideoOutputPreset value, out CoreMedia.CMTagCollectionError status);
}
public interface IAVAudioRecorderDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void EncoderError (AVAudioRecorder recorder, Foundation.NSError error);
public virtual void FinishedRecording (AVAudioRecorder recorder, bool flag);
}
public interface IAVCaptureAudioDataOutputSampleBufferDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
public interface IAVCaptureDataOutputSynchronizerDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidOutputSynchronizedDataCollection (AVCaptureDataOutputSynchronizer synchronizer, AVCaptureSynchronizedDataCollection synchronizedDataCollection);
}
public interface IAVCaptureDepthDataOutputDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidDropDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
public virtual void DidOutputDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
public interface IAVCaptureMetadataOutputObjectsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
public interface IAVCapturePhotoCaptureDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void DidFinishCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public virtual void DidFinishProcessingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
public virtual void DidFinishProcessingPhoto (AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
public virtual void DidFinishRecordingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void WillBeginCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
public virtual void WillCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
public interface IAVCapturePhotoFileDataRepresentationCustomizer : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementAppleProRawCompressionSettings (AVCapturePhoto photo, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> defaultSettings, IntPtr maximumBitDepth);
public virtual AVDepthData GetReplacementDepthData (AVCapturePhoto photo);
public virtual CoreVideo.CVPixelBuffer GetReplacementEmbeddedThumbnail (out Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormatOut, AVCapturePhoto photo);
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementMetadata (AVCapturePhoto photo);
public virtual AVPortraitEffectsMatte GetReplacementPortraitEffectsMatte (AVCapturePhoto photo);
public virtual AVSemanticSegmentationMatte GetReplacementSemanticSegmentationMatte (Foundation.NSString semanticSegmentationMatteType, AVCapturePhoto photo);
}
public interface IAVCapturePhotoOutputReadinessCoordinatorDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}
public interface IAVCaptureSessionControlsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidBecomeActive (AVCaptureSession session);
public virtual void DidBecomeInactive (AVCaptureSession session);
public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}
public interface IAVCaptureVideoDataOutputSampleBufferDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidDropSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
public interface IAVMetricEventStreamPublisher : ObjCRuntime.INativeObject, System.IDisposable {
}
public interface IAVMetricEventStreamSubscriber : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidReceiveEvent (IAVMetricEventStreamPublisher publisher, AVMetricEvent event);
}
public interface IAVPlayerItemIntegratedTimelineObserver : ObjCRuntime.INativeObject, System.IDisposable {
}
public class AVContinuityDevicePickerViewController : UIKit.UIViewController {
// constructors
public AVContinuityDevicePickerViewController ();
public AVContinuityDevicePickerViewController (Foundation.NSCoder coder);
protected AVContinuityDevicePickerViewController (Foundation.NSObjectFlag t);
protected AVContinuityDevicePickerViewController (ObjCRuntime.NativeHandle handle);
// properties
public override ObjCRuntime.NativeHandle ClassHandle { get; }
public IAVContinuityDevicePickerViewControllerDelegate Delegate { get; set; }
public static bool Supported { get; }
public virtual Foundation.NSObject WeakDelegate { get; set; }
// methods
protected override void Dispose (bool disposing);
}
public class AVContinuityDevicePickerViewControllerDelegate : Foundation.NSObject, IAVContinuityDevicePickerViewControllerDelegate, ObjCRuntime.INativeObject, System.IDisposable {
// constructors
public AVContinuityDevicePickerViewControllerDelegate ();
protected AVContinuityDevicePickerViewControllerDelegate (Foundation.NSObjectFlag t);
protected AVContinuityDevicePickerViewControllerDelegate (ObjCRuntime.NativeHandle handle);
// methods
public virtual void DidCancel (AVContinuityDevicePickerViewController pickerViewController);
public virtual void DidConnectDevice (AVContinuityDevicePickerViewController pickerViewController, AVFoundation.AVContinuityDevice device);
public virtual void DidEndPresenting (AVContinuityDevicePickerViewController pickerViewController);
public virtual void WillBeginPresenting (AVContinuityDevicePickerViewController pickerViewController);
}
public interface IAVContinuityDevicePickerViewControllerDelegate : ObjCRuntime.INativeObject, System.IDisposable {
// methods
public virtual void DidCancel (AVContinuityDevicePickerViewController pickerViewController);
public virtual void DidConnectDevice (AVContinuityDevicePickerViewController pickerViewController, AVFoundation.AVContinuityDevice device);
public virtual void DidEndPresenting (AVContinuityDevicePickerViewController pickerViewController);
public virtual void WillBeginPresenting (AVContinuityDevicePickerViewController pickerViewController);
}
[Serializable]
public enum CFComparisonResult {
EqualTo = 0,
GreaterThan = 1,
LessThan = -1,
}
Added constructor:
public CHHapticEngine (AVFoundation.AVAudioSession audioSession, out Foundation.NSError error);
Added property:
public CMTaggedBufferGroupFormatType TaggedBufferGroupFormatType { get; }
Added value:
TaggedBufferGroup = 1952606066,
Added property:
public CMTaggedBufferGroup TaggedBufferGroup { get; }
Added methods:
public static CMSampleBuffer CreateWithNewTiming (CMSampleBuffer original, CMSampleTimingInfo[] timing, out int status);
public CMSampleTimingInfo[] GetSampleTimingInfo (out int status);
[Serializable]
public enum CMPackingType {
None = 1852796517,
OverUnder = 1870030194,
SideBySide = 1936286821,
}
[Serializable]
public enum CMProjectionType {
Equirectangular = 1701934441,
Fisheye = 1718186856,
HalfEquirectangular = 1751478645,
Rectangular = 1919247220,
}
[Serializable]
[Flags]
public enum CMStereoViewComponents {
LeftEye = 1,
None = 0,
RightEye = 2,
}
[Serializable]
[Flags]
public enum CMStereoViewInterpretationOptions {
AdditionalViews = 2,
Default = 0,
StereoOrderReversed = 1,
}
public struct CMTag {
// properties
public CMTagCategory Category { get; }
public CMTagDataType DataType { get; }
public ulong FlagsValue { get; }
public double Float64Value { get; }
public bool HasFlagsValue { get; }
public bool HasFloat64Value { get; }
public bool HasInt64Value { get; }
public bool HasOSTypeValue { get; }
public long Int64Value { get; }
public static CMTag Invalid { get; }
public bool IsValid { get; }
public static CMTag MediaSubTypeMebx { get; }
public static CMTag MediaTypeAudio { get; }
public static CMTag MediaTypeMetadata { get; }
public static CMTag MediaTypeVideo { get; }
public uint OSTypeValue { get; }
public static CMTag PackingTypeNone { get; }
public static CMTag PackingTypeOverUnder { get; }
public static CMTag PackingTypeSideBySide { get; }
public static CMTag ProjectionTypeEquirectangular { get; }
public static CMTag ProjectionTypeFisheye { get; }
public static CMTag ProjectionTypeHalfEquirectangular { get; }
public static CMTag ProjectionTypeRectangular { get; }
public static CMTag StereoInterpretationOrderReversed { get; }
public static CMTag StereoLeftAndRightEye { get; }
public static CMTag StereoLeftEye { get; }
public static CMTag StereoNone { get; }
public static CMTag StereoRightEye { get; }
public ulong Value { get; }
// methods
public static CoreFoundation.CFComparisonResult Compare (CMTag tag1, CMTag tag2);
public static CMTag? Create (Foundation.NSDictionary dictionary);
public static CMTag CreateWithFlagsValue (CMTagCategory category, ulong flags);
public static CMTag CreateWithFloat64Value (CMTagCategory category, double value);
public static CMTag CreateWithOSTypeValue (CMTagCategory category, uint osTypeValue);
public static CMTag CreateWithSInt64Value (CMTagCategory category, long value);
public override bool Equals (object obj);
public static bool Equals (CMTag tag1, CMTag tag2);
public override int GetHashCode ();
public Foundation.NSDictionary ToDictionary ();
public override string ToString ();
}
[Serializable]
public enum CMTagCategory {
ChannelId = 1986226286,
MediaSubType = 1836283234,
MediaType = 1835297121,
PackingType = 1885430635,
PixelFormat = 1885960294,
ProjectionType = 1886547818,
StereoView = 1702454643,
StereoViewInterpretation = 1702455664,
TrackId = 1953653099,
Undefined = 0,
VideoLayerId = 1986814329,
}
public class CMTagCollection : CoreFoundation.NativeObject {
// properties
public IntPtr Count { get; }
public bool IsEmpty { get; }
public CMTag[] Tags { get; }
// methods
public CMTagCollectionError Add (CMTag tag);
public CMTagCollectionError Add (CMTagCollection collection);
public CMTagCollectionError Add (CMTag[] tags);
public void Apply (CMTagCollectionApplyFunction callback);
public CMTag ApplyUntil (CMTagCollectionTagFilterFunction callback);
public bool ContainsCategory (CMTagCategory category);
public bool ContainsTag (CMTag tag);
public bool ContainsTagCollection (CMTagCollection tagCollection);
public bool ContainsTags (CMTag[] tags);
public CMTagCollection Copy (out CMTagCollectionError status);
public static CMTagCollection Create (CMTag[] tags);
public static CMTagCollection Create (Foundation.NSData data, out CMTagCollectionError status);
public static CMTagCollection Create (Foundation.NSDictionary dictionary, out CMTagCollectionError status);
public static CMTagCollection Create (out CMTagCollectionError status, CMTag[] tags);
public static CMTagCollection CreateMutable ();
public static CMTagCollection CreateMutable (out CMTagCollectionError status);
public static CMTagCollection CreateMutable (IntPtr capacity, out CMTagCollectionError status);
public CMTagCollection CreateMutableCopy (out CMTagCollectionError status);
public CMTagCollection CreateWithCopyOfTags (out CMTagCollectionError status, CMTagCategory[] categories);
public CMTagCollection ExclusiveOr (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection ExclusiveOr (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public IntPtr GetCount (CMTagCategory category);
public IntPtr GetCount (CMTagCollectionTagFilterFunction filter);
public CMTag[] GetTags (CMTagCollectionTagFilterFunction filter);
public CMTag[] GetTags (out CMTagCollectionError status);
public CMTag[] GetTags (CMTagCategory category, out CMTagCollectionError status);
public CMTagCollectionError GetTags (CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public CMTagCollectionError GetTags (CMTagCategory category, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public CMTagCollectionError GetTags (CMTagCollectionTagFilterFunction filter, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
public static IntPtr GetTypeId ();
public CMTagCollection Intersect (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Intersect (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public CMTagCollectionError Remove (CMTag tag);
public CMTagCollectionError RemoveAllTags ();
public CMTagCollectionError RemoveAllTags (CMTagCategory category);
public CMTagCollection Subtract (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Subtract (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
public Foundation.NSData ToData ();
public Foundation.NSDictionary ToDictionary ();
public override string ToString ();
public CMTagCollection Union (CMTagCollection collection, out CMTagCollectionError status);
public static CMTagCollection Union (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
}
public sealed delegate CMTagCollectionApplyFunction : System.MulticastDelegate {
// constructors
public CMTagCollectionApplyFunction (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CMTag tag, System.AsyncCallback callback, object object);
public virtual void EndInvoke (System.IAsyncResult result);
public virtual void Invoke (CMTag tag);
}
[Serializable]
public enum CMTagCollectionError {
AllocationFailed = -15741,
ExhaustedBufferSize = -15748,
InternalError = -15742,
InvalidTag = -15743,
InvalidTagCollectionData = -15745,
InvalidTagCollectionDataVersion = -15747,
InvalidTagCollectionDictionary = -15744,
NotYetImplemented = -15749,
ParamErr = -15740,
Success = 0,
TagNotFound = -15746,
}
public sealed delegate CMTagCollectionTagFilterFunction : System.MulticastDelegate {
// constructors
public CMTagCollectionTagFilterFunction (object object, IntPtr method);
// methods
public virtual System.IAsyncResult BeginInvoke (CMTag tag, System.AsyncCallback callback, object object);
public virtual bool EndInvoke (System.IAsyncResult result);
public virtual bool Invoke (CMTag tag);
}
[Serializable]
public enum CMTagDataType {
Flags = 7,
Float64 = 3,
Invalid = 0,
OSType = 5,
SInt64 = 2,
}
[Serializable]
public enum CMTagError {
AllocationFailed = -15731,
ParamErr = -15730,
Success = 0,
}
public class CMTaggedBufferGroup : CoreFoundation.NativeObject {
// properties
public IntPtr Count { get; }
// methods
public static CMTaggedBufferGroup Combine (CMTaggedBufferGroup[] groups);
public static CMTaggedBufferGroup Combine (out CMTaggedBufferGroupError status, CMTaggedBufferGroup[] groups);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreFoundation.NativeObject[] buffers, out CMTaggedBufferGroupError status);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CMSampleBuffer[] buffers, out CMTaggedBufferGroupError status);
public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreVideo.CVPixelBuffer[] buffers, out CMTaggedBufferGroupError status);
public CMFormatDescription CreateFormatDescription (out CMTaggedBufferGroupError status);
public CMSampleBuffer CreateSampleBuffer (CMTime sampleBufferPts, CMTime sampleBufferDuration, CMFormatDescription formatDescription, out CMTaggedBufferGroupError status);
public IntPtr GetNumberOfMatches (CMTagCollection tagCollection);
public CoreVideo.CVPixelBuffer GetPixelBuffer (IntPtr index);
public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTag tag, out IntPtr index);
public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTagCollection tagCollection, out IntPtr index);
public CMSampleBuffer GetSampleBuffer (IntPtr index);
public CMSampleBuffer GetSampleBuffer (CMTag tag, out IntPtr index);
public CMSampleBuffer GetSampleBuffer (CMTagCollection tagCollection, out IntPtr index);
public CMTagCollection GetTagCollection (IntPtr index);
public static CMTaggedBufferGroup GetTaggedBufferGroup (CMSampleBuffer sampleBuffer);
public static IntPtr GetTypeId ();
public bool Matches (CMFormatDescription formatDescription);
}
[Serializable]
public enum CMTaggedBufferGroupError {
AllocationFailed = -15781,
InternalError = -15782,
ParamErr = -15780,
Success = 0,
}
[Serializable]
public enum CMTaggedBufferGroupFormatType {
TaggedBufferGroup = 1952606066,
}
Obsoleted constructors:
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData data, ref NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl url, ref NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData data, NSAttributedStringDocumentAttributes documentAttributes, ref NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl url, NSAttributedStringDocumentAttributes documentAttributes, ref NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
[Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
public NSAttributedString (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
Added methods:
public static NSAttributedString Create (NSData data, out NSError error);
public static NSAttributedString Create (NSUrl url, out NSError error);
public static NSAttributedString Create (NSData data, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSUrl url, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
Added property:
public bool IsStubClass { get; set; }
Obsoleted fields:
[Obsolete ("Not available on the current platform.")]
System = 0,
Added value:
IsThreadSafe = 8,
Removed value:
None = 0,
Added value:
Default = 0,
Added properties:
public string Library { get; set; }
public string NativePrefix { get; set; }
public string NativeSuffix { get; set; }
Added values:
CustomMarshalDirective = 32,
IsThreadSafe = 64,
Added values:
CustomMarshalDirective = 32,
DisableZeroCopy = 64,
IsThreadSafe = 128,
MarshalNativeExceptions = 16,
public class BindingTypeAttribute`1 : System.Attribute {
// constructors
public BindingTypeAttribute`1 ();
// properties
public T Flags { get; set; }
public string Name { get; set; }
}
[Serializable]
[Flags]
public enum Category {
Default = 0,
IsThreadSafe = 4,
}
[Serializable]
[Flags]
public enum Class {
Default = 0,
DisableDefaultCtor = 4,
IsThreadSafe = 8,
}
[Serializable]
[Flags]
public enum Protocol {
Default = 0,
IsThreadSafe = 4,
}
[Serializable]
[Flags]
public enum StrongDictionary {
Default = 0,
}
Modified fields:
-public const string Version = "18.2.9170";
+public const string Version = "18.2.9354";
Added method:
public static T GetStruct<T> (IntPtr handle, string symbol);
Added constructor:
public MarshalManagedExceptionEventArgs (System.Exception exception, MarshalManagedExceptionMode mode);
Added constructor:
public MarshalObjectiveCExceptionEventArgs (Foundation.NSException exception, MarshalObjectiveCExceptionMode mode);
Added method:
public virtual void UpdateBroadcastUrl (Foundation.NSUrl broadcastUrl);
Added properties:
public virtual CoreGraphics.CGPoint AccessibilityActivationPoint { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedHint { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedLabel { get; set; }
public virtual Foundation.NSAttributedString[] AccessibilityAttributedUserInputLabels { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedValue { get; set; }
public virtual UIAccessibilityDirectTouchOptions AccessibilityDirectTouchOptions { get; set; }
public virtual bool AccessibilityElementsHidden { get; set; }
public virtual UIAccessibilityExpandedStatus AccessibilityExpandedStatus { get; set; }
public virtual CoreGraphics.CGRect AccessibilityFrame { get; set; }
public virtual Foundation.NSObject[] AccessibilityHeaderElements { get; set; }
public virtual string AccessibilityHint { get; set; }
public virtual string AccessibilityLabel { get; set; }
public virtual string AccessibilityLanguage { get; set; }
public virtual UIAccessibilityNavigationStyle AccessibilityNavigationStyle { get; set; }
public virtual UIBezierPath AccessibilityPath { get; set; }
public virtual bool AccessibilityRespondsToUserInteraction { get; set; }
public virtual string AccessibilityTextualContext { get; set; }
public virtual UIAccessibilityTrait AccessibilityTraits { get; set; }
public virtual string[] AccessibilityUserInputLabels { get; set; }
public virtual string AccessibilityValue { get; set; }
public virtual bool AccessibilityViewIsModal { get; set; }
public static Foundation.NSString AnnouncementDidFinishNotification { get; }
public static int AnnouncementNotification { get; }
public static Foundation.NSString AssistiveTechnologyKey { get; }
public static Foundation.NSString AssistiveTouchStatusDidChangeNotification { get; }
public static Foundation.NSString BoldTextStatusDidChangeNotification { get; }
public static Foundation.NSString ButtonShapesEnabledStatusDidChangeNotification { get; }
public static Foundation.NSString ClosedCaptioningStatusDidChangeNotification { get; }
public static Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
public static Foundation.NSString ElementFocusedNotification { get; }
public static Foundation.NSString FocusedElementKey { get; }
public static Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
public static Foundation.NSString GuidedAccessStatusDidChangeNotification { get; }
public static Foundation.NSString InvertColorsStatusDidChangeNotification { get; }
public virtual bool IsAccessibilityElement { get; set; }
public static int LayoutChangedNotification { get; }
public static Foundation.NSString MonoAudioStatusDidChangeNotification { get; }
public static Foundation.NSString NotificationSwitchControlIdentifier { get; }
public static Foundation.NSString NotificationVoiceOverIdentifier { get; }
public static Foundation.NSString OnOffSwitchLabelsDidChangeNotification { get; }
public static int PageScrolledNotification { get; }
public static int PauseAssistiveTechnologyNotification { get; }
public static Foundation.NSString PrefersCrossFadeTransitionsStatusDidChangeNotification { get; }
public static Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
public static Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
public static int ResumeAssistiveTechnologyNotification { get; }
public static int ScreenChangedNotification { get; }
public static Foundation.NSString ShakeToUndoDidChangeNotification { get; }
public static Foundation.NSString ShouldDifferentiateWithoutColorDidChangeNotification { get; }
public virtual bool ShouldGroupAccessibilityChildren { get; set; }
public static Foundation.NSString SpeakScreenStatusDidChangeNotification { get; }
public static Foundation.NSString SpeakSelectionStatusDidChangeNotification { get; }
public static Foundation.NSString SpeechAttributeAnnouncementPriority { get; }
public static Foundation.NSString SpeechAttributeIpaNotation { get; }
public static Foundation.NSString SpeechAttributeLanguage { get; }
public static Foundation.NSString SpeechAttributePitch { get; }
public static Foundation.NSString SpeechAttributePunctuation { get; }
public static Foundation.NSString SpeechAttributeQueueAnnouncement { get; }
public static Foundation.NSString SpeechAttributeSpellOut { get; }
public static Foundation.NSString SwitchControlStatusDidChangeNotification { get; }
public static Foundation.NSString TextAttributeContext { get; }
public static Foundation.NSString TextAttributeCustom { get; }
public static Foundation.NSString TextAttributeHeadingLevel { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitAdjustable { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitAllowsDirectInteraction { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitButton { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitCausesPageTurn { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitHeader { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitImage { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitKeyboardKey { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitLink { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitNone { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitNotEnabled { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitPlaysSound { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSearchField { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSelected { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitStartsMediaSession { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitStaticText { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSummaryElement { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitTabBar { get; }
[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitUpdatesFrequently { get; }
public static Foundation.NSString UnfocusedElementKey { get; }
public static Foundation.NSString VideoAutoplayStatusDidChangeNotification { get; }
public static Foundation.NSString VoiceOverStatusChanged { get; }
public static Foundation.NSString VoiceOverStatusDidChangeNotification { get; }
Added method:
public virtual bool AccessibilityActivate ();
Added methods:
public static Foundation.NSObject ObserveAnnouncementDidFinish (System.EventHandler<UIAccessibilityAnnouncementFinishedEventArgs> handler);
public static Foundation.NSObject ObserveAnnouncementDidFinish (Foundation.NSObject objectToObserve, System.EventHandler<UIAccessibilityAnnouncementFinishedEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTechnologyKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTechnologyKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTouchStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTouchStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveBoldTextStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveBoldTextStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveButtonShapesEnabledStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveButtonShapesEnabledStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveClosedCaptioningStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveClosedCaptioningStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveElementFocused (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveElementFocused (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveFocusedElementKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveFocusedElementKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGrayscaleStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGrayscaleStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGuidedAccessStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGuidedAccessStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveInvertColorsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveInvertColorsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveMonoAudioStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveMonoAudioStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveOnOffSwitchLabelsDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveOnOffSwitchLabelsDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObservePrefersCrossFadeTransitionsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObservePrefersCrossFadeTransitionsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceMotionStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceMotionStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceTransparencyStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceTransparencyStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShakeToUndoDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShakeToUndoDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShouldDifferentiateWithoutColorDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShouldDifferentiateWithoutColorDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakScreenStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakScreenStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakSelectionStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakSelectionStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSwitchControlStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSwitchControlStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveUnfocusedElementKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveUnfocusedElementKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVideoAutoplayStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVideoAutoplayStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVoiceOverStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVoiceOverStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);