diff --git a/src/avfoundation.cs b/src/avfoundation.cs index ef6009288b0e..a22355a31c0d 100644 --- a/src/avfoundation.cs +++ b/src/avfoundation.cs @@ -30,6 +30,7 @@ // using System.ComponentModel; +using System.Runtime.CompilerServices; using Vector3 = global::System.Numerics.Vector3; using NMatrix3 = global::CoreGraphics.NMatrix3; @@ -5674,22 +5675,71 @@ interface AVAsset : NSCopying { [Export ("loadMetadataForFormat:completionHandler:")] void LoadMetadata (string format, Action, NSError> completionHandler); +#if !XAMCORE_5_0 + [Obsolete ("Call 'LoadTrack2' instead.")] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTrackWithTrackID:completionHandler:")] void LoadTrack (int trackId, Action completionHandler); +#endif + [Async] + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTrackWithTrackID:completionHandler:")] +#if XAMCORE_5_0 + void LoadTrack (int trackId, AVAssetLoadTrackCallback completionHandler); +#else + [Sealed] + void LoadTrack2 (int trackId, AVAssetLoadTrackCallback completionHandler); +#endif + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTrackWithMediaCharacteristics (..., AVAssetLoadTracksCallback)' overload instead (or the 'LoadTrackWithMediaCharacteristics2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] void LoadTrackWithMediaCharacteristics (string mediaCharacteristic, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTrackWithMediaCharacteristics2Async")] + [Sealed] +#endif + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] + void LoadTrackWithMediaCharacteristics (string mediaCharacteristic, AVAssetLoadTracksCallback completionHandler); +#if !XAMCORE_5_0 + [Obsolete ("Call 'LoadTracksWithMediaType (..., AVAssetLoadTracksCallback)' instead (or the 'LoadTracksWithMediaType2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaType:completionHandler:")] void LoadTracksWithMediaType (string mediaType, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaType2Async")] + [Sealed] +#endif + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaType:completionHandler:")] + void LoadTracksWithMediaType (string mediaType, AVAssetLoadTracksCallback completionHandler); + + [Async] + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Wrap ("LoadTracksWithMediaType (mediaType.GetConstant ()!, completionHandler)")] + void LoadTracksWithMediaType (AVMediaTypes mediaType, AVAssetLoadTracksCallback completionHandler); } + delegate void AVAssetLoadTrackCallback ([NullAllowed] AVAssetTrack track, [NullAllowed] NSError error); + delegate void AVAssetLoadTracksCallback ([NullAllowed] AVAssetTrack [] tracks, [NullAllowed] NSError error); + interface IAVFragmentMinding { } /// Interface for to support tracking whether fragments have been appended to a fragmented asset. @@ -12657,22 +12707,69 @@ interface AVMovie_AVMovieTrackInspection { [Wrap ("This.GetTracksWithMediaCharacteristic (mediaCharacteristic.GetConstant ()!)")] AVMovieTrack [] GetTracks (AVMediaCharacteristics mediaCharacteristic); +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTrack (..., AVMovieLoadTrackCallback)' overload instead (or the 'LoadTrack2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTrackWithTrackID:completionHandler:")] void LoadTrack (int trackId, Action completionHandler); +#endif +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTrack2Async")] +#endif + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTrackWithTrackID:completionHandler:")] + void LoadTrack (int trackId, AVMovieLoadTrackCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaType (..., AVMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaType2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaType:completionHandler:")] void LoadTracksWithMediaType (string mediaType, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaType2Async")] +#endif + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaType:completionHandler:")] + void LoadTracksWithMediaType (string mediaType, AVMovieLoadTracksCallback completionHandler); + [Async] + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Wrap ("This.LoadTracksWithMediaType (mediaType.GetConstant ()!, completionHandler)")] + void LoadTracksWithMediaType (AVMediaTypes mediaType, AVMovieLoadTracksCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaCharacteristic (..., AVMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaCharacteristic2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaCharacteristic2Async")] +#endif + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] + void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, AVMovieLoadTracksCallback completionHandler); } + delegate void AVMovieLoadTrackCallback ([NullAllowed] AVMovieTrack track, [NullAllowed] NSError error); + delegate void AVMovieLoadTracksCallback ([NullAllowed] AVMovieTrack [] tracks, [NullAllowed] NSError error); + [NoTV, iOS (13, 0)] [MacCatalyst (13, 1)] [BaseType (typeof (AVMovie))] @@ -12736,20 +12833,66 @@ interface AVMutableMovie { [Export ("interleavingPeriod", ArgumentSemantic.Assign)] CMTime InterleavingPeriod { get; set; } +#if !XAMCORE_5_0 + [Obsolete ("Call 'LoadTrack2' instead.")] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTrackWithTrackID:completionHandler:")] void LoadTrack (int trackId, Action completionHandler); +#endif + + [Async] + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTrackWithTrackID:completionHandler:")] +#if XAMCORE_5_0 + void LoadTrack (int trackId, AVMutableMovieLoadTrackCallback completionHandler); +#else + [Sealed] + void LoadTrack2 (int trackId, AVMutableMovieLoadTrackCallback completionHandler); +#endif +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaType (..., AVMutableMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaType2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaType:completionHandler:")] void LoadTracksWithMediaType (string mediaType, Action, NSError> completionHandler); +#endif +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaType2Async")] + [Sealed] +#endif + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaType:completionHandler:")] + void LoadTracksWithMediaType (string mediaType, AVMutableMovieLoadTracksCallback completionHandler); + + [Async] + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Wrap ("LoadTracksWithMediaType (mediaType.GetConstant ()!, completionHandler)")] + void LoadTracksWithMediaType (AVMediaTypes mediaType, AVMutableMovieLoadTracksCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaCharacteristic (..., AVMutableMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaCharacteristic2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [NoTV, iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaCharacteristic2Async")] + [Sealed] +#endif + [NoTV, iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] + void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, AVMutableMovieLoadTracksCallback completionHandler); // inlined from the AVMutableMovie (SynchronousAssetInterface) category [Export ("metadataForFormat:")] @@ -12773,6 +12916,9 @@ interface AVMutableMovie { int GetUnusedTrackId (); } + delegate void AVMutableMovieLoadTrackCallback ([NullAllowed] AVMutableMovieTrack track, [NullAllowed] NSError error); + delegate void AVMutableMovieLoadTracksCallback ([NullAllowed] AVMutableMovieTrack [] tracks, [NullAllowed] NSError error); + [NoTV, iOS (13, 0)] [MacCatalyst (13, 1)] [Category] @@ -12973,22 +13119,69 @@ interface AVFragmentedMovie_AVFragmentedMovieTrackInspection { [Wrap ("This.GetTracksWithMediaCharacteristic (mediaCharacteristic.GetConstant ()!)")] AVFragmentedMovieTrack [] GetTracks (AVMediaCharacteristics mediaCharacteristic); +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTrack (..., AVFragmentedMovieLoadTrackCallback)' overload instead (or the 'LoadTrack2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTrackWithTrackID:completionHandler:")] void LoadTrack (int trackId, Action completionHandler); +#endif +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTrack2Async")] +#endif + [iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTrackWithTrackID:completionHandler:")] + void LoadTrack (int trackId, AVFragmentedMovieLoadTrackCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaType (..., AVFragmentedMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaType2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaType:completionHandler:")] void LoadTracksWithMediaType (string mediaType, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaType2Async")] +#endif + [iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaType:completionHandler:")] + void LoadTracksWithMediaType (string mediaType, AVFragmentedMovieLoadTracksCallback completionHandler); + [Async] + [iOS (15, 0), MacCatalyst (15, 0)] + [Wrap ("This.LoadTracksWithMediaType (mediaType.GetConstant ()!, completionHandler)")] + void LoadTracksWithMediaType (AVMediaTypes mediaType, AVFragmentedMovieLoadTracksCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaCharacteristic (..., AVFragmentedMovieLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaCharacteristic2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaCharacteristic2Async")] +#endif + [iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] + void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, AVFragmentedMovieLoadTracksCallback completionHandler); } + delegate void AVFragmentedMovieLoadTrackCallback ([NullAllowed] AVFragmentedMovieTrack track, [NullAllowed] NSError error); + delegate void AVFragmentedMovieLoadTracksCallback ([NullAllowed] AVFragmentedMovieTrack [] tracks, [NullAllowed] NSError error); + [iOS (13, 0), NoTV] [MacCatalyst (13, 1)] [BaseType (typeof (AVFragmentedAssetMinder))] @@ -13563,22 +13756,69 @@ interface AVComposition_AVCompositionTrackInspection { [Wrap ("This.GetTracksWithMediaCharacteristic (mediaCharacteristic.GetConstant ()!)")] AVCompositionTrack [] GetTracks (AVMediaCharacteristics mediaCharacteristic); +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTrack (..., AVCompositionLoadTrackCallback)' overload instead (or the 'LoadTrack2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTrackWithTrackID:completionHandler:")] void LoadTrack (int trackId, Action completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTrack2Async")] +#endif + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTrackWithTrackID:completionHandler:")] + void LoadTrack (int trackId, AVCompositionLoadTrackCallback completionHandler); +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaType (..., AVCompositionLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaType2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaType:completionHandler:")] void LoadTracksWithMediaType (string mediaType, Action, NSError> completionHandler); +#endif +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaType2Async")] +#endif + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaType:completionHandler:")] + void LoadTracksWithMediaType (string mediaType, AVCompositionLoadTracksCallback completionHandler); + + [Async] + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Wrap ("This.LoadTracksWithMediaType (mediaType.GetConstant ()!, completionHandler)")] + void LoadTracksWithMediaType (AVMediaTypes mediaType, AVCompositionLoadTracksCallback completionHandler); + +#if !XAMCORE_5_0 + [Obsolete ("Call the 'LoadTracksWithMediaCharacteristic (..., AVCompositionLoadTracksCallback)' overload instead (or the 'LoadTracksWithMediaCharacteristic2Async' method).")] + [OverloadResolutionPriority (-1)] [Async] [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, Action, NSError> completionHandler); +#endif + +#if XAMCORE_5_0 + [Async] +#else + [Async ("LoadTracksWithMediaCharacteristic2Async")] +#endif + [TV (15, 0), iOS (15, 0), MacCatalyst (15, 0)] + [Export ("loadTracksWithMediaCharacteristic:completionHandler:")] + void LoadTracksWithMediaCharacteristic (string mediaCharacteristic, AVCompositionLoadTracksCallback completionHandler); } + delegate void AVCompositionLoadTrackCallback ([NullAllowed] AVCompositionTrack track, [NullAllowed] NSError error); + delegate void AVCompositionLoadTracksCallback ([NullAllowed] AVCompositionTrack [] tracks, [NullAllowed] NSError error); + [MacCatalyst (13, 1)] [BaseType (typeof (AVComposition))] interface AVMutableComposition { diff --git a/src/bgen/AttributeManager.cs b/src/bgen/AttributeManager.cs index e60d72269b9a..d0130bcab978 100644 --- a/src/bgen/AttributeManager.cs +++ b/src/bgen/AttributeManager.cs @@ -218,6 +218,8 @@ public AttributeManager (TypeCache typeCache) return typeof (WrapAttribute); case "System.Diagnostics.CodeAnalysis.ExperimentalAttribute": return typeof (System.Diagnostics.CodeAnalysis.ExperimentalAttribute); + case "System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute": + return typeof (System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute); case "System.Runtime.Versioning.SupportedOSPlatformAttribute": return typeof (System.Runtime.Versioning.SupportedOSPlatformAttribute); case "System.Runtime.Versioning.UnsupportedOSPlatformAttribute": diff --git a/src/bgen/Caches/NamespaceCache.cs b/src/bgen/Caches/NamespaceCache.cs index e71ca575cb4d..795a8fb97074 100644 --- a/src/bgen/Caches/NamespaceCache.cs +++ b/src/bgen/Caches/NamespaceCache.cs @@ -66,6 +66,7 @@ public NamespaceCache (PlatformName currentPlatform, string customObjCRuntimeNS) ImplicitNamespaces = new HashSet (); ImplicitNamespaces.Add ("System"); + ImplicitNamespaces.Add ("System.Runtime.CompilerServices"); ImplicitNamespaces.Add ("System.Runtime.InteropServices"); ImplicitNamespaces.Add ("System.Diagnostics"); ImplicitNamespaces.Add ("System.Diagnostics.CodeAnalysis"); diff --git a/src/bgen/Generator.cs b/src/bgen/Generator.cs index c3d63086f392..644deea6e6dc 100644 --- a/src/bgen/Generator.cs +++ b/src/bgen/Generator.cs @@ -1481,6 +1481,7 @@ public void Go () case "BindingImplAttribute": case "XpcInterfaceAttribute": case "NativeIntegerAttribute": + case "OverloadResolutionPriorityAttribute": continue; default: throw new BindingException (1007, true, attr.GetType (), mi.DeclaringType, mi.Name); @@ -3943,6 +3944,14 @@ void PrintObsoleteAttributes (ICustomAttributeProvider? provider) print ("[EditorBrowsable (EditorBrowsableState.Never)]"); } + void PrintOverloadResolutionPriorityAttribute (ICustomAttributeProvider? provider) + { + var attributes = AttributeManager.GetCustomAttributes (provider); + foreach (var attr in attributes) { + print ("[OverloadResolutionPriority ({0})]", attr.Priority); + } + } + bool TryGetPrintEditorBrowsableAttribute (ICustomAttributeProvider? provider, out string attribute) { attribute = string.Empty; @@ -4506,6 +4515,7 @@ void PrintMethodAttributes (MemberInformation minfo) print (sa.Safe ? "[ThreadSafe]" : "[ThreadSafe (false)]"); PrintObsoleteAttributes (mi); + PrintOverloadResolutionPriorityAttribute (mi); if (minfo.is_return_release) print ("[return: ReleaseAttribute ()]"); diff --git a/tests/cecil-tests/Documentation.KnownFailures.txt b/tests/cecil-tests/Documentation.KnownFailures.txt index be4383668c70..4c00219213f2 100644 --- a/tests/cecil-tests/Documentation.KnownFailures.txt +++ b/tests/cecil-tests/Documentation.KnownFailures.txt @@ -9403,9 +9403,14 @@ M:AVFoundation.AVAsset.LoadChapterMetadataGroupsAsync(Foundation.NSLocale,System M:AVFoundation.AVAsset.LoadChapterMetadataGroupsAsync(System.String[]) M:AVFoundation.AVAsset.LoadMediaSelectionGroupAsync(System.String) M:AVFoundation.AVAsset.LoadMetadataAsync(System.String) -M:AVFoundation.AVAsset.LoadTrackAsync(System.Int32) -M:AVFoundation.AVAsset.LoadTracksWithMediaTypeAsync(System.String) -M:AVFoundation.AVAsset.LoadTrackWithMediaCharacteristicsAsync(System.String) +M:AVFoundation.AVAsset.LoadTrack2(System.Int32,AVFoundation.AVAssetLoadTrackCallback) +M:AVFoundation.AVAsset.LoadTrack2Async(System.Int32) +M:AVFoundation.AVAsset.LoadTracksWithMediaType(AVFoundation.AVMediaTypes,AVFoundation.AVAssetLoadTracksCallback) +M:AVFoundation.AVAsset.LoadTracksWithMediaType(System.String,AVFoundation.AVAssetLoadTracksCallback) +M:AVFoundation.AVAsset.LoadTracksWithMediaType2Async(System.String) +M:AVFoundation.AVAsset.LoadTracksWithMediaTypeAsync(AVFoundation.AVMediaTypes) +M:AVFoundation.AVAsset.LoadTrackWithMediaCharacteristics(System.String,AVFoundation.AVAssetLoadTracksCallback) +M:AVFoundation.AVAsset.LoadTrackWithMediaCharacteristics2Async(System.String) M:AVFoundation.AVAssetDownloadDelegate_Extensions.DidReceiveMetricEvent(AVFoundation.IAVAssetDownloadDelegate,Foundation.NSUrlSession,AVFoundation.AVAssetDownloadTask,AVFoundation.AVMetricEvent) M:AVFoundation.AVAssetDownloadDelegate_Extensions.WillDownloadVariants(AVFoundation.IAVAssetDownloadDelegate,Foundation.NSUrlSession,AVFoundation.AVAssetDownloadTask,AVFoundation.AVAssetVariant[]) M:AVFoundation.AVAssetDownloadDelegate.DidCreateTask(Foundation.NSUrlSession,Foundation.NSUrlSessionTask) @@ -9558,12 +9563,14 @@ M:AVFoundation.AVCaptureWhiteBalanceGains.op_Equality(AVFoundation.AVCaptureWhit M:AVFoundation.AVCaptureWhiteBalanceGains.op_Inequality(AVFoundation.AVCaptureWhiteBalanceGains,AVFoundation.AVCaptureWhiteBalanceGains) M:AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues.op_Equality(AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues,AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues) M:AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues.op_Inequality(AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues,AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTrack(AVFoundation.AVComposition,System.Int32,System.Action{AVFoundation.AVMutableCompositionTrack,Foundation.NSError}) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTrackAsync(AVFoundation.AVComposition,System.Int32) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVComposition,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaCharacteristicAsync(AVFoundation.AVComposition,System.String) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaType(AVFoundation.AVComposition,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVComposition,System.String) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTrack(AVFoundation.AVComposition,System.Int32,AVFoundation.AVCompositionLoadTrackCallback) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTrack2Async(AVFoundation.AVComposition,System.Int32) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVComposition,System.String,AVFoundation.AVCompositionLoadTracksCallback) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaCharacteristic2Async(AVFoundation.AVComposition,System.String) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaType(AVFoundation.AVComposition,AVFoundation.AVMediaTypes,AVFoundation.AVCompositionLoadTracksCallback) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaType(AVFoundation.AVComposition,System.String,AVFoundation.AVCompositionLoadTracksCallback) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaType2Async(AVFoundation.AVComposition,System.String) +M:AVFoundation.AVComposition_AVCompositionTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVComposition,AVFoundation.AVMediaTypes) M:AVFoundation.AVContentKeyRecipient_Extensions.DidProvideContentKey(AVFoundation.IAVContentKeyRecipient,AVFoundation.AVContentKeySession,AVFoundation.AVContentKey) M:AVFoundation.AVContentKeyRequest.Dispose(System.Boolean) M:AVFoundation.AVContentKeyResponse.Create(Foundation.NSData,AVFoundation.AVContentKeyResponseDataType) @@ -9586,12 +9593,14 @@ M:AVFoundation.AVFragmentedAsset_AVFragmentedAssetTrackInspection.LoadTracksWith M:AVFoundation.AVFragmentedAsset_AVFragmentedAssetTrackInspection.LoadTracksWithMediaCharacteristicAsync(AVFoundation.AVFragmentedAsset,System.String) M:AVFoundation.AVFragmentedAsset_AVFragmentedAssetTrackInspection.LoadTracksWithMediaType(AVFoundation.AVFragmentedAsset,System.String,System.Action{Foundation.NSArray{AVFoundation.AVFragmentedAssetTrack},Foundation.NSError}) M:AVFoundation.AVFragmentedAsset_AVFragmentedAssetTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVFragmentedAsset,System.String) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTrack(AVFoundation.AVFragmentedMovie,System.Int32,System.Action{AVFoundation.AVMutableCompositionTrack,Foundation.NSError}) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTrackAsync(AVFoundation.AVFragmentedMovie,System.Int32) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVFragmentedMovie,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaCharacteristicAsync(AVFoundation.AVFragmentedMovie,System.String) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVFragmentedMovie,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVFragmentedMovie,System.String) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTrack(AVFoundation.AVFragmentedMovie,System.Int32,AVFoundation.AVFragmentedMovieLoadTrackCallback) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTrack2Async(AVFoundation.AVFragmentedMovie,System.Int32) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVFragmentedMovie,System.String,AVFoundation.AVFragmentedMovieLoadTracksCallback) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaCharacteristic2Async(AVFoundation.AVFragmentedMovie,System.String) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVFragmentedMovie,AVFoundation.AVMediaTypes,AVFoundation.AVFragmentedMovieLoadTracksCallback) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVFragmentedMovie,System.String,AVFoundation.AVFragmentedMovieLoadTracksCallback) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaType2Async(AVFoundation.AVFragmentedMovie,System.String) +M:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVFragmentedMovie,AVFoundation.AVMediaTypes) M:AVFoundation.AVMediaSelection.Dispose(System.Boolean) M:AVFoundation.AVMetadataItemValueRequest.Dispose(System.Boolean) M:AVFoundation.AVMetadataObjectTypeExtensions.ToFlags(System.Collections.Generic.IEnumerable{Foundation.NSString}) @@ -9605,12 +9614,14 @@ M:AVFoundation.AVMidiPitchBendEvent.#ctor(System.UInt32,System.UInt32) M:AVFoundation.AVMidiPolyPressureEvent.#ctor(System.UInt32,System.UInt32,System.UInt32) M:AVFoundation.AVMidiProgramChangeEvent.#ctor(System.UInt32,System.UInt32) M:AVFoundation.AVMidiSysexEvent.#ctor(Foundation.NSData) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTrack(AVFoundation.AVMovie,System.Int32,System.Action{AVFoundation.AVMutableCompositionTrack,Foundation.NSError}) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTrackAsync(AVFoundation.AVMovie,System.Int32) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVMovie,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaCharacteristicAsync(AVFoundation.AVMovie,System.String) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVMovie,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) -M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVMovie,System.String) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTrack(AVFoundation.AVMovie,System.Int32,AVFoundation.AVMovieLoadTrackCallback) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTrack2Async(AVFoundation.AVMovie,System.Int32) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaCharacteristic(AVFoundation.AVMovie,System.String,AVFoundation.AVMovieLoadTracksCallback) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaCharacteristic2Async(AVFoundation.AVMovie,System.String) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVMovie,AVFoundation.AVMediaTypes,AVFoundation.AVMovieLoadTracksCallback) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaType(AVFoundation.AVMovie,System.String,AVFoundation.AVMovieLoadTracksCallback) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaType2Async(AVFoundation.AVMovie,System.String) +M:AVFoundation.AVMovie_AVMovieTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVMovie,AVFoundation.AVMediaTypes) M:AVFoundation.AVMusicTrack.AddEvent(AVFoundation.AVMusicEvent,System.Double) M:AVFoundation.AVMusicTrack.ClearEvents(AVFoundation.AVBeatRange) M:AVFoundation.AVMusicTrack.CopyAndMergeEvents(AVFoundation.AVBeatRange,AVFoundation.AVMusicTrack,System.Double) @@ -9626,9 +9637,14 @@ M:AVFoundation.AVMutableComposition_AVMutableCompositionTrackInspection.LoadTrac M:AVFoundation.AVMutableComposition_AVMutableCompositionTrackInspection.LoadTracksWithMediaType(AVFoundation.AVMutableComposition,System.String,System.Action{Foundation.NSArray{AVFoundation.AVMutableCompositionTrack},Foundation.NSError}) M:AVFoundation.AVMutableComposition_AVMutableCompositionTrackInspection.LoadTracksWithMediaTypeAsync(AVFoundation.AVMutableComposition,System.String) M:AVFoundation.AVMutableComposition.InsertAsync(CoreMedia.CMTimeRange,AVFoundation.AVAsset,CoreMedia.CMTime) -M:AVFoundation.AVMutableMovie.LoadTrackAsync(System.Int32) -M:AVFoundation.AVMutableMovie.LoadTracksWithMediaCharacteristicAsync(System.String) -M:AVFoundation.AVMutableMovie.LoadTracksWithMediaTypeAsync(System.String) +M:AVFoundation.AVMutableMovie.LoadTrack2(System.Int32,AVFoundation.AVMutableMovieLoadTrackCallback) +M:AVFoundation.AVMutableMovie.LoadTrack2Async(System.Int32) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaCharacteristic(System.String,AVFoundation.AVMutableMovieLoadTracksCallback) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaCharacteristic2Async(System.String) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaType(AVFoundation.AVMediaTypes,AVFoundation.AVMutableMovieLoadTracksCallback) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaType(System.String,AVFoundation.AVMutableMovieLoadTracksCallback) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaType2Async(System.String) +M:AVFoundation.AVMutableMovie.LoadTracksWithMediaTypeAsync(AVFoundation.AVMediaTypes) M:AVFoundation.AVMutableVideoComposition.CreateAsync(AVFoundation.AVAsset,AVFoundation.AVMutableVideoCompositionCreateApplier) M:AVFoundation.AVMutableVideoComposition.CreateAsync(AVFoundation.AVAsset,AVFoundation.AVVideoCompositionInstruction) M:AVFoundation.AVMutableVideoComposition.CreateAsync(AVFoundation.AVAsset) @@ -25637,6 +25653,8 @@ T:AVFoundation.AVAssetExportPresetApple T:AVFoundation.AVAssetImageGenerateAsynchronouslyForTimeCompletionHandler T:AVFoundation.AVAssetImageGeneratorCompletionHandler2 T:AVFoundation.AVAssetImageGeneratorDynamicRangePolicy +T:AVFoundation.AVAssetLoadTrackCallback +T:AVFoundation.AVAssetLoadTracksCallback T:AVFoundation.AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler T:AVFoundation.AVAssetPlaybackConfigurationOption T:AVFoundation.AVAssetSegmentType @@ -25729,6 +25747,8 @@ T:AVFoundation.AVCaptureTimecodeGeneratorSynchronizationStatus T:AVFoundation.AVCaptureTimecodeSourceType T:AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValue T:AVFoundation.AVComposition_AVCompositionTrackInspection +T:AVFoundation.AVCompositionLoadTrackCallback +T:AVFoundation.AVCompositionLoadTracksCallback T:AVFoundation.AVContentAuthorizationStatus T:AVFoundation.AVContentKeyRequest_AVContentKeyRequestRenewal T:AVFoundation.AVContentKeyRequestRetryReason @@ -25750,6 +25770,8 @@ T:AVFoundation.AVExternalSyncDeviceStatus T:AVFoundation.AVFileTypeProfile T:AVFoundation.AVFragmentedAsset_AVFragmentedAssetTrackInspection T:AVFoundation.AVFragmentedMovie_AVFragmentedMovieTrackInspection +T:AVFoundation.AVFragmentedMovieLoadTrackCallback +T:AVFoundation.AVFragmentedMovieLoadTracksCallback T:AVFoundation.AVMetadataFormat T:AVFoundation.AVMetadataIdentifiers.CommonIdentifier T:AVFoundation.AVMetadataIdentifiers.IcyMetadata @@ -25772,6 +25794,8 @@ T:AVFoundation.AVMidiProgramChangeEvent T:AVFoundation.AVMidiSysexEvent T:AVFoundation.AVMovie_AVMovieMovieHeaderSupport T:AVFoundation.AVMovie_AVMovieTrackInspection +T:AVFoundation.AVMovieLoadTrackCallback +T:AVFoundation.AVMovieLoadTracksCallback T:AVFoundation.AVMovieWritingOptions T:AVFoundation.AVMusicEvent T:AVFoundation.AVMusicEventEnumerationBlock @@ -25782,6 +25806,8 @@ T:AVFoundation.AVMutableCompositionInsertHandler T:AVFoundation.AVMutableMovie_AVMutableMovieMovieLevelEditing T:AVFoundation.AVMutableMovie_AVMutableMovieTrackInspection T:AVFoundation.AVMutableMovie_AVMutableMovieTrackLevelEditing +T:AVFoundation.AVMutableMovieLoadTrackCallback +T:AVFoundation.AVMutableMovieLoadTracksCallback T:AVFoundation.AVMutableMovieTrack_AVMutableMovieTrack_TrackLevelEditing T:AVFoundation.AVMutableMovieTrack_AVMutableMovieTrackTrackAssociations T:AVFoundation.AVMutableVideoCompositionCreateApplier diff --git a/tests/monotouch-test/AVFoundation/AVAssetLoadTracksTest.cs b/tests/monotouch-test/AVFoundation/AVAssetLoadTracksTest.cs new file mode 100644 index 000000000000..3f3c1e357980 --- /dev/null +++ b/tests/monotouch-test/AVFoundation/AVAssetLoadTracksTest.cs @@ -0,0 +1,414 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System.IO; +using System.Threading.Tasks; + +using AVFoundation; +using CoreMedia; + +#nullable enable + +namespace MonoTouchFixtures.AVFoundation { + + [TestFixture] + [Preserve (AllMembers = true)] + public class AVAssetLoadTracksTest { + + static string VideoPath => Path.Combine (NSBundle.MainBundle.ResourcePath, "xamvideotest.mp4"); + + #region AVAsset + + [Test] + public void AVAsset_LoadTrack2 () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + + var tcs = new TaskCompletionSource (); + asset.LoadTrack2 (1, (track, error) => { + tcs.TrySetResult (track); + }); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) + Assert.That (result, Is.InstanceOf (), "result type"); + } + + [Test] + public void AVAsset_LoadTrackWithMediaCharacteristics () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + + var tcs = new TaskCompletionSource (); + asset.LoadTrackWithMediaCharacteristics (AVMediaCharacteristics.Visual.GetConstant ()!, (tracks, error) => { + tcs.TrySetResult (tracks); + }); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + [Test] + public void AVAsset_LoadTracksWithMediaType () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + + var tcs = new TaskCompletionSource (); + asset.LoadTracksWithMediaType (AVMediaTypes.Video.GetConstant ()!, (AVAssetLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + [Test] + public void AVAsset_LoadTracksWithMediaType_Enum () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + + var tcs = new TaskCompletionSource (); + asset.LoadTracksWithMediaType (AVMediaTypes.Video, (AVAssetLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + #endregion + +#if !__TVOS__ + #region AVMovie + + [Test] + public void AVMovie_LoadTrack () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMovie (url, (NSDictionary?) null); + + var tcs = new TaskCompletionSource (); + movie.LoadTrack (1, (AVMovieLoadTrackCallback) ((track, error) => { + tcs.TrySetResult (track); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) + Assert.That (result, Is.InstanceOf (), "result type"); + } + + [Test] + public void AVMovie_LoadTracksWithMediaType () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMovie (url, (NSDictionary?) null); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaType (AVMediaTypes.Video.GetConstant ()!, (AVMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + // mp4 files may not be recognized as movies, so tracks could be null + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + [Test] + public void AVMovie_LoadTracksWithMediaType_Enum () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMovie (url, (NSDictionary?) null); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaType (AVMediaTypes.Video, (AVMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + [Test] + public void AVMovie_LoadTracksWithMediaCharacteristic () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMovie (url, (NSDictionary?) null); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaCharacteristic (AVMediaCharacteristics.Visual.GetConstant ()!, (AVMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + #endregion + + #region AVMutableMovie + + [Test] + public void AVMutableMovie_LoadTrack2 () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMutableMovie (url, (NSDictionary?) null, out var initError); + if (initError is not null) + Assert.Ignore ($"Could not create AVMutableMovie from test file: {initError.LocalizedDescription}"); + + var tcs = new TaskCompletionSource (); + movie.LoadTrack2 (1, (track, error) => { + tcs.TrySetResult (track); + }); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) + Assert.That (result, Is.InstanceOf (), "result type"); + } + + [Test] + public void AVMutableMovie_LoadTracksWithMediaType () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMutableMovie (url, (NSDictionary?) null, out var initError); + if (initError is not null) + Assert.Ignore ($"Could not create AVMutableMovie from test file: {initError.LocalizedDescription}"); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaType (AVMediaTypes.Video.GetConstant ()!, (AVMutableMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + [Test] + public void AVMutableMovie_LoadTracksWithMediaType_Enum () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMutableMovie (url, (NSDictionary?) null, out var initError); + if (initError is not null) + Assert.Ignore ($"Could not create AVMutableMovie from test file: {initError.LocalizedDescription}"); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaType (AVMediaTypes.Video, (AVMutableMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + [Test] + public void AVMutableMovie_LoadTracksWithMediaCharacteristic () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var movie = new AVMutableMovie (url, (NSDictionary?) null, out var initError); + if (initError is not null) + Assert.Ignore ($"Could not create AVMutableMovie from test file: {initError.LocalizedDescription}"); + + var tcs = new TaskCompletionSource (); + movie.LoadTracksWithMediaCharacteristic (AVMediaCharacteristics.Visual.GetConstant ()!, (AVMutableMovieLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + if (result is not null) { + Assert.That (result.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + } + + #endregion +#endif // !__TVOS__ + + #region AVComposition + + [Test] + public void AVComposition_LoadTrack () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + using var composition = AVMutableComposition.Create (); + + var compositionTrack = composition.AddMutableTrack (AVMediaTypes.Video.GetConstant ()!, 0); + if (compositionTrack is null) + Assert.Ignore ("Could not add track to composition"); + + var sourceTracks = asset.GetTracks (AVMediaTypes.Video); + if (sourceTracks.Length == 0) + Assert.Ignore ("No video tracks in source asset"); + + compositionTrack.InsertTimeRange (new CMTimeRange { Start = CMTime.Zero, Duration = asset.Duration }, sourceTracks [0], CMTime.Zero, out _); + + var trackId = compositionTrack.TrackID; + var tcs = new TaskCompletionSource (); + composition.LoadTrack (trackId, (AVCompositionLoadTrackCallback) ((track, error) => { + tcs.TrySetResult (track); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result, Is.InstanceOf (), "result type"); + } + + [Test] + public void AVComposition_LoadTracksWithMediaType () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + using var composition = AVMutableComposition.Create (); + + var compositionTrack = composition.AddMutableTrack (AVMediaTypes.Video.GetConstant ()!, 0); + if (compositionTrack is null) + Assert.Ignore ("Could not add track to composition"); + + var sourceTracks = asset.GetTracks (AVMediaTypes.Video); + if (sourceTracks.Length == 0) + Assert.Ignore ("No video tracks in source asset"); + + compositionTrack.InsertTimeRange (new CMTimeRange { Start = CMTime.Zero, Duration = asset.Duration }, sourceTracks [0], CMTime.Zero, out _); + + var tcs = new TaskCompletionSource (); + composition.LoadTracksWithMediaType (AVMediaTypes.Video.GetConstant ()!, (AVCompositionLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + [Test] + public void AVComposition_LoadTracksWithMediaType_Enum () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + using var composition = AVMutableComposition.Create (); + + var compositionTrack = composition.AddMutableTrack (AVMediaTypes.Video.GetConstant ()!, 0); + if (compositionTrack is null) + Assert.Ignore ("Could not add track to composition"); + + var sourceTracks = asset.GetTracks (AVMediaTypes.Video); + if (sourceTracks.Length == 0) + Assert.Ignore ("No video tracks in source asset"); + + compositionTrack.InsertTimeRange (new CMTimeRange { Start = CMTime.Zero, Duration = asset.Duration }, sourceTracks [0], CMTime.Zero, out _); + + var tcs = new TaskCompletionSource (); + composition.LoadTracksWithMediaType (AVMediaTypes.Video, (AVCompositionLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + [Test] + public void AVComposition_LoadTracksWithMediaCharacteristic () + { + TestRuntime.AssertXcodeVersion (13, 0); + + using var url = NSUrl.FromFilename (VideoPath); + using var asset = AVAsset.FromUrl (url); + using var composition = AVMutableComposition.Create (); + + var compositionTrack = composition.AddMutableTrack (AVMediaTypes.Video.GetConstant ()!, 0); + if (compositionTrack is null) + Assert.Ignore ("Could not add track to composition"); + + var sourceTracks = asset.GetTracks (AVMediaTypes.Video); + if (sourceTracks.Length == 0) + Assert.Ignore ("No video tracks in source asset"); + + compositionTrack.InsertTimeRange (new CMTimeRange { Start = CMTime.Zero, Duration = asset.Duration }, sourceTracks [0], CMTime.Zero, out _); + + var tcs = new TaskCompletionSource (); + composition.LoadTracksWithMediaCharacteristic (AVMediaCharacteristics.Visual.GetConstant ()!, (AVCompositionLoadTracksCallback) ((tracks, error) => { + tcs.TrySetResult (tracks); + })); + + Assert.That (tcs.Task.Wait (TimeSpan.FromSeconds (10)), Is.True, "Timed out"); + var result = tcs.Task.Result; + Assert.That (result, Is.Not.Null, "result"); + Assert.That (result!.Length, Is.GreaterThan (0), "result.Length"); + Assert.That (result [0], Is.InstanceOf (), "result[0] type"); + } + + #endregion + } +}