-
Notifications
You must be signed in to change notification settings - Fork 548
AVFoundation iOS xcode26.0 rc
Alex Soto edited this page Sep 10, 2025
·
2 revisions
#AVFoundation.framework https://github.com/dotnet/macios/pull/23779
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureDevice.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureDevice.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureDevice.h 2025-08-13 02:04:07
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureDevice.h 2025-08-26 23:37:25
@@ -372,19 +372,35 @@
*/
@property(nonatomic) CMTime activeVideoMaxFrameDuration API_AVAILABLE(macos(10.9), ios(7.0), macCatalyst(14.0), tvos(17.0), visionos(1.0));
+/// Whether the device's video frame rate (expressed as a duration) is currently locked.
+///
+/// Returns `true` when an ``AVCaptureDeviceInput`` associated with the device has its ``AVCaptureDeviceInput/activeLockedVideoFrameDuration`` property set to something other than `kCMTimeInvalid`. See ``AVCaptureDeviceInput/activeLockedVideoFrameDuration`` for more information on video frame duration locking.
+@property(nonatomic, readonly, getter=isVideoFrameDurationLocked) BOOL videoFrameDurationLocked API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
-/*!
- @property autoVideoFrameRateEnabled
- @abstract
- Indicates whether the receiver should enable auto video frame rate.
+/// The maximum frame rate (expressed as a minimum duration) that can be set on an input associated with this device.
+///
+/// `kCMTimeInvalid` is returned when the device or its current configuration does not support locked frame rate. Use ``AVCaptureDeviceInput/activeLockedVideoFrameDuration`` to set the locked frame rate on the input.
+@property(nonatomic, readonly) CMTime minSupportedLockedVideoFrameDuration API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
-@discussion
- When enabled the receiver automatically adjusts the active frame rate, depending on light level. Under low light conditions, frame rate is decreased to properly expose the scene. For formats with a maximum frame rate of 30 fps, the frame rate switches between 30 - 24. For formats with a maximum frame rate of 60 fps, the frame rate switches between 60 - 30 - 24.
+/// Whether the device is following an external sync device.
+///
+/// See ``AVCaptureDeviceInput/followExternalSyncDevice:videoFrameDuration:delegate:`` for more information on external sync.
+@property(nonatomic, readonly, getter=isFollowingExternalSyncDevice) BOOL followingExternalSyncDevice API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
- Setting this property throws an NSInvalidArgumentException if the active format's -isAutoVideoFrameRateSupported returns NO. Changing the device's active format resets isAutoVideoFrameRateEnabled to its default value of NO.
+/// The minimum frame duration that can be passed as the `videoFrameDuration` when directing your device input to follow an external sync device.
+///
+/// Use this property as the minimum allowable frame duration to pass to ``AVCaptureDeviceInput/follow:externalSyncDevice:videoFrameDuration:delegate:`` when you want to follow an external sync device. This property returns `kCMTimeInvalid` when the device's' current configuration does not support external sync device following.
+@property(nonatomic, readonly) CMTime minSupportedExternalSyncFrameDuration API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
- When autoVideoFrameRateEnabled is true, setting activeVideoMinFrameDuration or activeVideoMaxFrameDuration throws an NSInvalidArgumentException.
- */
+/// Indicates whether the receiver should enable auto video frame rate.
+///
+/// When you enable this property, the device automatically adjusts the active frame rate, depending on light level. Under low light conditions, it decreases the frame rate to properly expose the scene. For formats with a maximum frame rate of 30 fps, the device switches the frame rate between 30 - 24. For formats with a maximum frame rate of 60 fps, the device switches the frame rate between 60 - 30 - 24.
+///
+/// Setting this property throws an `NSInvalidArgumentException` if the active format's ``AVCaptureDeviceFormat/autoVideoFrameRateSupported`` returns `false`. When you change the device's active format, this property resets to its default value of `false`.
+///
+/// If you set this property to `true`, frame rate is under device control, and you may not set ``activeVideoMinFrameDuration`` or ``activeVideoMaxFrameDuration``. Doing so throws an `NSInvalidArgumentException`.
+///
+/// - Note: Setting this property to `true` throws an `NSInvalidArgumentException` if ``videoFrameDurationLocked`` or ``followingExternalSyncDevice`` are `true`.
@property(nonatomic, getter=isAutoVideoFrameRateEnabled) BOOL autoVideoFrameRateEnabled API_AVAILABLE(macos(15.0), ios(18.0), macCatalyst(18.0), tvos(18.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
/*!
@@ -1656,7 +1672,22 @@
float tint;
} AVCaptureWhiteBalanceTemperatureAndTintValues API_AVAILABLE(ios(8.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+/// Temperature and tint values ideal for scenes illuminated with a tungsten light source.
+AVF_EXPORT AVCaptureWhiteBalanceTemperatureAndTintValues const AVCaptureWhiteBalanceTemperatureAndTintValuesTungsten NS_SWIFT_NAME(AVCaptureWhiteBalanceTemperatureAndTintValues.tungsten) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+/// Temperature and tint values ideal for scenes illuminated with a fluorescent light source.
+AVF_EXPORT AVCaptureWhiteBalanceTemperatureAndTintValues const AVCaptureWhiteBalanceTemperatureAndTintValuesFluorescent NS_SWIFT_NAME(AVCaptureWhiteBalanceTemperatureAndTintValues.fluorescent) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+
+/// Temperature and tint values ideal for scenes illuminated with natural daylight.
+AVF_EXPORT AVCaptureWhiteBalanceTemperatureAndTintValues const AVCaptureWhiteBalanceTemperatureAndTintValuesDaylight NS_SWIFT_NAME(AVCaptureWhiteBalanceTemperatureAndTintValues.daylight) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+
+/// Temperature and tint values ideal for scenes illuminated with natural cloudy daylight.
+AVF_EXPORT AVCaptureWhiteBalanceTemperatureAndTintValues const AVCaptureWhiteBalanceTemperatureAndTintValuesCloudy NS_SWIFT_NAME(AVCaptureWhiteBalanceTemperatureAndTintValues.cloudy) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+
+/// Temperature and tint values ideal for scenes illuminated with daylight but in heavy shade.
+AVF_EXPORT AVCaptureWhiteBalanceTemperatureAndTintValues const AVCaptureWhiteBalanceTemperatureAndTintValuesShadow NS_SWIFT_NAME(AVCaptureWhiteBalanceTemperatureAndTintValues.shadow) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+
+
API_AVAILABLE(macos(10.7), ios(4.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
@interface AVCaptureDevice (AVCaptureDeviceWhiteBalance)
@@ -1741,6 +1772,14 @@
*/
AVF_EXPORT const AVCaptureWhiteBalanceGains AVCaptureWhiteBalanceGainsCurrent API_AVAILABLE(ios(8.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+/// Sets white balance to locked mode with explicit temperature and tint values.
+///
+/// - Parameter whiteBalanceTemperatureAndTintValues: The white balance temperature and tint values, as computed from ``temperatureAndTintValuesForDeviceWhiteBalanceGains:`` method, ``AVCaptureWhiteBalanceTemperatureAndTintValues`` presets or manual input.
+///
+/// - Parameter handler: A block to be called when white balance values have been set to the values specified and ``whiteBalanceMode`` is set to ``AVCaptureWhiteBalanceModeLocked``. If ``setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues:completionHandler:`` is called multiple times, the completion handlers are called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the ``AVCaptureSession/synchronizationClock`` prior to comparison with the timestamps of buffers delivered via an ``AVCaptureVideoDataOutput``. This parameter may be `nil` if synchronization is not required.
+///
+/// This method takes a ``AVCaptureWhiteBalanceTemperatureAndTintValues`` struct and applies the appropriate ``AVCaptureWhiteBalanceGains``. This method throws an `NSRangeException` if any of the values are set to an unsupported level. This method throws an `NSGenericException` if called without first obtaining exclusive access to the device using ``AVCaptureDevice/lockForConfiguration:``.
+- (void)setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues:(AVCaptureWhiteBalanceTemperatureAndTintValues)whiteBalanceTemperatureAndTintValues completionHandler:(nullable void (^)(CMTime syncTime))handler NS_SWIFT_NAME(setWhiteBalanceModeLocked(whiteBalanceTemperatureAndTintValues:handler:)) API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
/*!
@method setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains:completionHandler:
@@ -2125,25 +2164,18 @@
@end
-/*!
- @enum AVCaptureColorSpace
- @abstract
- Constants indicating active or supported video color space.
-
- @constant AVCaptureColorSpace_sRGB
- The sRGB color space ( https://www.w3.org/Graphics/Color/srgb )
- @constant AVCaptureColorSpace_P3_D65
- The P3 D65 wide color space which uses Illuminant D65 as the white point.
- @constant AVCaptureColorSpace_HLG_BT2020
- The BT2020 wide color space which uses Illuminant D65 as the white point and Hybrid Log-Gamma as the transfer function.
- @constant AVCaptureColorSpace_AppleLog
- The Apple Log Color space, which uses BT2020 as the color primaries, and an Apple defined Log curve as a transfer function. When this is set as the active color space on an AVCaptureDevice, any AVCapturePhotoOutput or AVCaptureStillImageOutput connected to the same AVCaptureDevice will have its video connection disabled.
- */
+/// Constants indicating active or supported video color space.
typedef NS_ENUM(NSInteger, AVCaptureColorSpace) {
+ /// The sRGB color space ( https://www.w3.org/Graphics/Color/srgb ).
AVCaptureColorSpace_sRGB = 0,
+ /// The P3 D65 wide color space which uses Illuminant D65 as the white point.
AVCaptureColorSpace_P3_D65 = 1,
+ /// The BT2020 wide color space which uses Illuminant D65 as the white point and Hybrid Log-Gamma as the transfer function.
AVCaptureColorSpace_HLG_BT2020 API_AVAILABLE(ios(14.1), macCatalyst(14.1), tvos(17.0)) API_UNAVAILABLE(macos, visionos) = 2,
+ /// The Apple Log Color space, which uses BT2020 as the color primaries, and an Apple defined Log curve as a transfer function. When you set this as the active color space on an ``AVCaptureDevice``, any ``AVCapturePhotoOutput`` or ``AVCaptureStillImageOutput`` connected to the same ``AVCaptureDevice`` is made inactive (its ``AVCaptureConnection/active`` property returns `false`).
AVCaptureColorSpace_AppleLog API_AVAILABLE(ios(17.0), macCatalyst(17.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) = 3,
+ /// The Apple Log 2 Color space, which uses Apple Gamut as the color primaries, and an Apple defined Log curve as a transfer function. When you set this as the active color space on an ``AVCaptureDevice``, any ``AVCapturePhotoOutput`` or ``AVCaptureStillImageOutput`` connected to the same ``AVCaptureDevice`` is made inactive (its ``AVCaptureConnection/active`` property returns `false`).
+ AVCaptureColorSpace_AppleLog2 API_AVAILABLE(ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(macos, visionos) = 4,
} API_AVAILABLE(macos(10.15), ios(10.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
API_AVAILABLE(macos(10.7), ios(4.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
@@ -2240,9 +2272,16 @@
@property geometricDistortionCorrectionEnabled
@abstract
Indicates whether geometric distortion correction is enabled by the receiver.
-
+
@discussion
Where supported, the default value is YES. The receiver must be locked for configuration using lockForConfiguration: before clients can set this method, otherwise an NSGenericException is thrown.
+
+ In the case of ProRes RAW, when geometricDistortionCorrectionEnabled is YES, GDC is applied to your outputs in different ways:
+ - It is always applied to AVCaptureVideoPreviewLayer.
+ - It is applied to AVCaptureVideoDataOutput only if deliversPreviewSizedOutputBuffers is set to YES.
+ - It is never applied to AVCaptureMovieFileOutput.
+
+ When GDC is enabled, AVCaptureVideoDataOutput buffers contain GDC metadata attachments, and AVCaptureMovieFileOutput movies contain GDC metadata which an application supporting ProRes RAW can optionally apply at playback time using the ProRes RAW SDK. To learn more about the ProRes RAW SDK, refer to the Apple ProRes and ProRes RAW Authorized Products article at https://support.apple.com/en-us/118584.
*/
@property(nonatomic, getter=isGeometricDistortionCorrectionEnabled) BOOL geometricDistortionCorrectionEnabled API_AVAILABLE(ios(13.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
@@ -2656,6 +2695,125 @@
@end
+/// String constants describing the different video aspect ratios you can configure for a particular device.
+typedef NSString *AVCaptureAspectRatio NS_TYPED_ENUM NS_SWIFT_NAME(AVCaptureDevice.AspectRatio) API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/// An aspect ratio of 1x1.
+AVF_EXPORT AVCaptureAspectRatio const AVCaptureAspectRatio1x1 API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/// An aspect ratio of 16x9.
+AVF_EXPORT AVCaptureAspectRatio const AVCaptureAspectRatio16x9 API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/// An aspect ratio of 9x16.
+AVF_EXPORT AVCaptureAspectRatio const AVCaptureAspectRatio9x16 API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/// An aspect ratio of 4x3.
+AVF_EXPORT AVCaptureAspectRatio const AVCaptureAspectRatio4x3 API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/// An aspect ratio of 3x4.
+AVF_EXPORT AVCaptureAspectRatio const AVCaptureAspectRatio3x4 API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureDevice (DynamicAspectRatio)
+
+/// A key-value observable property indicating the current aspect ratio for a device.
+///
+/// This property is initialized to the first ``AVCaptureAspectRatio`` listed in the device's activeFormat's ``AVCaptureDeviceFormat/supportedDynamicAspectRatios`` property. If the activeFormat's ``AVCaptureDeviceFormat/supportedDynamicAspectRatios`` is an empty array, this property returns nil.
+@property(readonly, nullable) AVCaptureAspectRatio dynamicAspectRatio;
+
+/// A key-value observable property describing the output dimensions of the video buffer based on the device's dynamic aspect ratio.
+///
+/// If the device's activeFormat's ``AVCaptureDeviceFormat/supportedDynamicAspectRatios`` is an empty array, this property returns {0,0}.
+@property(readonly) CMVideoDimensions dynamicDimensions;
+
+/// Updates the dynamic aspect ratio of the device.
+///
+/// - Parameter dynamicAspectRatio: The new ``AVCaptureAspectRatio`` the device should output.
+/// - Parameter handler: A block called by the device when `dynamicAspectRatio` is set to the value specified. If you call ``setDynamicAspectRatio:completionHandler:`` multiple times, the completion handlers are called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the ``AVCaptureSession/synchronizationClock`` prior to comparison with the timestamps of buffers delivered via an ``AVCaptureVideoDataOutput``. You may pass `nil` for the `handler` parameter if you do not need to know when the operation completes.
+///
+/// This is the only way of setting ``dynamicAspectRatio``. This method throws an `NSInvalidArgumentException` if `dynamicAspectRatio` is not a supported aspect ratio found in the device's activeFormat's ``AVCaptureDeviceFormat/supportedDynamicAspectRatios``. This method throws an `NSGenericException` if you call it without first obtaining exclusive access to the device using ``AVCaptureDevice/lockForConfiguration:``.
+- (void)setDynamicAspectRatio:(AVCaptureAspectRatio)dynamicAspectRatio completionHandler:(nullable void (^)(CMTime syncTime, NSError * _Nullable error))handler;
+
+@end
+
+@class AVCaptureSmartFramingMonitor;
+
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureDevice (AVCaptureDeviceSmartFraming)
+
+/// A monitor owned by the device that recommends an optimal framing based on the content in the scene.
+///
+/// An ultra wide camera device that supports dynamic aspect ratio configuration may also support "smart framing monitoring". If this property returns non `nil`, you may use it to listen for framing recommendations by configuring its ``AVCaptureSmartFramingMonitor/enabledFramings`` and calling ``AVCaptureSmartFramingMonitor/startMonitoringWithError:``. The smart framing monitor only makes recommendations when the current ``AVCaptureDevice/activeFormat`` supports smart framing (see ``AVCaptureDeviceFormat/smartFramingSupported``).
+@property(nonatomic, readonly, nullable) AVCaptureSmartFramingMonitor *smartFramingMonitor;
+
+@end
+
+@class AVCaptureFraming;
+
+/// An object associated with a capture device that monitors the scene and suggests an optimal framing.
+///
+/// A smart framing monitor observes its associated device for objects of interest entering and exiting the camera's field of view and recommends an optimal framing for good photographic composition. This framing recommendation consists of an aspect ratio and zoom factor. You may respond to the device's framing recommendation by calling ``AVCaptureDevice/setDynamicAspectRatio:completionHandler:`` and setting ``AVCaptureDevice/videoZoomFactor`` on the associated device in whatever order best matches your animation between old and new framings.
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureSmartFramingMonitor : NSObject
+
+AV_INIT_UNAVAILABLE
+
+/// An array of framings supported by the monitor in its current configuration.
+///
+/// The monitor is capable of recommending any of the framings in this array. This property is key-value observable and may change as the target capture device's ``AVCaptureDevice/activeFormat`` property changes. This array contains the full set of framings supported by the monitor in the device's current configuration. You must tell the monitor which smart framings you are interested in having recommended to you by setting the ``enabledFramings`` property.
+@property(nonatomic, readonly) NSArray<AVCaptureFraming *> *supportedFramings;
+
+/// An array of framings that the monitor is allowed to suggest.
+///
+/// The monitor is capable of recommending any of the framings in the ``supportedFramings`` array. This property contains the subset of ``supportedFramings`` you would like to have recommended to you. You may set this property at any time while running your ``AVCaptureSession``. This property's default value is the empty array.
+@property(nonatomic, copy) NSArray<AVCaptureFraming *> *enabledFramings;
+
+/// The latest recommended framing from the monitor.
+///
+/// While your ``AVCaptureSession`` is running, the monitor continuously observes its device's scene to recommend the best framing. This recommended framing is always one of the values in ``enabledFramings``. This property may return `nil` if smart framing isn't supported for the device in its current configuration. Its default value is `nil`. This property is key-value observable, and when you observe a change, you may respond to the new recommendation by calling ``AVCaptureDevice/setDynamicAspectRatio:completionHandler:`` and setting ``AVCaptureDevice/videoZoomFactor`` on the associated device in whatever order best matches your animation between old and new framings.
+@property(nonatomic, readonly, nullable) AVCaptureFraming *recommendedFraming;
+
+/// Begins monitoring the device's active scene and making framing recommendations.
+///
+/// - Parameter outError: A pointer to an ``NSError`` indicating why ``startMonitoringWithError:`` failed, or to a `nil` ``NSError`` on success.
+/// - Returns: `true` if successful, `false` if monitoring could not be started.
+///
+/// The monitor's ``recommendedFraming`` is `nil` when it is not actively running. Call this method to start monitoring. You may start monitoring before or after calling ``AVCaptureSession/startRunning``, and you may stop active monitoring without stopping the capture session by calling ``stopMonitoring`` at any time, but you must set ``enabledFramings`` before running your capture session so that the monitor is prepared for your desired framing recommendations. While the monitor is running, you may set ``enabledFramings`` at any time to change the framing choices the monitor should consider in its recommendations.
+- (BOOL)startMonitoringWithError:(NSError **)outError;
+
+/// Stops monitoring the device's active scene and making framing recommendations.
+///
+/// The monitor's ``recommendedFraming`` is `nil` when it is not actively running. Call this method to stop actively monitoring the scene and making framing recommendations. You may start monitoring before or after calling ``AVCaptureSession/startRunning``, and may stop active monitoring without stopping the capture session by calling ``stopMonitoring`` at any time.
+- (void)stopMonitoring;
+
+/// Yes when the receiver is actively monitoring.
+///
+/// See ``startMonitoringWithError:`` and ``stopMonitoring``.
+@property(nonatomic, readonly, getter=isMonitoring) BOOL monitoring;
+
+@end
+
+/// A framing, consisting of an aspect ratio and a zoom factor.
+///
+/// An ``AVCaptureSmartFramingMonitor`` provides framing recommendations using this object.
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureFraming : NSObject
+
+AV_INIT_UNAVAILABLE
+
+/// An aspect ratio.
+///
+/// One of the enumerated aspect ratios suitable for use with the ``AVCaptureDevice`` dynamic aspect ratio APIs.
+@property(atomic, readonly) AVCaptureAspectRatio aspectRatio;
+
+/// A zoom factor.
+///
+/// Suitable for use with the ``AVCaptureDevice/videoZoomFactor`` property or ``AVCaptureDevice/rampToVideoZoomFactor:withRate:``.
+@property(atomic, readonly) float zoomFactor;
+
+@end
+
@interface AVCaptureDevice (AVCaptureDeviceNominalFocalLengthIn35mmFilm)
/// The nominal 35mm equivalent focal length of the capture device's lens.
@@ -2956,33 +3114,23 @@
@end
-/*!
- @enum AVCaptureVideoStabilizationMode
- @abstract
- Constants indicating the modes of video stabilization supported by the device's format.
-
- @constant AVCaptureVideoStabilizationModeOff
- Indicates that video should not be stabilized.
- @constant AVCaptureVideoStabilizationModeStandard
- Indicates that video should be stabilized using the standard video stabilization algorithm introduced with iOS 5.0. Standard video stabilization has a reduced field of view. Enabling video stabilization may introduce additional latency into the video capture pipeline.
- @constant AVCaptureVideoStabilizationModeCinematic
- Indicates that video should be stabilized using the cinematic stabilization algorithm for more dramatic results. Cinematic video stabilization has a reduced field of view compared to standard video stabilization. Enabling cinematic video stabilization introduces much more latency into the video capture pipeline than standard video stabilization and consumes significantly more system memory. Use narrow or identical min and max frame durations in conjunction with this mode.
- @constant AVCaptureVideoStabilizationModeCinematicExtended
- Indicates that the video should be stabilized using the extended cinematic stabilization algorithm. Enabling extended cinematic stabilization introduces longer latency into the video capture pipeline compared to the AVCaptureVideoStabilizationModeCinematic and consumes more memory, but yields improved stability. It is recommended to use identical or similar min and max frame durations in conjunction with this mode.
- @constant AVCaptureVideoStabilizationModePreviewOptimized
- Indicates that video should be stabilized using the preview optimized stabilization algorithm. Preview stabilization is a low latency and low power algorithm which is supported only on connections which either have an associated preview layer or have a preview-sized VideoDataOutput.
- @constant AVCaptureVideoStabilizationModeCinematicExtendedEnhanced
- Indicates that the video should be stabilized using the enhanced extended cinematic stabilization algorithm. Enhanced extended cinematic has a reduced field of view compared to extended cinematic, without any noticeable increase in latency, and it yields improved stability. It is recommended to use identical or similar min and max frame durations in conjunction with this mode.
- @constant AVCaptureVideoStabilizationModeAuto
- Indicates that the most appropriate video stabilization mode for the device and format should be chosen.
- */
+/// Constants indicating the modes of video stabilization supported by the device's format.
typedef NS_ENUM(NSInteger, AVCaptureVideoStabilizationMode) {
+ /// Indicates that video should not be stabilized.
AVCaptureVideoStabilizationModeOff = 0,
+ /// Indicates that video should be stabilized using the standard video stabilization algorithm introduced with iOS 5.0. Standard video stabilization has a reduced field of view. Enabling video stabilization may introduce additional latency into the video capture pipeline.
AVCaptureVideoStabilizationModeStandard = 1,
+ /// Indicates that video should be stabilized using the cinematic stabilization algorithm for more dramatic results. Cinematic video stabilization has a reduced field of view compared to standard video stabilization. Enabling cinematic video stabilization introduces much more latency into the video capture pipeline than standard video stabilization and consumes significantly more system memory. Use narrow or identical min and max frame durations in conjunction with this mode.
AVCaptureVideoStabilizationModeCinematic = 2,
+ /// Indicates that the video should be stabilized using the extended cinematic stabilization algorithm. Enabling extended cinematic stabilization introduces longer latency into the video capture pipeline compared to the ``AVCaptureVideoStabilizationModeCinematic`` and consumes more memory, but yields improved stability. It is recommended to use identical or similar min and max frame durations in conjunction with this mode. Cinematic extended mode is face aware when enabled on a front-facing ultra wide camera on iPhone, and prioritizes stabilization of the subject of the frame rather than the background.
AVCaptureVideoStabilizationModeCinematicExtended API_AVAILABLE(ios(13.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(visionos) = 3,
+ /// Indicates that video should be stabilized using the preview optimized stabilization algorithm. Preview stabilization is a low latency and low power algorithm which is supported only on connections which either have an associated preview layer or have a preview-sized ``AVCaptureVideoDataOutput``.
AVCaptureVideoStabilizationModePreviewOptimized API_AVAILABLE(ios(17.0), macCatalyst(17.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) = 4,
+ /// Indicates that the video should be stabilized using the enhanced extended cinematic stabilization algorithm. Enhanced extended cinematic has a reduced field of view compared to extended cinematic, without any noticeable increase in latency, and it yields improved stability. It is recommended to use identical or similar min and max frame durations in conjunction with this mode. Cinematic extended enhanced mode is face aware when enabled on a front-facing ultra wide camera on iPhone, and prioritizes stabilization of the subject of the frame rather than the background.
AVCaptureVideoStabilizationModeCinematicExtendedEnhanced API_AVAILABLE(ios(18.0), macCatalyst(18.0), tvos(18.0)) API_UNAVAILABLE(macos, visionos) = 5,
+ /// Indicates that video should be stabilized using the low latency stabilization algorithm. Low Latency stabilization has a reduced field of view. Enabling low latency stabilization introduces no additional latency into the video capture pipeline.
+ AVCaptureVideoStabilizationModeLowLatency API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) = 6,
+ /// Indicates that the most appropriate video stabilization mode for the device and format should be chosen.
AVCaptureVideoStabilizationModeAuto = -1,
} API_AVAILABLE(ios(8.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
@@ -3638,6 +3786,31 @@
///
/// Devices may support a limited frame rate range when Cinematic Video capture is active. If this device format does not support Cinematic Video capture, this property returns `nil`.
@property(nonatomic, readonly, nullable) AVFrameRateRange *videoFrameRateRangeForCinematicVideo API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+@end
+
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureDeviceFormat (DynamicAspectRatio)
+
+/// Indicates the supported aspect ratios for the device format.
+///
+/// An array that describes the aspect ratios that are supported for this format. If this device format does not support dynamic aspect ratio, this property returns an empty array.
+@property(readonly, copy) NSArray<AVCaptureAspectRatio> *supportedDynamicAspectRatios;
+
+/// Indicates the horizontal field of view for an aspect ratio, either uncorrected or corrected for geometric distortion.
+///
+/// A float indicating the field of view for the corresponding ``AVCaptureAspectRatio``. Set ``AVCaptureDevice/geometricDistortionCorrected`` to `true` to receive the field of view corrected for geometric distortion. If this device format does not support dynamic aspect ratio, this function returns `0`.
+- (float)videoFieldOfViewForAspectRatio:(AVCaptureAspectRatio)aspectRatio geometricDistortionCorrected:(BOOL)geometricDistortionCorrected NS_SWIFT_NAME(videoFieldOfView(for:geometricDistortionCorrected:));
+
+@end
+
+API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureDeviceFormat (AVCaptureDeviceFormatSmartFraming)
+
+/// Returns `true` if smart framing is supported by the current format.
+///
+/// An ultra wide camera device that supports dynamic aspect ratio configuration may also support "smart framing monitoring" on particular formats.
+@property(nonatomic, readonly, getter=isSmartFramingSupported) BOOL smartFramingSupported;
@end
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureExternalDisplayConfigurator.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureExternalDisplayConfigurator.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureExternalDisplayConfigurator.h 1969-12-31 19:00:00
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureExternalDisplayConfigurator.h 2025-08-26 23:30:12
@@ -0,0 +1,114 @@
+#if !__has_include(<AVFCapture/AVCaptureExternalDisplayConfigurator.h>)
+/*
+ File: AVCaptureExternalDisplayConfigurator.h
+
+ Framework: AVFoundation
+
+ Copyright 2025 Apple Inc. All rights reserved.
+*/
+
+#import <AVFoundation/AVBase.h>
+
+#if __has_include(<QuartzCore/QuartzCore.h>)
+#import <QuartzCore/QuartzCore.h>
+#import <AVFoundation/AVCaptureDevice.h>
+#import <CoreMedia/CMFormatDescription.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A class you use to specify a configuration to your external display configurator.
+///
+/// Using an ``AVCaptureExternalDisplayConfiguration``, you direct your ``AVCaptureExternalDisplayConfigurator`` how to configure an external display to match your device's active video format.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureExternalDisplayConfiguration : NSObject
+
+/// A property indicating whether the frame rate of the external display should be configured to match the camera's frame rate.
+///
+/// If you want to configure your ``AVCaptureVideoPreviewLayer`` to match its source ``AVCaptureDevice/activeVideoMinFrameDuration``, set ``shouldMatchFrameRate`` to `true`. The default value is `false`.
+@property(nonatomic, assign) BOOL shouldMatchFrameRate;
+
+/// A property indicating whether the color space of the configurator's preview layer should be preserved on the output display by avoiding color space conversions.
+///
+/// Set ``bypassColorSpaceConversion`` to `true` if you would like the configurator's ``AVCaptureVideoPreviewLayer`` color space preserved on the output display. This is accomplished by setting the working color space to match the color space of the external display. The color properties of the ``CALayer`` remain untouched. The default value is `false`.
+@property(nonatomic, assign) BOOL bypassColorSpaceConversion;
+
+/// Your preferred external display resolution.
+///
+/// Use ``preferredResolution`` to set your desired resolution of the external display. When left at the default value of { 0, 0 }, the native resolution of the external display is used.
+@property(nonatomic, assign) CMVideoDimensions preferredResolution;
+
+@end
+
+/// A configurator class allowing you to configure properties of an external display to match the camera's active video format.
+///
+/// An ``AVCaptureExternalDisplayConfigurator`` allows you to configure a connected external display to output a clean feed using a ``CALayer``. Using the configurator, you can opt into automatic adjustment of the external display’s color space and / or frame rate to match your device’s capture configuration. These adjustments are only applied to the external display, not to the device.
+///
+/// - Note: Not all displays support the same configuration options as the device’s capture formats. Your adjustments to the external display are applied with utmost effort to accurately represent the capture device. When your capture device's ``AVCaptureDevice/activeFormat`` is unavailable on the external display, the configurator automatically chooses the closest available format.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureExternalDisplayConfigurator : NSObject
+
+AV_INIT_UNAVAILABLE
+
+/// An external display configurator instance that attempts to synchronize the preview layer configuration with the device capture configuration.
+///
+/// - Parameter device: The device for which to monitor the configuration.
+/// - Parameter previewLayer: The layer that is being used on an external display for displaying the camera preview.
+/// - Parameter configuration: A configuration specifying which aspects of the camera's active format to monitor and configure on the external display.
+/// - Returns: an ``AVCaptureExternalDisplayConfigurator`` instance.
+///
+/// An ``AVCaptureExternalDisplayConfigurator`` is only applicable to external displays. It determines which properties to configure on the external display based on your provided configuration (see ``AVCaptureExternalDisplayConfiguration``). The configurator observes changes to your camera''s configuration, and when changes are observed, it modifies the external display's properties to match.
+///
+/// If multiple configurators are linked to the same external display ,the last one created becomes the active configurator for the external display (see ``active``).
+///
+/// - Important: An `NSInvalidArgumentException` is thrown if any of the ``AVCaptureExternalDisplayConfiguration`` options are not supported.
+- (instancetype)initWithDevice:(AVCaptureDevice *)device previewLayer:(CALayer *)previewLayer configuration:(AVCaptureExternalDisplayConfiguration *)configuration;
+
+/// The device for which the coordinator configures the preview layer.
+///
+/// The value of this property is the ``AVCaptureDevice`` instance you provided when instantiating the configurator. ``AVCaptureExternalDisplayConfigurator`` holds a weak reference to the device. If the device is released, this property returns `nil`.
+@property(nonatomic, readonly, nullable, weak) AVCaptureDevice *device;
+
+/// The layer for which the configurator adjusts display properties to match the device's state.
+///
+/// The value of this property is the ``CALayer`` instance that you provided when instantiating the configurator. You may specify either an ``AVCaptureVideoPreviewLayer`` or another ``CALayer`` instance that displays a camera's video preview. ``AVCaptureExternalDisplayConfigurator``holds a weak reference to the layer. If the layer is released, this property returns `nil`.
+@property(nonatomic, readonly, nullable, weak) CALayer *previewLayer;
+
+/// This property tells you whether the configurator is actively configuring the external display.
+///
+/// When this property returns `true`, the external display is successfully configured to match the device. If it returns`false`, the configurator is not making any configuration changes to the external display. If another ``AVCaptureExternalDisplayConfigurator`` instance takes over the configuration of the external display, this property returns `false`.
+@property(nonatomic, readonly, getter=isActive) BOOL active;
+
+/// Forces the external display configurator to asynchronously stop configuring the external display.
+///
+/// Call ``stop`` to force the ``AVCaptureExternalDisplayConfigurator`` to asynchronously stop configuring the external display. Once stopped, the ``active`` property changes to `false` and the ``activeExternalDisplayFrameRate`` becomes 0.
+- (void)stop;
+
+/// The currently configured frame rate on the external display that's displaying the preview layer.
+///
+/// Observe this property to determine if the configured frame rate matches the max frame rate (``AVCaptureDevice/activeVideoMinFrameDuration``) of the device. When the ``active`` property becomes `false`, this property changes to 0.
+@property(nonatomic, readonly) double activeExternalDisplayFrameRate;
+
+/// Whether the external display supports matching frame rate to a capture device.
+///
+/// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/shouldMatchFrameRate`` set to `true`.
+@property(class, readonly, getter=isMatchingFrameRateSupported) BOOL shouldMatchFrameRateSupported;
+
+/// Whether the external display supports bypassing color space conversion.
+///
+/// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/bypassColorSpaceConversion`` set to `true`.
+@property(class, readonly, getter=isBypassingColorSpaceConversionSupported) BOOL supportsBypassingColorSpaceConversion;
+
+/// Whether the external display supports configuration to your preferred resolution.
+///
+/// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/preferredResolution`` set to `true`.
+@property(class, readonly, getter=isPreferredResolutionSupported) BOOL supportsPreferredResolution;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // __has_include(<QuartzCore/QuartzCore.h>)
+
+#else
+#import <AVFCapture/AVCaptureExternalDisplayConfigurator.h>
+#endif
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureFileOutput.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureFileOutput.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureFileOutput.h 2025-08-06 01:59:06
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureFileOutput.h 2025-08-26 23:30:11
@@ -584,6 +584,10 @@
This property enables capturing spatial video to a file. By default, this property is set to NO. Check spatialVideoCaptureSupported before setting this property, as setting to YES will throw an exception if the feature is not supported.
On iOS, enabling spatial video will overwrite the connected AVCaptureDevice's `videoZoomFactor`, `minAvailableVideoZoomFactor`, and `maxAvailableVideoZoomFactor` to the field of view of the narrower camera in the pair.
+
+ When spatialVideoCaptureEnabled is true, setting -[AVCaptureDeviceInput activeVideoMinFrameDuration] or -[AVCaptureDeviceInput activeVideoMaxFrameDuration] throws an NSInvalidArgumentException.
+
+ Enabling this property throws an NSInvalidArgumentException if -[AVCaptureDevice isVideoFrameDurationLocked] or -[AVCaptureDevice isFollowingExternalSyncDevice] is true.
*/
@property(nonatomic, getter=isSpatialVideoCaptureEnabled) BOOL spatialVideoCaptureEnabled API_AVAILABLE(macos(15.0), ios(18.0), macCatalyst(18.0), tvos(18.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureInput.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureInput.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureInput.h 2025-08-07 21:40:39
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureInput.h 2025-08-26 23:33:46
@@ -10,6 +10,7 @@
#import <AVFoundation/AVBase.h>
#import <AVFoundation/AVMediaFormat.h>
#import <AVFoundation/AVCaptureDevice.h>
+#import <AVFoundation/AVExternalSyncDevice.h>
#import <Foundation/Foundation.h>
#import <CoreMedia/CMFormatDescription.h>
#import <CoreMedia/CMSync.h>
@@ -281,7 +282,72 @@
*/
@property(nonatomic) CMTime videoMinFrameDurationOverride API_AVAILABLE(ios(13.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
+/// Indicates whether the device input supports locked frame durations.
+///
+/// See ``AVCaptureDeviceInput/activeLockedVideoFrameDuration`` for more information on video frame duration locking.
+@property(nonatomic, readonly, getter=isLockedVideoFrameDurationSupported) BOOL lockedVideoFrameDurationSupported API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+/// The receiver's locked frame duration (the reciprocal of its frame rate). Setting this property guarantees the intra-frame duration delivered by the device input is precisely the frame duration you request.
+///
+/// Set this property to run the receiver's associated ``AVCaptureDevice`` at precisely your provided frame rate (expressed as a duration). Query ``AVCaptureDevice/minSupportedLockedVideoFrameDuration`` to find the minimum value supported by this ``AVCaptureDeviceInput``. In order to disable locked video frame duration, set this property to `kCMTimeInvalid`. This property resets itself to `kCMTimeInvalid` when the receiver's attached ``AVCaptureDevice/activeFormat`` changes. When you set this property, its value is also reflected in the receiver's ``AVCaptureDevice/activeVideoMinFrameDuration`` and ``AVCaptureDevice/activeVideoMaxFrameDuration``.
+///
+/// - Note: Locked frame duration availability may change depending on the device configuration. For example, locked frame duration is unsupported when ``AVCaptureDevice/autoVideoFrameRateEnabled`` or ``AVCaptureMovieFileOutput/spatialVideoCaptureEnabled`` is set to `true`.
+///
+/// - Note: Only one ``AVCaptureDeviceInput`` added to an ``AVCaptureMultiCamSession`` can follow an external sync device or run at a locked frame duration.
+///
+/// - Note: Setting this property may cause a lengthy reconfiguration of the receiver, similar to setting ``AVCaptureDevice/activeFormat`` or ``AVCaptureSession/sessionPreset``.
+///
+/// - Important: If you set this property to a valid value while the receiver's ``AVCaptureDevice/minSupportedLockedVideoFrameDuration`` is `kCMTimeInvalid`, it throws an `NSInvalidArgumentException`.
+///
+/// - Important: If you set this property while the receiver's ``lockedVideoFrameDurationSupported`` property returns `false`, it throws an `NSInvalidArgumentException`.
+@property(nonatomic) CMTime activeLockedVideoFrameDuration API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+
+/// Indicates whether the device input supports being configured to follow an external sync device.
+///
+/// See ``AVCaptureDeviceInput/followExternalSyncDevice:videoFrameDuration:delegate:`` for more information on external sync.
+@property(nonatomic, readonly, getter=isExternalSyncSupported) BOOL externalSyncSupported API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Configures the the device input to follow an external sync device at the given frame duration.
+///
+/// - Parameter externalSyncDevice: The ``AVExternalSyncDevice`` hardware to follow.
+/// - Parameter videoFrameDuration: The frame duration to which the ``AVExternalSyncDevice`` is calibrated.
+/// - Parameter delegate: The delegate to notify when the connection status changes, or an error occurs.
+///
+/// Call this method to direct your ``AVCaptureDeviceInput`` to follow the external sync pulse from a sync device at the given frame duration.
+///
+/// Your provided `videoFrameDuration` value must match the sync pulse duration of the external sync device. If it does not, the request times out, the external sync device's status returns to ``AVExternalSyncDeviceStatusReady``, and your session stops running, posting a ``AVCaptureSessionRuntimeErrorNotification`` with ``AVErrorFollowExternalSyncDeviceTimedOut``.
+///
+/// The ability to follow an external sync device may change depending on the device configuration. For example, ``followExternalSyncDevice:videoFrameDuration:delegate:`` cannot be used when ``AVCaptureDevice/autoVideoFrameRateEnabled`` is `true`.
+///
+/// To stop following an external pulse, call ``unfollowExternalSyncDevice``. External sync device following is also disabled when your device's ``AVCaptureDeviceFormat`` changes.
+///
+/// Your provided delegate's ``AVExternalSyncDeviceDelegate/externalSyncDeviceStatusDidChange:`` method is called with a status of ``AVExternalSyncDeviceStatusReady`` if the external pulse signal is not close enough to the provided `videoFrameDuration` for successful calibration.
+///
+/// Once your ``AVExternalSyncDevice/status`` changes to ``AVExternalSyncDeviceStatusActiveSync``, your input's ``AVCaptureInput/activeExternalSyncVideoFrameDuration`` property reports the up-to-date frame duration. ``AVCaptureInput/activeExternalSyncVideoFrameDuration`` is also reflected in the ``AVCaptureDevice/activeVideoMinFrameDuration`` and ``AVCaptureDevice/activeVideoMaxFrameDuration`` of your input's associated device.
+///
+/// - Note: Calling this method may cause a lengthy reconfiguration of the receiver, similar to setting a new active format or ``AVCaptureSession/sessionPreset``.
+///
+/// - Important: Calling this method throws an `NSInvalidArgumentException` if ``AVCaptureDeviceInput/externalSyncSupported`` returns `false`.
+///
+/// - Important: The provided external sync device's ``status`` must be ``AVExternalSyncDeviceStatusReady`` when you call this method, otherwise an `NSInvalidArgumentException` is thrown.
+- (void)followExternalSyncDevice:(AVExternalSyncDevice *)externalSyncDevice videoFrameDuration:(CMTime)frameDuration delegate:(id <AVExternalSyncDeviceDelegate> _Nullable)delegate NS_SWIFT_NAME(follow(_:videoFrameDuration:delegate:)) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// The receiver's external sync frame duration (the reciprocal of its frame rate) when being driven by an external sync device.
+///
+/// Set up your input to follow an external sync device by calling ``followExternalSyncDevice:videoFrameDuration:delegate:``.
+/// - Note: The value of this readonly property is `kCMTimeInvalid` unless the ``AVExternalSyncDevice`` is actively driving the ``AVCaptureDeviceInput``. This is reflected by the ``AVExternalSyncDevice/status`` being either ``AVExternalSyncDeviceStatusActiveSync`` or ``AVExternalSyncDeviceStatusFreeRunSync``.
+@property(nonatomic, readonly) CMTime activeExternalSyncVideoFrameDuration API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// The external sync device currently being followed by this input.
+///
+/// This readonly property returns the ``AVExternalSyncDevice`` instance you provided in ``followExternalSyncDevice:videoFrameDuration:delegate:``. This property returns `nil` when an external sync device is disconnected or fails to calibrate.
+@property(nonatomic, readonly, nullable) AVExternalSyncDevice *externalSyncDevice API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Discontinues external sync.
+///
+/// This method stops your input from syncing to the external sync device you specified in ``followExternalSyncDevice:videoFrameDuration:delegate:``.
+- (void)unfollowExternalSyncDevice API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
/*!
@enum AVCaptureMultichannelAudioMode
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCapturePhotoOutput.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCapturePhotoOutput.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCapturePhotoOutput.h 2025-08-13 02:04:07
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCapturePhotoOutput.h 2025-08-26 23:37:25
@@ -113,7 +113,7 @@
- If the receiver's autoDeferredPhotoDeliveryEnabled is YES, your delegate must respond to -captureOutput:didFinishCapturingDeferredPhotoProxy:error:.
- The maxPhotoDimensions setting for 24MP (5712, 4284), when supported, is only serviced as 24MP via deferred photo delivery.
Color space rules:
- - Photo capture is not supported when AVCaptureDevice has selected AVCaptureColorSpace_AppleLog as color space.
+ - Photo capture is not supported when AVCaptureDevice has selected AVCaptureColorSpace_AppleLog or AVCaptureColorSpace_AppleLog2 as color space.
*/
- (void)capturePhotoWithSettings:(AVCapturePhotoSettings *)settings delegate:(id<AVCapturePhotoCaptureDelegate>)delegate;
@@ -794,6 +794,23 @@
*/
@property(nonatomic, readonly, getter=isShutterSoundSuppressionSupported) BOOL shutterSoundSuppressionSupported API_AVAILABLE(macos(15.0), ios(18.0), macCatalyst(18.0), tvos(18.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+/*!
+ @property cameraSensorOrientationCompensationSupported
+ @abstract
+ A read-only BOOL value indicating whether still image buffers may be rotated to match the sensor orientation of earlier generation hardware.
+ @discussion
+ Value is YES for camera configurations which support compensation for the sensor orientation, which is applied to HEIC, JPEG, and uncompressed processed photos only; compensation is never applied to Bayer RAW or Apple ProRaw captures.
+ */
+@property(nonatomic, readonly, getter=isCameraSensorOrientationCompensationSupported) BOOL cameraSensorOrientationCompensationSupported API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/*!
+ @property cameraSensorOrientationCompensationEnabled
+ @abstract
+ A BOOL value indicating that still image buffers will be rotated to match the sensor orientation of earlier generation hardware.
+ @discussion
+ Default is YES when cameraSensorOrientationCompensationSupported is YES. Set to NO if your app does not require sensor orientation compensation.
+ */
+@property(nonatomic, getter=isCameraSensorOrientationCompensationEnabled) BOOL cameraSensorOrientationCompensationEnabled API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
@end
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureStillImageOutput.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureStillImageOutput.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureStillImageOutput.h 2025-08-07 21:40:39
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureStillImageOutput.h 2025-08-26 23:30:12
@@ -108,6 +108,23 @@
*/
@property(nonatomic, getter=isHighResolutionStillImageOutputEnabled) BOOL highResolutionStillImageOutputEnabled API_AVAILABLE(macos(10.14), ios(8.0), macCatalyst(14.0)) API_UNAVAILABLE(visionos);
+/*!
+ @property cameraSensorOrientationCompensationSupported
+ @abstract
+ A read-only BOOL value indicating whether still image buffers may be rotated to match the sensor orientation of earlier generation hardware.
+ @discussion
+ Value is YES for camera configurations which support compensation for the sensor orientation, which is applied to HEIC, JPEG, and uncompressed processed photos only; compensation is never applied to Bayer RAW or Apple ProRaw captures.
+ */
+@property(nonatomic, readonly, getter=isCameraSensorOrientationCompensationSupported) BOOL cameraSensorOrientationCompensationSupported API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
+
+/*!
+ @property cameraSensorOrientationCompensationEnabled
+ @abstract
+ A BOOL value indicating that still image buffers will be rotated to match the sensor orientation of earlier generation hardware.
+ @discussion
+ Default is YES when cameraSensorOrientationCompensationSupported is YES. Set to NO if your app does not require sensor orientation compensation.
+ */
+@property(nonatomic, getter=isCameraSensorOrientationCompensationEnabled) BOOL cameraSensorOrientationCompensationEnabled API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos);
/*!
@property capturingStillImage
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureTimecodeGenerator.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureTimecodeGenerator.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureTimecodeGenerator.h 1969-12-31 19:00:00
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureTimecodeGenerator.h 2025-08-26 23:37:58
@@ -0,0 +1,223 @@
+#if !__has_include(<AVFCapture/AVCaptureTimecodeGenerator.h>)
+/*
+ File: AVCaptureTimecodeGenerator.h
+
+ Framework: AVFoundation
+
+ Copyright 2024-2025 Apple Inc. All rights reserved.
+*/
+
+#import <CoreMedia/CMSampleBuffer.h>
+#import <CoreMedia/CMTime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Defines possible sources for generating timecode in using a timecode generator.
+typedef NS_ENUM(NSInteger, AVCaptureTimecodeSourceType) {
+ /// No internal or external source is adopted. Timecodes are zero-based, sequentially generated frame counts.
+ AVCaptureTimecodeSourceTypeFrameCount NS_SWIFT_NAME(frameCount) = 0,
+ /// Synchronizes timecode to the system clock for real-time applications. Useful for live events or scenarios requiring alignment with the actual time of day.
+ AVCaptureTimecodeSourceTypeRealTimeClock NS_SWIFT_NAME(realTimeClock) = 1,
+ /// Synchronizes timecode to an external timecode data stream. Ideal for professional audio and video synchronization with external quarter-frame MIDI or HID timecode hardware.
+ AVCaptureTimecodeSourceTypeExternal NS_SWIFT_NAME(external) = 2,
+} NS_SWIFT_NAME(AVCaptureTimecode.SourceType) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Constants defining the synchronization status of a timecode generator .
+typedef NS_ENUM(NSInteger, AVCaptureTimecodeGeneratorSynchronizationStatus) {
+ /// The initial state before a source is selected or during error conditions.
+ AVCaptureTimecodeGeneratorSynchronizationStatusUnknown = 0,
+ /// A timecode source has been selected, but synchronization has not yet started.
+ AVCaptureTimecodeGeneratorSynchronizationStatusSourceSelected = 1,
+ /// The timecode generator is actively synchronizing to the selected source.
+ AVCaptureTimecodeGeneratorSynchronizationStatusSynchronizing = 2,
+ /// The timecode generator is successfully synchronized to the selected source, maintaining active timing alignment.
+ AVCaptureTimecodeGeneratorSynchronizationStatusSynchronized = 3,
+ /// The synchronization has timed out.
+ AVCaptureTimecodeGeneratorSynchronizationStatusTimedOut = 4,
+ /// The timecode generator has failed to establish a connection with a given source.
+ AVCaptureTimecodeGeneratorSynchronizationStatusSourceUnavailable = 5,
+ /// The timecode generator is receiving data from the source in an unrecognized format.
+ AVCaptureTimecodeGeneratorSynchronizationStatusSourceUnsupported = 6,
+ /// The timecode generator does not require active synchronization for a given source.
+ AVCaptureTimecodeGeneratorSynchronizationStatusNotRequired = 7
+} NS_SWIFT_NAME(AVCaptureTimecodeGenerator.SynchronizationStatus) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Describes a timecode source that a timecode generator can synchronize to.
+///
+/// `AVCaptureTimecodeSource` provides information about a specific timecode source available for synchronization in `AVCaptureTimecodeGenerator`. It includes metadata such as the source’s name, type, and unique identifier.
+NS_SWIFT_NAME(AVCaptureTimecode.Source)
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureTimecodeSource : NSObject <NSCopying>
+
+/// The name of the timecode source.
+///
+/// This property provides a descriptive name of the timecode source, useful for display in user interfaces or logging.
+@property (nonatomic, copy, readonly, nonnull) NSString *displayName;
+
+/// The type of timecode source.
+///
+/// Indicates the type of timecode source, represented as a value from the ``AVCaptureTimecodeSynchronizationSourceType`` enum. This helps you identify the source for specific synchronization use cases, such as frame counter, real-time clock, MIDI, or HID.
+@property (nonatomic, assign, readonly) AVCaptureTimecodeSourceType type;
+
+/// A unique identifier for the timecode source.
+///
+/// The UUID uniquely identifies this timecode source. It is particularly useful when multiple sources of the same type are available, allowing your application to distinguish between them.
+///
+/// - Note: This value does not persist across application sessions.
+@property (nonatomic, copy, readonly) NSUUID *uuid;
+
+@end
+
+/// This structure represents a timecode, adhering to SMPTE standards, which define precise time information and associated timestamps for video or audio synchronization.
+///
+/// This structure corresponds to the SMPTE 12M-1 Linear Timecode (LTC) format, widely used for professional video and audio synchronization.
+typedef struct {
+ /// Time component representing the current timecode in hours.
+ uint8_t hours;
+ /// Time component representing the current timecode in minutes.
+ uint8_t minutes;
+ /// Time component representing the current timecode in seconds.
+ uint8_t seconds;
+ /// Frame component of the timecode, indicating the frame count within the second.
+ uint8_t frames;
+ /// A 32-bit field carrying SMPTE user bits, which are not strictly standardized. User bits are often used for additional metadata such as scene-take information, reel numbers, or dates, but their exact usage is application-dependent.
+ uint32_t userBits;
+ /// Frame duration of the timecode. If unknown, the value is `kCMTimeInvalid`.
+ CMTime frameDuration;
+ /// Source type of the timecode, indicating the emitter, carriage, or transport mechanism.
+ AVCaptureTimecodeSourceType sourceType API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+} AVCaptureTimecode API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Creates a sample buffer containing Timecode Media Description metadata for integration with a video track.
+///
+/// - Parameter timecode: The ``AVCaptureTimecode`` instance providing the timecode details to encode.
+/// - Parameter presentationTimeStamp: The presentation time stamp that determines the exact moment in the media timeline where the metadata should be applied. It is embedded in the sample timing info (``CMSampleTimingInfo``) and ensures that the packaged metadata synchronizes accurately with the corresponding video frame.
+/// - Returns: A ``CMSampleBufferRef`` with the encoded Timecode Media Description metadata for video synchronization, or `nil` if sample buffer creation fails.
+CMSampleBufferRef _Nullable AVCaptureTimecodeCreateMetadataSampleBufferAssociatedWithPresentationTimeStamp(AVCaptureTimecode timecode, CMTime presentationTimeStamp) NS_SWIFT_NAME(AVCaptureTimecode.createMetadataSampleBuffer(from:associatedWithPresentationTimeStamp:)) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Creates a sample buffer containing Timecode Media Description metadata for a specified duration.
+///
+/// - Parameter timecode: The ``AVCaptureTimecode`` instance providing the timecode details for the metadata sample.
+/// - Parameter duration: The duration that the metadata sample buffer should represent.
+/// - Returns: A ``CMSampleBufferRef`` with encoded Timecode Media Description metadata for the given duration, or `nil` if sample buffer creation fails.
+///
+/// Use this function for scenarios where timecode metadata needs to span a custom interval (not just a single frame), such as non-frame-accurate workflows or for describing a segment of media with a consistent timecode.
+CMSampleBufferRef _Nullable AVCaptureTimecodeCreateMetadataSampleBufferForDuration(AVCaptureTimecode timecode, CMTime duration) NS_SWIFT_NAME(AVCaptureTimecode.createMetadataSampleBuffer(from:forDuration:)) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// Generates a new timecode by adding a specified number of frames to the given timecode, handling overflow for seconds, minutes, and hours.
+///
+/// - Parameter timecode: The original ``AVCaptureTimecode`` to be incremented.
+/// - Parameter framesToAdd: The number of frames to add to the timecode.
+/// - Returns: A new ``AVCaptureTimecode`` struct with the updated time values after adding the specified frames.
+AVCaptureTimecode AVCaptureTimecodeAdvancedByFrames(AVCaptureTimecode timecode, int64_t framesToAdd) NS_SWIFT_NAME(AVCaptureTimecode.advanced(_:by:)) API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+@class AVCaptureTimecodeGenerator;
+
+/// A protocol for receiving real-time timecode updates and error notifications from a timecode generator.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@protocol AVCaptureTimecodeGeneratorDelegate <NSObject>
+
+@required
+
+/// Notifies the delegate when new, unaligned timecodes are parsed from the specified source.
+///
+/// - Parameter generator: The timecode generator providing the update.
+/// - Parameter timecode: The updated timecode data.
+/// - Parameter source: The source from which the timecode was received.
+- (void)timecodeGenerator:(AVCaptureTimecodeGenerator *)generator didReceiveUpdate:(AVCaptureTimecode)timecode fromSource:(AVCaptureTimecodeSource *)source;
+
+/// Notifies the delegate when the synchronization status of a timecode source changes.
+///
+/// - Parameter generator: The ``AVCaptureTimecodeGenerator`` instance providing the status update.
+/// - Parameter synchronizationStatus: The updated synchronization state.
+/// - Parameter source: The internal or external source to which the generator synchronizes.
+- (void)timecodeGenerator:(AVCaptureTimecodeGenerator *)generator transitionedToSynchronizationStatus:(AVCaptureTimecodeGeneratorSynchronizationStatus)synchronizationStatus forSource:(AVCaptureTimecodeSource *)source;
+
+/// Notifies the delegate when the list of available timecode synchronization sources is updated.
+///
+/// - Parameter generator: The ``AVCaptureTimecodeGenerator`` instance providing the source list update.
+/// - Parameter availableSources: An array of ``AVCaptureTimecodeSource`` objects representing the available timecode synchronization sources.
+- (void)timecodeGenerator:(AVCaptureTimecodeGenerator *)generator didUpdateAvailableSources:(NSArray<AVCaptureTimecodeSource *> *)availableSources;
+
+@end
+
+/// Generates and synchronizes timecode data from various sources for precise video and audio synchronization.
+///
+/// The ``AVCaptureTimecodeGenerator`` class supports multiple timecode sources, including frame counting, system clock synchronization, and MIDI timecode input (MTC). Suitable for playback, recording, or other time-sensitive operations where precise timecode metadata is required.
+///
+/// Use the ``startSynchronizationWithTimecodeSource:`` method to set up the desired timecode source.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@interface AVCaptureTimecodeGenerator : NSObject
+
+/// An array of available timecode synchronization sources that can be used by the timecode generator.
+///
+/// This property provides a list of ``AVCaptureTimecodeSource`` objects representing the available timecode sources with which the generator can synchronize. The sources may include built-in options such as the frame counter and real-time clock, as well as dynamically detected sources such as connected MIDI or HID devices.
+///
+/// This array is key-value observable, allowing you to monitor changes in real-time. For example, when a new MIDI device is connected, the array is updated to include the corresponding timecode source.
+///
+/// - Returns: A read-only array of ``AVCaptureTimecodeSource`` objects representing the available timecode synchronization sources.
+@property(atomic, copy, readonly) NSArray<AVCaptureTimecodeSource *> *availableSources;
+
+/// The active timecode source used by ``AVCaptureTimecodeGenerator`` to maintain clock synchronization for accurate timecode generation.
+///
+/// Indicates the active timecode source, as defined in the ``AVCaptureTimecodeSynchronizationSourceType`` enum. If an ``AVCaptureTimecodeGenerator`` becomes disconnected from its source, it continues generating timecodes using historical data from its ring buffer. This approach allows the generator to maintain synchronization during brief disruptions, as is common in cinema workflows where timecode signals may experience discontinuities.
+@property(nonatomic, readonly) AVCaptureTimecodeSource *currentSource;
+
+/// The delegate that receives timecode updates from the timecode generator.
+///
+/// You can use your ``delegate`` to receive real-time timecode updates. Implement the ``timecodeGenerator:didReceiveUpdate:`` method in your delegate to handle updates.
+@property(nonatomic, readonly, nullable) id<AVCaptureTimecodeGeneratorDelegate> delegate;
+
+/// The dispatch queue on which delegate callbacks are invoked.
+///
+/// Provides the queue set in ``setDelegate:queue:``. If no delegate is assigned, this property is `nil`.
+@property(nonatomic, readonly, nullable) dispatch_queue_t delegateCallbackQueue;
+
+/// Assigns a delegate to receive real-time timecode updates and specifies a queue for callbacks.
+///
+/// - Parameter delegate: An object conforming to the ``AVCaptureTimecodeGeneratorDelegate`` protocol.
+/// - Parameter callbackQueue: The dispatch queue on which the delegate methods are invoked. The `callbackQueue` parameter may not be `nil`, except when setting the ``AVCaptureTimecodeGeneratorDelegate`` to `nil`, otherwise ``setDelegate:queue:`` throws an `NSInvalidArgumentException`.
+///
+/// Use this method to configure a delegate that handles timecode updates. The specified `queue` ensures thread-safe invocation of delegate methods.
+- (void)setDelegate:(nullable id<AVCaptureTimecodeGeneratorDelegate>)delegate queue:(nullable dispatch_queue_t)callbackQueue;
+
+/// The maximum time interval allowed for source synchronization attempts before timing out.
+///
+/// This property specifies the duration, in seconds, that the ``AVCaptureTimecodeGenerator`` will attempt to synchronize with a timecode source before timing out if synchronization cannot be achieved. If this threshold is exceeded, the synchronization status updates to reflect a timeout, and your ``AVCaptureTimecodeGeneratorDelegate/timecodeGenerator:transitionedToSynchronizationStatus:forSource:`` delegate method fires, informing you of the event. The default value is 15 seconds.
+@property(nonatomic) NSTimeInterval synchronizationTimeout;
+
+/// The time offset, in seconds, applied to the generated timecode.
+///
+/// This offset allows fine-tuning of time alignment for synchronization with external sources or to accommodate any intentional delay. The default value is 0 seconds.
+@property(nonatomic) NSTimeInterval timecodeAlignmentOffset;
+
+/// The frame duration that the generator will use to generate timecodes.
+@property(nonatomic) CMTime timecodeFrameDuration;
+
+/// Synchronizes the generator with the specified timecode source.
+///
+/// - Parameter source: The timecode source for synchronization.
+- (void)startSynchronizationWithTimecodeSource:(AVCaptureTimecodeSource *)source NS_SWIFT_NAME(startSynchronization(source:));
+
+/// Generates an initial timecode intended to be the first in a sequence.
+///
+/// - Returns: A populated ``AVCaptureTimecode`` structure.
+- (AVCaptureTimecode)generateInitialTimecode;
+
+/// A frame counter timecode source that operates independently of any internal or external synchronization.
+///
+/// This class property represents a standalone timecode source that advances based purely on frame count, independent of any real-time or external synchronization. It is ideal for scenarios where a simple, self-contained timing reference is sufficient, without requiring alignment to system clocks or external devices.
+@property(class, nonatomic, readonly) AVCaptureTimecodeSource *frameCountSource;
+
+/// A predefined timecode source synchronized to the real-time system clock.
+///
+/// This class property provides a default timecode source based on the real-time system clock, requiring no external device. It is ideal for live events or scenarios where alignment with the current time of day is necessary.
+@property(class, nonatomic, readonly) AVCaptureTimecodeSource *realTimeClockSource;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#else
+#import <AVFCapture/AVCaptureTimecodeGenerator.h>
+#endif
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureVideoDataOutput.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureVideoDataOutput.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureVideoDataOutput.h 2025-08-04 04:25:00
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVCaptureVideoDataOutput.h 2025-08-03 01:17:18
@@ -183,6 +183,20 @@
*/
- (nullable NSDictionary<NSString *, id> *)recommendedVideoSettingsForVideoCodecType:(AVVideoCodecType)videoCodecType assetWriterOutputFileType:(AVFileType)outputFileType outputFileURL:(nullable NSURL *)outputFileURL API_AVAILABLE(macos(14.0), ios(17.0), macCatalyst(17.0), tvos(17.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+/// Recommends movie-level metadata for a particular video codec type and output file type, to be used with an asset writer input.
+///
+/// - Parameter videoCodecType: The desired ``AVVideoCodecKey`` to be used for compression (see <doc://com.apple.documentation/documentation/avfoundation/video-settings>).
+/// - Parameter outputFileType: Specifies the UTI of the file type to be written (see <doc://com.apple.documentation/documentation/avfoundation/avfiletype>).
+/// - Returns: A fully populated array of ``AVMetadataItem`` objects compatible with ``AVAssetWriter``.
+///
+/// The value of this property is an array of ``AVMetadataItem`` objects representing the collection of top-level metadata to be written in each output file. This array is suitable to use as the ``AVAssetWriter/metadata`` property before you have called ``AVAssetWriter/startWriting``. For more details see <doc://com.apple.documentation/documentation/avfoundation/avassetwriter/startwriting()>.
+///
+/// The ``videoCodecType`` string you provide must be present in ``availableVideoCodecTypesForAssetWriterWithOutputFileType:`` array, or an `NSInvalidArgumentException` is thrown.
+///
+/// For clients writing files using a ProRes Raw codec type, white balance must be locked (call ``AVCaptureDevice/setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains:completionHandler:``) before querying this property, or an `NSIvalidArgumentException` is thrown.
+///
+/// - Note: The array of metadata is dependent on the current configuration of the receiver's ``AVCaptureSession`` and its inputs. The array may change when the session's configuration changes. As such, you should configure and start your session first, then query this method.
+- (nullable NSArray<AVMetadataItem *> *)recommendedMovieMetadataForVideoCodecType:(AVVideoCodecType)videoCodecType assetWriterOutputFileType:(AVFileType)outputFileType API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
/// Indicates the recommended media timescale for the video track.
///
@@ -243,9 +257,11 @@
@property deliversPreviewSizedOutputBuffers
@abstract
Indicates whether the receiver is currently configured to deliver preview sized buffers.
-
+
@discussion
If you wish to manually set deliversPreviewSizedOutputBuffers, you must first set automaticallyConfiguresOutputBufferDimensions to NO. When deliversPreviewSizedOutputBuffers is set to YES, auto focus, exposure, and white balance changes are quicker. AVCaptureVideoDataOutput assumes that the buffers are being used for on-screen preview rather than recording.
+
+ When AVCaptureDevice.activeFormat supports ProRes Raw video, setting deliversPreviewSizedOutputBuffers gives out buffers with 422 format that can be used for proxy video recording.
*/
@property(nonatomic) BOOL deliversPreviewSizedOutputBuffers API_AVAILABLE(ios(13.0), macCatalyst(14.0), tvos(17.0)) API_UNAVAILABLE(macos, visionos) API_UNAVAILABLE(watchos);
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVError.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVError.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVError.h 2025-08-04 04:58:40
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVError.h 2025-08-14 00:02:56
@@ -124,6 +124,9 @@
AVErrorMediaExtensionConflict API_AVAILABLE(macos(15.0)) API_UNAVAILABLE(ios, tvos, watchos, visionos) = -11887,
AVErrorContentKeyRequestPlaybackDestinationDoesNotSupportDeviceIdentifierRandomization API_UNAVAILABLE(macos, ios, tvos, watchos, visionos) = -11888,
AVErrorContentKeyInvalid API_UNAVAILABLE(macos, ios, tvos, watchos, visionos) = -11889,
+ AVErrorNoSmartFramingsEnabled API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, visionos) API_UNAVAILABLE(watchos) = -11890,
+ AVErrorAutoWhiteBalanceNotLocked API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, watchos, visionos) = -11891,
+ AVErrorFollowExternalSyncDeviceTimedOut API_AVAILABLE(ios(26.0)) API_UNAVAILABLE(macos, macCatalyst, tvos, watchos, visionos) = -11892,
};
#else
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVExternalSyncDevice.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVExternalSyncDevice.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVExternalSyncDevice.h 1969-12-31 19:00:00
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVExternalSyncDevice.h 2025-08-04 00:16:24
@@ -0,0 +1,116 @@
+#if !__has_include(<AVFCapture/AVExternalSyncDevice.h>)
+/*
+ File: AVExternalSyncDevice.h
+
+ Framework: AVFoundation
+
+ Copyright 2024-2025 Apple, Inc. All rights reserved.
+
+*/
+
+#import <AVFoundation/AVBase.h>
+#import <Foundation/Foundation.h>
+#import <CoreMedia/CMSync.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Connection state of an external sync device
+typedef NS_ENUM( NSInteger, AVExternalSyncDeviceStatus ) {
+ /// Indicates that external sync signal is not connected, or has transitioned to a state that is not recoverable.
+ AVExternalSyncDeviceStatusUnavailable = 0,
+ /// Indicates that a device supporting external sync is connected, but calibration has not started.
+ AVExternalSyncDeviceStatusReady = 1,
+ /// Indicates that the external sync signal is connected and that the AVExternalSyncDevice object is calibrating to follow.
+ AVExternalSyncDeviceStatusCalibrating = 2,
+ /// Indicates that the ``AVExternalSyncDevice`` object is running and that the clock property on ``AVExternalSyncDevice`` is calibrated to the external sync signal.
+ AVExternalSyncDeviceStatusActiveSync = 3,
+ /// Indicates that the AVExternalSyncDevice was calibrated to follow the external sync, but the sync signal has been lost. The camera will continue to match the last signal it received, but sync is not guaranteed.
+ AVExternalSyncDeviceStatusFreeRunSync = 4,
+} API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos);
+
+/// An external sync device connected to a host device that can be used to drive the timing of an internal component, such as a camera sensor.
+///
+/// Each instance of ``AVExternalSyncDevice`` corresponds to a physical external device that can drive an internal component, like a camera readout. You cannot create instances of ``AVExternalSyncDevice``. Instead, you obtain an array of all currently available external sync devices using ``AVExternalSyncDeviceDiscoverySession``.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@interface AVExternalSyncDevice : NSObject
+
+AV_INIT_UNAVAILABLE
+
+/// The status of the externally connected device.
+///
+/// Use this property to query the current connection status of the external sync device. This property is key-value observable.
+@property(nonatomic, readonly) AVExternalSyncDeviceStatus status;
+
+/// A clock representing the source of time from the external sync device.
+///
+/// This property returns `NULL` until the ``status`` reaches ``AVExternalSyncDeviceStatusActiveSync``.
+@property(nonatomic, readonly, nullable) __attribute__((NSObject)) CMClockRef clock;
+
+/// Delay to wait before starting the frame capture.
+///
+/// An external sync is generally used to configure multiple devices in the real world. A display and a camera may receive a signal at the same time, but that does not mean the refresh of the display and camera are aligned in a way that does not cause tearing in the recording. The signal compensation delay can be used to offset the readout of a camera on an intra-frame scale.
+///
+/// - Important: You should always set this property to a value less than the frame duration at which the camera is operating.
+@property(nonatomic) CMTime signalCompensationDelay;
+
+/// A unique identifier for an external sync device.
+///
+/// Use this property to select a specific external sync device.
+@property(nonatomic, readonly) NSUUID *uuid;
+
+/// The USB vendor identifier associated with the external sync device.
+///
+/// This `UInt32` value is provided by the hardware vendor, and returns 0 if not available.
+@property(nonatomic, readonly) UInt32 vendorID;
+
+/// The USB product identifier associated with the external sync device.
+///
+/// This `UInt32` value comes from the hardware vendor, and returns 0 if not available. Use this value in conjunction with the ``vendorID`` to determine a specific product.
+@property(nonatomic, readonly) UInt32 productID;
+
+@end
+
+/// A means of discovering and monitoring connection / disconnection of external sync devices to the host.
+///
+/// ``AVExternalSyncDeviceDiscoverySession`` is a singleton that lists the external sync devices connected to the host. The client is expected to key-value observe the ``AVExternalSyncDeviceDiscoverySession/devices`` property for changes to the external sync devices list.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+NS_SWIFT_NAME(AVExternalSyncDevice.DiscoverySession)
+@interface AVExternalSyncDeviceDiscoverySession : NSObject
+
+AV_INIT_UNAVAILABLE
+
+/// The singleton instance of the external sync source device discovery session.
+///
+/// Access the one and only external sync device discovery session on this host device using this method. ``sharedSession`` returns `nil` if the host device doesn't support external sync devices.
+@property(class, readonly, nullable) AVExternalSyncDeviceDiscoverySession *sharedSession;
+
+/// Whether external sync devices are supported by this device.
+///
+/// A value of `true` indicates that external sync devices are supported while `false` indicates they are not.
+@property(class, readonly, getter=isSupported) BOOL supported;
+
+/// An array of external sync devices connected to this host.
+///
+/// The list is updated when external sync devices are connected to the host and they remain in the list until they become unavailable. This property is key-value observable.
+@property(readonly) NSArray<AVExternalSyncDevice *> *devices;
+
+@end
+
+/// Defines an interface for delegates of ``AVCaptureDeviceInput`` to respond to events that occur when connecting, calibrating, and disconnecting external sync devices.
+API_AVAILABLE(macos(26.0), ios(26.0), macCatalyst(26.0), tvos(26.0)) API_UNAVAILABLE(visionos) API_UNAVAILABLE(watchos)
+@protocol AVExternalSyncDeviceDelegate <NSObject>
+
+@optional
+/// Informs your delegate when the external sync device status has changed.
+- (void)externalSyncDeviceStatusDidChange:(AVExternalSyncDevice *)device;
+
+// Informs your delegate when the external sync device has encountered an error.
+- (void)externalSyncDevice:(AVExternalSyncDevice *)device failedWithError:(nullable NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#else
+#import <AVFCapture/AVExternalSyncDevice.h>
+#endif
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVFCapture.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVFCapture.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVFCapture.h 2025-08-13 02:04:05
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVFCapture.h 2025-08-26 23:30:11
@@ -16,6 +16,7 @@
#import <AVFoundation/AVCaptureDepthDataOutput.h>
#import <AVFoundation/AVCaptureDeskViewApplication.h>
#import <AVFoundation/AVCaptureDevice.h>
+#import <AVFoundation/AVCaptureExternalDisplayConfigurator.h>
#import <AVFoundation/AVCaptureFileOutput.h>
#import <AVFoundation/AVCaptureIndexPicker.h>
#import <AVFoundation/AVCaptureInput.h>
@@ -31,11 +32,13 @@
#import <AVFoundation/AVCaptureSystemExposureBiasSlider.h>
#import <AVFoundation/AVCaptureSystemPressure.h>
#import <AVFoundation/AVCaptureSystemZoomSlider.h>
+#import <AVFoundation/AVCaptureTimecodeGenerator.h>
#import <AVFoundation/AVCaptureVideoDataOutput.h>
#import <AVFoundation/AVCaptureVideoPreviewLayer.h>
#import <AVFoundation/AVContinuityDevice.h>
#import <AVFoundation/AVDepthData.h>
#import <AVFoundation/AVExternalStorageDevice.h>
+#import <AVFoundation/AVExternalSyncDevice.h>
#import <AVFoundation/AVMetadataObject.h>
#import <AVFoundation/AVPortraitEffectsMatte.h>
#import <AVFoundation/AVSemanticSegmentationMatte.h>
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataFormat.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataFormat.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataFormat.h 2025-08-04 04:58:41
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataFormat.h 2025-08-18 23:31:58
@@ -178,6 +178,30 @@
AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCinematicVideoIntent API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the sensitivity of the camera to light in terms of ISO exposure index (e.g. "800"). See SMPTE RDD 18.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCameraISOSensitivity API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the white balance value defined by the temperature in Kelvin units (e.g. "5500K" or "5500"). See SMPTE RDD 18.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCameraWhiteBalance API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_RawData indicating the reference white balance multiplication factor data for ProRes RAW.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyWhiteBalanceByCCTWhiteBalanceFactors API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_RawData indicating the reference color translation matrix data for ProRes RAW.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyWhiteBalanceByCCTColorMatrices API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the exposure period expressed as an angle in minutes (1/60 degree) (e.g. "21600" or "360.00deg"").
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCameraShutterSpeedAngle API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the exposure period expressed as a time per one frame/field period in seconds.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCameraShutterSpeedTime API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating measure of the amount of light transmitted through the lens. It is the focal length divided by the effective lens aperture diameter (e.g. "F2.8" or "2.8").
+///
+/// This is track-level metadata for video track that is associated with the camera.
+AVF_EXPORT AVMetadataKey const AVMetadataQuickTimeMetadataKeyCameraLensIrisFNumber API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+
/// A value of type kCMMetadataBaseDataType_UTF8 indicating the lens model (e.g. "iPhone 16 Pro back camera 6.765mm f/1.78").
///
/// This is track-level metadata for video track that is associated with the camera.
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataIdentifiers.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataIdentifiers.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataIdentifiers.h 2025-08-04 04:23:16
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVMetadataIdentifiers.h 2025-08-14 00:02:58
@@ -164,6 +164,30 @@
AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCinematicVideoIntent API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the sensitivity of the camera to light in terms of ISO exposure index (e.g. "800"). See SMPTE RDD 18.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCameraISOSensitivity API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the white balance value defined by the temperature in Kelvin units (e.g. "5500K" or "5500"). See SMPTE RDD 18.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCameraWhiteBalance API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_RawData indicating the reference white balance multiplication factor data for ProRes RAW.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataWhiteBalanceByCCTWhiteBalanceFactors API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_RawData indicating the reference color translation matrix data for ProRes RAW.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataWhiteBalanceByCCTColorMatrices API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the exposure period expressed as an angle in minutes (1/60 degree) (e.g. "21600" or "360.00deg"").
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCameraShutterSpeedAngle API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating the exposure period expressed as a time per one frame/field period in seconds.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCameraShutterSpeedTime API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+/// A value of type kCMMetadataBaseDataType_UTF8 indicating measure of the amount of light transmitted through the lens. It is the focal length divided by the effective lens aperture diameter (e.g. "F2.8" or "2.8").
+///
+/// This is track-level metadata for video track that is associated with the camera.
+AVF_EXPORT AVMetadataIdentifier const AVMetadataIdentifierQuickTimeMetadataCameraLensIrisFNumber API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0), watchos(26.0), visionos(26.0));
+
+
/// A value of type kCMMetadataBaseDataType_UTF8 indicating the lens model (e.g. "iPhone 16 Pro back camera 6.765mm f/1.78").
///
/// This is track-level metadata for video track that is associated with the camera.
diff -ruN /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVVideoSettings.h /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVVideoSettings.h
--- /Applications/Xcode_26.0.0-beta7.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVVideoSettings.h 2025-08-08 03:31:58
+++ /Applications/Xcode_26.0.0-rc.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/AVFoundation.framework/Headers/AVVideoSettings.h 2025-08-03 00:35:52
@@ -58,6 +58,8 @@
AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeAppleProRes422HQ /* @"apch" */ API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0)) API_UNAVAILABLE(watchos) API_UNAVAILABLE(visionos);
AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeAppleProRes422LT /* @"apcs" */ API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0)) API_UNAVAILABLE(watchos) API_UNAVAILABLE(visionos);
AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeAppleProRes422Proxy /* @"apco" */ API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0)) API_UNAVAILABLE(watchos) API_UNAVAILABLE(visionos);
+ AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeAppleProResRAW /* @"aprn" */ API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0)) API_UNAVAILABLE(watchos) API_UNAVAILABLE(visionos) NS_SWIFT_NAME(proResRAW);
+ AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeAppleProResRAWHQ /* @"aprh" */ API_AVAILABLE(macos(26.0), ios(26.0), tvos(26.0)) API_UNAVAILABLE(watchos) API_UNAVAILABLE(visionos) NS_SWIFT_NAME(proResRAWHQ);
/* IMPORTANT NOTE: this constant is used to select the appropriate encoder, but is NOT used on the encoded content, which is backwards compatible and hence uses 'hvc1' as its codec type. */
AVF_EXPORT AVVideoCodecType const AVVideoCodecTypeHEVCWithAlpha /* @"muxa" */ API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0), visionos(1.0)) API_UNAVAILABLE(watchos);