Documentation Archive Developer
Search

AVFoundation Changes for Swift

AVFoundation

Removed AVAssetReferenceRestrictions.init(_: UInt)
Removed AVAudioEnvironmentNode.applicableRenderingAlgorithms() -> [AnyObject]!
Removed AVAudioPlayerNodeBufferOptions.init(_: UInt)
Removed AVCaptureDeviceInput.deviceInputWithDevice(_: AVCaptureDevice!, error: NSErrorPointer) -> AnyObject! [class]
Removed AVCaptureVideoPreviewLayer.layerWithSession(_: AVCaptureSession!) -> AnyObject! [class]
Removed AVCaptureVideoPreviewLayer.layerWithSessionWithNoConnection(_: AVCaptureSession!) -> AnyObject! [class]
Removed AVPlayer.playerWithPlayerItem(_: AVPlayerItem!) -> AnyObject! [class]
Removed AVPlayer.playerWithURL(_: NSURL!) -> AnyObject! [class]
Removed AVQueuePlayer.queuePlayerWithItems(_: [AnyObject]!) -> AnyObject! [class]
Added AVAudioConverterPrimeInfo.init()
Added AVAudioConverterPrimeInfo.init(leadingFrames: AVAudioFrameCount, trailingFrames: AVAudioFrameCount)
Added AVMovieWritingOptions.init(rawValue: UInt)
Added AVMusicSequenceLoadOptions.init(rawValue: UInt)
Modified AVAsset
Declaration
From
class AVAsset : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    class func assetWithURL(_ URL: NSURL!) -> AnyObject!
    var duration: CMTime { get }
    var preferredRate: Float { get }
    var preferredVolume: Float { get }
    var preferredTransform: CGAffineTransform { get }
    var naturalSize: CGSize { get }
}
extension AVAsset {
    var providesPreciseDurationAndTiming: Bool { get }
    func cancelLoading()
}
extension AVAsset {
    var referenceRestrictions: AVAssetReferenceRestrictions { get }
}
extension AVAsset {
    var tracks: [AnyObject]! { get }
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack!
    func tracksWithMediaType(_ mediaType: String!) -> [AnyObject]!
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String!) -> [AnyObject]!
    var trackGroups: [AnyObject]! { get }
}
extension AVAsset {
    var creationDate: AVMetadataItem! { get }
    var lyrics: String! { get }
    var commonMetadata: [AnyObject]! { get }
    var metadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
}
extension AVAsset {
    var availableChapterLocales: [AnyObject]! { get }
    func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale!, containingItemsWithCommonKeys commonKeys: [AnyObject]!) -> [AnyObject]!
    func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [AnyObject]!) -> [AnyObject]!
}
extension AVAsset {
    var availableMediaCharacteristicsWithMediaSelectionOptions: [AnyObject]! { get }
    func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVMediaSelectionGroup!
}
extension AVAsset {
    var hasProtectedContent: Bool { get }
}
extension AVAsset {
    var playable: Bool { get }
    var exportable: Bool { get }
    var readable: Bool { get }
    var composable: Bool { get }
}
extension AVAsset {
    func unusedTrackID() -> CMPersistentTrackID
}
To
class AVAsset : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    convenience init(URL URL: NSURL)
    class func assetWithURL(_ URL: NSURL) -> Self
    var duration: CMTime { get }
    var preferredRate: Float { get }
    var preferredVolume: Float { get }
    var preferredTransform: CGAffineTransform { get }
    var naturalSize: CGSize { get }
}
extension AVAsset {
    var providesPreciseDurationAndTiming: Bool { get }
    func cancelLoading()
}
extension AVAsset {
    var referenceRestrictions: AVAssetReferenceRestrictions { get }
}
extension AVAsset {
    var tracks: [AVAssetTrack] { get }
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVAssetTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVAssetTrack]
    var trackGroups: [AVAssetTrackGroup] { get }
}
extension AVAsset {
    var creationDate: AVMetadataItem? { get }
    var lyrics: String? { get }
    var commonMetadata: [AVMetadataItem] { get }
    var metadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
}
extension AVAsset {
    var availableChapterLocales: [NSLocale] { get }
    func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale, containingItemsWithCommonKeys commonKeys: [String]?) -> [AVTimedMetadataGroup]
    func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [String]) -> [AVTimedMetadataGroup]
}
extension AVAsset {
    var availableMediaCharacteristicsWithMediaSelectionOptions: [String] { get }
    func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String) -> AVMediaSelectionGroup?
    var preferredMediaSelection: AVMediaSelection { get }
}
extension AVAsset {
    var hasProtectedContent: Bool { get }
}
extension AVAsset {
    var canContainFragments: Bool { get }
    var containsFragments: Bool { get }
}
extension AVAsset {
    var playable: Bool { get }
    var exportable: Bool { get }
    var readable: Bool { get }
    var composable: Bool { get }
    var compatibleWithAirPlayVideo: Bool { get }
}
extension AVAsset {
    func unusedTrackID() -> CMPersistentTrackID
}

Declaration
From
var availableChapterLocales: [AnyObject]! { get }
To
var availableChapterLocales: [NSLocale] { get }

Declaration
From
var availableMediaCharacteristicsWithMediaSelectionOptions: [AnyObject]! { get }
To
var availableMediaCharacteristicsWithMediaSelectionOptions: [String] { get }

Declaration
From
var availableMetadataFormats: [AnyObject]! { get }
To
var availableMetadataFormats: [String] { get }

Declaration
From
func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [AnyObject]!) -> [AnyObject]!
To
func chapterMetadataGroupsBestMatchingPreferredLanguages(_ preferredLanguages: [String]) -> [AVTimedMetadataGroup]

Declaration
From
func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale!, containingItemsWithCommonKeys commonKeys: [AnyObject]!) -> [AnyObject]!
To
func chapterMetadataGroupsWithTitleLocale(_ locale: NSLocale, containingItemsWithCommonKeys commonKeys: [String]?) -> [AVTimedMetadataGroup]

Declaration
From
var commonMetadata: [AnyObject]! { get }
To
var commonMetadata: [AVMetadataItem] { get }

Declaration
From
var creationDate: AVMetadataItem! { get }
To
var creationDate: AVMetadataItem? { get }

NameDeclarationIntroduction
FromassetWithURL(_:)
class func assetWithURL(_ URL: NSURL!) -> AnyObject!
OS X 10.10
Toinit(URL:)
convenience init(URL URL: NSURL)
OS X 10.11

Declaration
From
var lyrics: String! { get }
To
var lyrics: String? { get }

Declaration
From
func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVMediaSelectionGroup!
To
func mediaSelectionGroupForMediaCharacteristic(_ mediaCharacteristic: String) -> AVMediaSelectionGroup?

Declaration
From
var metadata: [AnyObject]! { get }
To
var metadata: [AVMetadataItem] { get }

Declaration
From
func metadataForFormat(_ format: String!) -> [AnyObject]!
To
func metadataForFormat(_ format: String) -> [AVMetadataItem]

Declaration
From
var trackGroups: [AnyObject]! { get }
To
var trackGroups: [AVAssetTrackGroup] { get }

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVAssetTrack] { get }

Declaration
From
func tracksWithMediaCharacteristic(_ mediaCharacteristic: String!) -> [AnyObject]!
To
func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVAssetTrack]

Declaration
From
func tracksWithMediaType(_ mediaType: String!) -> [AnyObject]!
To
func tracksWithMediaType(_ mediaType: String) -> [AVAssetTrack]

Declaration
From
func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack!
To
func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVAssetTrack?

Declaration
From
class AVAssetExportSession : NSObject {
    class func allExportPresets() -> [AnyObject]!
    class func exportPresetsCompatibleWithAsset(_ asset: AVAsset!) -> [AnyObject]!
    class func determineCompatibilityOfExportPreset(_ presetName: String!, withAsset asset: AVAsset!, outputFileType outputFileType: String!, completionHandler handler: ((Bool) -> Void)!)
    init!(asset asset: AVAsset!, presetName presetName: String!) -> AVAssetExportSession
    class func exportSessionWithAsset(_ asset: AVAsset!, presetName presetName: String!) -> AVAssetExportSession!
    init!(asset asset: AVAsset!, presetName presetName: String!)
    var presetName: String! { get }
    var asset: AVAsset! { get }
    var supportedFileTypes: [AnyObject]! { get }
    var outputFileType: String!
    @NSCopying var outputURL: NSURL!
    var status: AVAssetExportSessionStatus { get }
    var error: NSError! { get }
    var progress: Float { get }
    var estimatedOutputFileLength: Int64 { get }
    var timeRange: CMTimeRange
    var metadata: [AnyObject]!
    var metadataItemFilter: AVMetadataItemFilter!
    var audioTimePitchAlgorithm: String!
    @NSCopying var audioMix: AVAudioMix!
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
    var shouldOptimizeForNetworkUse: Bool
    var canPerformMultiplePassesOverSourceMediaData: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL!
    func determineCompatibleFileTypesWithCompletionHandler(_ handler: (([AnyObject]!) -> Void)!)
    func exportAsynchronouslyWithCompletionHandler(_ handler: (() -> Void)!)
    func cancelExport()
}
To
class AVAssetExportSession : NSObject {
    convenience init()
    convenience init?(asset asset: AVAsset, presetName presetName: String)
    class func exportSessionWithAsset(_ asset: AVAsset, presetName presetName: String) -> Self?
    init?(asset asset: AVAsset, presetName presetName: String)
    var presetName: String { get }
    var asset: AVAsset { get }
    var outputFileType: String?
    @NSCopying var outputURL: NSURL?
    var shouldOptimizeForNetworkUse: Bool
    var status: AVAssetExportSessionStatus { get }
    var error: NSError? { get }
    func exportAsynchronouslyWithCompletionHandler(_ handler: () -> Void)
    var progress: Float { get }
    func cancelExport()
}
extension AVAssetExportSession {
    class func allExportPresets() -> [String]
    class func exportPresetsCompatibleWithAsset(_ asset: AVAsset) -> [String]
    class func determineCompatibilityOfExportPreset(_ presetName: String, withAsset asset: AVAsset, outputFileType outputFileType: String?, completionHandler handler: (Bool) -> Void)
}
extension AVAssetExportSession {
    var supportedFileTypes: [String] { get }
    func determineCompatibleFileTypesWithCompletionHandler(_ handler: ([String]) -> Void)
}
extension AVAssetExportSession {
    var timeRange: CMTimeRange
    var estimatedOutputFileLength: Int64 { get }
}
extension AVAssetExportSession {
    var metadata: [AVMetadataItem]?
    var metadataItemFilter: AVMetadataItemFilter?
}
extension AVAssetExportSession {
    var audioTimePitchAlgorithm: String
    @NSCopying var audioMix: AVAudioMix?
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
}
extension AVAssetExportSession {
    var canPerformMultiplePassesOverSourceMediaData: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL?
}

Declaration
From
class func allExportPresets() -> [AnyObject]!
To
class func allExportPresets() -> [String]

Declaration
From
var asset: AVAsset! { get }
To
var asset: AVAsset { get }

Declaration
From
@NSCopying var audioMix: AVAudioMix!
To
@NSCopying var audioMix: AVAudioMix?

Declaration
From
var audioTimePitchAlgorithm: String!
To
var audioTimePitchAlgorithm: String

Declaration
From
var customVideoCompositor: AVVideoCompositing! { get }
To
var customVideoCompositor: AVVideoCompositing? { get }

Declaration
From
class func determineCompatibilityOfExportPreset(_ presetName: String!, withAsset asset: AVAsset!, outputFileType outputFileType: String!, completionHandler handler: ((Bool) -> Void)!)
To
class func determineCompatibilityOfExportPreset(_ presetName: String, withAsset asset: AVAsset, outputFileType outputFileType: String?, completionHandler handler: (Bool) -> Void)

Declaration
From
func determineCompatibleFileTypesWithCompletionHandler(_ handler: (([AnyObject]!) -> Void)!)
To
func determineCompatibleFileTypesWithCompletionHandler(_ handler: ([String]) -> Void)

Declaration
From
@NSCopying var directoryForTemporaryFiles: NSURL!
To
@NSCopying var directoryForTemporaryFiles: NSURL?

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
func exportAsynchronouslyWithCompletionHandler(_ handler: (() -> Void)!)
To
func exportAsynchronouslyWithCompletionHandler(_ handler: () -> Void)

Declaration
From
class func exportPresetsCompatibleWithAsset(_ asset: AVAsset!) -> [AnyObject]!
To
class func exportPresetsCompatibleWithAsset(_ asset: AVAsset) -> [String]

Declaration
From
init!(asset asset: AVAsset!, presetName presetName: String!)
To
init?(asset asset: AVAsset, presetName presetName: String)

Declaration
From
var metadata: [AnyObject]!
To
var metadata: [AVMetadataItem]?

Declaration
From
var metadataItemFilter: AVMetadataItemFilter!
To
var metadataItemFilter: AVMetadataItemFilter?

Declaration
From
var outputFileType: String!
To
var outputFileType: String?

Declaration
From
@NSCopying var outputURL: NSURL!
To
@NSCopying var outputURL: NSURL?

Declaration
From
var presetName: String! { get }
To
var presetName: String { get }

Declaration
From
var supportedFileTypes: [AnyObject]! { get }
To
var supportedFileTypes: [String] { get }

Declaration
From
@NSCopying var videoComposition: AVVideoComposition!
To
@NSCopying var videoComposition: AVVideoComposition?

Raw Value Type
From--
ToInt

Declaration
From
class AVAssetImageGenerator : NSObject {
    var asset: AVAsset! { get }
    var appliesPreferredTrackTransform: Bool
    var maximumSize: CGSize
    var apertureMode: String!
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
    var requestedTimeToleranceBefore: CMTime
    var requestedTimeToleranceAfter: CMTime
    init!(asset asset: AVAsset!) -> AVAssetImageGenerator
    class func assetImageGeneratorWithAsset(_ asset: AVAsset!) -> AVAssetImageGenerator!
    init!(asset asset: AVAsset!)
    func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>, error outError: NSErrorPointer) -> CGImage!
    func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [AnyObject]!, completionHandler handler: AVAssetImageGeneratorCompletionHandler!)
    func cancelAllCGImageGeneration()
}
To
class AVAssetImageGenerator : NSObject {
    convenience init()
    var asset: AVAsset { get }
    var appliesPreferredTrackTransform: Bool
    var maximumSize: CGSize
    var apertureMode: String?
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
    var requestedTimeToleranceBefore: CMTime
    var requestedTimeToleranceAfter: CMTime
    convenience init(asset asset: AVAsset)
    class func assetImageGeneratorWithAsset(_ asset: AVAsset) -> Self
    init(asset asset: AVAsset)
    func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>) throws -> CGImage
    func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [NSValue], completionHandler handler: AVAssetImageGeneratorCompletionHandler)
    func cancelAllCGImageGeneration()
}

Declaration
From
var apertureMode: String!
To
var apertureMode: String?

Declaration
From
var asset: AVAsset! { get }
To
var asset: AVAsset { get }

Declaration
From
func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>, error outError: NSErrorPointer) -> CGImage!
To
func copyCGImageAtTime(_ requestedTime: CMTime, actualTime actualTime: UnsafeMutablePointer<CMTime>) throws -> CGImage

Declaration
From
var customVideoCompositor: AVVideoCompositing! { get }
To
var customVideoCompositor: AVVideoCompositing? { get }

Declaration
From
func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [AnyObject]!, completionHandler handler: AVAssetImageGeneratorCompletionHandler!)
To
func generateCGImagesAsynchronouslyForTimes(_ requestedTimes: [NSValue], completionHandler handler: AVAssetImageGeneratorCompletionHandler)

Declaration
From
init!(asset asset: AVAsset!)
To
init(asset asset: AVAsset)

Declaration
From
@NSCopying var videoComposition: AVVideoComposition!
To
@NSCopying var videoComposition: AVVideoComposition?

Raw Value Type
From--
ToInt

Modified AVAssetReader
Declaration
From
class AVAssetReader : NSObject {
    convenience init!(asset asset: AVAsset!, error outError: NSErrorPointer)
    class func assetReaderWithAsset(_ asset: AVAsset!, error outError: NSErrorPointer) -> Self!
    init!(asset asset: AVAsset!, error outError: NSErrorPointer)
    var asset: AVAsset! { get }
    var status: AVAssetReaderStatus { get }
    var error: NSError! { get }
    var timeRange: CMTimeRange
    var outputs: [AnyObject]! { get }
    func canAddOutput(_ output: AVAssetReaderOutput!) -> Bool
    func addOutput(_ output: AVAssetReaderOutput!)
    func startReading() -> Bool
    func cancelReading()
}
To
class AVAssetReader : NSObject {
    convenience init()
    convenience init(asset asset: AVAsset) throws
    class func assetReaderWithAsset(_ asset: AVAsset) throws -> Self
    init(asset asset: AVAsset) throws
    var asset: AVAsset { get }
    var status: AVAssetReaderStatus { get }
    var error: NSError? { get }
    var timeRange: CMTimeRange
    var outputs: [AVAssetReaderOutput] { get }
    func canAddOutput(_ output: AVAssetReaderOutput) -> Bool
    func addOutput(_ output: AVAssetReaderOutput)
    func startReading() -> Bool
    func cancelReading()
}

Declaration
From
func addOutput(_ output: AVAssetReaderOutput!)
To
func addOutput(_ output: AVAssetReaderOutput)

Declaration
From
var asset: AVAsset! { get }
To
var asset: AVAsset { get }

Declaration
From
func canAddOutput(_ output: AVAssetReaderOutput!) -> Bool
To
func canAddOutput(_ output: AVAssetReaderOutput) -> Bool

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
init!(asset asset: AVAsset!, error outError: NSErrorPointer)
To
init(asset asset: AVAsset) throws

Declaration
From
var outputs: [AnyObject]! { get }
To
var outputs: [AVAssetReaderOutput] { get }

Declaration
From
class AVAssetReaderAudioMixOutput : AVAssetReaderOutput {
    convenience init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)
    class func assetReaderAudioMixOutputWithAudioTracks(_ audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!) -> Self!
    init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)
    var audioTracks: [AnyObject]! { get }
    var audioSettings: [NSObject : AnyObject]! { get }
    @NSCopying var audioMix: AVAudioMix!
    var audioTimePitchAlgorithm: String!
}
To
class AVAssetReaderAudioMixOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)
    class func assetReaderAudioMixOutputWithAudioTracks(_ audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?) -> Self
    init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)
    var audioTracks: [AVAssetTrack] { get }
    var audioSettings: [String : AnyObject]? { get }
    @NSCopying var audioMix: AVAudioMix?
    var audioTimePitchAlgorithm: String
}

Declaration
From
@NSCopying var audioMix: AVAudioMix!
To
@NSCopying var audioMix: AVAudioMix?

Declaration
From
var audioSettings: [NSObject : AnyObject]! { get }
To
var audioSettings: [String : AnyObject]? { get }

Declaration
From
var audioTimePitchAlgorithm: String!
To
var audioTimePitchAlgorithm: String

Declaration
From
var audioTracks: [AnyObject]! { get }
To
var audioTracks: [AVAssetTrack] { get }

Declaration
From
init!(audioTracks audioTracks: [AnyObject]!, audioSettings audioSettings: [NSObject : AnyObject]!)
To
init(audioTracks audioTracks: [AVAssetTrack], audioSettings audioSettings: [String : AnyObject]?)

Declaration
From
class AVAssetReaderOutput : NSObject {
    var mediaType: String! { get }
    var alwaysCopiesSampleData: Bool
    func copyNextSampleBuffer() -> CMSampleBuffer!
}
extension AVAssetReaderOutput {
    var supportsRandomAccess: Bool
    func resetForReadingTimeRanges(_ timeRanges: [AnyObject]!)
    func markConfigurationAsFinal()
}
To
class AVAssetReaderOutput : NSObject {
    var mediaType: String { get }
    var alwaysCopiesSampleData: Bool
    func copyNextSampleBuffer() -> CMSampleBuffer?
}
extension AVAssetReaderOutput {
    var supportsRandomAccess: Bool
    func resetForReadingTimeRanges(_ timeRanges: [NSValue])
    func markConfigurationAsFinal()
}

Declaration
From
func copyNextSampleBuffer() -> CMSampleBuffer!
To
func copyNextSampleBuffer() -> CMSampleBuffer?

Declaration
From
var mediaType: String! { get }
To
var mediaType: String { get }

Declaration
From
func resetForReadingTimeRanges(_ timeRanges: [AnyObject]!)
To
func resetForReadingTimeRanges(_ timeRanges: [NSValue])

Declaration
From
class AVAssetReaderOutputMetadataAdaptor : NSObject {
    convenience init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)
    class func assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput(_ trackOutput: AVAssetReaderTrackOutput!) -> Self!
    init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)
    var assetReaderTrackOutput: AVAssetReaderTrackOutput! { get }
    func nextTimedMetadataGroup() -> AVTimedMetadataGroup!
}
To
class AVAssetReaderOutputMetadataAdaptor : NSObject {
    convenience init()
    convenience init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)
    class func assetReaderOutputMetadataAdaptorWithAssetReaderTrackOutput(_ trackOutput: AVAssetReaderTrackOutput) -> Self
    init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)
    var assetReaderTrackOutput: AVAssetReaderTrackOutput { get }
    func nextTimedMetadataGroup() -> AVTimedMetadataGroup?
}

Declaration
From
var assetReaderTrackOutput: AVAssetReaderTrackOutput! { get }
To
var assetReaderTrackOutput: AVAssetReaderTrackOutput { get }

Declaration
From
init!(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput!)
To
init(assetReaderTrackOutput trackOutput: AVAssetReaderTrackOutput)

Declaration
From
func nextTimedMetadataGroup() -> AVTimedMetadataGroup!
To
func nextTimedMetadataGroup() -> AVTimedMetadataGroup?

Declaration
From
class AVAssetReaderSampleReferenceOutput : AVAssetReaderOutput {
    init!(track track: AVAssetTrack!) -> AVAssetReaderSampleReferenceOutput
    class func assetReaderSampleReferenceOutputWithTrack(_ track: AVAssetTrack!) -> AVAssetReaderSampleReferenceOutput!
    init!(track track: AVAssetTrack!)
    var track: AVAssetTrack! { get }
}
To
class AVAssetReaderSampleReferenceOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(track track: AVAssetTrack)
    class func assetReaderSampleReferenceOutputWithTrack(_ track: AVAssetTrack) -> Self
    init(track track: AVAssetTrack)
    var track: AVAssetTrack { get }
}

Declaration
From
init!(track track: AVAssetTrack!)
To
init(track track: AVAssetTrack)

Declaration
From
var track: AVAssetTrack! { get }
To
var track: AVAssetTrack { get }

Raw Value Type
From--
ToInt

Declaration
From
class AVAssetReaderTrackOutput : AVAssetReaderOutput {
    convenience init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)
    class func assetReaderTrackOutputWithTrack(_ track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!) -> Self!
    init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)
    var track: AVAssetTrack! { get }
    var outputSettings: [NSObject : AnyObject]! { get }
    var audioTimePitchAlgorithm: String!
}
To
class AVAssetReaderTrackOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)
    class func assetReaderTrackOutputWithTrack(_ track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?) -> Self
    init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)
    var track: AVAssetTrack { get }
    var outputSettings: [String : AnyObject]? { get }
    var audioTimePitchAlgorithm: String
}

Declaration
From
var audioTimePitchAlgorithm: String!
To
var audioTimePitchAlgorithm: String

Declaration
From
init!(track track: AVAssetTrack!, outputSettings outputSettings: [NSObject : AnyObject]!)
To
init(track track: AVAssetTrack, outputSettings outputSettings: [String : AnyObject]?)

Declaration
From
var outputSettings: [NSObject : AnyObject]! { get }
To
var outputSettings: [String : AnyObject]? { get }

Declaration
From
var track: AVAssetTrack! { get }
To
var track: AVAssetTrack { get }

Declaration
From
class AVAssetReaderVideoCompositionOutput : AVAssetReaderOutput {
    convenience init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)
    class func assetReaderVideoCompositionOutputWithVideoTracks(_ videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!) -> Self!
    init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)
    var videoTracks: [AnyObject]! { get }
    var videoSettings: [NSObject : AnyObject]! { get }
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
}
To
class AVAssetReaderVideoCompositionOutput : AVAssetReaderOutput {
    convenience init()
    convenience init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)
    class func assetReaderVideoCompositionOutputWithVideoTracks(_ videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?) -> Self
    init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)
    var videoTracks: [AVAssetTrack] { get }
    var videoSettings: [String : AnyObject]? { get }
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
}

Declaration
From
var customVideoCompositor: AVVideoCompositing! { get }
To
var customVideoCompositor: AVVideoCompositing? { get }

Declaration
From
init!(videoTracks videoTracks: [AnyObject]!, videoSettings videoSettings: [NSObject : AnyObject]!)
To
init(videoTracks videoTracks: [AVAssetTrack], videoSettings videoSettings: [String : AnyObject]?)

Declaration
From
@NSCopying var videoComposition: AVVideoComposition!
To
@NSCopying var videoComposition: AVVideoComposition?

Declaration
From
var videoSettings: [NSObject : AnyObject]! { get }
To
var videoSettings: [String : AnyObject]? { get }

Declaration
From
var videoTracks: [AnyObject]! { get }
To
var videoTracks: [AVAssetTrack] { get }

DeclarationProtocols
From
struct AVAssetReferenceRestrictions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var RestrictionForbidNone: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidCrossSiteReference: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var RestrictionForbidAll: AVAssetReferenceRestrictions { get }
}
RawOptionSetType
To
struct AVAssetReferenceRestrictions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var ForbidNone: AVAssetReferenceRestrictions { get }
    static var ForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var ForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }
    static var ForbidCrossSiteReference: AVAssetReferenceRestrictions { get }
    static var ForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }
    static var ForbidAll: AVAssetReferenceRestrictions { get }
}
OptionSetType

Declaration
From
static var RestrictionForbidAll: AVAssetReferenceRestrictions { get }
To
static var ForbidAll: AVAssetReferenceRestrictions { get }

Declaration
From
static var RestrictionForbidCrossSiteReference: AVAssetReferenceRestrictions { get }
To
static var ForbidCrossSiteReference: AVAssetReferenceRestrictions { get }

Declaration
From
static var RestrictionForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }
To
static var ForbidLocalReferenceToLocal: AVAssetReferenceRestrictions { get }

Declaration
From
static var RestrictionForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }
To
static var ForbidLocalReferenceToRemote: AVAssetReferenceRestrictions { get }

Declaration
From
static var RestrictionForbidNone: AVAssetReferenceRestrictions { get }
To
static var ForbidNone: AVAssetReferenceRestrictions { get }

Declaration
From
static var RestrictionForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }
To
static var ForbidRemoteReferenceToLocal: AVAssetReferenceRestrictions { get }

Declaration
From
class AVAssetResourceLoader : NSObject {
    func setDelegate(_ delegate: AVAssetResourceLoaderDelegate!, queue delegateQueue: dispatch_queue_t!)
    var delegate: AVAssetResourceLoaderDelegate! { get }
    var delegateQueue: dispatch_queue_t! { get }
}
To
class AVAssetResourceLoader : NSObject {
    init()
    func setDelegate(_ delegate: AVAssetResourceLoaderDelegate?, queue delegateQueue: dispatch_queue_t?)
    weak var delegate: AVAssetResourceLoaderDelegate? { get }
    var delegateQueue: dispatch_queue_t? { get }
}
extension AVAssetResourceLoader {
    var preloadsEligibleContentKeys: Bool
}

Declaration
From
var delegate: AVAssetResourceLoaderDelegate! { get }
To
weak var delegate: AVAssetResourceLoaderDelegate? { get }

Declaration
From
var delegateQueue: dispatch_queue_t! { get }
To
var delegateQueue: dispatch_queue_t? { get }

Declaration
From
func setDelegate(_ delegate: AVAssetResourceLoaderDelegate!, queue delegateQueue: dispatch_queue_t!)
To
func setDelegate(_ delegate: AVAssetResourceLoaderDelegate?, queue delegateQueue: dispatch_queue_t?)

Declaration
From
protocol AVAssetResourceLoaderDelegate : NSObjectProtocol {
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest!)
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!)
}
To
protocol AVAssetResourceLoaderDelegate : NSObjectProtocol {
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest)
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge) -> Bool
    optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge)
}

Declaration
From
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!)
To
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge)

Declaration
From
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest!)
To
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancelLoadingRequest loadingRequest: AVAssetResourceLoadingRequest)

Declaration
From
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest!) -> Bool
To
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool

Declaration
From
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest!) -> Bool
To
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest) -> Bool

Declaration
From
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader!, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge!) -> Bool
To
optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForResponseToAuthenticationChallenge authenticationChallenge: NSURLAuthenticationChallenge) -> Bool

Declaration
From
class AVAssetResourceLoadingContentInformationRequest : NSObject {
    var contentType: String!
    var contentLength: Int64
    var byteRangeAccessSupported: Bool
    @NSCopying var renewalDate: NSDate!
}
To
class AVAssetResourceLoadingContentInformationRequest : NSObject {
    init()
    var contentType: String?
    var contentLength: Int64
    var byteRangeAccessSupported: Bool
    @NSCopying var renewalDate: NSDate?
}

Declaration
From
var contentType: String!
To
var contentType: String?

Declaration
From
@NSCopying var renewalDate: NSDate!
To
@NSCopying var renewalDate: NSDate?

Declaration
From
class AVAssetResourceLoadingDataRequest : NSObject {
    var requestedOffset: Int64 { get }
    var requestedLength: Int { get }
    var currentOffset: Int64 { get }
    func respondWithData(_ data: NSData!)
}
To
class AVAssetResourceLoadingDataRequest : NSObject {
    init()
    var requestedOffset: Int64 { get }
    var requestedLength: Int { get }
    var requestsAllDataToEndOfResource: Bool { get }
    var currentOffset: Int64 { get }
    func respondWithData(_ data: NSData)
}

Declaration
From
func respondWithData(_ data: NSData!)
To
func respondWithData(_ data: NSData)

Declaration
From
class AVAssetResourceLoadingRequest : NSObject {
    var request: NSURLRequest! { get }
    var finished: Bool { get }
    var cancelled: Bool { get }
    var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest! { get }
    var dataRequest: AVAssetResourceLoadingDataRequest! { get }
    @NSCopying var response: NSURLResponse!
    @NSCopying var redirect: NSURLRequest!
    func finishLoading()
    func finishLoadingWithError(_ error: NSError!)
}
extension AVAssetResourceLoadingRequest {
    func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData!, contentIdentifier contentIdentifier: NSData!, options options: [NSObject : AnyObject]!, error outError: NSErrorPointer) -> NSData!
}
extension AVAssetResourceLoadingRequest {
    func finishLoadingWithResponse(_ response: NSURLResponse!, data data: NSData!, redirect redirect: NSURLRequest!)
}
To
class AVAssetResourceLoadingRequest : NSObject {
    init()
    var request: NSURLRequest { get }
    var finished: Bool { get }
    var cancelled: Bool { get }
    var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest? { get }
    var dataRequest: AVAssetResourceLoadingDataRequest? { get }
    @NSCopying var response: NSURLResponse?
    @NSCopying var redirect: NSURLRequest?
    func finishLoading()
    func finishLoadingWithError(_ error: NSError?)
}
extension AVAssetResourceLoadingRequest {
    func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData, contentIdentifier contentIdentifier: NSData, options options: [String : AnyObject]?) throws -> NSData
    func persistentContentKeyFromKeyVendorResponse(_ keyVendorResponse: NSData, options options: [String : AnyObject]?, error outError: NSErrorPointer) -> NSData
}
extension AVAssetResourceLoadingRequest {
    func finishLoadingWithResponse(_ response: NSURLResponse?, data data: NSData?, redirect redirect: NSURLRequest?)
}

Declaration
From
var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest! { get }
To
var contentInformationRequest: AVAssetResourceLoadingContentInformationRequest? { get }

Declaration
From
var dataRequest: AVAssetResourceLoadingDataRequest! { get }
To
var dataRequest: AVAssetResourceLoadingDataRequest? { get }

Declaration
From
func finishLoadingWithError(_ error: NSError!)
To
func finishLoadingWithError(_ error: NSError?)

Declaration
From
@NSCopying var redirect: NSURLRequest!
To
@NSCopying var redirect: NSURLRequest?

Declaration
From
var request: NSURLRequest! { get }
To
var request: NSURLRequest { get }

Declaration
From
@NSCopying var response: NSURLResponse!
To
@NSCopying var response: NSURLResponse?

Declaration
From
func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData!, contentIdentifier contentIdentifier: NSData!, options options: [NSObject : AnyObject]!, error outError: NSErrorPointer) -> NSData!
To
func streamingContentKeyRequestDataForApp(_ appIdentifier: NSData, contentIdentifier contentIdentifier: NSData, options options: [String : AnyObject]?) throws -> NSData

Modified AVAssetTrack
Declaration
From
class AVAssetTrack : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    var asset: AVAsset! { get }
    var trackID: CMPersistentTrackID { get }
}
extension AVAssetTrack {
    var mediaType: String! { get }
    var formatDescriptions: [AnyObject]! { get }
    var playable: Bool { get }
    var enabled: Bool { get }
    var selfContained: Bool { get }
    var totalSampleDataLength: Int64 { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
}
extension AVAssetTrack {
    var timeRange: CMTimeRange { get }
    var naturalTimeScale: CMTimeScale { get }
    var estimatedDataRate: Float { get }
}
extension AVAssetTrack {
    var languageCode: String! { get }
    var extendedLanguageTag: String! { get }
}
extension AVAssetTrack {
    var naturalSize: CGSize { get }
    var preferredTransform: CGAffineTransform { get }
}
extension AVAssetTrack {
    var preferredVolume: Float { get }
}
extension AVAssetTrack {
    var nominalFrameRate: Float { get }
    var minFrameDuration: CMTime { get }
    var requiresFrameReordering: Bool { get }
}
extension AVAssetTrack {
    var segments: [AnyObject]! { get }
    func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment!
    func samplePresentationTimeForTrackTime(_ trackTime: CMTime) -> CMTime
}
extension AVAssetTrack {
    var commonMetadata: [AnyObject]! { get }
    var metadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
}
extension AVAssetTrack {
    var availableTrackAssociationTypes: [AnyObject]! { get }
    func associatedTracksOfType(_ trackAssociationType: String!) -> [AnyObject]!
}
extension AVAssetTrack {
    var canProvideSampleCursors: Bool { get }
    func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor!
    func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor!
    func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor!
}
To
class AVAssetTrack : NSObject, NSCopying, AVAsynchronousKeyValueLoading {
    init()
    weak var asset: AVAsset? { get }
    var trackID: CMPersistentTrackID { get }
}
extension AVAssetTrack {
    var mediaType: String { get }
    var formatDescriptions: [AnyObject] { get }
    var playable: Bool { get }
    var enabled: Bool { get }
    var selfContained: Bool { get }
    var totalSampleDataLength: Int64 { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool
}
extension AVAssetTrack {
    var timeRange: CMTimeRange { get }
    var naturalTimeScale: CMTimeScale { get }
    var estimatedDataRate: Float { get }
}
extension AVAssetTrack {
    var languageCode: String { get }
    var extendedLanguageTag: String { get }
}
extension AVAssetTrack {
    var naturalSize: CGSize { get }
    var preferredTransform: CGAffineTransform { get }
}
extension AVAssetTrack {
    var preferredVolume: Float { get }
}
extension AVAssetTrack {
    var nominalFrameRate: Float { get }
    var minFrameDuration: CMTime { get }
    var requiresFrameReordering: Bool { get }
}
extension AVAssetTrack {
    var segments: [AVAssetTrackSegment] { get }
    func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment?
    func samplePresentationTimeForTrackTime(_ trackTime: CMTime) -> CMTime
}
extension AVAssetTrack {
    var commonMetadata: [AVMetadataItem] { get }
    var metadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
}
extension AVAssetTrack {
    var availableTrackAssociationTypes: [String] { get }
    func associatedTracksOfType(_ trackAssociationType: String) -> [AVAssetTrack]
}
extension AVAssetTrack {
    var canProvideSampleCursors: Bool { get }
    func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor?
    func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor?
    func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor?
}

Declaration
From
var asset: AVAsset! { get }
To
weak var asset: AVAsset? { get }

Declaration
From
func associatedTracksOfType(_ trackAssociationType: String!) -> [AnyObject]!
To
func associatedTracksOfType(_ trackAssociationType: String) -> [AVAssetTrack]

Declaration
From
var availableMetadataFormats: [AnyObject]! { get }
To
var availableMetadataFormats: [String] { get }

Declaration
From
var availableTrackAssociationTypes: [AnyObject]! { get }
To
var availableTrackAssociationTypes: [String] { get }

Declaration
From
var commonMetadata: [AnyObject]! { get }
To
var commonMetadata: [AVMetadataItem] { get }

Declaration
From
var extendedLanguageTag: String! { get }
To
var extendedLanguageTag: String { get }

Declaration
From
var formatDescriptions: [AnyObject]! { get }
To
var formatDescriptions: [AnyObject] { get }

Declaration
From
func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
To
func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool

Declaration
From
var languageCode: String! { get }
To
var languageCode: String { get }

Declaration
From
func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor!
To
func makeSampleCursorAtFirstSampleInDecodeOrder() -> AVSampleCursor?

Declaration
From
func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor!
To
func makeSampleCursorAtLastSampleInDecodeOrder() -> AVSampleCursor?

Declaration
From
func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor!
To
func makeSampleCursorWithPresentationTimeStamp(_ presentationTimeStamp: CMTime) -> AVSampleCursor?

Declaration
From
var mediaType: String! { get }
To
var mediaType: String { get }

Declaration
From
var metadata: [AnyObject]! { get }
To
var metadata: [AVMetadataItem] { get }

Declaration
From
func metadataForFormat(_ format: String!) -> [AnyObject]!
To
func metadataForFormat(_ format: String) -> [AVMetadataItem]

Declaration
From
func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment!
To
func segmentForTrackTime(_ trackTime: CMTime) -> AVAssetTrackSegment?

Declaration
From
var segments: [AnyObject]! { get }
To
var segments: [AVAssetTrackSegment] { get }

Declaration
From
class AVAssetTrackGroup : NSObject, NSCopying {
    var trackIDs: [AnyObject]! { get }
}
To
class AVAssetTrackGroup : NSObject, NSCopying {
    var trackIDs: [NSNumber] { get }
}

Declaration
From
var trackIDs: [AnyObject]! { get }
To
var trackIDs: [NSNumber] { get }

Declaration
From
class AVAssetTrackSegment : NSObject {
    var timeMapping: CMTimeMapping { get }
    var empty: Bool { get }
}
To
class AVAssetTrackSegment : NSObject {
    init()
    var timeMapping: CMTimeMapping { get }
    var empty: Bool { get }
}

Modified AVAssetWriter
Declaration
From
class AVAssetWriter : NSObject {
    convenience init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)
    class func assetWriterWithURL(_ outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer) -> Self!
    init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)
    @NSCopying var outputURL: NSURL! { get }
    var outputFileType: String! { get }
    var availableMediaTypes: [AnyObject]! { get }
    var status: AVAssetWriterStatus { get }
    var error: NSError! { get }
    var metadata: [AnyObject]!
    var shouldOptimizeForNetworkUse: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL!
    var inputs: [AnyObject]! { get }
    func canApplyOutputSettings(_ outputSettings: [NSObject : AnyObject]!, forMediaType mediaType: String!) -> Bool
    func canAddInput(_ input: AVAssetWriterInput!) -> Bool
    func addInput(_ input: AVAssetWriterInput!)
    func startWriting() -> Bool
    func startSessionAtSourceTime(_ startTime: CMTime)
    func endSessionAtSourceTime(_ endTime: CMTime)
    func cancelWriting()
    func finishWriting() -> Bool
    func finishWritingWithCompletionHandler(_ handler: (() -> Void)!)
}
extension AVAssetWriter {
    var movieFragmentInterval: CMTime
    var movieTimeScale: CMTimeScale
}
extension AVAssetWriter {
    func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup!) -> Bool
    func addInputGroup(_ inputGroup: AVAssetWriterInputGroup!)
    var inputGroups: [AnyObject]! { get }
}
To
class AVAssetWriter : NSObject {
    convenience init()
    convenience init(URL outputURL: NSURL, fileType outputFileType: String) throws
    class func assetWriterWithURL(_ outputURL: NSURL, fileType outputFileType: String) throws -> Self
    init(URL outputURL: NSURL, fileType outputFileType: String) throws
    @NSCopying var outputURL: NSURL { get }
    var outputFileType: String { get }
    var availableMediaTypes: [String] { get }
    var status: AVAssetWriterStatus { get }
    var error: NSError? { get }
    var metadata: [AVMetadataItem]
    var shouldOptimizeForNetworkUse: Bool
    @NSCopying var directoryForTemporaryFiles: NSURL?
    var inputs: [AVAssetWriterInput] { get }
    func canApplyOutputSettings(_ outputSettings: [String : AnyObject]?, forMediaType mediaType: String) -> Bool
    func canAddInput(_ input: AVAssetWriterInput) -> Bool
    func addInput(_ input: AVAssetWriterInput)
    func startWriting() -> Bool
    func startSessionAtSourceTime(_ startTime: CMTime)
    func endSessionAtSourceTime(_ endTime: CMTime)
    func cancelWriting()
    func finishWriting() -> Bool
    func finishWritingWithCompletionHandler(_ handler: () -> Void)
}
extension AVAssetWriter {
    var movieFragmentInterval: CMTime
    var overallDurationHint: CMTime
    var movieTimeScale: CMTimeScale
}
extension AVAssetWriter {
    func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup) -> Bool
    func addInputGroup(_ inputGroup: AVAssetWriterInputGroup)
    var inputGroups: [AVAssetWriterInputGroup] { get }
}

Declaration
From
func addInput(_ input: AVAssetWriterInput!)
To
func addInput(_ input: AVAssetWriterInput)

Declaration
From
func addInputGroup(_ inputGroup: AVAssetWriterInputGroup!)
To
func addInputGroup(_ inputGroup: AVAssetWriterInputGroup)

Declaration
From
var availableMediaTypes: [AnyObject]! { get }
To
var availableMediaTypes: [String] { get }

Declaration
From
func canAddInput(_ input: AVAssetWriterInput!) -> Bool
To
func canAddInput(_ input: AVAssetWriterInput) -> Bool

Declaration
From
func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup!) -> Bool
To
func canAddInputGroup(_ inputGroup: AVAssetWriterInputGroup) -> Bool

Declaration
From
func canApplyOutputSettings(_ outputSettings: [NSObject : AnyObject]!, forMediaType mediaType: String!) -> Bool
To
func canApplyOutputSettings(_ outputSettings: [String : AnyObject]?, forMediaType mediaType: String) -> Bool

Declaration
From
@NSCopying var directoryForTemporaryFiles: NSURL!
To
@NSCopying var directoryForTemporaryFiles: NSURL?

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
func finishWritingWithCompletionHandler(_ handler: (() -> Void)!)
To
func finishWritingWithCompletionHandler(_ handler: () -> Void)

Declaration
From
init!(URL outputURL: NSURL!, fileType outputFileType: String!, error outError: NSErrorPointer)
To
init(URL outputURL: NSURL, fileType outputFileType: String) throws

Declaration
From
var inputGroups: [AnyObject]! { get }
To
var inputGroups: [AVAssetWriterInputGroup] { get }

Declaration
From
var inputs: [AnyObject]! { get }
To
var inputs: [AVAssetWriterInput] { get }

Declaration
From
var metadata: [AnyObject]!
To
var metadata: [AVMetadataItem]

Declaration
From
var outputFileType: String! { get }
To
var outputFileType: String { get }

Declaration
From
@NSCopying var outputURL: NSURL! { get }
To
@NSCopying var outputURL: NSURL { get }

Declaration
From
class AVAssetWriterInput : NSObject {
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!) -> AVAssetWriterInput
    class func assetWriterInputWithMediaType(_ mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!) -> AVAssetWriterInput!
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!) -> AVAssetWriterInput
    class func assetWriterInputWithMediaType(_ mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!) -> AVAssetWriterInput!
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!)
    init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!)
    var mediaType: String! { get }
    var outputSettings: [NSObject : AnyObject]! { get }
    var sourceFormatHint: CMFormatDescription! { get }
    var metadata: [AnyObject]!
    var readyForMoreMediaData: Bool { get }
    var expectsMediaDataInRealTime: Bool
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)
    func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer!) -> Bool
    func markAsFinished()
}
extension AVAssetWriterInput {
    var languageCode: String!
    var extendedLanguageTag: String!
}
extension AVAssetWriterInput {
    var naturalSize: CGSize
    var transform: CGAffineTransform
}
extension AVAssetWriterInput {
    var preferredVolume: Float
}
extension AVAssetWriterInput {
    var marksOutputTrackAsEnabled: Bool
    var mediaTimeScale: CMTimeScale
    var preferredMediaChunkDuration: CMTime
    var preferredMediaChunkAlignment: Int
    @NSCopying var sampleReferenceBaseURL: NSURL!
}
extension AVAssetWriterInput {
    func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!) -> Bool
    func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!)
}
extension AVAssetWriterInput {
    var performsMultiPassEncodingIfSupported: Bool
    var canPerformMultiplePasses: Bool { get }
    var currentPassDescription: AVAssetWriterInputPassDescription! { get }
    func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t!, usingBlock block: dispatch_block_t!)
    func markCurrentPassAsFinished()
}
To
class AVAssetWriterInput : NSObject {
    convenience init()
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)
    class func assetWriterInputWithMediaType(_ mediaType: String, outputSettings outputSettings: [String : AnyObject]?) -> Self
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)
    class func assetWriterInputWithMediaType(_ mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?) -> Self
    convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)
    init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)
    var mediaType: String { get }
    var outputSettings: [String : AnyObject]? { get }
    var sourceFormatHint: CMFormatDescription? { get }
    var metadata: [AVMetadataItem]
    var readyForMoreMediaData: Bool { get }
    var expectsMediaDataInRealTime: Bool
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)
    func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer) -> Bool
    func markAsFinished()
}
extension AVAssetWriterInput {
    var languageCode: String?
    var extendedLanguageTag: String?
}
extension AVAssetWriterInput {
    var naturalSize: CGSize
    var transform: CGAffineTransform
}
extension AVAssetWriterInput {
    var preferredVolume: Float
}
extension AVAssetWriterInput {
    var marksOutputTrackAsEnabled: Bool
    var mediaTimeScale: CMTimeScale
    var preferredMediaChunkDuration: CMTime
    var preferredMediaChunkAlignment: Int
    @NSCopying var sampleReferenceBaseURL: NSURL?
}
extension AVAssetWriterInput {
    func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String) -> Bool
    func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String)
}
extension AVAssetWriterInput {
    var performsMultiPassEncodingIfSupported: Bool
    var canPerformMultiplePasses: Bool { get }
    var currentPassDescription: AVAssetWriterInputPassDescription? { get }
    func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t, usingBlock block: dispatch_block_t)
    func markCurrentPassAsFinished()
}

Declaration
From
func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!)
To
func addTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String)

Declaration
From
func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer!) -> Bool
To
func appendSampleBuffer(_ sampleBuffer: CMSampleBuffer) -> Bool

Declaration
From
func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput!, type trackAssociationType: String!) -> Bool
To
func canAddTrackAssociationWithTrackOfInput(_ input: AVAssetWriterInput, type trackAssociationType: String) -> Bool

Declaration
From
var currentPassDescription: AVAssetWriterInputPassDescription! { get }
To
var currentPassDescription: AVAssetWriterInputPassDescription? { get }

Declaration
From
var extendedLanguageTag: String!
To
var extendedLanguageTag: String?

Declaration
From
init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!)
To
convenience init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?)

Declaration
From
init!(mediaType mediaType: String!, outputSettings outputSettings: [NSObject : AnyObject]!, sourceFormatHint sourceFormatHint: CMFormatDescription!)
To
init(mediaType mediaType: String, outputSettings outputSettings: [String : AnyObject]?, sourceFormatHint sourceFormatHint: CMFormatDescription?)

Declaration
From
var languageCode: String!
To
var languageCode: String?

Declaration
From
var mediaType: String! { get }
To
var mediaType: String { get }

Declaration
From
var metadata: [AnyObject]!
To
var metadata: [AVMetadataItem]

Declaration
From
var outputSettings: [NSObject : AnyObject]! { get }
To
var outputSettings: [String : AnyObject]? { get }

Declaration
From
func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)
To
func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)

Declaration
From
func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t!, usingBlock block: dispatch_block_t!)
To
func respondToEachPassDescriptionOnQueue(_ queue: dispatch_queue_t, usingBlock block: dispatch_block_t)

Declaration
From
@NSCopying var sampleReferenceBaseURL: NSURL!
To
@NSCopying var sampleReferenceBaseURL: NSURL?

Declaration
From
var sourceFormatHint: CMFormatDescription! { get }
To
var sourceFormatHint: CMFormatDescription? { get }

Declaration
From
class AVAssetWriterInputGroup : AVMediaSelectionGroup {
    init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!) -> AVAssetWriterInputGroup
    class func assetWriterInputGroupWithInputs(_ inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!) -> AVAssetWriterInputGroup!
    init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!)
    var inputs: [AnyObject]! { get }
    var defaultInput: AVAssetWriterInput! { get }
}
To
class AVAssetWriterInputGroup : AVMediaSelectionGroup {
    convenience init()
    convenience init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)
    class func assetWriterInputGroupWithInputs(_ inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?) -> Self
    init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)
    var inputs: [AVAssetWriterInput] { get }
    var defaultInput: AVAssetWriterInput? { get }
}

Declaration
From
var defaultInput: AVAssetWriterInput! { get }
To
var defaultInput: AVAssetWriterInput? { get }

Declaration
From
init!(inputs inputs: [AnyObject]!, defaultInput defaultInput: AVAssetWriterInput!)
To
init(inputs inputs: [AVAssetWriterInput], defaultInput defaultInput: AVAssetWriterInput?)

Declaration
From
var inputs: [AnyObject]! { get }
To
var inputs: [AVAssetWriterInput] { get }

Declaration
From
class AVAssetWriterInputMetadataAdaptor : NSObject {
    convenience init!(assetWriterInput input: AVAssetWriterInput!)
    class func assetWriterInputMetadataAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput!) -> Self!
    init!(assetWriterInput input: AVAssetWriterInput!)
    var assetWriterInput: AVAssetWriterInput! { get }
    func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup!) -> Bool
}
To
class AVAssetWriterInputMetadataAdaptor : NSObject {
    convenience init()
    convenience init(assetWriterInput input: AVAssetWriterInput)
    class func assetWriterInputMetadataAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput) -> Self
    init(assetWriterInput input: AVAssetWriterInput)
    var assetWriterInput: AVAssetWriterInput { get }
    func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup) -> Bool
}

Declaration
From
func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup!) -> Bool
To
func appendTimedMetadataGroup(_ timedMetadataGroup: AVTimedMetadataGroup) -> Bool

Declaration
From
var assetWriterInput: AVAssetWriterInput! { get }
To
var assetWriterInput: AVAssetWriterInput { get }

Declaration
From
init!(assetWriterInput input: AVAssetWriterInput!)
To
init(assetWriterInput input: AVAssetWriterInput)

Declaration
From
class AVAssetWriterInputPassDescription : NSObject {
    var sourceTimeRanges: [AnyObject]! { get }
}
To
class AVAssetWriterInputPassDescription : NSObject {
    init()
    var sourceTimeRanges: [NSValue] { get }
}

Declaration
From
var sourceTimeRanges: [AnyObject]! { get }
To
var sourceTimeRanges: [NSValue] { get }

Declaration
From
class AVAssetWriterInputPixelBufferAdaptor : NSObject {
    convenience init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)
    class func assetWriterInputPixelBufferAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!) -> Self!
    init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)
    var assetWriterInput: AVAssetWriterInput! { get }
    var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }
    var pixelBufferPool: CVPixelBufferPool! { get }
    func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer!, withPresentationTime presentationTime: CMTime) -> Bool
}
To
class AVAssetWriterInputPixelBufferAdaptor : NSObject {
    convenience init()
    convenience init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)
    class func assetWriterInputPixelBufferAdaptorWithAssetWriterInput(_ input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?) -> Self
    init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)
    var assetWriterInput: AVAssetWriterInput { get }
    var sourcePixelBufferAttributes: [String : AnyObject]? { get }
    var pixelBufferPool: CVPixelBufferPool? { get }
    func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer, withPresentationTime presentationTime: CMTime) -> Bool
}

Declaration
From
func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer!, withPresentationTime presentationTime: CMTime) -> Bool
To
func appendPixelBuffer(_ pixelBuffer: CVPixelBuffer, withPresentationTime presentationTime: CMTime) -> Bool

Declaration
From
var assetWriterInput: AVAssetWriterInput! { get }
To
var assetWriterInput: AVAssetWriterInput { get }

Declaration
From
init!(assetWriterInput input: AVAssetWriterInput!, sourcePixelBufferAttributes sourcePixelBufferAttributes: [NSObject : AnyObject]!)
To
init(assetWriterInput input: AVAssetWriterInput, sourcePixelBufferAttributes sourcePixelBufferAttributes: [String : AnyObject]?)

Declaration
From
var pixelBufferPool: CVPixelBufferPool! { get }
To
var pixelBufferPool: CVPixelBufferPool? { get }

Declaration
From
var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }
To
var sourcePixelBufferAttributes: [String : AnyObject]? { get }

Raw Value Type
From--
ToInt

Declaration
From
protocol AVAsynchronousKeyValueLoading {
    func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
}
To
protocol AVAsynchronousKeyValueLoading {
    func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)
}

Declaration
From
func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
To
func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)

Declaration
From
func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
To
func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus

Declaration
From
class AVAsynchronousVideoCompositionRequest : NSObject, NSCopying {
    var renderContext: AVVideoCompositionRenderContext! { get }
    var compositionTime: CMTime { get }
    var sourceTrackIDs: [AnyObject]! { get }
    var videoCompositionInstruction: AVVideoCompositionInstructionProtocol! { get }
    func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> Unmanaged<CVPixelBuffer>!
    func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer!)
    func finishWithError(_ error: NSError!)
    func finishCancelledRequest()
}
To
class AVAsynchronousVideoCompositionRequest : NSObject, NSCopying {
    var renderContext: AVVideoCompositionRenderContext { get }
    var compositionTime: CMTime { get }
    var sourceTrackIDs: [NSNumber] { get }
    var videoCompositionInstruction: AVVideoCompositionInstructionProtocol { get }
    func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> CVPixelBuffer?
    func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer)
    func finishWithError(_ error: NSError)
    func finishCancelledRequest()
}

Declaration
From
func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer!)
To
func finishWithComposedVideoFrame(_ composedVideoFrame: CVPixelBuffer)

Declaration
From
func finishWithError(_ error: NSError!)
To
func finishWithError(_ error: NSError)

Declaration
From
var renderContext: AVVideoCompositionRenderContext! { get }
To
var renderContext: AVVideoCompositionRenderContext { get }

Declaration
From
func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> Unmanaged<CVPixelBuffer>!
To
func sourceFrameByTrackID(_ trackID: CMPersistentTrackID) -> CVPixelBuffer?

Declaration
From
var sourceTrackIDs: [AnyObject]! { get }
To
var sourceTrackIDs: [NSNumber] { get }

Declaration
From
var videoCompositionInstruction: AVVideoCompositionInstructionProtocol! { get }
To
var videoCompositionInstruction: AVVideoCompositionInstructionProtocol { get }

Raw Value Type
From--
ToInt

Modified AVAudioBuffer
Declaration
From
class AVAudioBuffer : NSObject, NSCopying, NSMutableCopying {
    var format: AVAudioFormat! { get }
    var audioBufferList: UnsafePointer<AudioBufferList> { get }
    var mutableAudioBufferList: UnsafeMutablePointer<AudioBufferList> { get }
}
To
class AVAudioBuffer : NSObject, NSCopying, NSMutableCopying {
    var format: AVAudioFormat { get }
    var audioBufferList: UnsafePointer<AudioBufferList> { get }
    var mutableAudioBufferList: UnsafeMutablePointer<AudioBufferList> { get }
}

Declaration
From
var format: AVAudioFormat! { get }
To
var format: AVAudioFormat { get }

DeclarationProtocols
From
class AVAudioChannelLayout : NSObject {
    init!(layoutTag layoutTag: AudioChannelLayoutTag)
    init!(layout layout: UnsafePointer<AudioChannelLayout>)
    func isEqual(_ object: AnyObject!) -> Bool
    class func layoutWithLayoutTag(_ layoutTag: AudioChannelLayoutTag) -> Self!
    class func layoutWithLayout(_ layout: UnsafePointer<AudioChannelLayout>) -> Self!
    var layoutTag: AudioChannelLayoutTag { get }
    var layout: UnsafePointer<AudioChannelLayout> { get }
    var channelCount: AVAudioChannelCount { get }
}
AnyObject
To
class AVAudioChannelLayout : NSObject, NSSecureCoding, NSCoding {
    convenience init(layoutTag layoutTag: AudioChannelLayoutTag)
    init(layout layout: UnsafePointer<AudioChannelLayout>)
    func isEqual(_ object: AnyObject) -> Bool
    class func layoutWithLayoutTag(_ layoutTag: AudioChannelLayoutTag) -> Self
    class func layoutWithLayout(_ layout: UnsafePointer<AudioChannelLayout>) -> Self
    var layoutTag: AudioChannelLayoutTag { get }
    var layout: UnsafePointer<AudioChannelLayout> { get }
    var channelCount: AVAudioChannelCount { get }
}
AnyObject, NSCoding, NSSecureCoding

Declaration
From
init!(layout layout: UnsafePointer<AudioChannelLayout>)
To
init(layout layout: UnsafePointer<AudioChannelLayout>)

Declaration
From
init!(layoutTag layoutTag: AudioChannelLayoutTag)
To
convenience init(layoutTag layoutTag: AudioChannelLayoutTag)

Declaration
From
func isEqual(_ object: AnyObject!) -> Bool
To
func isEqual(_ object: AnyObject) -> Bool

Raw Value Type
From--
ToUInt

Modified AVAudioEngine
Declaration
From
class AVAudioEngine : NSObject {
    init!()
    func attachNode(_ node: AVAudioNode!)
    func detachNode(_ node: AVAudioNode!)
    func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat!)
    func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, format format: AVAudioFormat!)
    func disconnectNodeInput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
    func disconnectNodeInput(_ node: AVAudioNode!)
    func disconnectNodeOutput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
    func disconnectNodeOutput(_ node: AVAudioNode!)
    func prepare()
    func startAndReturnError(_ outError: NSErrorPointer) -> Bool
    func pause()
    func reset()
    func stop()
    var musicSequence: MusicSequence
    var outputNode: AVAudioOutputNode! { get }
    var inputNode: AVAudioInputNode! { get }
    var mainMixerNode: AVAudioMixerNode! { get }
    var running: Bool { get }
}
To
class AVAudioEngine : NSObject {
    init()
    func attachNode(_ node: AVAudioNode)
    func detachNode(_ node: AVAudioNode)
    func connect(_ node1: AVAudioNode, to node2: AVAudioNode, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat?)
    func connect(_ node1: AVAudioNode, to node2: AVAudioNode, format format: AVAudioFormat?)
    func connect(_ sourceNode: AVAudioNode, toConnectionPoints destNodes: [AVAudioConnectionPoint], fromBus sourceBus: AVAudioNodeBus, format format: AVAudioFormat?)
    func disconnectNodeInput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)
    func disconnectNodeInput(_ node: AVAudioNode)
    func disconnectNodeOutput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)
    func disconnectNodeOutput(_ node: AVAudioNode)
    func prepare()
    func start() throws
    func pause()
    func reset()
    func stop()
    func inputConnectionPointForNode(_ node: AVAudioNode, inputBus bus: AVAudioNodeBus) -> AVAudioConnectionPoint?
    func outputConnectionPointsForNode(_ node: AVAudioNode, outputBus bus: AVAudioNodeBus) -> [AVAudioConnectionPoint]
    var musicSequence: MusicSequence
    var outputNode: AVAudioOutputNode { get }
    var inputNode: AVAudioInputNode? { get }
    var mainMixerNode: AVAudioMixerNode { get }
    var running: Bool { get }
}

Declaration
From
func attachNode(_ node: AVAudioNode!)
To
func attachNode(_ node: AVAudioNode)

Declaration
From
func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, format format: AVAudioFormat!)
To
func connect(_ node1: AVAudioNode, to node2: AVAudioNode, format format: AVAudioFormat?)

Declaration
From
func connect(_ node1: AVAudioNode!, to node2: AVAudioNode!, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat!)
To
func connect(_ node1: AVAudioNode, to node2: AVAudioNode, fromBus bus1: AVAudioNodeBus, toBus bus2: AVAudioNodeBus, format format: AVAudioFormat?)

Declaration
From
func detachNode(_ node: AVAudioNode!)
To
func detachNode(_ node: AVAudioNode)

Declaration
From
func disconnectNodeInput(_ node: AVAudioNode!)
To
func disconnectNodeInput(_ node: AVAudioNode)

Declaration
From
func disconnectNodeInput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
To
func disconnectNodeInput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)

Declaration
From
func disconnectNodeOutput(_ node: AVAudioNode!)
To
func disconnectNodeOutput(_ node: AVAudioNode)

Declaration
From
func disconnectNodeOutput(_ node: AVAudioNode!, bus bus: AVAudioNodeBus)
To
func disconnectNodeOutput(_ node: AVAudioNode, bus bus: AVAudioNodeBus)

Declaration
From
init!()
To
init()

Declaration
From
var inputNode: AVAudioInputNode! { get }
To
var inputNode: AVAudioInputNode? { get }

Declaration
From
var mainMixerNode: AVAudioMixerNode! { get }
To
var mainMixerNode: AVAudioMixerNode { get }

Declaration
From
var outputNode: AVAudioOutputNode! { get }
To
var outputNode: AVAudioOutputNode { get }

Declaration
From
func startAndReturnError(_ outError: NSErrorPointer) -> Bool
To
func start() throws

Raw Value Type
From--
ToInt

Declaration
From
class AVAudioEnvironmentNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
    var listenerPosition: AVAudio3DPoint
    var listenerVectorOrientation: AVAudio3DVectorOrientation
    var listenerAngularOrientation: AVAudio3DAngularOrientation
    var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters! { get }
    var reverbParameters: AVAudioEnvironmentReverbParameters! { get }
    func applicableRenderingAlgorithms() -> [AnyObject]!
}
To
class AVAudioEnvironmentNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
    var listenerPosition: AVAudio3DPoint
    var listenerVectorOrientation: AVAudio3DVectorOrientation
    var listenerAngularOrientation: AVAudio3DAngularOrientation
    var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters { get }
    var reverbParameters: AVAudioEnvironmentReverbParameters { get }
    var applicableRenderingAlgorithms: [NSNumber] { get }
}

Declaration
From
var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters! { get }
To
var distanceAttenuationParameters: AVAudioEnvironmentDistanceAttenuationParameters { get }

Declaration
From
var reverbParameters: AVAudioEnvironmentReverbParameters! { get }
To
var reverbParameters: AVAudioEnvironmentReverbParameters { get }

Declaration
From
class AVAudioEnvironmentReverbParameters : NSObject {
    var enable: Bool
    var level: Float
    var filterParameters: AVAudioUnitEQFilterParameters! { get }
    func loadFactoryReverbPreset(_ preset: AVAudioUnitReverbPreset)
}
To
class AVAudioEnvironmentReverbParameters : NSObject {
    var enable: Bool
    var level: Float
    var filterParameters: AVAudioUnitEQFilterParameters { get }
    func loadFactoryReverbPreset(_ preset: AVAudioUnitReverbPreset)
}

Declaration
From
var filterParameters: AVAudioUnitEQFilterParameters! { get }
To
var filterParameters: AVAudioUnitEQFilterParameters { get }

Modified AVAudioFile
Declaration
From
class AVAudioFile : NSObject {
    init!(forReading fileURL: NSURL!, error outError: NSErrorPointer)
    init!(forReading fileURL: NSURL!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
    init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
    init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, frameCount frames: AVAudioFrameCount, error outError: NSErrorPointer) -> Bool
    func writeFromBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
    var url: NSURL! { get }
    var fileFormat: AVAudioFormat! { get }
    var processingFormat: AVAudioFormat! { get }
    var length: AVAudioFramePosition { get }
    var framePosition: AVAudioFramePosition
}
To
class AVAudioFile : NSObject {
    init(forReading fileURL: NSURL) throws
    init(forReading fileURL: NSURL, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws
    init(forWriting fileURL: NSURL, settings settings: [String : AnyObject]) throws
    init(forWriting fileURL: NSURL, settings settings: [String : AnyObject], commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer) throws
    func readIntoBuffer(_ buffer: AVAudioPCMBuffer, frameCount frames: AVAudioFrameCount) throws
    func writeFromBuffer(_ buffer: AVAudioPCMBuffer) throws
    var url: NSURL { get }
    var fileFormat: AVAudioFormat { get }
    var processingFormat: AVAudioFormat { get }
    var length: AVAudioFramePosition { get }
    var framePosition: AVAudioFramePosition
}

Declaration
From
var fileFormat: AVAudioFormat! { get }
To
var fileFormat: AVAudioFormat { get }

Declaration
From
init!(forReading fileURL: NSURL!, error outError: NSErrorPointer)
To
init(forReading fileURL: NSURL) throws

Declaration
From
init!(forReading fileURL: NSURL!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
To
init(forReading fileURL: NSURL, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws

Declaration
From
init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
To
init(forWriting fileURL: NSURL, settings settings: [String : AnyObject]) throws

Declaration
From
init!(forWriting fileURL: NSURL!, settings settings: [NSObject : AnyObject]!, commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool, error outError: NSErrorPointer)
To
init(forWriting fileURL: NSURL, settings settings: [String : AnyObject], commonFormat format: AVAudioCommonFormat, interleaved interleaved: Bool) throws

Declaration
From
var processingFormat: AVAudioFormat! { get }
To
var processingFormat: AVAudioFormat { get }

Declaration
From
func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
To
func readIntoBuffer(_ buffer: AVAudioPCMBuffer) throws

Declaration
From
func readIntoBuffer(_ buffer: AVAudioPCMBuffer!, frameCount frames: AVAudioFrameCount, error outError: NSErrorPointer) -> Bool
To
func readIntoBuffer(_ buffer: AVAudioPCMBuffer, frameCount frames: AVAudioFrameCount) throws

Declaration
From
var url: NSURL! { get }
To
var url: NSURL { get }

Declaration
From
func writeFromBuffer(_ buffer: AVAudioPCMBuffer!, error outError: NSErrorPointer) -> Bool
To
func writeFromBuffer(_ buffer: AVAudioPCMBuffer) throws

Modified AVAudioFormat
DeclarationProtocols
From
class AVAudioFormat : NSObject {
    init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)
    init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout!)
    init!(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)
    init!(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout!)
    init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)
    init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout!)
    init!(settings settings: [NSObject : AnyObject]!)
    func isEqual(_ object: AnyObject!) -> Bool
    var standard: Bool { get }
    var commonFormat: AVAudioCommonFormat { get }
    var channelCount: AVAudioChannelCount { get }
    var sampleRate: Double { get }
    var interleaved: Bool { get }
    var streamDescription: UnsafePointer<AudioStreamBasicDescription> { get }
    var channelLayout: AVAudioChannelLayout! { get }
    var settings: [NSObject : AnyObject]! { get }
}
AnyObject
To
class AVAudioFormat : NSObject, NSSecureCoding, NSCoding {
    init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)
    init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout?)
    init(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)
    init(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout)
    init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)
    init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout)
    init(settings settings: [String : AnyObject])
    init(CMAudioFormatDescription formatDescription: CMAudioFormatDescription)
    func isEqual(_ object: AnyObject) -> Bool
    var standard: Bool { get }
    var commonFormat: AVAudioCommonFormat { get }
    var channelCount: AVAudioChannelCount { get }
    var sampleRate: Double { get }
    var interleaved: Bool { get }
    var streamDescription: UnsafePointer<AudioStreamBasicDescription> { get }
    var channelLayout: AVAudioChannelLayout? { get }
    var settings: [String : AnyObject] { get }
    var formatDescription: CMAudioFormatDescription { get }
}
AnyObject, NSCoding, NSSecureCoding

Declaration
From
var channelLayout: AVAudioChannelLayout! { get }
To
var channelLayout: AVAudioChannelLayout? { get }

Declaration
From
init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)
To
init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, channels channels: AVAudioChannelCount, interleaved interleaved: Bool)

Declaration
From
init!(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout!)
To
init(commonFormat format: AVAudioCommonFormat, sampleRate sampleRate: Double, interleaved interleaved: Bool, channelLayout layout: AVAudioChannelLayout)

Declaration
From
init!(settings settings: [NSObject : AnyObject]!)
To
init(settings settings: [String : AnyObject])

Declaration
From
init!(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout!)
To
init(standardFormatWithSampleRate sampleRate: Double, channelLayout layout: AVAudioChannelLayout)

Declaration
From
init!(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)
To
init(standardFormatWithSampleRate sampleRate: Double, channels channels: AVAudioChannelCount)

Declaration
From
init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)
To
init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>)

Declaration
From
init!(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout!)
To
init(streamDescription asbd: UnsafePointer<AudioStreamBasicDescription>, channelLayout layout: AVAudioChannelLayout?)

Declaration
From
func isEqual(_ object: AnyObject!) -> Bool
To
func isEqual(_ object: AnyObject) -> Bool

Declaration
From
var settings: [NSObject : AnyObject]! { get }
To
var settings: [String : AnyObject] { get }

Declaration
From
class AVAudioInputNode : AVAudioIONode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
}
To
class AVAudioInputNode : AVAudioIONode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
}

Modified AVAudioMix
Declaration
From
class AVAudioMix : NSObject, NSCopying, NSMutableCopying {
    var inputParameters: [AnyObject]! { get }
}
To
class AVAudioMix : NSObject, NSCopying, NSMutableCopying {
    var inputParameters: [AVAudioMixInputParameters] { get }
}

Declaration
From
var inputParameters: [AnyObject]! { get }
To
var inputParameters: [AVAudioMixInputParameters] { get }

Declaration
From
class AVAudioMixerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
}
To
class AVAudioMixerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    var outputVolume: Float
    var nextAvailableInputBus: AVAudioNodeBus { get }
}

Modified AVAudioMixing
Declaration
From
protocol AVAudioMixing : AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    var volume: Float { get set }
}
To
protocol AVAudioMixing : AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    func destinationForMixer(_ mixer: AVAudioNode, bus bus: AVAudioNodeBus) -> AVAudioMixingDestination?
    var volume: Float { get set }
}

Declaration
From
class AVAudioMixInputParameters : NSObject, NSCopying, NSMutableCopying {
    var trackID: CMPersistentTrackID { get }
    var audioTimePitchAlgorithm: String! { get }
    var audioTapProcessor: MTAudioProcessingTap! { get }
    func getVolumeRampForTime(_ time: CMTime, startVolume startVolume: UnsafeMutablePointer<Float>, endVolume endVolume: UnsafeMutablePointer<Float>, timeRange timeRange: UnsafeMutablePointer<CMTimeRange>) -> Bool
}
To
class AVAudioMixInputParameters : NSObject, NSCopying, NSMutableCopying {
    var trackID: CMPersistentTrackID { get }
    var audioTimePitchAlgorithm: String? { get }
    var audioTapProcessor: MTAudioProcessingTap? { get }
    func getVolumeRampForTime(_ time: CMTime, startVolume startVolume: UnsafeMutablePointer<Float>, endVolume endVolume: UnsafeMutablePointer<Float>, timeRange timeRange: UnsafeMutablePointer<CMTimeRange>) -> Bool
}

Declaration
From
var audioTapProcessor: MTAudioProcessingTap! { get }
To
var audioTapProcessor: MTAudioProcessingTap? { get }

Declaration
From
var audioTimePitchAlgorithm: String! { get }
To
var audioTimePitchAlgorithm: String? { get }

Modified AVAudioNode
Declaration
From
class AVAudioNode : NSObject {
    func reset()
    func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
    func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
    func nameForInputBus(_ bus: AVAudioNodeBus) -> String!
    func nameForOutputBus(_ bus: AVAudioNodeBus) -> String!
    func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat!, block tapBlock: AVAudioNodeTapBlock!)
    func removeTapOnBus(_ bus: AVAudioNodeBus)
    var engine: AVAudioEngine! { get }
    var numberOfInputs: Int { get }
    var numberOfOutputs: Int { get }
    var lastRenderTime: AVAudioTime! { get }
}
To
class AVAudioNode : NSObject {
    func reset()
    func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat
    func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat
    func nameForInputBus(_ bus: AVAudioNodeBus) -> String
    func nameForOutputBus(_ bus: AVAudioNodeBus) -> String
    func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat?, block tapBlock: AVAudioNodeTapBlock)
    func removeTapOnBus(_ bus: AVAudioNodeBus)
    var engine: AVAudioEngine? { get }
    var numberOfInputs: Int { get }
    var numberOfOutputs: Int { get }
    var lastRenderTime: AVAudioTime? { get }
}

Declaration
From
var engine: AVAudioEngine! { get }
To
var engine: AVAudioEngine? { get }

Declaration
From
func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
To
func inputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat

Declaration
From
func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat!, block tapBlock: AVAudioNodeTapBlock!)
To
func installTapOnBus(_ bus: AVAudioNodeBus, bufferSize bufferSize: AVAudioFrameCount, format format: AVAudioFormat?, block tapBlock: AVAudioNodeTapBlock)

Declaration
From
var lastRenderTime: AVAudioTime! { get }
To
var lastRenderTime: AVAudioTime? { get }

Declaration
From
func nameForInputBus(_ bus: AVAudioNodeBus) -> String!
To
func nameForInputBus(_ bus: AVAudioNodeBus) -> String

Declaration
From
func nameForOutputBus(_ bus: AVAudioNodeBus) -> String!
To
func nameForOutputBus(_ bus: AVAudioNodeBus) -> String

Declaration
From
func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat!
To
func outputFormatForBus(_ bus: AVAudioNodeBus) -> AVAudioFormat

Declaration
From
class AVAudioPCMBuffer : AVAudioBuffer {
    init!(PCMFormat format: AVAudioFormat!, frameCapacity frameCapacity: AVAudioFrameCount)
    var frameCapacity: AVAudioFrameCount { get }
    var frameLength: AVAudioFrameCount
    var stride: Int { get }
    var floatChannelData: UnsafePointer<UnsafeMutablePointer<Float>> { get }
    var int16ChannelData: UnsafePointer<UnsafeMutablePointer<Int16>> { get }
    var int32ChannelData: UnsafePointer<UnsafeMutablePointer<Int32>> { get }
}
To
class AVAudioPCMBuffer : AVAudioBuffer {
    init(PCMFormat format: AVAudioFormat, frameCapacity frameCapacity: AVAudioFrameCount)
    var frameCapacity: AVAudioFrameCount { get }
    var frameLength: AVAudioFrameCount
    var stride: Int { get }
    var floatChannelData: UnsafePointer<UnsafeMutablePointer<Float>> { get }
    var int16ChannelData: UnsafePointer<UnsafeMutablePointer<Int16>> { get }
    var int32ChannelData: UnsafePointer<UnsafeMutablePointer<Int32>> { get }
}

Declaration
From
init!(PCMFormat format: AVAudioFormat!, frameCapacity frameCapacity: AVAudioFrameCount)
To
init(PCMFormat format: AVAudioFormat, frameCapacity frameCapacity: AVAudioFrameCount)

Modified AVAudioPlayer
Declaration
From
class AVAudioPlayer : NSObject {
    init!(contentsOfURL url: NSURL!, error outError: NSErrorPointer)
    init!(data data: NSData!, error outError: NSErrorPointer)
    init!(contentsOfURL url: NSURL!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
    init!(data data: NSData!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
    func prepareToPlay() -> Bool
    func play() -> Bool
    func playAtTime(_ time: NSTimeInterval) -> Bool
    func pause()
    func stop()
    var playing: Bool { get }
    var numberOfChannels: Int { get }
    var duration: NSTimeInterval { get }
    unowned(unsafe) var delegate: AVAudioPlayerDelegate!
    var url: NSURL! { get }
    var data: NSData! { get }
    var pan: Float
    var volume: Float
    var enableRate: Bool
    var rate: Float
    var currentTime: NSTimeInterval
    var deviceCurrentTime: NSTimeInterval { get }
    var numberOfLoops: Int
    var settings: [NSObject : AnyObject]! { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}
To
class AVAudioPlayer : NSObject {
    init(contentsOfURL url: NSURL) throws
    init(data data: NSData) throws
    init(contentsOfURL url: NSURL, fileTypeHint utiString: String?) throws
    init(data data: NSData, fileTypeHint utiString: String?) throws
    func prepareToPlay() -> Bool
    func play() -> Bool
    func playAtTime(_ time: NSTimeInterval) -> Bool
    func pause()
    func stop()
    var playing: Bool { get }
    var numberOfChannels: Int { get }
    var duration: NSTimeInterval { get }
    unowned(unsafe) var delegate: AVAudioPlayerDelegate?
    var url: NSURL? { get }
    var data: NSData? { get }
    var pan: Float
    var volume: Float
    var enableRate: Bool
    var rate: Float
    var currentTime: NSTimeInterval
    var deviceCurrentTime: NSTimeInterval { get }
    var numberOfLoops: Int
    var settings: [String : AnyObject] { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

Declaration
From
var data: NSData! { get }
To
var data: NSData? { get }

Declaration
From
unowned(unsafe) var delegate: AVAudioPlayerDelegate!
To
unowned(unsafe) var delegate: AVAudioPlayerDelegate?

Declaration
From
init!(contentsOfURL url: NSURL!, error outError: NSErrorPointer)
To
init(contentsOfURL url: NSURL) throws

Declaration
From
init!(contentsOfURL url: NSURL!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
To
init(contentsOfURL url: NSURL, fileTypeHint utiString: String?) throws

Declaration
From
init!(data data: NSData!, error outError: NSErrorPointer)
To
init(data data: NSData) throws

Declaration
From
init!(data data: NSData!, fileTypeHint utiString: String!, error outError: NSErrorPointer)
To
init(data data: NSData, fileTypeHint utiString: String?) throws

Declaration
From
var settings: [NSObject : AnyObject]! { get }
To
var settings: [String : AnyObject] { get }

Declaration
From
var url: NSURL! { get }
To
var url: NSURL? { get }

Declaration
From
protocol AVAudioPlayerDelegate : NSObjectProtocol {
    optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer!, successfully flag: Bool)
    optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer!, error error: NSError!)
}
To
protocol AVAudioPlayerDelegate : NSObjectProtocol {
    optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)
    optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error error: NSError?)
}

DeclarationIntroduction
From
optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer!, error error: NSError!)
OS X 10.10
To
optional func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error error: NSError?)
OS X 10.7

DeclarationIntroduction
From
optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer!, successfully flag: Bool)
OS X 10.10
To
optional func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)
OS X 10.7

Declaration
From
class AVAudioPlayerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, atTime when: AVAudioTime!, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleFile(_ file: AVAudioFile!, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func scheduleSegment(_ file: AVAudioFile!, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
    func stop()
    func prepareWithFrameCount(_ frameCount: AVAudioFrameCount)
    func play()
    func playAtTime(_ when: AVAudioTime!)
    func pause()
    func nodeTimeForPlayerTime(_ playerTime: AVAudioTime!) -> AVAudioTime!
    func playerTimeForNodeTime(_ nodeTime: AVAudioTime!) -> AVAudioTime!
    var playing: Bool { get }
}
To
class AVAudioPlayerNode : AVAudioNode, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleBuffer(_ buffer: AVAudioPCMBuffer, atTime when: AVAudioTime?, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleFile(_ file: AVAudioFile, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func scheduleSegment(_ file: AVAudioFile, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)
    func stop()
    func prepareWithFrameCount(_ frameCount: AVAudioFrameCount)
    func play()
    func playAtTime(_ when: AVAudioTime?)
    func pause()
    func nodeTimeForPlayerTime(_ playerTime: AVAudioTime) -> AVAudioTime?
    func playerTimeForNodeTime(_ nodeTime: AVAudioTime) -> AVAudioTime?
    var playing: Bool { get }
}

Declaration
From
func nodeTimeForPlayerTime(_ playerTime: AVAudioTime!) -> AVAudioTime!
To
func nodeTimeForPlayerTime(_ playerTime: AVAudioTime) -> AVAudioTime?

Declaration
From
func playAtTime(_ when: AVAudioTime!)
To
func playAtTime(_ when: AVAudioTime?)

Declaration
From
func playerTimeForNodeTime(_ nodeTime: AVAudioTime!) -> AVAudioTime!
To
func playerTimeForNodeTime(_ nodeTime: AVAudioTime) -> AVAudioTime?

Declaration
From
func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, atTime when: AVAudioTime!, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
To
func scheduleBuffer(_ buffer: AVAudioPCMBuffer, atTime when: AVAudioTime?, options options: AVAudioPlayerNodeBufferOptions, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

Declaration
From
func scheduleBuffer(_ buffer: AVAudioPCMBuffer!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
To
func scheduleBuffer(_ buffer: AVAudioPCMBuffer, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

Declaration
From
func scheduleFile(_ file: AVAudioFile!, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
To
func scheduleFile(_ file: AVAudioFile, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

Declaration
From
func scheduleSegment(_ file: AVAudioFile!, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime!, completionHandler completionHandler: AVAudioNodeCompletionHandler!)
To
func scheduleSegment(_ file: AVAudioFile, startingFrame startFrame: AVAudioFramePosition, frameCount numberFrames: AVAudioFrameCount, atTime when: AVAudioTime?, completionHandler completionHandler: AVAudioNodeCompletionHandler?)

DeclarationProtocols
From
struct AVAudioPlayerNodeBufferOptions : RawOptionSetType {
    init(_ rawValue: UInt)
    init(rawValue rawValue: UInt)
    static var Loops: AVAudioPlayerNodeBufferOptions { get }
    static var Interrupts: AVAudioPlayerNodeBufferOptions { get }
    static var InterruptsAtLoop: AVAudioPlayerNodeBufferOptions { get }
}
RawOptionSetType
To
struct AVAudioPlayerNodeBufferOptions : OptionSetType {
    init(rawValue rawValue: UInt)
    static var Loops: AVAudioPlayerNodeBufferOptions { get }
    static var Interrupts: AVAudioPlayerNodeBufferOptions { get }
    static var InterruptsAtLoop: AVAudioPlayerNodeBufferOptions { get }
}
OptionSetType

Raw Value Type
From--
ToInt

Declaration
From
class AVAudioRecorder : NSObject {
    init!(URL url: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
    func prepareToRecord() -> Bool
    func record() -> Bool
    func recordAtTime(_ time: NSTimeInterval) -> Bool
    func recordForDuration(_ duration: NSTimeInterval) -> Bool
    func recordAtTime(_ time: NSTimeInterval, forDuration duration: NSTimeInterval) -> Bool
    func pause()
    func stop()
    func deleteRecording() -> Bool
    var recording: Bool { get }
    var url: NSURL! { get }
    var settings: [NSObject : AnyObject]! { get }
    unowned(unsafe) var delegate: AVAudioRecorderDelegate!
    var currentTime: NSTimeInterval { get }
    var deviceCurrentTime: NSTimeInterval { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}
To
class AVAudioRecorder : NSObject {
    init(URL url: NSURL, settings settings: [String : AnyObject]) throws
    func prepareToRecord() -> Bool
    func record() -> Bool
    func recordAtTime(_ time: NSTimeInterval) -> Bool
    func recordForDuration(_ duration: NSTimeInterval) -> Bool
    func recordAtTime(_ time: NSTimeInterval, forDuration duration: NSTimeInterval) -> Bool
    func pause()
    func stop()
    func deleteRecording() -> Bool
    var recording: Bool { get }
    var url: NSURL { get }
    var settings: [String : AnyObject] { get }
    unowned(unsafe) var delegate: AVAudioRecorderDelegate?
    var currentTime: NSTimeInterval { get }
    var deviceCurrentTime: NSTimeInterval { get }
    var meteringEnabled: Bool
    func updateMeters()
    func peakPowerForChannel(_ channelNumber: Int) -> Float
    func averagePowerForChannel(_ channelNumber: Int) -> Float
}

Declaration
From
unowned(unsafe) var delegate: AVAudioRecorderDelegate!
To
unowned(unsafe) var delegate: AVAudioRecorderDelegate?

Declaration
From
init!(URL url: NSURL!, settings settings: [NSObject : AnyObject]!, error outError: NSErrorPointer)
To
init(URL url: NSURL, settings settings: [String : AnyObject]) throws

Declaration
From
var settings: [NSObject : AnyObject]! { get }
To
var settings: [String : AnyObject] { get }

Declaration
From
var url: NSURL! { get }
To
var url: NSURL { get }

Declaration
From
protocol AVAudioRecorderDelegate : NSObjectProtocol {
    optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder!, successfully flag: Bool)
    optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder!, error error: NSError!)
}
To
protocol AVAudioRecorderDelegate : NSObjectProtocol {
    optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)
    optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder, error error: NSError?)
}

DeclarationIntroduction
From
optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder!, successfully flag: Bool)
OS X 10.10
To
optional func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)
OS X 10.7

DeclarationIntroduction
From
optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder!, error error: NSError!)
OS X 10.10
To
optional func audioRecorderEncodeErrorDidOccur(_ recorder: AVAudioRecorder, error error: NSError?)
OS X 10.7

Modified AVAudioTime
Declaration
From
class AVAudioTime : NSObject {
    init!(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)
    init!(hostTime hostTime: UInt64)
    init!(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    init!(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    class func timeWithAudioTimeStamp(_ ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double) -> Self!
    class func timeWithHostTime(_ hostTime: UInt64) -> Self!
    class func timeWithSampleTime(_ sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self!
    class func timeWithHostTime(_ hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self!
    class func hostTimeForSeconds(_ seconds: NSTimeInterval) -> UInt64
    class func secondsForHostTime(_ hostTime: UInt64) -> NSTimeInterval
    func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime!) -> AVAudioTime!
    var hostTimeValid: Bool { get }
    var hostTime: UInt64 { get }
    var sampleTimeValid: Bool { get }
    var sampleTime: AVAudioFramePosition { get }
    var sampleRate: Double { get }
    var audioTimeStamp: AudioTimeStamp { get }
}
To
class AVAudioTime : NSObject {
    init(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)
    init(hostTime hostTime: UInt64)
    init(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    init(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
    class func timeWithAudioTimeStamp(_ ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double) -> Self
    class func timeWithHostTime(_ hostTime: UInt64) -> Self
    class func timeWithSampleTime(_ sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self
    class func timeWithHostTime(_ hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double) -> Self
    class func hostTimeForSeconds(_ seconds: NSTimeInterval) -> UInt64
    class func secondsForHostTime(_ hostTime: UInt64) -> NSTimeInterval
    func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime) -> AVAudioTime
    var hostTimeValid: Bool { get }
    var hostTime: UInt64 { get }
    var sampleTimeValid: Bool { get }
    var sampleTime: AVAudioFramePosition { get }
    var sampleRate: Double { get }
    var audioTimeStamp: AudioTimeStamp { get }
}

Declaration
From
func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime!) -> AVAudioTime!
To
func extrapolateTimeFromAnchor(_ anchorTime: AVAudioTime) -> AVAudioTime

Declaration
From
init!(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)
To
init(audioTimeStamp ts: UnsafePointer<AudioTimeStamp>, sampleRate sampleRate: Double)

Declaration
From
init!(hostTime hostTime: UInt64)
To
init(hostTime hostTime: UInt64)

Declaration
From
init!(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
To
init(hostTime hostTime: UInt64, sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

Declaration
From
init!(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)
To
init(sampleTime sampleTime: AVAudioFramePosition, atRate sampleRate: Double)

Modified AVAudioUnit
Declaration
From
class AVAudioUnit : AVAudioNode {
    func loadAudioUnitPresetAtURL(_ url: NSURL!, error error: NSErrorPointer) -> Bool
    var audioComponentDescription: AudioComponentDescription { get }
    var audioUnit: AudioUnit { get }
    var name: String! { get }
    var manufacturerName: String! { get }
    var version: Int { get }
}
To
class AVAudioUnit : AVAudioNode {
    class func instantiateWithComponentDescription(_ audioComponentDescription: AudioComponentDescription, options options: AudioComponentInstantiationOptions, completionHandler completionHandler: (AVAudioUnit?, NSError?) -> Void)
    func loadAudioUnitPresetAtURL(_ url: NSURL) throws
    var audioComponentDescription: AudioComponentDescription { get }
    var audioUnit: AudioUnit { get }
    var AUAudioUnit: AUAudioUnit { get }
    var name: String { get }
    var manufacturerName: String { get }
    var version: Int { get }
}

Declaration
From
func loadAudioUnitPresetAtURL(_ url: NSURL!, error error: NSErrorPointer) -> Bool
To
func loadAudioUnitPresetAtURL(_ url: NSURL) throws

Declaration
From
var manufacturerName: String! { get }
To
var manufacturerName: String { get }

Declaration
From
var name: String! { get }
To
var name: String { get }

Declaration
From
class AVAudioUnitComponent : NSObject {
    var name: String! { get }
    var typeName: String! { get }
    var localizedTypeName: String! { get }
    var manufacturerName: String! { get }
    var version: Int { get }
    var versionString: String! { get }
    var iconURL: NSURL! { get }
    var componentURL: NSURL! { get }
    var availableArchitectures: [AnyObject]! { get }
    var hasCustomView: Bool { get }
    var passesAUVal: Bool { get }
    var sandboxSafe: Bool { get }
    var hasMIDIInput: Bool { get }
    var hasMIDIOutput: Bool { get }
    var audioComponent: AudioComponent { get }
    var configurationDictionary: [NSObject : AnyObject]! { get }
    var userTagNames: [AnyObject]!
    var allTagNames: [AnyObject]! { get }
    var audioComponentDescription: AudioComponentDescription { get }
    func supportsNumberInputChannels(_ numInputChannels: Int, outputChannels numOutputChannels: Int) -> Bool
}
To
class AVAudioUnitComponent : NSObject {
    var name: String { get }
    var typeName: String { get }
    var localizedTypeName: String { get }
    var manufacturerName: String { get }
    var version: Int { get }
    var versionString: String { get }
    var componentURL: NSURL? { get }
    var availableArchitectures: [NSNumber] { get }
    var sandboxSafe: Bool { get }
    var hasMIDIInput: Bool { get }
    var hasMIDIOutput: Bool { get }
    var audioComponent: AudioComponent { get }
    var userTagNames: [String]
    var allTagNames: [String] { get }
    var audioComponentDescription: AudioComponentDescription { get }
    var iconURL: NSURL? { get }
    var icon: NSImage? { get }
    var passesAUVal: Bool { get }
    var hasCustomView: Bool { get }
    var configurationDictionary: [String : AnyObject] { get }
    func supportsNumberInputChannels(_ numInputChannels: Int, outputChannels numOutputChannels: Int) -> Bool
}

Declaration
From
var allTagNames: [AnyObject]! { get }
To
var allTagNames: [String] { get }

Declaration
From
var availableArchitectures: [AnyObject]! { get }
To
var availableArchitectures: [NSNumber] { get }

DeclarationDeprecation
From
var componentURL: NSURL! { get }
--
To
var componentURL: NSURL? { get }
OS X 10.11

Declaration
From
var configurationDictionary: [NSObject : AnyObject]! { get }
To
var configurationDictionary: [String : AnyObject] { get }

Declaration
From
var iconURL: NSURL! { get }
To
var iconURL: NSURL? { get }

Declaration
From
var localizedTypeName: String! { get }
To
var localizedTypeName: String { get }

Declaration
From
var manufacturerName: String! { get }
To
var manufacturerName: String { get }

Declaration
From
var name: String! { get }
To
var name: String { get }

Declaration
From
var typeName: String! { get }
To
var typeName: String { get }

Declaration
From
var userTagNames: [AnyObject]!
To
var userTagNames: [String]

Declaration
From
var versionString: String! { get }
To
var versionString: String { get }

Declaration
From
class AVAudioUnitComponentManager : NSObject {
    var tagNames: [AnyObject]! { get }
    var standardLocalizedTagNames: [AnyObject]! { get }
    class func sharedAudioUnitComponentManager() -> Self!
    func componentsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!
    func componentsPassingTest(_ testHandler: ((AVAudioUnitComponent!, UnsafeMutablePointer<ObjCBool>) -> Bool)!) -> [AnyObject]!
    func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AnyObject]!
}
To
class AVAudioUnitComponentManager : NSObject {
    var tagNames: [String] { get }
    var standardLocalizedTagNames: [String] { get }
    class func sharedAudioUnitComponentManager() -> Self
    func componentsMatchingPredicate(_ predicate: NSPredicate) -> [AVAudioUnitComponent]
    func componentsPassingTest(_ testHandler: (AVAudioUnitComponent, UnsafeMutablePointer<ObjCBool>) -> Bool) -> [AVAudioUnitComponent]
    func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AVAudioUnitComponent]
}

Declaration
From
func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AnyObject]!
To
func componentsMatchingDescription(_ desc: AudioComponentDescription) -> [AVAudioUnitComponent]

Declaration
From
func componentsMatchingPredicate(_ predicate: NSPredicate!) -> [AnyObject]!
To
func componentsMatchingPredicate(_ predicate: NSPredicate) -> [AVAudioUnitComponent]

Declaration
From
func componentsPassingTest(_ testHandler: ((AVAudioUnitComponent!, UnsafeMutablePointer<ObjCBool>) -> Bool)!) -> [AnyObject]!
To
func componentsPassingTest(_ testHandler: (AVAudioUnitComponent, UnsafeMutablePointer<ObjCBool>) -> Bool) -> [AVAudioUnitComponent]

Declaration
From
class func sharedAudioUnitComponentManager() -> Self!
To
class func sharedAudioUnitComponentManager() -> Self

Declaration
From
var standardLocalizedTagNames: [AnyObject]! { get }
To
var standardLocalizedTagNames: [String] { get }

Declaration
From
var tagNames: [AnyObject]! { get }
To
var tagNames: [String] { get }

Raw Value Type
From--
ToInt

Declaration
From
class AVAudioUnitEffect : AVAudioUnit {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}
To
class AVAudioUnitEffect : AVAudioUnit {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

Declaration
From
init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
To
init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

Modified AVAudioUnitEQ
Declaration
From
class AVAudioUnitEQ : AVAudioUnitEffect {
    init!(numberOfBands numberOfBands: Int)
    var bands: [AnyObject]! { get }
    var globalGain: Float
}
To
class AVAudioUnitEQ : AVAudioUnitEffect {
    init(numberOfBands numberOfBands: Int)
    var bands: [AVAudioUnitEQFilterParameters] { get }
    var globalGain: Float
}

Declaration
From
var bands: [AnyObject]! { get }
To
var bands: [AVAudioUnitEQFilterParameters] { get }

Declaration
From
init!(numberOfBands numberOfBands: Int)
To
init(numberOfBands numberOfBands: Int)

Raw Value Type
From--
ToInt

Declaration
From
class AVAudioUnitGenerator : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, NSObjectProtocol, AVAudio3DMixing {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}
To
class AVAudioUnitGenerator : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

Declaration
From
init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
To
init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

DeclarationProtocols
From
class AVAudioUnitMIDIInstrument : AVAudioUnit {
    init!(audioComponentDescription description: AudioComponentDescription)
    func startNote(_ note: UInt8, withVelocity velocity: UInt8, onChannel channel: UInt8)
    func stopNote(_ note: UInt8, onChannel channel: UInt8)
    func sendController(_ controller: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendPitchBend(_ pitchbend: UInt16, onChannel channel: UInt8)
    func sendPressure(_ pressure: UInt8, onChannel channel: UInt8)
    func sendPressureForKey(_ key: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, onChannel channel: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8, data2 data2: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8)
    func sendMIDISysExEvent(_ midiData: NSData!)
}
AnyObject
To
class AVAudioUnitMIDIInstrument : AVAudioUnit, AVAudioMixing, AVAudioStereoMixing, AVAudio3DMixing {
    init(audioComponentDescription description: AudioComponentDescription)
    func startNote(_ note: UInt8, withVelocity velocity: UInt8, onChannel channel: UInt8)
    func stopNote(_ note: UInt8, onChannel channel: UInt8)
    func sendController(_ controller: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendPitchBend(_ pitchbend: UInt16, onChannel channel: UInt8)
    func sendPressure(_ pressure: UInt8, onChannel channel: UInt8)
    func sendPressureForKey(_ key: UInt8, withValue value: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, onChannel channel: UInt8)
    func sendProgramChange(_ program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, onChannel channel: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8, data2 data2: UInt8)
    func sendMIDIEvent(_ midiStatus: UInt8, data1 data1: UInt8)
    func sendMIDISysExEvent(_ midiData: NSData)
}
AVAudio3DMixing, AVAudioMixing, AVAudioStereoMixing, AnyObject, NSObjectProtocol

Declaration
From
init!(audioComponentDescription description: AudioComponentDescription)
To
init(audioComponentDescription description: AudioComponentDescription)

Declaration
From
func sendMIDISysExEvent(_ midiData: NSData!)
To
func sendMIDISysExEvent(_ midiData: NSData)

Raw Value Type
From--
ToInt

Declaration
From
class AVAudioUnitSampler : AVAudioUnitMIDIInstrument {
    func loadSoundBankInstrumentAtURL(_ bankURL: NSURL!, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, error outError: NSErrorPointer) -> Bool
    func loadInstrumentAtURL(_ instrumentURL: NSURL!, error outError: NSErrorPointer) -> Bool
    func loadAudioFilesAtURLs(_ audioFiles: [AnyObject]!, error outError: NSErrorPointer) -> Bool
    var stereoPan: Float
    var masterGain: Float
    var globalTuning: Float
}
To
class AVAudioUnitSampler : AVAudioUnitMIDIInstrument {
    func loadSoundBankInstrumentAtURL(_ bankURL: NSURL, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8) throws
    func loadInstrumentAtURL(_ instrumentURL: NSURL) throws
    func loadAudioFilesAtURLs(_ audioFiles: [NSURL]) throws
    var stereoPan: Float
    var masterGain: Float
    var globalTuning: Float
}

Declaration
From
func loadAudioFilesAtURLs(_ audioFiles: [AnyObject]!, error outError: NSErrorPointer) -> Bool
To
func loadAudioFilesAtURLs(_ audioFiles: [NSURL]) throws

Declaration
From
func loadInstrumentAtURL(_ instrumentURL: NSURL!, error outError: NSErrorPointer) -> Bool
To
func loadInstrumentAtURL(_ instrumentURL: NSURL) throws

Declaration
From
func loadSoundBankInstrumentAtURL(_ bankURL: NSURL!, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8, error outError: NSErrorPointer) -> Bool
To
func loadSoundBankInstrumentAtURL(_ bankURL: NSURL, program program: UInt8, bankMSB bankMSB: UInt8, bankLSB bankLSB: UInt8) throws

Declaration
From
class AVAudioUnitTimeEffect : AVAudioUnit {
    init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}
To
class AVAudioUnitTimeEffect : AVAudioUnit {
    init(audioComponentDescription audioComponentDescription: AudioComponentDescription)
    var bypass: Bool
}

Declaration
From
init!(audioComponentDescription audioComponentDescription: AudioComponentDescription)
To
init(audioComponentDescription audioComponentDescription: AudioComponentDescription)

Declaration
From
class AVCaptureAudioDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var audioSettings: [NSObject : AnyObject]!
}
To
class AVCaptureAudioDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureAudioDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var audioSettings: [NSObject : AnyObject]!
    func recommendedAudioSettingsForAssetWriterWithOutputFileType(_ outputFileType: String!) -> [NSObject : AnyObject]!
}

Introduction
FromOS X 10.10
ToOS X 10.7

Declaration
From
class AVCaptureConnection : NSObject {
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!) -> AVCaptureConnection
    class func connectionWithInputPorts(_ ports: [AnyObject]!, output output: AVCaptureOutput!) -> AVCaptureConnection!
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> AVCaptureConnection
    class func connectionWithInputPort(_ port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> AVCaptureConnection!
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    var inputPorts: [AnyObject]! { get }
    var output: AVCaptureOutput! { get }
    var videoPreviewLayer: AVCaptureVideoPreviewLayer! { get }
    var enabled: Bool
    var active: Bool { get }
    var audioChannels: [AnyObject]! { get }
    var supportsVideoMirroring: Bool { get }
    var videoMirrored: Bool
    var automaticallyAdjustsVideoMirroring: Bool
    var supportsVideoOrientation: Bool { get }
    var videoOrientation: AVCaptureVideoOrientation
    var supportsVideoFieldMode: Bool { get }
    var videoFieldMode: AVVideoFieldMode
    var supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
    var videoMaxScaleAndCropFactor: CGFloat { get }
    var videoScaleAndCropFactor: CGFloat
    var supportsVideoStabilization: Bool { get }
    var videoStabilizationEnabled: Bool { get }
    var enablesVideoStabilizationWhenAvailable: Bool
}
To
class AVCaptureConnection : NSObject {
    convenience init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    class func connectionWithInputPorts(_ ports: [AnyObject]!, output output: AVCaptureOutput!) -> Self!
    convenience init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    class func connectionWithInputPort(_ port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!) -> Self!
    init!(inputPorts ports: [AnyObject]!, output output: AVCaptureOutput!)
    init!(inputPort port: AVCaptureInputPort!, videoPreviewLayer layer: AVCaptureVideoPreviewLayer!)
    var inputPorts: [AnyObject]! { get }
    var output: AVCaptureOutput! { get }
    var videoPreviewLayer: AVCaptureVideoPreviewLayer! { get }
    var enabled: Bool
    var active: Bool { get }
    var audioChannels: [AnyObject]! { get }
    var supportsVideoMirroring: Bool { get }
    var videoMirrored: Bool
    var automaticallyAdjustsVideoMirroring: Bool
    var supportsVideoOrientation: Bool { get }
    var videoOrientation: AVCaptureVideoOrientation
    var supportsVideoFieldMode: Bool { get }
    var videoFieldMode: AVVideoFieldMode
    var supportsVideoMinFrameDuration: Bool { get }
    var videoMinFrameDuration: CMTime
    var supportsVideoMaxFrameDuration: Bool { get }
    var videoMaxFrameDuration: CMTime
}

Declaration
From
class AVCaptureDevice : NSObject {
    class func devices() -> [AnyObject]!
    class func devicesWithMediaType(_ mediaType: String!) -> [AnyObject]!
    class func defaultDeviceWithMediaType(_ mediaType: String!) -> AVCaptureDevice!
    init!(uniqueID deviceUniqueID: String!) -> AVCaptureDevice
    class func deviceWithUniqueID(_ deviceUniqueID: String!) -> AVCaptureDevice!
    var uniqueID: String! { get }
    var modelID: String! { get }
    var localizedName: String! { get }
    var manufacturer: String! { get }
    var transportType: Int32 { get }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration(_ outError: NSErrorPointer) -> Bool
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var inUseByAnotherApplication: Bool { get }
    var suspended: Bool { get }
    var linkedDevices: [AnyObject]! { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
    var inputSources: [AnyObject]! { get }
    var activeInputSource: AVCaptureDeviceInputSource!
}
extension AVCaptureDevice {
    var position: AVCaptureDevicePosition { get }
}
extension AVCaptureDevice {
    var hasFlash: Bool { get }
    var flashAvailable: Bool { get }
    var flashActive: Bool { get }
    func isFlashModeSupported(_ flashMode: AVCaptureFlashMode) -> Bool
    var flashMode: AVCaptureFlashMode
}
extension AVCaptureDevice {
    var hasTorch: Bool { get }
    var torchAvailable: Bool { get }
    var torchActive: Bool { get }
    var torchLevel: Float { get }
    func isTorchModeSupported(_ torchMode: AVCaptureTorchMode) -> Bool
    var torchMode: AVCaptureTorchMode
    func setTorchModeOnWithLevel(_ torchLevel: Float, error outError: NSErrorPointer) -> Bool
}
extension AVCaptureDevice {
    func isFocusModeSupported(_ focusMode: AVCaptureFocusMode) -> Bool
    var focusMode: AVCaptureFocusMode
    var focusPointOfInterestSupported: Bool { get }
    var focusPointOfInterest: CGPoint
    var adjustingFocus: Bool { get }
}
extension AVCaptureDevice {
    func isExposureModeSupported(_ exposureMode: AVCaptureExposureMode) -> Bool
    var exposureMode: AVCaptureExposureMode
    var exposurePointOfInterestSupported: Bool { get }
    var exposurePointOfInterest: CGPoint
    var adjustingExposure: Bool { get }
}
extension AVCaptureDevice {
    func isWhiteBalanceModeSupported(_ whiteBalanceMode: AVCaptureWhiteBalanceMode) -> Bool
    var whiteBalanceMode: AVCaptureWhiteBalanceMode
    var adjustingWhiteBalance: Bool { get }
}
extension AVCaptureDevice {
    var subjectAreaChangeMonitoringEnabled: Bool
}
extension AVCaptureDevice {
    var lowLightBoostSupported: Bool { get }
    var lowLightBoostEnabled: Bool { get }
    var automaticallyEnablesLowLightBoostWhenAvailable: Bool
}
extension AVCaptureDevice {
    var transportControlsSupported: Bool { get }
    var transportControlsPlaybackMode: AVCaptureDeviceTransportControlsPlaybackMode { get }
    var transportControlsSpeed: AVCaptureDeviceTransportControlsSpeed { get }
    func setTransportControlsPlaybackMode(_ mode: AVCaptureDeviceTransportControlsPlaybackMode, speed speed: AVCaptureDeviceTransportControlsSpeed)
}
To
class AVCaptureDevice : NSObject {
    class func devices() -> [AnyObject]!
    class func devicesWithMediaType(_ mediaType: String!) -> [AnyObject]!
    class func defaultDeviceWithMediaType(_ mediaType: String!) -> AVCaptureDevice!
     init!(uniqueID deviceUniqueID: String!)
    class func deviceWithUniqueID(_ deviceUniqueID: String!) -> AVCaptureDevice!
    var uniqueID: String! { get }
    var modelID: String! { get }
    var localizedName: String! { get }
    var manufacturer: String! { get }
    var transportType: Int32 { get }
    func hasMediaType(_ mediaType: String!) -> Bool
    func lockForConfiguration() throws
    func unlockForConfiguration()
    func supportsAVCaptureSessionPreset(_ preset: String!) -> Bool
    var connected: Bool { get }
    var inUseByAnotherApplication: Bool { get }
    var suspended: Bool { get }
    var linkedDevices: [AnyObject]! { get }
    var formats: [AnyObject]! { get }
    var activeFormat: AVCaptureDeviceFormat!
    var activeVideoMinFrameDuration: CMTime
    var activeVideoMaxFrameDuration: CMTime
    var inputSources: [AnyObject]! { get }
    var activeInputSource: AVCaptureDeviceInputSource!
}
extension AVCaptureDevice {
    var position: AVCaptureDevicePosition { get }
}
extension AVCaptureDevice {
    var hasFlash: Bool { get }
    var flashAvailable: Bool { get }
    var flashActive: Bool { get }
    func isFlashModeSupported(_ flashMode: AVCaptureFlashMode) -> Bool
    var flashMode: AVCaptureFlashMode
}
extension AVCaptureDevice {
    var hasTorch: Bool { get }
    var torchAvailable: Bool { get }
    var torchActive: Bool { get }
    var torchLevel: Float { get }
    func isTorchModeSupported(_ torchMode: AVCaptureTorchMode) -> Bool
    var torchMode: AVCaptureTorchMode
    func setTorchModeOnWithLevel(_ torchLevel: Float) throws
}
extension AVCaptureDevice {
    func isFocusModeSupported(_ focusMode: AVCaptureFocusMode) -> Bool
    var focusMode: AVCaptureFocusMode
    var focusPointOfInterestSupported: Bool { get }
    var focusPointOfInterest: CGPoint
    var adjustingFocus: Bool { get }
    var autoFocusRangeRestrictionSupported: Bool { get }
    var autoFocusRangeRestriction: AVCaptureAutoFocusRangeRestriction
    var smoothAutoFocusSupported: Bool { get }
    var smoothAutoFocusEnabled: Bool
    var lensPosition: Float { get }
    func setFocusModeLockedWithLensPosition(_ lensPosition: Float, completionHandler handler: ((CMTime) -> Void)!)
}
extension AVCaptureDevice {
    func isExposureModeSupported(_ exposureMode: AVCaptureExposureMode) -> Bool
    var exposureMode: AVCaptureExposureMode
    var exposurePointOfInterestSupported: Bool { get }
    var exposurePointOfInterest: CGPoint
    var adjustingExposure: Bool { get }
    var lensAperture: Float { get }
    var exposureDuration: CMTime { get }
    var ISO: Float { get }
    func setExposureModeCustomWithDuration(_ duration: CMTime, ISO ISO: Float, completionHandler handler: ((CMTime) -> Void)!)
    var exposureTargetOffset: Float { get }
    var exposureTargetBias: Float { get }
    var minExposureTargetBias: Float { get }
    var maxExposureTargetBias: Float { get }
    func setExposureTargetBias(_ bias: Float, completionHandler handler: ((CMTime) -> Void)!)
}
extension AVCaptureDevice {
    func isWhiteBalanceModeSupported(_ whiteBalanceMode: AVCaptureWhiteBalanceMode) -> Bool
    var whiteBalanceMode: AVCaptureWhiteBalanceMode
    var adjustingWhiteBalance: Bool { get }
    var deviceWhiteBalanceGains: AVCaptureWhiteBalanceGains { get }
    var grayWorldDeviceWhiteBalanceGains: AVCaptureWhiteBalanceGains { get }
    var maxWhiteBalanceGain: Float { get }
    func setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains, completionHandler handler: ((CMTime) -> Void)!)
    func chromaticityValuesForDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains) -> AVCaptureWhiteBalanceChromaticityValues
    func deviceWhiteBalanceGainsForChromaticityValues(_ chromaticityValues: AVCaptureWhiteBalanceChromaticityValues) -> AVCaptureWhiteBalanceGains
    func temperatureAndTintValuesForDeviceWhiteBalanceGains(_ whiteBalanceGains: AVCaptureWhiteBalanceGains) -> AVCaptureWhiteBalanceTemperatureAndTintValues
    func deviceWhiteBalanceGainsForTemperatureAndTintValues(_ tempAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues) -> AVCaptureWhiteBalanceGains
}
extension AVCaptureDevice {
    var subjectAreaChangeMonitoringEnabled: Bool
}
extension AVCaptureDevice {
    var lowLightBoostSupported: Bool { get }
    var lowLightBoostEnabled: Bool { get }
    var automaticallyEnablesLowLightBoostWhenAvailable: Bool
}
extension AVCaptureDevice {
    var videoZoomFactor: CGFloat
    func rampToVideoZoomFactor(_ factor: CGFloat, withRate rate: Float)
    var rampingVideoZoom: Bool { get }
    func cancelVideoZoomRamp()
}
extension AVCaptureDevice {
    class func authorizationStatusForMediaType(_ mediaType: String!) -> AVAuthorizationStatus
    class func requestAccessForMediaType(_ mediaType: String!, completionHandler handler: ((Bool) -> Void)!)
}
extension AVCaptureDevice {
    var transportControlsSupported: Bool { get }
    var transportControlsPlaybackMode: AVCaptureDeviceTransportControlsPlaybackMode { get }
    var transportControlsSpeed: AVCaptureDeviceTransportControlsSpeed { get }
    func setTransportControlsPlaybackMode(_ mode: AVCaptureDeviceTransportControlsPlaybackMode, speed speed: AVCaptureDeviceTransportControlsSpeed)
}
extension AVCaptureDevice {
    var automaticallyAdjustsVideoHDREnabled: Bool
    var videoHDREnabled: Bool
}

Declaration
From
init!(uniqueID deviceUniqueID: String!) -> AVCaptureDevice
To
init!(uniqueID deviceUniqueID: String!)

Declaration
From
func lockForConfiguration(_ outError: NSErrorPointer) -> Bool
To
func lockForConfiguration() throws

Declaration
From
class AVCaptureDeviceInput : AVCaptureInput {
    class func deviceInputWithDevice(_ device: AVCaptureDevice!, error outError: NSErrorPointer) -> AnyObject!
    init!(device device: AVCaptureDevice!, error outError: NSErrorPointer)
    var device: AVCaptureDevice! { get }
}
To
class AVCaptureDeviceInput : AVCaptureInput {
    convenience init(device device: AVCaptureDevice!) throws
    class func deviceInputWithDevice(_ device: AVCaptureDevice!) throws -> Self
    init(device device: AVCaptureDevice!) throws
    var device: AVCaptureDevice! { get }
}

Declaration
From
init!(device device: AVCaptureDevice!, error outError: NSErrorPointer)
To
init(device device: AVCaptureDevice!) throws

Raw Value Type
From--
ToInt

Raw Value Type
From--
ToInt

DeclarationRaw Value Type
From
enum AVCaptureExposureMode : Int {
    case Locked
    case AutoExpose
    case ContinuousAutoExposure
}
--
To
enum AVCaptureExposureMode : Int {
    case Locked
    case AutoExpose
    case ContinuousAutoExposure
    case Custom
}
Int

Introduction
FromOS X 10.10
ToOS X 10.7

Introduction
FromOS X 10.10
ToOS X 10.7

Raw Value Type
From--
ToInt

Raw Value Type
From--
ToInt

Introduction
FromOS X 10.10
ToOS X 10.7

Declaration
From
class AVCaptureOutput : NSObject {
    var connections: [AnyObject]! { get }
    func connectionWithMediaType(_ mediaType: String!) -> AVCaptureConnection!
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!, connection connection: AVCaptureConnection!) -> AVMetadataObject!
}
To
class AVCaptureOutput : NSObject {
    var connections: [AnyObject]! { get }
    func connectionWithMediaType(_ mediaType: String!) -> AVCaptureConnection!
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!, connection connection: AVCaptureConnection!) -> AVMetadataObject!
    func metadataOutputRectOfInterestForRect(_ rectInOutputCoordinates: CGRect) -> CGRect
    func rectForMetadataOutputRectOfInterest(_ rectInMetadataOutputCoordinates: CGRect) -> CGRect
}

Deprecation
From--
ToOS X 10.10

Raw Value Type
From--
ToInt

Declaration
From
class AVCaptureVideoDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var videoSettings: [NSObject : AnyObject]!
    var availableVideoCVPixelFormatTypes: [AnyObject]! { get }
    var availableVideoCodecTypes: [AnyObject]! { get }
    var minFrameDuration: CMTime
    var alwaysDiscardsLateVideoFrames: Bool
}
To
class AVCaptureVideoDataOutput : AVCaptureOutput {
    func setSampleBufferDelegate(_ sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate!, queue sampleBufferCallbackQueue: dispatch_queue_t!)
    var sampleBufferDelegate: AVCaptureVideoDataOutputSampleBufferDelegate! { get }
    var sampleBufferCallbackQueue: dispatch_queue_t! { get }
    var videoSettings: [NSObject : AnyObject]!
    func recommendedVideoSettingsForAssetWriterWithOutputFileType(_ outputFileType: String!) -> [NSObject : AnyObject]!
    var availableVideoCVPixelFormatTypes: [AnyObject]! { get }
    var availableVideoCodecTypes: [AnyObject]! { get }
    var minFrameDuration: CMTime
    var alwaysDiscardsLateVideoFrames: Bool
}

Introduction
FromOS X 10.10
ToOS X 10.7

Raw Value Type
From--
ToInt

Declaration
From
class AVCaptureVideoPreviewLayer : CALayer {
    class func layerWithSession(_ session: AVCaptureSession!) -> AnyObject!
    init!(session session: AVCaptureSession!)
    class func layerWithSessionWithNoConnection(_ session: AVCaptureSession!) -> AnyObject!
    init!(sessionWithNoConnection session: AVCaptureSession!)
    var session: AVCaptureSession!
    func setSessionWithNoConnection(_ session: AVCaptureSession!)
    var connection: AVCaptureConnection! { get }
    var videoGravity: String!
    func captureDevicePointOfInterestForPoint(_ pointInLayer: CGPoint) -> CGPoint
    func pointForCaptureDevicePointOfInterest(_ captureDevicePointOfInterest: CGPoint) -> CGPoint
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!) -> AVMetadataObject!
}
To
class AVCaptureVideoPreviewLayer : CALayer {
    convenience init!(session session: AVCaptureSession!)
    class func layerWithSession(_ session: AVCaptureSession!) -> Self!
    init!(session session: AVCaptureSession!)
    convenience init!(sessionWithNoConnection session: AVCaptureSession!)
    class func layerWithSessionWithNoConnection(_ session: AVCaptureSession!) -> Self!
    init!(sessionWithNoConnection session: AVCaptureSession!)
    var session: AVCaptureSession!
    func setSessionWithNoConnection(_ session: AVCaptureSession!)
    var connection: AVCaptureConnection! { get }
    var videoGravity: String!
    func captureDevicePointOfInterestForPoint(_ pointInLayer: CGPoint) -> CGPoint
    func pointForCaptureDevicePointOfInterest(_ captureDevicePointOfInterest: CGPoint) -> CGPoint
    func metadataOutputRectOfInterestForRect(_ rectInLayerCoordinates: CGRect) -> CGRect
    func rectForMetadataOutputRectOfInterest(_ rectInMetadataOutputCoordinates: CGRect) -> CGRect
    func transformedMetadataObjectForMetadataObject(_ metadataObject: AVMetadataObject!) -> AVMetadataObject!
}

Raw Value Type
From--
ToInt

Modified AVComposition
Declaration
From
class AVComposition : AVAsset, NSMutableCopying {
    var tracks: [AnyObject]! { get }
    var naturalSize: CGSize { get }
}
To
class AVComposition : AVAsset, NSMutableCopying {
    var tracks: [AVCompositionTrack] { get }
    var naturalSize: CGSize { get }
    var URLAssetInitializationOptions: [String : AnyObject] { get }
}
extension AVComposition {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVCompositionTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVCompositionTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVCompositionTrack]
}

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVCompositionTrack] { get }

Declaration
From
class AVCompositionTrack : AVAssetTrack {
    var segments: [AnyObject]! { get }
}
To
class AVCompositionTrack : AVAssetTrack {
    var segments: [AVCompositionTrackSegment] { get }
}

Declaration
From
var segments: [AnyObject]! { get }
To
var segments: [AVCompositionTrackSegment] { get }

Declaration
From
class AVCompositionTrackSegment : AVAssetTrackSegment {
    init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> AVCompositionTrackSegment
    class func compositionTrackSegmentWithURL(_ URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> AVCompositionTrackSegment!
    init!(timeRange timeRange: CMTimeRange) -> AVCompositionTrackSegment
    class func compositionTrackSegmentWithTimeRange(_ timeRange: CMTimeRange) -> AVCompositionTrackSegment!
    init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    init!(timeRange timeRange: CMTimeRange)
    var empty: Bool { get }
    var sourceURL: NSURL! { get }
    var sourceTrackID: CMPersistentTrackID { get }
}
To
class AVCompositionTrackSegment : AVAssetTrackSegment {
    convenience init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    class func compositionTrackSegmentWithURL(_ URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange) -> Self
    convenience init(timeRange timeRange: CMTimeRange)
    class func compositionTrackSegmentWithTimeRange(_ timeRange: CMTimeRange) -> Self
    init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
    init(timeRange timeRange: CMTimeRange)
    var empty: Bool { get }
    var sourceURL: NSURL? { get }
    var sourceTrackID: CMPersistentTrackID { get }
}

Declaration
From
init!(timeRange timeRange: CMTimeRange)
To
init(timeRange timeRange: CMTimeRange)

Declaration
From
init!(URL URL: NSURL!, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)
To
init(URL URL: NSURL, trackID trackID: CMPersistentTrackID, sourceTimeRange sourceTimeRange: CMTimeRange, targetTimeRange targetTimeRange: CMTimeRange)

Declaration
From
var sourceURL: NSURL! { get }
To
var sourceURL: NSURL? { get }

Raw Value Type
From--
ToInt

DeclarationProtocolsRaw Value Type
From
enum AVError : Int {
    case Unknown
    case OutOfMemory
    case SessionNotRunning
    case DeviceAlreadyUsedByAnotherSession
    case NoDataCaptured
    case SessionConfigurationChanged
    case DiskFull
    case DeviceWasDisconnected
    case MediaChanged
    case MaximumDurationReached
    case MaximumFileSizeReached
    case MediaDiscontinuity
    case MaximumNumberOfSamplesForFileFormatReached
    case DeviceNotConnected
    case DeviceInUseByAnotherApplication
    case DeviceLockedForConfigurationByAnotherProcess
    case ExportFailed
    case DecodeFailed
    case InvalidSourceMedia
    case FileAlreadyExists
    case CompositionTrackSegmentsNotContiguous
    case InvalidCompositionTrackSegmentDuration
    case InvalidCompositionTrackSegmentSourceStartTime
    case InvalidCompositionTrackSegmentSourceDuration
    case FileFormatNotRecognized
    case FileFailedToParse
    case MaximumStillImageCaptureRequestsExceeded
    case ContentIsProtected
    case NoImageAtTime
    case DecoderNotFound
    case EncoderNotFound
    case ContentIsNotAuthorized
    case ApplicationIsNotAuthorized
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
}
Equatable, Hashable, RawRepresentable--
To
enum AVError : Int {
    case Unknown
    case OutOfMemory
    case SessionNotRunning
    case DeviceAlreadyUsedByAnotherSession
    case NoDataCaptured
    case SessionConfigurationChanged
    case DiskFull
    case DeviceWasDisconnected
    case MediaChanged
    case MaximumDurationReached
    case MaximumFileSizeReached
    case MediaDiscontinuity
    case MaximumNumberOfSamplesForFileFormatReached
    case DeviceNotConnected
    case DeviceInUseByAnotherApplication
    case DeviceLockedForConfigurationByAnotherProcess
    case ExportFailed
    case DecodeFailed
    case InvalidSourceMedia
    case FileAlreadyExists
    case CompositionTrackSegmentsNotContiguous
    case InvalidCompositionTrackSegmentDuration
    case InvalidCompositionTrackSegmentSourceStartTime
    case InvalidCompositionTrackSegmentSourceDuration
    case FileFormatNotRecognized
    case FileFailedToParse
    case MaximumStillImageCaptureRequestsExceeded
    case ContentIsProtected
    case NoImageAtTime
    case DecoderNotFound
    case EncoderNotFound
    case ContentIsNotAuthorized
    case ApplicationIsNotAuthorized
    case OperationNotSupportedForAsset
    case DecoderTemporarilyUnavailable
    case EncoderTemporarilyUnavailable
    case InvalidVideoComposition
    case ReferenceForbiddenByReferencePolicy
    case InvalidOutputURLPathExtension
    case ScreenCaptureFailed
    case DisplayWasDisabled
    case TorchLevelUnavailable
    case IncompatibleAsset
    case FailedToLoadMediaData
    case ServerIncorrectlyConfigured
    case ApplicationIsNotAuthorizedToUseDevice
    case FailedToParse
    case FileTypeDoesNotSupportSampleReferences
    case UndecodableMediaData
    case AirPlayControllerRequiresInternet
    case AirPlayReceiverRequiresInternet
    case VideoCompositorFailed
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
extension AVError : Hashable, Equatable, __BridgedNSError, ErrorType, RawRepresentable, _ObjectiveCBridgeableErrorType, _BridgedNSError {
}
Equatable, ErrorType, Hashable, RawRepresentableInt

DeclarationProtocols
From
class AVFragmentedMovie : AVMovie {
    var tracks: [AnyObject]! { get }
}
AnyObject
To
class AVFragmentedMovie : AVMovie, AVFragmentMinding {
    var tracks: [AVFragmentedMovieTrack] { get }
}
extension AVFragmentedMovie {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVFragmentedMovieTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVFragmentedMovieTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVFragmentedMovieTrack]
}
AVFragmentMinding, AnyObject

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVFragmentedMovieTrack] { get }

DeclarationSuperclasses
From
class AVFragmentedMovieMinder : NSObject {
    convenience init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)
    class func fragmentedMovieMinderWithMovie(_ movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval) -> Self!
    init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)
    var mindingInterval: NSTimeInterval
    var movies: [AnyObject]! { get }
    func addFragmentedMovie(_ movie: AVFragmentedMovie!)
    func removeFragmentedMovie(_ movie: AVFragmentedMovie!)
}
NSObject
To
class AVFragmentedMovieMinder : AVFragmentedAssetMinder {
    convenience init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)
    class func fragmentedMovieMinderWithMovie(_ movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval) -> Self
    init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)
    var mindingInterval: NSTimeInterval
    var movies: [AVFragmentedMovie] { get }
    func addFragmentedMovie(_ movie: AVFragmentedMovie)
    func removeFragmentedMovie(_ movie: AVFragmentedMovie)
}
AVFragmentedAssetMinder

Declaration
From
func addFragmentedMovie(_ movie: AVFragmentedMovie!)
To
func addFragmentedMovie(_ movie: AVFragmentedMovie)

Declaration
From
init!(movie movie: AVFragmentedMovie!, mindingInterval mindingInterval: NSTimeInterval)
To
init(movie movie: AVFragmentedMovie, mindingInterval mindingInterval: NSTimeInterval)

Declaration
From
var movies: [AnyObject]! { get }
To
var movies: [AVFragmentedMovie] { get }

Declaration
From
func removeFragmentedMovie(_ movie: AVFragmentedMovie!)
To
func removeFragmentedMovie(_ movie: AVFragmentedMovie)

Raw Value Type
From--
ToInt

Declaration
From
class AVMediaSelectionGroup : NSObject, NSCopying {
    var options: [AnyObject]! { get }
    var defaultOption: AVMediaSelectionOption! { get }
    var allowsEmptySelection: Bool { get }
    func mediaSelectionOptionWithPropertyList(_ plist: AnyObject!) -> AVMediaSelectionOption!
}
extension AVMediaSelectionGroup {
    class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withoutMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
}
To
class AVMediaSelectionGroup : NSObject, NSCopying {
    var options: [AVMediaSelectionOption] { get }
    var defaultOption: AVMediaSelectionOption? { get }
    var allowsEmptySelection: Bool { get }
    func mediaSelectionOptionWithPropertyList(_ plist: AnyObject) -> AVMediaSelectionOption?
}
extension AVMediaSelectionGroup {
    class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withLocale locale: NSLocale) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]
    class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withoutMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]
}

Declaration
From
var defaultOption: AVMediaSelectionOption! { get }
To
var defaultOption: AVMediaSelectionOption? { get }

Declaration
From
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
To
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMediaSelectionOption]

Declaration
From
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
To
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withLocale locale: NSLocale) -> [AVMediaSelectionOption]

Declaration
From
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
To
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]

Declaration
From
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!, withoutMediaCharacteristics mediaCharacteristics: [AnyObject]!) -> [AnyObject]!
To
class func mediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption], withoutMediaCharacteristics mediaCharacteristics: [String]) -> [AVMediaSelectionOption]

Declaration
From
func mediaSelectionOptionWithPropertyList(_ plist: AnyObject!) -> AVMediaSelectionOption!
To
func mediaSelectionOptionWithPropertyList(_ plist: AnyObject) -> AVMediaSelectionOption?

Declaration
From
var options: [AnyObject]! { get }
To
var options: [AVMediaSelectionOption] { get }

Declaration
From
class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AnyObject]!) -> [AnyObject]!
To
class func playableMediaSelectionOptionsFromArray(_ mediaSelectionOptions: [AVMediaSelectionOption]) -> [AVMediaSelectionOption]

Declaration
From
class AVMediaSelectionOption : NSObject, NSCopying {
    var mediaType: String! { get }
    var mediaSubTypes: [AnyObject]! { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
    var playable: Bool { get }
    var extendedLanguageTag: String! { get }
    var locale: NSLocale! { get }
    var commonMetadata: [AnyObject]! { get }
    var availableMetadataFormats: [AnyObject]! { get }
    func metadataForFormat(_ format: String!) -> [AnyObject]!
    func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!
    func propertyList() -> AnyObject!
    func displayNameWithLocale(_ locale: NSLocale!) -> String!
    var displayName: String! { get }
}
To
class AVMediaSelectionOption : NSObject, NSCopying {
    var mediaType: String { get }
    var mediaSubTypes: [NSNumber] { get }
    func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool
    var playable: Bool { get }
    var extendedLanguageTag: String? { get }
    var locale: NSLocale? { get }
    var commonMetadata: [AVMetadataItem] { get }
    var availableMetadataFormats: [String] { get }
    func metadataForFormat(_ format: String) -> [AVMetadataItem]
    func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?
    func propertyList() -> AnyObject
    func displayNameWithLocale(_ locale: NSLocale) -> String
    var displayName: String { get }
}

Declaration
From
func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!
To
func associatedMediaSelectionOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?

Declaration
From
var availableMetadataFormats: [AnyObject]! { get }
To
var availableMetadataFormats: [String] { get }

Declaration
From
var commonMetadata: [AnyObject]! { get }
To
var commonMetadata: [AVMetadataItem] { get }

Declaration
From
var displayName: String! { get }
To
var displayName: String { get }

Declaration
From
func displayNameWithLocale(_ locale: NSLocale!) -> String!
To
func displayNameWithLocale(_ locale: NSLocale) -> String

Declaration
From
var extendedLanguageTag: String! { get }
To
var extendedLanguageTag: String? { get }

Declaration
From
func hasMediaCharacteristic(_ mediaCharacteristic: String!) -> Bool
To
func hasMediaCharacteristic(_ mediaCharacteristic: String) -> Bool

Declaration
From
var locale: NSLocale! { get }
To
var locale: NSLocale? { get }

Declaration
From
var mediaSubTypes: [AnyObject]! { get }
To
var mediaSubTypes: [NSNumber] { get }

Declaration
From
var mediaType: String! { get }
To
var mediaType: String { get }

Declaration
From
func metadataForFormat(_ format: String!) -> [AnyObject]!
To
func metadataForFormat(_ format: String) -> [AVMetadataItem]

Declaration
From
func propertyList() -> AnyObject!
To
func propertyList() -> AnyObject

Declaration
From
class AVMetadataItem : NSObject, AVAsynchronousKeyValueLoading, NSCopying, NSMutableCopying {
    var identifier: String! { get }
    var extendedLanguageTag: String! { get }
    @NSCopying var locale: NSLocale! { get }
    var time: CMTime { get }
    var duration: CMTime { get }
    var dataType: String! { get }
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>! { get }
    var extraAttributes: [NSObject : AnyObject]! { get }
}
extension AVMetadataItem {
    var stringValue: String! { get }
    var numberValue: NSNumber! { get }
    var dateValue: NSDate! { get }
    var dataValue: NSData! { get }
}
extension AVMetadataItem {
    func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByIdentifier identifier: String!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter!) -> [AnyObject]!
}
extension AVMetadataItem {
    class func identifierForKey(_ key: AnyObject!, keySpace keySpace: String!) -> String!
    class func keySpaceForIdentifier(_ identifier: String!) -> String!
    class func keyForIdentifier(_ identifier: String!) -> AnyObject!
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>! { get }
    var commonKey: String! { get }
    var keySpace: String! { get }
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
    class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withKey key: AnyObject!, keySpace keySpace: String!) -> [AnyObject]!
}
To
class AVMetadataItem : NSObject, AVAsynchronousKeyValueLoading, NSCopying, NSMutableCopying {
    var identifier: String? { get }
    var extendedLanguageTag: String? { get }
    @NSCopying var locale: NSLocale? { get }
    var time: CMTime { get }
    var duration: CMTime { get }
    var dataType: String? { get }
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>? { get }
    var extraAttributes: [String : AnyObject]? { get }
}
extension AVMetadataItem {
    @NSCopying var startDate: NSDate? { get }
}
extension AVMetadataItem {
    var stringValue: String? { get }
    var numberValue: NSNumber? { get }
    var dateValue: NSDate? { get }
    var dataValue: NSData? { get }
}
extension AVMetadataItem {
    func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus
    func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByIdentifier identifier: String) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter) -> [AVMetadataItem]
}
extension AVMetadataItem {
    class func identifierForKey(_ key: AnyObject, keySpace keySpace: String) -> String?
    class func keySpaceForIdentifier(_ identifier: String) -> String?
    class func keyForIdentifier(_ identifier: String) -> AnyObject?
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>? { get }
    var commonKey: String? { get }
    var keySpace: String? { get }
}
extension AVMetadataItem {
     init(propertiesOfMetadataItem metadataItem: AVMetadataItem, valueLoadingHandler handler: (AVMetadataItemValueRequest) -> Void)
    class func metadataItemWithPropertiesOfMetadataItem(_ metadataItem: AVMetadataItem, valueLoadingHandler handler: (AVMetadataItemValueRequest) -> Void) -> AVMetadataItem
}
extension AVMetadataItem {
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withLocale locale: NSLocale) -> [AVMetadataItem]
    class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withKey key: AnyObject?, keySpace keySpace: String?) -> [AVMetadataItem]
}

Declaration
From
var commonKey: String! { get }
To
var commonKey: String? { get }

Declaration
From
var dataType: String! { get }
To
var dataType: String? { get }

Declaration
From
var dataValue: NSData! { get }
To
var dataValue: NSData? { get }

Declaration
From
var dateValue: NSDate! { get }
To
var dateValue: NSDate? { get }

Declaration
From
var extendedLanguageTag: String! { get }
To
var extendedLanguageTag: String? { get }

Declaration
From
var extraAttributes: [NSObject : AnyObject]! { get }
To
var extraAttributes: [String : AnyObject]? { get }

Declaration
From
var identifier: String! { get }
To
var identifier: String? { get }

Declaration
From
class func identifierForKey(_ key: AnyObject!, keySpace keySpace: String!) -> String!
To
class func identifierForKey(_ key: AnyObject, keySpace keySpace: String) -> String?

Declaration
From
@NSCopying var key: protocol<NSCopying, NSObjectProtocol>! { get }
To
@NSCopying var key: protocol<NSCopying, NSObjectProtocol>? { get }

Declaration
From
class func keyForIdentifier(_ identifier: String!) -> AnyObject!
To
class func keyForIdentifier(_ identifier: String) -> AnyObject?

Declaration
From
var keySpace: String! { get }
To
var keySpace: String? { get }

Declaration
From
class func keySpaceForIdentifier(_ identifier: String!) -> String!
To
class func keySpaceForIdentifier(_ identifier: String) -> String?

Declaration
From
func loadValuesAsynchronouslyForKeys(_ keys: [AnyObject]!, completionHandler handler: (() -> Void)!)
To
func loadValuesAsynchronouslyForKeys(_ keys: [String], completionHandler handler: (() -> Void)?)

Declaration
From
@NSCopying var locale: NSLocale! { get }
To
@NSCopying var locale: NSLocale? { get }

Declaration
From
class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [AnyObject]!) -> [AnyObject]!
To
class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredAndSortedAccordingToPreferredLanguages preferredLanguages: [String]) -> [AVMetadataItem]

Declaration
From
class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByIdentifier identifier: String!) -> [AnyObject]!
To
class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByIdentifier identifier: String) -> [AVMetadataItem]

Declaration
From
class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter!) -> [AnyObject]!
To
class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], filteredByMetadataItemFilter metadataItemFilter: AVMetadataItemFilter) -> [AVMetadataItem]

Declaration
From
class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withKey key: AnyObject!, keySpace keySpace: String!) -> [AnyObject]!
To
class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withKey key: AnyObject?, keySpace keySpace: String?) -> [AVMetadataItem]

Declaration
From
class func metadataItemsFromArray(_ metadataItems: [AnyObject]!, withLocale locale: NSLocale!) -> [AnyObject]!
To
class func metadataItemsFromArray(_ metadataItems: [AVMetadataItem], withLocale locale: NSLocale) -> [AVMetadataItem]

Declaration
From
var numberValue: NSNumber! { get }
To
var numberValue: NSNumber? { get }

Declaration
From
func statusOfValueForKey(_ key: String!, error outError: NSErrorPointer) -> AVKeyValueStatus
To
func statusOfValueForKey(_ key: String, error outError: NSErrorPointer) -> AVKeyValueStatus

Declaration
From
var stringValue: String! { get }
To
var stringValue: String? { get }

Declaration
From
@NSCopying var value: protocol<NSCopying, NSObjectProtocol>! { get }
To
@NSCopying var value: protocol<NSCopying, NSObjectProtocol>? { get }

Declaration
From
class AVMetadataItemFilter : NSObject {
    class func metadataItemFilterForSharing() -> AVMetadataItemFilter!
}
To
class AVMetadataItemFilter : NSObject {
    class func metadataItemFilterForSharing() -> AVMetadataItemFilter
}

Declaration
From
class func metadataItemFilterForSharing() -> AVMetadataItemFilter!
To
class func metadataItemFilterForSharing() -> AVMetadataItemFilter

Declaration
From
class AVMetadataObject : NSObject {
    var time: CMTime { get }
    var duration: CMTime { get }
    var bounds: CGRect { get }
    var type: String! { get }
}
To
class AVMetadataObject : NSObject {
    init!()
    var time: CMTime { get }
    var duration: CMTime { get }
    var bounds: CGRect { get }
    var type: String! { get }
}

Modified AVMIDIPlayer
Declaration
From
class AVMIDIPlayer : NSObject {
    init!(contentsOfURL inURL: NSURL!, soundBankURL bankURL: NSURL!, error outError: NSErrorPointer)
    init!(data data: NSData!, soundBankURL bankURL: NSURL!, error outError: NSErrorPointer)
    func prepareToPlay()
    func play(_ completionHandler: AVMIDIPlayerCompletionHandler!)
    func stop()
    var duration: NSTimeInterval { get }
    var playing: Bool { get }
    var rate: Float
    var currentPosition: NSTimeInterval
}
To
class AVMIDIPlayer : NSObject {
    init(contentsOfURL inURL: NSURL, soundBankURL bankURL: NSURL?) throws
    init(data data: NSData, soundBankURL bankURL: NSURL?) throws
    func prepareToPlay()
    func play(_ completionHandler: AVMIDIPlayerCompletionHandler?)
    func stop()
    var duration: NSTimeInterval { get }
    var playing: Bool { get }
    var rate: Float
    var currentPosition: NSTimeInterval
}

Declaration
From
init!(contentsOfURL inURL: NSURL!, soundBankURL bankURL: NSURL!, error outError: NSErrorPointer)
To
init(contentsOfURL inURL: NSURL, soundBankURL bankURL: NSURL?) throws

Declaration
From
init!(data data: NSData!, soundBankURL bankURL: NSURL!, error outError: NSErrorPointer)
To
init(data data: NSData, soundBankURL bankURL: NSURL?) throws

Declaration
From
func play(_ completionHandler: AVMIDIPlayerCompletionHandler!)
To
func play(_ completionHandler: AVMIDIPlayerCompletionHandler?)

Modified AVMovie
DeclarationProtocols
From
class AVMovie : AVAsset {
    class func movieTypes() -> [AnyObject]!
    convenience init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!)
    class func movieWithURL(_ URL: NSURL!, options options: [NSObject : AnyObject]!) -> Self!
    init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!)
    var URL: NSURL! { get }
    var tracks: [AnyObject]! { get }
    var canContainMovieFragments: Bool { get }
}
AnyObject
To
class AVMovie : AVAsset, NSMutableCopying {
    class func movieTypes() -> [String]
    convenience init(URL URL: NSURL, options options: [String : AnyObject]?)
    class func movieWithURL(_ URL: NSURL, options options: [String : AnyObject]?) -> Self
    init(URL URL: NSURL, options options: [String : AnyObject]?)
    convenience init(data data: NSData, options options: [String : AnyObject]?)
    class func movieWithData(_ data: NSData, options options: [String : AnyObject]?) -> Self
    init(data data: NSData, options options: [String : AnyObject]?)
    var URL: NSURL? { get }
    var data: NSData? { get }
    var defaultMediaDataStorage: AVMediaDataStorage? { get }
    var tracks: [AVMovieTrack] { get }
    var canContainMovieFragments: Bool { get }
    var containsMovieFragments: Bool { get }
}
extension AVMovie {
    func movieHeaderWithFileType(_ fileType: String) throws -> NSData
    func writeMovieHeaderToURL(_ URL: NSURL, fileType fileType: String, options options: AVMovieWritingOptions) throws
    func isCompatibleWithFileType(_ fileType: String) -> Bool
}
extension AVMovie {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVMovieTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVMovieTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVMovieTrack]
}
AnyObject, NSCopying, NSMutableCopying

Declaration
From
init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!)
To
init(URL URL: NSURL, options options: [String : AnyObject]?)

Declaration
From
class func movieTypes() -> [AnyObject]!
To
class func movieTypes() -> [String]

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVMovieTrack] { get }

Modified AVMovie.URL
Declaration
From
var URL: NSURL! { get }
To
var URL: NSURL? { get }

Modified AVMovieTrack
Declaration
From
class AVMovieTrack : AVAssetTrack {
}
To
class AVMovieTrack : AVAssetTrack {
    var mediaPresentationTimeRange: CMTimeRange { get }
    var mediaDecodeTimeRange: CMTimeRange { get }
    var alternateGroupID: Int { get }
}
extension AVMovieTrack {
    @NSCopying var mediaDataStorage: AVMediaDataStorage? { get }
}

Declaration
From
class AVMutableAudioMix : AVAudioMix {
    init!() -> AVMutableAudioMix
    class func audioMix() -> AVMutableAudioMix!
    var inputParameters: [AnyObject]!
}
To
class AVMutableAudioMix : AVAudioMix {
    convenience init()
    class func audioMix() -> Self
    var inputParameters: [AVAudioMixInputParameters]
}

Declaration
From
var inputParameters: [AnyObject]!
To
var inputParameters: [AVAudioMixInputParameters]

Declaration
From
class AVMutableAudioMixInputParameters : AVAudioMixInputParameters {
    init!(track track: AVAssetTrack!) -> AVMutableAudioMixInputParameters
    class func audioMixInputParametersWithTrack(_ track: AVAssetTrack!) -> AVMutableAudioMixInputParameters!
    init!() -> AVMutableAudioMixInputParameters
    class func audioMixInputParameters() -> AVMutableAudioMixInputParameters!
    var trackID: CMPersistentTrackID
    var audioTimePitchAlgorithm: String!
    var audioTapProcessor: MTAudioProcessingTap!
    func setVolumeRampFromStartVolume(_ startVolume: Float, toEndVolume endVolume: Float, timeRange timeRange: CMTimeRange)
    func setVolume(_ volume: Float, atTime time: CMTime)
}
To
class AVMutableAudioMixInputParameters : AVAudioMixInputParameters {
    convenience init(track track: AVAssetTrack?)
    class func audioMixInputParametersWithTrack(_ track: AVAssetTrack?) -> Self
    convenience init()
    class func audioMixInputParameters() -> Self
    var trackID: CMPersistentTrackID
    var audioTimePitchAlgorithm: String?
    var audioTapProcessor: MTAudioProcessingTap?
    func setVolumeRampFromStartVolume(_ startVolume: Float, toEndVolume endVolume: Float, timeRange timeRange: CMTimeRange)
    func setVolume(_ volume: Float, atTime time: CMTime)
}

Declaration
From
var audioTapProcessor: MTAudioProcessingTap!
To
var audioTapProcessor: MTAudioProcessingTap?

Declaration
From
var audioTimePitchAlgorithm: String!
To
var audioTimePitchAlgorithm: String?

Declaration
From
init!(track track: AVAssetTrack!) -> AVMutableAudioMixInputParameters
To
convenience init(track track: AVAssetTrack?)

Declaration
From
class AVMutableComposition : AVComposition {
    var tracks: [AnyObject]! { get }
    var naturalSize: CGSize
    init!() -> AVMutableComposition
    class func composition() -> AVMutableComposition!
}
extension AVMutableComposition {
    func insertTimeRange(_ timeRange: CMTimeRange, ofAsset asset: AVAsset!, atTime startTime: CMTime, error outError: NSErrorPointer) -> Bool
    func insertEmptyTimeRange(_ timeRange: CMTimeRange)
    func removeTimeRange(_ timeRange: CMTimeRange)
    func scaleTimeRange(_ timeRange: CMTimeRange, toDuration duration: CMTime)
}
extension AVMutableComposition {
    func addMutableTrackWithMediaType(_ mediaType: String!, preferredTrackID preferredTrackID: CMPersistentTrackID) -> AVMutableCompositionTrack!
    func removeTrack(_ track: AVCompositionTrack!)
    func mutableTrackCompatibleWithTrack(_ track: AVAssetTrack!) -> AVMutableCompositionTrack!
}
To
class AVMutableComposition : AVComposition {
    var tracks: [AVMutableCompositionTrack] { get }
    var naturalSize: CGSize
    convenience init()
    class func composition() -> Self
    convenience init(URLAssetInitializationOptions URLAssetInitializationOptions: [String : AnyObject]?)
    class func compositionWithURLAssetInitializationOptions(_ URLAssetInitializationOptions: [String : AnyObject]?) -> Self
}
extension AVMutableComposition {
    func insertTimeRange(_ timeRange: CMTimeRange, ofAsset asset: AVAsset, atTime startTime: CMTime) throws
    func insertEmptyTimeRange(_ timeRange: CMTimeRange)
    func removeTimeRange(_ timeRange: CMTimeRange)
    func scaleTimeRange(_ timeRange: CMTimeRange, toDuration duration: CMTime)
}
extension AVMutableComposition {
    func addMutableTrackWithMediaType(_ mediaType: String, preferredTrackID preferredTrackID: CMPersistentTrackID) -> AVMutableCompositionTrack
    func removeTrack(_ track: AVCompositionTrack)
    func mutableTrackCompatibleWithTrack(_ track: AVAssetTrack) -> AVMutableCompositionTrack?
}
extension AVMutableComposition {
    func trackWithTrackID(_ trackID: CMPersistentTrackID) -> AVMutableCompositionTrack?
    func tracksWithMediaType(_ mediaType: String) -> [AVMutableCompositionTrack]
    func tracksWithMediaCharacteristic(_ mediaCharacteristic: String) -> [AVMutableCompositionTrack]
}

Declaration
From
func addMutableTrackWithMediaType(_ mediaType: String!, preferredTrackID preferredTrackID: CMPersistentTrackID) -> AVMutableCompositionTrack!
To
func addMutableTrackWithMediaType(_ mediaType: String, preferredTrackID preferredTrackID: CMPersistentTrackID) -> AVMutableCompositionTrack

Declaration
From
func insertTimeRange(_ timeRange: CMTimeRange, ofAsset asset: AVAsset!, atTime startTime: CMTime, error outError: NSErrorPointer) -> Bool
To
func insertTimeRange(_ timeRange: CMTimeRange, ofAsset asset: AVAsset, atTime startTime: CMTime) throws

Declaration
From
func mutableTrackCompatibleWithTrack(_ track: AVAssetTrack!) -> AVMutableCompositionTrack!
To
func mutableTrackCompatibleWithTrack(_ track: AVAssetTrack) -> AVMutableCompositionTrack?

Declaration
From
func removeTrack(_ track: AVCompositionTrack!)
To
func removeTrack(_ track: AVCompositionTrack)

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVMutableCompositionTrack] { get }

Declaration
From
class AVMutableCompositionTrack : AVCompositionTrack {
    var naturalTimeScale: CMTimeScale
    var languageCode: String!
    var extendedLanguageTag: String!
    var preferredTransform: CGAffineTransform
    var preferredVolume: Float
    var segments: [AnyObject]!
    func insertTimeRange(_ timeRange: CMTimeRange, ofTrack track: AVAssetTrack!, atTime startTime: CMTime, error error: NSErrorPointer) -> Bool
    func insertTimeRanges(_ timeRanges: [AnyObject]!, ofTracks tracks: [AnyObject]!, atTime startTime: CMTime, error error: NSErrorPointer) -> Bool
    func insertEmptyTimeRange(_ timeRange: CMTimeRange)
    func removeTimeRange(_ timeRange: CMTimeRange)
    func scaleTimeRange(_ timeRange: CMTimeRange, toDuration duration: CMTime)
    func validateTrackSegments(_ trackSegments: [AnyObject]!, error error: NSErrorPointer) -> Bool
}
To
class AVMutableCompositionTrack : AVCompositionTrack {
    var naturalTimeScale: CMTimeScale
    var languageCode: String?
    var extendedLanguageTag: String?
    var preferredTransform: CGAffineTransform
    var preferredVolume: Float
    var segments: [AVCompositionTrackSegment]!
    func insertTimeRange(_ timeRange: CMTimeRange, ofTrack track: AVAssetTrack, atTime startTime: CMTime) throws
    func insertTimeRanges(_ timeRanges: [NSValue], ofTracks tracks: [AVAssetTrack], atTime startTime: CMTime) throws
    func insertEmptyTimeRange(_ timeRange: CMTimeRange)
    func removeTimeRange(_ timeRange: CMTimeRange)
    func scaleTimeRange(_ timeRange: CMTimeRange, toDuration duration: CMTime)
    func validateTrackSegments(_ trackSegments: [AVCompositionTrackSegment]) throws
}

Declaration
From
var extendedLanguageTag: String!
To
var extendedLanguageTag: String?

Declaration
From
func insertTimeRange(_ timeRange: CMTimeRange, ofTrack track: AVAssetTrack!, atTime startTime: CMTime, error error: NSErrorPointer) -> Bool
To
func insertTimeRange(_ timeRange: CMTimeRange, ofTrack track: AVAssetTrack, atTime startTime: CMTime) throws

Declaration
From
func insertTimeRanges(_ timeRanges: [AnyObject]!, ofTracks tracks: [AnyObject]!, atTime startTime: CMTime, error error: NSErrorPointer) -> Bool
To
func insertTimeRanges(_ timeRanges: [NSValue], ofTracks tracks: [AVAssetTrack], atTime startTime: CMTime) throws

Declaration
From
var languageCode: String!
To
var languageCode: String?

Declaration
From
var segments: [AnyObject]!
To
var segments: [AVCompositionTrackSegment]!

Declaration
From
func validateTrackSegments(_ trackSegments: [AnyObject]!, error error: NSErrorPointer) -> Bool
To
func validateTrackSegments(_ trackSegments: [AVCompositionTrackSegment]) throws

Declaration
From
class AVMutableMetadataItem : AVMetadataItem {
    var identifier: String!
    var extendedLanguageTag: String!
    @NSCopying var locale: NSLocale!
    var time: CMTime
    var duration: CMTime
    var dataType: String!
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>!
    var extraAttributes: [NSObject : AnyObject]!
    init!() -> AVMutableMetadataItem
    class func metadataItem() -> AVMutableMetadataItem!
}
extension AVMutableMetadataItem {
    var keySpace: String!
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>!
}
To
class AVMutableMetadataItem : AVMetadataItem {
    var identifier: String?
    var extendedLanguageTag: String?
    @NSCopying var locale: NSLocale?
    var time: CMTime
    var duration: CMTime
    var dataType: String?
    @NSCopying var value: protocol<NSCopying, NSObjectProtocol>?
    var extraAttributes: [String : AnyObject]?
     init()
    class func metadataItem() -> AVMutableMetadataItem
}
extension AVMutableMetadataItem {
    @NSCopying var startDate: NSDate?
}
extension AVMutableMetadataItem {
    var keySpace: String?
    @NSCopying var key: protocol<NSCopying, NSObjectProtocol>?
}

Declaration
From
var dataType: String!
To
var dataType: String?

Declaration
From
var extendedLanguageTag: String!
To
var extendedLanguageTag: String?

Declaration
From
var extraAttributes: [NSObject : AnyObject]!
To
var extraAttributes: [String : AnyObject]?

Declaration
From
var identifier: String!
To
var identifier: String?

Declaration
From
@NSCopying var key: protocol<NSCopying, NSObjectProtocol>!
To
@NSCopying var key: protocol<NSCopying, NSObjectProtocol>?

Declaration
From
var keySpace: String!
To
var keySpace: String?

Declaration
From
@NSCopying var locale: NSLocale!
To
@NSCopying var locale: NSLocale?

Declaration
From
@NSCopying var value: protocol<NSCopying, NSObjectProtocol>!
To
@NSCopying var value: protocol<NSCopying, NSObjectProtocol>?

Declaration
From
class AVMutableTimedMetadataGroup : AVTimedMetadataGroup {
    var timeRange: CMTimeRange
    var items: [AnyObject]!
}
To
class AVMutableTimedMetadataGroup : AVTimedMetadataGroup {
    var timeRange: CMTimeRange
    var items: [AVMetadataItem]
}

Declaration
From
var items: [AnyObject]!
To
var items: [AVMetadataItem]

Declaration
From
class AVMutableVideoComposition : AVVideoComposition {
    init!() -> AVMutableVideoComposition
    class func videoComposition() -> AVMutableVideoComposition!
    init!(propertiesOfAsset asset: AVAsset!) -> AVMutableVideoComposition
    class func videoCompositionWithPropertiesOfAsset(_ asset: AVAsset!) -> AVMutableVideoComposition!
    var customVideoCompositorClass: AnyObject.Type!
    var frameDuration: CMTime
    var renderSize: CGSize
    var instructions: [AnyObject]!
    var animationTool: AVVideoCompositionCoreAnimationTool!
}
To
class AVMutableVideoComposition : AVVideoComposition {
     init()
    class func videoComposition() -> AVMutableVideoComposition
     init(propertiesOfAsset asset: AVAsset)
    class func videoCompositionWithPropertiesOfAsset(_ asset: AVAsset) -> AVMutableVideoComposition
    var customVideoCompositorClass: AnyObject.Type?
    var frameDuration: CMTime
    var renderSize: CGSize
    var instructions: [AVVideoCompositionInstructionProtocol]
    var animationTool: AVVideoCompositionCoreAnimationTool?
}
extension AVMutableVideoComposition {
     init(asset asset: AVAsset, applyingCIFiltersWithHandler applier: (AVAsynchronousCIImageFilteringRequest) -> Void)
    class func videoCompositionWithAsset(_ asset: AVAsset, applyingCIFiltersWithHandler applier: (AVAsynchronousCIImageFilteringRequest) -> Void) -> AVMutableVideoComposition
}

Declaration
From
var animationTool: AVVideoCompositionCoreAnimationTool!
To
var animationTool: AVVideoCompositionCoreAnimationTool?

Declaration
From
var customVideoCompositorClass: AnyObject.Type!
To
var customVideoCompositorClass: AnyObject.Type?

Declaration
From
init!(propertiesOfAsset asset: AVAsset!) -> AVMutableVideoComposition
To
init(propertiesOfAsset asset: AVAsset)

Declaration
From
var instructions: [AnyObject]!
To
var instructions: [AVVideoCompositionInstructionProtocol]

Declaration
From
class AVMutableVideoCompositionInstruction : AVVideoCompositionInstruction {
    init!() -> AVMutableVideoCompositionInstruction
    class func videoCompositionInstruction() -> AVMutableVideoCompositionInstruction!
    var timeRange: CMTimeRange
    var backgroundColor: CGColor!
    var layerInstructions: [AnyObject]!
    var enablePostProcessing: Bool
}
To
class AVMutableVideoCompositionInstruction : AVVideoCompositionInstruction {
    convenience init()
    class func videoCompositionInstruction() -> Self
    var timeRange: CMTimeRange
    var backgroundColor: CGColor?
    var layerInstructions: [AVVideoCompositionLayerInstruction]
    var enablePostProcessing: Bool
}

Declaration
From
var backgroundColor: CGColor!
To
var backgroundColor: CGColor?

Declaration
From
var layerInstructions: [AnyObject]!
To
var layerInstructions: [AVVideoCompositionLayerInstruction]

Declaration
From
class AVMutableVideoCompositionLayerInstruction : AVVideoCompositionLayerInstruction {
    init!(assetTrack track: AVAssetTrack!) -> AVMutableVideoCompositionLayerInstruction
    class func videoCompositionLayerInstructionWithAssetTrack(_ track: AVAssetTrack!) -> AVMutableVideoCompositionLayerInstruction!
    init!() -> AVMutableVideoCompositionLayerInstruction
    class func videoCompositionLayerInstruction() -> AVMutableVideoCompositionLayerInstruction!
    var trackID: CMPersistentTrackID
    func setTransformRampFromStartTransform(_ startTransform: CGAffineTransform, toEndTransform endTransform: CGAffineTransform, timeRange timeRange: CMTimeRange)
    func setTransform(_ transform: CGAffineTransform, atTime time: CMTime)
    func setOpacityRampFromStartOpacity(_ startOpacity: Float, toEndOpacity endOpacity: Float, timeRange timeRange: CMTimeRange)
    func setOpacity(_ opacity: Float, atTime time: CMTime)
    func setCropRectangleRampFromStartCropRectangle(_ startCropRectangle: CGRect, toEndCropRectangle endCropRectangle: CGRect, timeRange timeRange: CMTimeRange)
    func setCropRectangle(_ cropRectangle: CGRect, atTime time: CMTime)
}
To
class AVMutableVideoCompositionLayerInstruction : AVVideoCompositionLayerInstruction {
    convenience init(assetTrack track: AVAssetTrack)
    class func videoCompositionLayerInstructionWithAssetTrack(_ track: AVAssetTrack) -> Self
    convenience init()
    class func videoCompositionLayerInstruction() -> Self
    var trackID: CMPersistentTrackID
    func setTransformRampFromStartTransform(_ startTransform: CGAffineTransform, toEndTransform endTransform: CGAffineTransform, timeRange timeRange: CMTimeRange)
    func setTransform(_ transform: CGAffineTransform, atTime time: CMTime)
    func setOpacityRampFromStartOpacity(_ startOpacity: Float, toEndOpacity endOpacity: Float, timeRange timeRange: CMTimeRange)
    func setOpacity(_ opacity: Float, atTime time: CMTime)
    func setCropRectangleRampFromStartCropRectangle(_ startCropRectangle: CGRect, toEndCropRectangle endCropRectangle: CGRect, timeRange timeRange: CMTimeRange)
    func setCropRectangle(_ cropRectangle: CGRect, atTime time: CMTime)
}

Declaration
From
init!(assetTrack track: AVAssetTrack!) -> AVMutableVideoCompositionLayerInstruction
To
convenience init(assetTrack track: AVAssetTrack)

Declaration
From
class AVOutputSettingsAssistant : NSObject {
    class func availableOutputSettingsPresets() -> [AnyObject]!
    convenience init!(preset presetIdentifier: String!)
    class func outputSettingsAssistantWithPreset(_ presetIdentifier: String!) -> Self!
    var audioSettings: [NSObject : AnyObject]! { get }
    var videoSettings: [NSObject : AnyObject]! { get }
    var outputFileType: String! { get }
}
extension AVOutputSettingsAssistant {
    var sourceAudioFormat: CMAudioFormatDescription!
    var sourceVideoFormat: CMVideoFormatDescription!
    var sourceVideoAverageFrameDuration: CMTime
    var sourceVideoMinFrameDuration: CMTime
}
To
class AVOutputSettingsAssistant : NSObject {
    init()
    class func availableOutputSettingsPresets() -> [String]
    convenience init?(preset presetIdentifier: String)
    class func outputSettingsAssistantWithPreset(_ presetIdentifier: String) -> Self?
    var audioSettings: [String : AnyObject]? { get }
    var videoSettings: [String : AnyObject]? { get }
    var outputFileType: String { get }
}
extension AVOutputSettingsAssistant {
    var sourceAudioFormat: CMAudioFormatDescription?
    var sourceVideoFormat: CMVideoFormatDescription?
    var sourceVideoAverageFrameDuration: CMTime
    var sourceVideoMinFrameDuration: CMTime
}

Declaration
From
var audioSettings: [NSObject : AnyObject]! { get }
To
var audioSettings: [String : AnyObject]? { get }

Declaration
From
class func availableOutputSettingsPresets() -> [AnyObject]!
To
class func availableOutputSettingsPresets() -> [String]

Declaration
From
convenience init!(preset presetIdentifier: String!)
To
convenience init?(preset presetIdentifier: String)

Declaration
From
var outputFileType: String! { get }
To
var outputFileType: String { get }

Declaration
From
var sourceAudioFormat: CMAudioFormatDescription!
To
var sourceAudioFormat: CMAudioFormatDescription?

Declaration
From
var sourceVideoFormat: CMVideoFormatDescription!
To
var sourceVideoFormat: CMVideoFormatDescription?

Declaration
From
var videoSettings: [NSObject : AnyObject]! { get }
To
var videoSettings: [String : AnyObject]? { get }

Modified AVPlayer
Declaration
From
class AVPlayer : NSObject {
    class func playerWithURL(_ URL: NSURL!) -> AnyObject!
    class func playerWithPlayerItem(_ item: AVPlayerItem!) -> AnyObject!
    init!(URL URL: NSURL!)
    init!(playerItem item: AVPlayerItem!)
    var status: AVPlayerStatus { get }
    var error: NSError! { get }
}
extension AVPlayer {
    var rate: Float
    func play()
    func pause()
}
extension AVPlayer {
    var currentItem: AVPlayerItem! { get }
    func replaceCurrentItemWithPlayerItem(_ item: AVPlayerItem!)
    var actionAtItemEnd: AVPlayerActionAtItemEnd
}
extension AVPlayer {
    func currentTime() -> CMTime
    func seekToDate(_ date: NSDate!)
    func seekToDate(_ date: NSDate!, completionHandler completionHandler: ((Bool) -> Void)!)
    func seekToTime(_ time: CMTime)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime)
    func seekToTime(_ time: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
}
extension AVPlayer {
    func setRate(_ rate: Float, time itemTime: CMTime, atHostTime hostClockTime: CMTime)
    func prerollAtRate(_ rate: Float, completionHandler completionHandler: ((Bool) -> Void)!)
    func cancelPendingPrerolls()
    var masterClock: CMClock!
}
extension AVPlayer {
    func addPeriodicTimeObserverForInterval(_ interval: CMTime, queue queue: dispatch_queue_t!, usingBlock block: ((CMTime) -> Void)!) -> AnyObject!
    func addBoundaryTimeObserverForTimes(_ times: [AnyObject]!, queue queue: dispatch_queue_t!, usingBlock block: (() -> Void)!) -> AnyObject!
    func removeTimeObserver(_ observer: AnyObject!)
}
extension AVPlayer {
    var volume: Float
    var muted: Bool
    var closedCaptionDisplayEnabled: Bool
}
extension AVPlayer {
    var appliesMediaSelectionCriteriaAutomatically: Bool
    func setMediaSelectionCriteria(_ criteria: AVPlayerMediaSelectionCriteria!, forMediaCharacteristic mediaCharacteristic: String!)
    func mediaSelectionCriteriaForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVPlayerMediaSelectionCriteria!
}
extension AVPlayer {
    var audioOutputDeviceUniqueID: String!
}
To
class AVPlayer : NSObject {
    convenience init(URL URL: NSURL)
    class func playerWithURL(_ URL: NSURL) -> Self
    convenience init(playerItem item: AVPlayerItem)
    class func playerWithPlayerItem(_ item: AVPlayerItem) -> Self
    init(URL URL: NSURL)
    init(playerItem item: AVPlayerItem)
    var status: AVPlayerStatus { get }
    var error: NSError? { get }
}
extension AVPlayer {
    var rate: Float
    func play()
    func pause()
}
extension AVPlayer {
    var currentItem: AVPlayerItem? { get }
    func replaceCurrentItemWithPlayerItem(_ item: AVPlayerItem?)
    var actionAtItemEnd: AVPlayerActionAtItemEnd
}
extension AVPlayer {
    func currentTime() -> CMTime
    func seekToDate(_ date: NSDate)
    func seekToDate(_ date: NSDate, completionHandler completionHandler: (Bool) -> Void)
    func seekToTime(_ time: CMTime)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime)
    func seekToTime(_ time: CMTime, completionHandler completionHandler: (Bool) -> Void)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: (Bool) -> Void)
}
extension AVPlayer {
    func setRate(_ rate: Float, time itemTime: CMTime, atHostTime hostClockTime: CMTime)
    func prerollAtRate(_ rate: Float, completionHandler completionHandler: ((Bool) -> Void)?)
    func cancelPendingPrerolls()
    var masterClock: CMClock?
}
extension AVPlayer {
    func addPeriodicTimeObserverForInterval(_ interval: CMTime, queue queue: dispatch_queue_t?, usingBlock block: (CMTime) -> Void) -> AnyObject
    func addBoundaryTimeObserverForTimes(_ times: [NSValue], queue queue: dispatch_queue_t?, usingBlock block: () -> Void) -> AnyObject
    func removeTimeObserver(_ observer: AnyObject)
}
extension AVPlayer {
    var volume: Float
    var muted: Bool
    var closedCaptionDisplayEnabled: Bool
}
extension AVPlayer {
    var appliesMediaSelectionCriteriaAutomatically: Bool
    func setMediaSelectionCriteria(_ criteria: AVPlayerMediaSelectionCriteria?, forMediaCharacteristic mediaCharacteristic: String)
    func mediaSelectionCriteriaForMediaCharacteristic(_ mediaCharacteristic: String) -> AVPlayerMediaSelectionCriteria?
}
extension AVPlayer {
    var audioOutputDeviceUniqueID: String?
}
extension AVPlayer {
    var allowsExternalPlayback: Bool
    var externalPlaybackActive: Bool { get }
    var usesExternalPlaybackWhileExternalScreenIsActive: Bool
    var externalPlaybackVideoGravity: String
}

Declaration
From
func addBoundaryTimeObserverForTimes(_ times: [AnyObject]!, queue queue: dispatch_queue_t!, usingBlock block: (() -> Void)!) -> AnyObject!
To
func addBoundaryTimeObserverForTimes(_ times: [NSValue], queue queue: dispatch_queue_t?, usingBlock block: () -> Void) -> AnyObject

Declaration
From
func addPeriodicTimeObserverForInterval(_ interval: CMTime, queue queue: dispatch_queue_t!, usingBlock block: ((CMTime) -> Void)!) -> AnyObject!
To
func addPeriodicTimeObserverForInterval(_ interval: CMTime, queue queue: dispatch_queue_t?, usingBlock block: (CMTime) -> Void) -> AnyObject

Declaration
From
var audioOutputDeviceUniqueID: String!
To
var audioOutputDeviceUniqueID: String?

Declaration
From
var currentItem: AVPlayerItem! { get }
To
var currentItem: AVPlayerItem? { get }

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
init!(playerItem item: AVPlayerItem!)
To
init(playerItem item: AVPlayerItem)

Declaration
From
init!(URL URL: NSURL!)
To
init(URL URL: NSURL)

Declaration
From
var masterClock: CMClock!
To
var masterClock: CMClock?

Declaration
From
func mediaSelectionCriteriaForMediaCharacteristic(_ mediaCharacteristic: String!) -> AVPlayerMediaSelectionCriteria!
To
func mediaSelectionCriteriaForMediaCharacteristic(_ mediaCharacteristic: String) -> AVPlayerMediaSelectionCriteria?

Declaration
From
func prerollAtRate(_ rate: Float, completionHandler completionHandler: ((Bool) -> Void)!)
To
func prerollAtRate(_ rate: Float, completionHandler completionHandler: ((Bool) -> Void)?)

Declaration
From
func removeTimeObserver(_ observer: AnyObject!)
To
func removeTimeObserver(_ observer: AnyObject)

Declaration
From
func replaceCurrentItemWithPlayerItem(_ item: AVPlayerItem!)
To
func replaceCurrentItemWithPlayerItem(_ item: AVPlayerItem?)

Declaration
From
func seekToDate(_ date: NSDate!)
To
func seekToDate(_ date: NSDate)

Declaration
From
func seekToDate(_ date: NSDate!, completionHandler completionHandler: ((Bool) -> Void)!)
To
func seekToDate(_ date: NSDate, completionHandler completionHandler: (Bool) -> Void)

Declaration
From
func seekToTime(_ time: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
To
func seekToTime(_ time: CMTime, completionHandler completionHandler: (Bool) -> Void)

Declaration
From
func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
To
func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: (Bool) -> Void)

Declaration
From
func setMediaSelectionCriteria(_ criteria: AVPlayerMediaSelectionCriteria!, forMediaCharacteristic mediaCharacteristic: String!)
To
func setMediaSelectionCriteria(_ criteria: AVPlayerMediaSelectionCriteria?, forMediaCharacteristic mediaCharacteristic: String)

Raw Value Type
From--
ToInt

Modified AVPlayerItem
Declaration
From
class AVPlayerItem : NSObject, NSCopying {
    init!(URL URL: NSURL!) -> AVPlayerItem
    class func playerItemWithURL(_ URL: NSURL!) -> AVPlayerItem!
    init!(asset asset: AVAsset!) -> AVPlayerItem
    class func playerItemWithAsset(_ asset: AVAsset!) -> AVPlayerItem!
    init!(asset asset: AVAsset!, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [AnyObject]!) -> AVPlayerItem
    class func playerItemWithAsset(_ asset: AVAsset!, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [AnyObject]!) -> AVPlayerItem!
    init!(URL URL: NSURL!)
    init!(asset asset: AVAsset!)
    init!(asset asset: AVAsset!, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [AnyObject]!)
    var status: AVPlayerItemStatus { get }
    var error: NSError! { get }
}
extension AVPlayerItem {
    var asset: AVAsset! { get }
    var tracks: [AnyObject]! { get }
    var duration: CMTime { get }
    var presentationSize: CGSize { get }
    var timedMetadata: [AnyObject]! { get }
    var automaticallyLoadedAssetKeys: [AnyObject]! { get }
}
extension AVPlayerItem {
    var canPlayFastForward: Bool { get }
    var canPlaySlowForward: Bool { get }
    var canPlayReverse: Bool { get }
    var canPlaySlowReverse: Bool { get }
    var canPlayFastReverse: Bool { get }
    var canStepForward: Bool { get }
    var canStepBackward: Bool { get }
}
extension AVPlayerItem {
    func currentTime() -> CMTime
    var forwardPlaybackEndTime: CMTime
    var reversePlaybackEndTime: CMTime
    var seekableTimeRanges: [AnyObject]! { get }
    func seekToTime(_ time: CMTime)
    func seekToTime(_ time: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
    func cancelPendingSeeks()
    func currentDate() -> NSDate!
    func seekToDate(_ date: NSDate!) -> Bool
    func seekToDate(_ date: NSDate!, completionHandler completionHandler: ((Bool) -> Void)!) -> Bool
    func stepByCount(_ stepCount: Int)
    var timebase: CMTimebase! { get }
}
extension AVPlayerItem {
    @NSCopying var videoComposition: AVVideoComposition!
    var customVideoCompositor: AVVideoCompositing! { get }
    var seekingWaitsForVideoCompositionRendering: Bool
    var textStyleRules: [AnyObject]!
}
extension AVPlayerItem {
    var audioTimePitchAlgorithm: String!
    @NSCopying var audioMix: AVAudioMix!
}
extension AVPlayerItem {
    var loadedTimeRanges: [AnyObject]! { get }
    var playbackLikelyToKeepUp: Bool { get }
    var playbackBufferFull: Bool { get }
    var playbackBufferEmpty: Bool { get }
}
extension AVPlayerItem {
    var preferredPeakBitRate: Double
}
extension AVPlayerItem {
    func selectMediaOption(_ mediaSelectionOption: AVMediaSelectionOption!, inMediaSelectionGroup mediaSelectionGroup: AVMediaSelectionGroup!)
    func selectMediaOptionAutomaticallyInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!)
    func selectedMediaOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!
}
extension AVPlayerItem {
    func accessLog() -> AVPlayerItemAccessLog!
    func errorLog() -> AVPlayerItemErrorLog!
}
extension AVPlayerItem {
    func addOutput(_ output: AVPlayerItemOutput!)
    func removeOutput(_ output: AVPlayerItemOutput!)
    var outputs: [AnyObject]! { get }
}
extension AVPlayerItem {
    var authorizationRequiredForPlayback: Bool { get }
    var applicationAuthorizedForPlayback: Bool { get }
    var contentAuthorizedForPlayback: Bool { get }
    func requestContentAuthorizationAsynchronouslyWithTimeoutInterval(_ timeoutInterval: NSTimeInterval, completionHandler handler: (() -> Void)!)
    func cancelContentAuthorizationRequest()
    var contentAuthorizationRequestStatus: AVContentAuthorizationStatus { get }
}
To
class AVPlayerItem : NSObject, NSCopying {
    convenience init()
     init(URL URL: NSURL)
    class func playerItemWithURL(_ URL: NSURL) -> AVPlayerItem
     init(asset asset: AVAsset)
    class func playerItemWithAsset(_ asset: AVAsset) -> AVPlayerItem
     init(asset asset: AVAsset, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [String]?)
    class func playerItemWithAsset(_ asset: AVAsset, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [String]?) -> AVPlayerItem
    convenience init(URL URL: NSURL)
    convenience init(asset asset: AVAsset)
    init(asset asset: AVAsset, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [String]?)
    var status: AVPlayerItemStatus { get }
    var error: NSError? { get }
}
extension AVPlayerItem {
    var asset: AVAsset { get }
    var tracks: [AVPlayerItemTrack] { get }
    var duration: CMTime { get }
    var presentationSize: CGSize { get }
    var timedMetadata: [AVMetadataItem]? { get }
    var automaticallyLoadedAssetKeys: [String] { get }
}
extension AVPlayerItem {
    var canPlayFastForward: Bool { get }
    var canPlaySlowForward: Bool { get }
    var canPlayReverse: Bool { get }
    var canPlaySlowReverse: Bool { get }
    var canPlayFastReverse: Bool { get }
    var canStepForward: Bool { get }
    var canStepBackward: Bool { get }
}
extension AVPlayerItem {
    func currentTime() -> CMTime
    var forwardPlaybackEndTime: CMTime
    var reversePlaybackEndTime: CMTime
    var seekableTimeRanges: [NSValue] { get }
    func seekToTime(_ time: CMTime)
    func seekToTime(_ time: CMTime, completionHandler completionHandler: (Bool) -> Void)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime)
    func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: (Bool) -> Void)
    func cancelPendingSeeks()
    func currentDate() -> NSDate?
    func seekToDate(_ date: NSDate) -> Bool
    func seekToDate(_ date: NSDate, completionHandler completionHandler: (Bool) -> Void) -> Bool
    func stepByCount(_ stepCount: Int)
    var timebase: CMTimebase? { get }
}
extension AVPlayerItem {
    @NSCopying var videoComposition: AVVideoComposition?
    var customVideoCompositor: AVVideoCompositing? { get }
    var seekingWaitsForVideoCompositionRendering: Bool
    var textStyleRules: [AVTextStyleRule]?
}
extension AVPlayerItem {
    var audioTimePitchAlgorithm: String
    @NSCopying var audioMix: AVAudioMix?
}
extension AVPlayerItem {
    var loadedTimeRanges: [NSValue] { get }
    var playbackLikelyToKeepUp: Bool { get }
    var playbackBufferFull: Bool { get }
    var playbackBufferEmpty: Bool { get }
    var canUseNetworkResourcesForLiveStreamingWhilePaused: Bool
}
extension AVPlayerItem {
    var preferredPeakBitRate: Double
}
extension AVPlayerItem {
    func selectMediaOption(_ mediaSelectionOption: AVMediaSelectionOption?, inMediaSelectionGroup mediaSelectionGroup: AVMediaSelectionGroup)
    func selectMediaOptionAutomaticallyInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup)
    func selectedMediaOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?
    var currentMediaSelection: AVMediaSelection { get }
}
extension AVPlayerItem {
    func accessLog() -> AVPlayerItemAccessLog?
    func errorLog() -> AVPlayerItemErrorLog?
}
extension AVPlayerItem {
    func addOutput(_ output: AVPlayerItemOutput)
    func removeOutput(_ output: AVPlayerItemOutput)
    var outputs: [AVPlayerItemOutput] { get }
}
extension AVPlayerItem {
    var authorizationRequiredForPlayback: Bool { get }
    var applicationAuthorizedForPlayback: Bool { get }
    var contentAuthorizedForPlayback: Bool { get }
    func requestContentAuthorizationAsynchronouslyWithTimeoutInterval(_ timeoutInterval: NSTimeInterval, completionHandler handler: () -> Void)
    func cancelContentAuthorizationRequest()
    var contentAuthorizationRequestStatus: AVContentAuthorizationStatus { get }
}

Declaration
From
func accessLog() -> AVPlayerItemAccessLog!
To
func accessLog() -> AVPlayerItemAccessLog?

Declaration
From
func addOutput(_ output: AVPlayerItemOutput!)
To
func addOutput(_ output: AVPlayerItemOutput)

Declaration
From
var asset: AVAsset! { get }
To
var asset: AVAsset { get }

Declaration
From
@NSCopying var audioMix: AVAudioMix!
To
@NSCopying var audioMix: AVAudioMix?

Declaration
From
var audioTimePitchAlgorithm: String!
To
var audioTimePitchAlgorithm: String

Declaration
From
var automaticallyLoadedAssetKeys: [AnyObject]! { get }
To
var automaticallyLoadedAssetKeys: [String] { get }

Declaration
From
func currentDate() -> NSDate!
To
func currentDate() -> NSDate?

Declaration
From
var customVideoCompositor: AVVideoCompositing! { get }
To
var customVideoCompositor: AVVideoCompositing? { get }

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
func errorLog() -> AVPlayerItemErrorLog!
To
func errorLog() -> AVPlayerItemErrorLog?

Declaration
From
init!(asset asset: AVAsset!)
To
convenience init(asset asset: AVAsset)

Declaration
From
init!(asset asset: AVAsset!, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [AnyObject]!)
To
init(asset asset: AVAsset, automaticallyLoadedAssetKeys automaticallyLoadedAssetKeys: [String]?)

Declaration
From
init!(URL URL: NSURL!)
To
convenience init(URL URL: NSURL)

Declaration
From
var loadedTimeRanges: [AnyObject]! { get }
To
var loadedTimeRanges: [NSValue] { get }

Declaration
From
var outputs: [AnyObject]! { get }
To
var outputs: [AVPlayerItemOutput] { get }

Declaration
From
func removeOutput(_ output: AVPlayerItemOutput!)
To
func removeOutput(_ output: AVPlayerItemOutput)

Declaration
From
func requestContentAuthorizationAsynchronouslyWithTimeoutInterval(_ timeoutInterval: NSTimeInterval, completionHandler handler: (() -> Void)!)
To
func requestContentAuthorizationAsynchronouslyWithTimeoutInterval(_ timeoutInterval: NSTimeInterval, completionHandler handler: () -> Void)

Declaration
From
var seekableTimeRanges: [AnyObject]! { get }
To
var seekableTimeRanges: [NSValue] { get }

Declaration
From
func seekToDate(_ date: NSDate!) -> Bool
To
func seekToDate(_ date: NSDate) -> Bool

Declaration
From
func seekToDate(_ date: NSDate!, completionHandler completionHandler: ((Bool) -> Void)!) -> Bool
To
func seekToDate(_ date: NSDate, completionHandler completionHandler: (Bool) -> Void) -> Bool

Declaration
From
func seekToTime(_ time: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
To
func seekToTime(_ time: CMTime, completionHandler completionHandler: (Bool) -> Void)

Declaration
From
func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: ((Bool) -> Void)!)
To
func seekToTime(_ time: CMTime, toleranceBefore toleranceBefore: CMTime, toleranceAfter toleranceAfter: CMTime, completionHandler completionHandler: (Bool) -> Void)

Declaration
From
func selectedMediaOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!) -> AVMediaSelectionOption!
To
func selectedMediaOptionInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup) -> AVMediaSelectionOption?

Declaration
From
func selectMediaOption(_ mediaSelectionOption: AVMediaSelectionOption!, inMediaSelectionGroup mediaSelectionGroup: AVMediaSelectionGroup!)
To
func selectMediaOption(_ mediaSelectionOption: AVMediaSelectionOption?, inMediaSelectionGroup mediaSelectionGroup: AVMediaSelectionGroup)

Declaration
From
func selectMediaOptionAutomaticallyInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup!)
To
func selectMediaOptionAutomaticallyInMediaSelectionGroup(_ mediaSelectionGroup: AVMediaSelectionGroup)

Declaration
From
var textStyleRules: [AnyObject]!
To
var textStyleRules: [AVTextStyleRule]?

Declaration
From
var timebase: CMTimebase! { get }
To
var timebase: CMTimebase? { get }

Declaration
From
var timedMetadata: [AnyObject]! { get }
To
var timedMetadata: [AVMetadataItem]? { get }

Declaration
From
var tracks: [AnyObject]! { get }
To
var tracks: [AVPlayerItemTrack] { get }

Declaration
From
@NSCopying var videoComposition: AVVideoComposition!
To
@NSCopying var videoComposition: AVVideoComposition?

Declaration
From
class AVPlayerItemAccessLog : NSObject, NSCopying {
    func extendedLogData() -> NSData!
    var extendedLogDataStringEncoding: UInt { get }
    var events: [AnyObject]! { get }
}
To
class AVPlayerItemAccessLog : NSObject, NSCopying {
    func extendedLogData() -> NSData?
    var extendedLogDataStringEncoding: UInt { get }
    var events: [AVPlayerItemAccessLogEvent] { get }
}

Declaration
From
var events: [AnyObject]! { get }
To
var events: [AVPlayerItemAccessLogEvent] { get }

Declaration
From
func extendedLogData() -> NSData!
To
func extendedLogData() -> NSData?

Declaration
From
class AVPlayerItemAccessLogEvent : NSObject, NSCopying {
    var numberOfSegmentsDownloaded: Int { get }
    var numberOfMediaRequests: Int { get }
    var playbackStartDate: NSDate! { get }
    var URI: String! { get }
    var serverAddress: String! { get }
    var numberOfServerAddressChanges: Int { get }
    var playbackSessionID: String! { get }
    var playbackStartOffset: NSTimeInterval { get }
    var segmentsDownloadedDuration: NSTimeInterval { get }
    var durationWatched: NSTimeInterval { get }
    var numberOfStalls: Int { get }
    var numberOfBytesTransferred: Int64 { get }
    var transferDuration: NSTimeInterval { get }
    var observedBitrate: Double { get }
    var indicatedBitrate: Double { get }
    var numberOfDroppedVideoFrames: Int { get }
    var startupTime: NSTimeInterval { get }
    var downloadOverdue: Int { get }
    var observedMaxBitrate: Double { get }
    var observedMinBitrate: Double { get }
    var observedBitrateStandardDeviation: Double { get }
    var playbackType: String! { get }
    var mediaRequestsWWAN: Int { get }
    var switchBitrate: Double { get }
}
To
class AVPlayerItemAccessLogEvent : NSObject, NSCopying {
    var numberOfSegmentsDownloaded: Int { get }
    var numberOfMediaRequests: Int { get }
    var playbackStartDate: NSDate? { get }
    var URI: String? { get }
    var serverAddress: String? { get }
    var numberOfServerAddressChanges: Int { get }
    var playbackSessionID: String? { get }
    var playbackStartOffset: NSTimeInterval { get }
    var segmentsDownloadedDuration: NSTimeInterval { get }
    var durationWatched: NSTimeInterval { get }
    var numberOfStalls: Int { get }
    var numberOfBytesTransferred: Int64 { get }
    var transferDuration: NSTimeInterval { get }
    var observedBitrate: Double { get }
    var indicatedBitrate: Double { get }
    var numberOfDroppedVideoFrames: Int { get }
    var startupTime: NSTimeInterval { get }
    var downloadOverdue: Int { get }
    var observedMaxBitrate: Double { get }
    var observedMinBitrate: Double { get }
    var observedBitrateStandardDeviation: Double { get }
    var playbackType: String? { get }
    var mediaRequestsWWAN: Int { get }
    var switchBitrate: Double { get }
}

Declaration
From
var playbackSessionID: String! { get }
To
var playbackSessionID: String? { get }

Declaration
From
var playbackStartDate: NSDate! { get }
To
var playbackStartDate: NSDate? { get }

Declaration
From
var playbackType: String! { get }
To
var playbackType: String? { get }

Declaration
From
var serverAddress: String! { get }
To
var serverAddress: String? { get }

Declaration
From
var URI: String! { get }
To
var URI: String? { get }

Declaration
From
class AVPlayerItemErrorLog : NSObject, NSCopying {
    func extendedLogData() -> NSData!
    var extendedLogDataStringEncoding: UInt { get }
    var events: [AnyObject]! { get }
}
To
class AVPlayerItemErrorLog : NSObject, NSCopying {
    func extendedLogData() -> NSData?
    var extendedLogDataStringEncoding: UInt { get }
    var events: [AVPlayerItemErrorLogEvent] { get }
}

Declaration
From
var events: [AnyObject]! { get }
To
var events: [AVPlayerItemErrorLogEvent] { get }

Declaration
From
func extendedLogData() -> NSData!
To
func extendedLogData() -> NSData?

Declaration
From
class AVPlayerItemErrorLogEvent : NSObject, NSCopying {
    var date: NSDate! { get }
    var URI: String! { get }
    var serverAddress: String! { get }
    var playbackSessionID: String! { get }
    var errorStatusCode: Int { get }
    var errorDomain: String! { get }
    var errorComment: String! { get }
}
To
class AVPlayerItemErrorLogEvent : NSObject, NSCopying {
    var date: NSDate? { get }
    var URI: String? { get }
    var serverAddress: String? { get }
    var playbackSessionID: String? { get }
    var errorStatusCode: Int { get }
    var errorDomain: String { get }
    var errorComment: String? { get }
}

Declaration
From
var date: NSDate! { get }
To
var date: NSDate? { get }

Declaration
From
var errorComment: String! { get }
To
var errorComment: String? { get }

Declaration
From
var errorDomain: String! { get }
To
var errorDomain: String { get }

Declaration
From
var playbackSessionID: String! { get }
To
var playbackSessionID: String? { get }

Declaration
From
var serverAddress: String! { get }
To
var serverAddress: String? { get }

Declaration
From
var URI: String! { get }
To
var URI: String? { get }

Declaration
From
class AVPlayerItemLegibleOutput : AVPlayerItemOutput {
    func setDelegate(_ delegate: AVPlayerItemLegibleOutputPushDelegate!, queue delegateQueue: dispatch_queue_t!)
    var delegate: AVPlayerItemLegibleOutputPushDelegate! { get }
    var delegateQueue: dispatch_queue_t! { get }
    var advanceIntervalForDelegateInvocation: NSTimeInterval
}
extension AVPlayerItemLegibleOutput {
    init!(mediaSubtypesForNativeRepresentation subtypes: [AnyObject]!)
}
extension AVPlayerItemLegibleOutput {
    var textStylingResolution: String!
}
To
class AVPlayerItemLegibleOutput : AVPlayerItemOutput {
    func setDelegate(_ delegate: AVPlayerItemLegibleOutputPushDelegate?, queue delegateQueue: dispatch_queue_t?)
    weak var delegate: AVPlayerItemLegibleOutputPushDelegate? { get }
    var delegateQueue: dispatch_queue_t? { get }
    var advanceIntervalForDelegateInvocation: NSTimeInterval
}
extension AVPlayerItemLegibleOutput {
    init(mediaSubtypesForNativeRepresentation subtypes: [NSNumber])
}
extension AVPlayerItemLegibleOutput {
    var textStylingResolution: String
}

Declaration
From
var delegate: AVPlayerItemLegibleOutputPushDelegate! { get }
To
weak var delegate: AVPlayerItemLegibleOutputPushDelegate? { get }

Declaration
From
var delegateQueue: dispatch_queue_t! { get }
To
var delegateQueue: dispatch_queue_t? { get }

Declaration
From
init!(mediaSubtypesForNativeRepresentation subtypes: [AnyObject]!)
To
init(mediaSubtypesForNativeRepresentation subtypes: [NSNumber])

Declaration
From
func setDelegate(_ delegate: AVPlayerItemLegibleOutputPushDelegate!, queue delegateQueue: dispatch_queue_t!)
To
func setDelegate(_ delegate: AVPlayerItemLegibleOutputPushDelegate?, queue delegateQueue: dispatch_queue_t?)

Declaration
From
var textStylingResolution: String!
To
var textStylingResolution: String

Declaration
From
protocol AVPlayerItemLegibleOutputPushDelegate : AVPlayerItemOutputPushDelegate, NSObjectProtocol {
    optional func legibleOutput(_ output: AVPlayerItemLegibleOutput!, didOutputAttributedStrings strings: [AnyObject]!, nativeSampleBuffers nativeSamples: [AnyObject]!, forItemTime itemTime: CMTime)
}
To
protocol AVPlayerItemLegibleOutputPushDelegate : AVPlayerItemOutputPushDelegate, NSObjectProtocol {
    optional func legibleOutput(_ output: AVPlayerItemLegibleOutput, didOutputAttributedStrings strings: [NSAttributedString], nativeSampleBuffers nativeSamples: [AnyObject], forItemTime itemTime: CMTime)
}

Declaration
From
optional func legibleOutput(_ output: AVPlayerItemLegibleOutput!, didOutputAttributedStrings strings: [AnyObject]!, nativeSampleBuffers nativeSamples: [AnyObject]!, forItemTime itemTime: CMTime)
To
optional func legibleOutput(_ output: AVPlayerItemLegibleOutput, didOutputAttributedStrings strings: [NSAttributedString], nativeSampleBuffers nativeSamples: [AnyObject], forItemTime itemTime: CMTime)

Declaration
From
class AVPlayerItemMetadataOutput : AVPlayerItemOutput {
    init!(identifiers identifiers: [AnyObject]!)
    func setDelegate(_ delegate: AVPlayerItemMetadataOutputPushDelegate!, queue delegateQueue: dispatch_queue_t!)
    var delegate: AVPlayerItemMetadataOutputPushDelegate! { get }
    var delegateQueue: dispatch_queue_t! { get }
    var advanceIntervalForDelegateInvocation: NSTimeInterval
}
To
class AVPlayerItemMetadataOutput : AVPlayerItemOutput {
    init(identifiers identifiers: [String]?)
    func setDelegate(_ delegate: AVPlayerItemMetadataOutputPushDelegate?, queue delegateQueue: dispatch_queue_t?)
    weak var delegate: AVPlayerItemMetadataOutputPushDelegate? { get }
    var delegateQueue: dispatch_queue_t? { get }
    var advanceIntervalForDelegateInvocation: NSTimeInterval
}

Declaration
From
var delegate: AVPlayerItemMetadataOutputPushDelegate! { get }
To
weak var delegate: AVPlayerItemMetadataOutputPushDelegate? { get }

Declaration
From
var delegateQueue: dispatch_queue_t! { get }
To
var delegateQueue: dispatch_queue_t? { get }

Declaration
From
init!(identifiers identifiers: [AnyObject]!)
To
init(identifiers identifiers: [String]?)

Declaration
From
func setDelegate(_ delegate: AVPlayerItemMetadataOutputPushDelegate!, queue delegateQueue: dispatch_queue_t!)
To
func setDelegate(_ delegate: AVPlayerItemMetadataOutputPushDelegate?, queue delegateQueue: dispatch_queue_t?)

Declaration
From
protocol AVPlayerItemMetadataOutputPushDelegate : AVPlayerItemOutputPushDelegate, NSObjectProtocol {
    optional func metadataOutput(_ output: AVPlayerItemMetadataOutput!, didOutputTimedMetadataGroups groups: [AnyObject]!, fromPlayerItemTrack track: AVPlayerItemTrack!)
}
To
protocol AVPlayerItemMetadataOutputPushDelegate : AVPlayerItemOutputPushDelegate, NSObjectProtocol {
    optional func metadataOutput(_ output: AVPlayerItemMetadataOutput, didOutputTimedMetadataGroups groups: [AVTimedMetadataGroup], fromPlayerItemTrack track: AVPlayerItemTrack)
}

Declaration
From
optional func metadataOutput(_ output: AVPlayerItemMetadataOutput!, didOutputTimedMetadataGroups groups: [AnyObject]!, fromPlayerItemTrack track: AVPlayerItemTrack!)
To
optional func metadataOutput(_ output: AVPlayerItemMetadataOutput, didOutputTimedMetadataGroups groups: [AVTimedMetadataGroup], fromPlayerItemTrack track: AVPlayerItemTrack)

Declaration
From
protocol AVPlayerItemOutputPullDelegate : NSObjectProtocol {
    optional func outputMediaDataWillChange(_ sender: AVPlayerItemOutput!)
    optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput!)
}
To
protocol AVPlayerItemOutputPullDelegate : NSObjectProtocol {
    optional func outputMediaDataWillChange(_ sender: AVPlayerItemOutput)
    optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput)
}

Declaration
From
optional func outputMediaDataWillChange(_ sender: AVPlayerItemOutput!)
To
optional func outputMediaDataWillChange(_ sender: AVPlayerItemOutput)

Declaration
From
optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput!)
To
optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput)

Declaration
From
protocol AVPlayerItemOutputPushDelegate : NSObjectProtocol {
    optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput!)
}
To
protocol AVPlayerItemOutputPushDelegate : NSObjectProtocol {
    optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput)
}

DeclarationIntroduction
From
optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput!)
OS X 10.10
To
optional func outputSequenceWasFlushed(_ output: AVPlayerItemOutput)
OS X 10.8

Raw Value Type
From--
ToInt

Declaration
From
class AVPlayerItemTrack : NSObject {
    var assetTrack: AVAssetTrack! { get }
    var enabled: Bool
    var currentVideoFrameRate: Float { get }
    var videoFieldMode: String!
}
To
class AVPlayerItemTrack : NSObject {
    var assetTrack: AVAssetTrack { get }
    var enabled: Bool
    var currentVideoFrameRate: Float { get }
    var videoFieldMode: String?
}

Declaration
From
var assetTrack: AVAssetTrack! { get }
To
var assetTrack: AVAssetTrack { get }

Declaration
From
var videoFieldMode: String!
To
var videoFieldMode: String?

Declaration
From
class AVPlayerItemVideoOutput : AVPlayerItemOutput {
    init!(pixelBufferAttributes pixelBufferAttributes: [NSObject : AnyObject]!)
    func hasNewPixelBufferForItemTime(_ itemTime: CMTime) -> Bool
    func copyPixelBufferForItemTime(_ itemTime: CMTime, itemTimeForDisplay outItemTimeForDisplay: UnsafeMutablePointer<CMTime>) -> CVPixelBuffer!
    func setDelegate(_ delegate: AVPlayerItemOutputPullDelegate!, queue delegateQueue: dispatch_queue_t!)
    func requestNotificationOfMediaDataChangeWithAdvanceInterval(_ interval: NSTimeInterval)
    var delegate: AVPlayerItemOutputPullDelegate! { get }
    var delegateQueue: dispatch_queue_t! { get }
}
To
class AVPlayerItemVideoOutput : AVPlayerItemOutput {
    init(pixelBufferAttributes pixelBufferAttributes: [String : AnyObject]?)
    func hasNewPixelBufferForItemTime(_ itemTime: CMTime) -> Bool
    func copyPixelBufferForItemTime(_ itemTime: CMTime, itemTimeForDisplay outItemTimeForDisplay: UnsafeMutablePointer<CMTime>) -> CVPixelBuffer?
    func setDelegate(_ delegate: AVPlayerItemOutputPullDelegate?, queue delegateQueue: dispatch_queue_t?)
    func requestNotificationOfMediaDataChangeWithAdvanceInterval(_ interval: NSTimeInterval)
    unowned(unsafe) var delegate: AVPlayerItemOutputPullDelegate? { get }
    var delegateQueue: dispatch_queue_t? { get }
}

Declaration
From
func copyPixelBufferForItemTime(_ itemTime: CMTime, itemTimeForDisplay outItemTimeForDisplay: UnsafeMutablePointer<CMTime>) -> CVPixelBuffer!
To
func copyPixelBufferForItemTime(_ itemTime: CMTime, itemTimeForDisplay outItemTimeForDisplay: UnsafeMutablePointer<CMTime>) -> CVPixelBuffer?

Declaration
From
var delegate: AVPlayerItemOutputPullDelegate! { get }
To
unowned(unsafe) var delegate: AVPlayerItemOutputPullDelegate? { get }

Declaration
From
var delegateQueue: dispatch_queue_t! { get }
To
var delegateQueue: dispatch_queue_t? { get }

Declaration
From
init!(pixelBufferAttributes pixelBufferAttributes: [NSObject : AnyObject]!)
To
init(pixelBufferAttributes pixelBufferAttributes: [String : AnyObject]?)

Declaration
From
func setDelegate(_ delegate: AVPlayerItemOutputPullDelegate!, queue delegateQueue: dispatch_queue_t!)
To
func setDelegate(_ delegate: AVPlayerItemOutputPullDelegate?, queue delegateQueue: dispatch_queue_t?)

Modified AVPlayerLayer
Declaration
From
class AVPlayerLayer : CALayer {
    init!(player player: AVPlayer!) -> AVPlayerLayer
    class func playerLayerWithPlayer(_ player: AVPlayer!) -> AVPlayerLayer!
    var player: AVPlayer!
    var videoGravity: String!
    var readyForDisplay: Bool { get }
    var videoRect: CGRect { get }
}
To
class AVPlayerLayer : CALayer {
     init(player player: AVPlayer?)
    class func playerLayerWithPlayer(_ player: AVPlayer?) -> AVPlayerLayer
    var player: AVPlayer?
    var videoGravity: String
    var readyForDisplay: Bool { get }
    var videoRect: CGRect { get }
    var pixelBufferAttributes: [String : AnyObject]?
}

Declaration
From
init!(player player: AVPlayer!) -> AVPlayerLayer
To
init(player player: AVPlayer?)

Declaration
From
var player: AVPlayer!
To
var player: AVPlayer?

Declaration
From
var videoGravity: String!
To
var videoGravity: String

Declaration
From
class AVPlayerMediaSelectionCriteria : NSObject {
    var preferredLanguages: [AnyObject]! { get }
    var preferredMediaCharacteristics: [AnyObject]! { get }
    init!(preferredLanguages preferredLanguages: [AnyObject]!, preferredMediaCharacteristics preferredMediaCharacteristics: [AnyObject]!)
}
To
class AVPlayerMediaSelectionCriteria : NSObject {
    var preferredLanguages: [String]? { get }
    var preferredMediaCharacteristics: [String]? { get }
    init(preferredLanguages preferredLanguages: [String]?, preferredMediaCharacteristics preferredMediaCharacteristics: [String]?)
}

Declaration
From
init!(preferredLanguages preferredLanguages: [AnyObject]!, preferredMediaCharacteristics preferredMediaCharacteristics: [AnyObject]!)
To
init(preferredLanguages preferredLanguages: [String]?, preferredMediaCharacteristics preferredMediaCharacteristics: [String]?)

Declaration
From
var preferredLanguages: [AnyObject]! { get }
To
var preferredLanguages: [String]? { get }

Declaration
From
var preferredMediaCharacteristics: [AnyObject]! { get }
To
var preferredMediaCharacteristics: [String]? { get }

Raw Value Type
From--
ToInt

Raw Value Type
From--
ToInt

Modified AVQueuePlayer
Declaration
From
class AVQueuePlayer : AVPlayer {
    class func queuePlayerWithItems(_ items: [AnyObject]!) -> AnyObject!
    init!(items items: [AnyObject]!)
    func items() -> [AnyObject]!
    func advanceToNextItem()
    func canInsertItem(_ item: AVPlayerItem!, afterItem afterItem: AVPlayerItem!) -> Bool
    func insertItem(_ item: AVPlayerItem!, afterItem afterItem: AVPlayerItem!)
    func removeItem(_ item: AVPlayerItem!)
    func removeAllItems()
}
To
class AVQueuePlayer : AVPlayer {
    convenience init(items items: [AVPlayerItem])
    class func queuePlayerWithItems(_ items: [AVPlayerItem]) -> Self
    init(items items: [AVPlayerItem])
    func items() -> [AVPlayerItem]
    func advanceToNextItem()
    func canInsertItem(_ item: AVPlayerItem, afterItem afterItem: AVPlayerItem?) -> Bool
    func insertItem(_ item: AVPlayerItem, afterItem afterItem: AVPlayerItem?)
    func removeItem(_ item: AVPlayerItem)
    func removeAllItems()
}

Declaration
From
func canInsertItem(_ item: AVPlayerItem!, afterItem afterItem: AVPlayerItem!) -> Bool
To
func canInsertItem(_ item: AVPlayerItem, afterItem afterItem: AVPlayerItem?) -> Bool

Declaration
From
init!(items items: [AnyObject]!)
To
init(items items: [AVPlayerItem])

Declaration
From
func insertItem(_ item: AVPlayerItem!, afterItem afterItem: AVPlayerItem!)
To
func insertItem(_ item: AVPlayerItem, afterItem afterItem: AVPlayerItem?)

Declaration
From
func items() -> [AnyObject]!
To
func items() -> [AVPlayerItem]

Declaration
From
func removeItem(_ item: AVPlayerItem!)
To
func removeItem(_ item: AVPlayerItem)

Declaration
From
class AVSampleBufferDisplayLayer : CALayer {
    var controlTimebase: CMTimebase!
    var videoGravity: String!
    var status: AVQueuedSampleBufferRenderingStatus { get }
    var error: NSError! { get }
}
extension AVSampleBufferDisplayLayer {
    func enqueueSampleBuffer(_ sampleBuffer: CMSampleBuffer!)
    func flush()
    func flushAndRemoveImage()
    var readyForMoreMediaData: Bool { get }
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)
    func stopRequestingMediaData()
}
To
class AVSampleBufferDisplayLayer : CALayer {
    var controlTimebase: CMTimebase?
    var videoGravity: String
    var status: AVQueuedSampleBufferRenderingStatus { get }
    var error: NSError? { get }
}
extension AVSampleBufferDisplayLayer {
    func enqueueSampleBuffer(_ sampleBuffer: CMSampleBuffer)
    func flush()
    func flushAndRemoveImage()
    var readyForMoreMediaData: Bool { get }
    func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)
    func stopRequestingMediaData()
}

Declaration
From
var controlTimebase: CMTimebase!
To
var controlTimebase: CMTimebase?

Declaration
From
func enqueueSampleBuffer(_ sampleBuffer: CMSampleBuffer!)
To
func enqueueSampleBuffer(_ sampleBuffer: CMSampleBuffer)

Declaration
From
var error: NSError! { get }
To
var error: NSError? { get }

Declaration
From
func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t!, usingBlock block: (() -> Void)!)
To
func requestMediaDataWhenReadyOnQueue(_ queue: dispatch_queue_t, usingBlock block: () -> Void)

Declaration
From
var videoGravity: String!
To
var videoGravity: String

Declaration
From
class AVSampleBufferGenerator : NSObject {
    init!(asset asset: AVAsset!, timebase timebase: CMTimebase!)
    func createSampleBufferForRequest(_ request: AVSampleBufferRequest!) -> Unmanaged<CMSampleBuffer>!
    class func notifyOfDataReadyForSampleBuffer(_ sbuf: CMSampleBuffer!, completionHandler completionHandler: ((Bool, NSError!) -> Void)!)
}
To
class AVSampleBufferGenerator : NSObject {
    convenience init()
    init(asset asset: AVAsset, timebase timebase: CMTimebase?)
    func createSampleBufferForRequest(_ request: AVSampleBufferRequest) -> CMSampleBuffer
    class func notifyOfDataReadyForSampleBuffer(_ sbuf: CMSampleBuffer, completionHandler completionHandler: (Bool, NSError) -> Void)
}

Declaration
From
func createSampleBufferForRequest(_ request: AVSampleBufferRequest!) -> Unmanaged<CMSampleBuffer>!
To
func createSampleBufferForRequest(_ request: AVSampleBufferRequest) -> CMSampleBuffer

Declaration
From
init!(asset asset: AVAsset!, timebase timebase: CMTimebase!)
To
init(asset asset: AVAsset, timebase timebase: CMTimebase?)

Declaration
From
class func notifyOfDataReadyForSampleBuffer(_ sbuf: CMSampleBuffer!, completionHandler completionHandler: ((Bool, NSError!) -> Void)!)
To
class func notifyOfDataReadyForSampleBuffer(_ sbuf: CMSampleBuffer, completionHandler completionHandler: (Bool, NSError) -> Void)

Declaration
From
class AVSampleBufferRequest : NSObject {
    init!(startCursor startCursor: AVSampleCursor!)
    var startCursor: AVSampleCursor! { get }
    var direction: AVSampleBufferRequestDirection
    var limitCursor: AVSampleCursor!
    var preferredMinSampleCount: Int
    var maxSampleCount: Int
    var mode: AVSampleBufferRequestMode
    var overrideTime: CMTime
}
To
class AVSampleBufferRequest : NSObject {
    convenience init()
    init(startCursor startCursor: AVSampleCursor)
    var startCursor: AVSampleCursor { get }
    var direction: AVSampleBufferRequestDirection
    var limitCursor: AVSampleCursor?
    var preferredMinSampleCount: Int
    var maxSampleCount: Int
    var mode: AVSampleBufferRequestMode
    var overrideTime: CMTime
}

Declaration
From
init!(startCursor startCursor: AVSampleCursor!)
To
init(startCursor startCursor: AVSampleCursor)

Declaration
From
var limitCursor: AVSampleCursor!
To
var limitCursor: AVSampleCursor?

Declaration
From
var startCursor: AVSampleCursor! { get }
To
var startCursor: AVSampleCursor { get }

Raw Value Type
From--
ToInt

Raw Value Type
From--
ToInt

Declaration
From
class AVSampleCursor : NSObject, NSCopying {
    func stepInDecodeOrderByCount(_ stepCount: Int64) -> Int64
    func stepInPresentationOrderByCount(_ stepCount: Int64) -> Int64
    func stepByDecodeTime(_ deltaDecodeTime: CMTime, wasPinned outWasPinned: UnsafeMutablePointer<ObjCBool>) -> CMTime
    func stepByPresentationTime(_ deltaPresentationTime: CMTime, wasPinned outWasPinned: UnsafeMutablePointer<ObjCBool>) -> CMTime
}
extension AVSampleCursor {
    var presentationTimeStamp: CMTime { get }
    var decodeTimeStamp: CMTime { get }
    func comparePositionInDecodeOrderWithPositionOfCursor(_ cursor: AVSampleCursor!) -> NSComparisonResult
    func samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor!) -> Bool
    func samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor!) -> Bool
}
extension AVSampleCursor {
    var currentSampleDuration: CMTime { get }
    func copyCurrentSampleFormatDescription() -> CMFormatDescription!
    var currentSampleSyncInfo: AVSampleCursorSyncInfo { get }
    var currentSampleDependencyInfo: AVSampleCursorDependencyInfo { get }
}
extension AVSampleCursor {
    var currentChunkStorageURL: NSURL! { get }
    var currentChunkStorageRange: AVSampleCursorStorageRange { get }
    var currentChunkInfo: AVSampleCursorChunkInfo { get }
    var currentSampleIndexInChunk: Int64 { get }
    var currentSampleStorageRange: AVSampleCursorStorageRange { get }
}
To
class AVSampleCursor : NSObject, NSCopying {
    init()
    func stepInDecodeOrderByCount(_ stepCount: Int64) -> Int64
    func stepInPresentationOrderByCount(_ stepCount: Int64) -> Int64
    func stepByDecodeTime(_ deltaDecodeTime: CMTime, wasPinned outWasPinned: UnsafeMutablePointer<ObjCBool>) -> CMTime
    func stepByPresentationTime(_ deltaPresentationTime: CMTime, wasPinned outWasPinned: UnsafeMutablePointer<ObjCBool>) -> CMTime
}
extension AVSampleCursor {
    var presentationTimeStamp: CMTime { get }
    var decodeTimeStamp: CMTime { get }
    func comparePositionInDecodeOrderWithPositionOfCursor(_ cursor: AVSampleCursor) -> NSComparisonResult
    func samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor) -> Bool
    func samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor) -> Bool
}
extension AVSampleCursor {
    var currentSampleDuration: CMTime { get }
    func copyCurrentSampleFormatDescription() -> CMFormatDescription
    var currentSampleSyncInfo: AVSampleCursorSyncInfo { get }
    var currentSampleDependencyInfo: AVSampleCursorDependencyInfo { get }
    var samplesRequiredForDecoderRefresh: Int { get }
}
extension AVSampleCursor {
    var currentChunkStorageURL: NSURL { get }
    var currentChunkStorageRange: AVSampleCursorStorageRange { get }
    var currentChunkInfo: AVSampleCursorChunkInfo { get }
    var currentSampleIndexInChunk: Int64 { get }
    var currentSampleStorageRange: AVSampleCursorStorageRange { get }
}

Declaration
From
func comparePositionInDecodeOrderWithPositionOfCursor(_ cursor: AVSampleCursor!) -> NSComparisonResult
To
func comparePositionInDecodeOrderWithPositionOfCursor(_ cursor: AVSampleCursor) -> NSComparisonResult

Declaration
From
func copyCurrentSampleFormatDescription() -> CMFormatDescription!
To
func copyCurrentSampleFormatDescription() -> CMFormatDescription

Declaration
From
var currentChunkStorageURL: NSURL! { get }
To
var currentChunkStorageURL: NSURL { get }

Declaration
From
func samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor!) -> Bool
To
func samplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor) -> Bool

Declaration
From
func samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor!) -> Bool
To
func samplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThanCursor(_ cursor: AVSampleCursor) -> Bool

Declaration
From
class AVSynchronizedLayer : CALayer {
    init!(playerItem playerItem: AVPlayerItem!) -> AVSynchronizedLayer
    class func synchronizedLayerWithPlayerItem(_ playerItem: AVPlayerItem!) -> AVSynchronizedLayer!
    var playerItem: AVPlayerItem!
}
To
class AVSynchronizedLayer : CALayer {
     init(playerItem playerItem: AVPlayerItem)
    class func synchronizedLayerWithPlayerItem(_ playerItem: AVPlayerItem) -> AVSynchronizedLayer
    var playerItem: AVPlayerItem?
}

Declaration
From
init!(playerItem playerItem: AVPlayerItem!) -> AVSynchronizedLayer
To
init(playerItem playerItem: AVPlayerItem)

Declaration
From
var playerItem: AVPlayerItem!
To
var playerItem: AVPlayerItem?

Declaration
From
class AVTextStyleRule : NSObject, NSCopying {
    class func propertyListForTextStyleRules(_ textStyleRules: [AnyObject]!) -> AnyObject!
    class func textStyleRulesFromPropertyList(_ plist: AnyObject!) -> [AnyObject]!
    init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!) -> AVTextStyleRule
    class func textStyleRuleWithTextMarkupAttributes(_ textMarkupAttributes: [NSObject : AnyObject]!) -> AVTextStyleRule!
    init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!, textSelector textSelector: String!) -> AVTextStyleRule
    class func textStyleRuleWithTextMarkupAttributes(_ textMarkupAttributes: [NSObject : AnyObject]!, textSelector textSelector: String!) -> AVTextStyleRule!
    init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!)
    init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!, textSelector textSelector: String!)
    var textMarkupAttributes: [NSObject : AnyObject]! { get }
    var textSelector: String! { get }
}
To
class AVTextStyleRule : NSObject, NSCopying {
    convenience init()
    class func propertyListForTextStyleRules(_ textStyleRules: [AVTextStyleRule]) -> AnyObject
    class func textStyleRulesFromPropertyList(_ plist: AnyObject) -> [AVTextStyleRule]?
     init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject])
    class func textStyleRuleWithTextMarkupAttributes(_ textMarkupAttributes: [String : AnyObject]) -> AVTextStyleRule?
     init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject], textSelector textSelector: String?)
    class func textStyleRuleWithTextMarkupAttributes(_ textMarkupAttributes: [String : AnyObject], textSelector textSelector: String?) -> AVTextStyleRule?
    convenience init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject])
    init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject], textSelector textSelector: String?)
    var textMarkupAttributes: [String : AnyObject] { get }
    var textSelector: String? { get }
}

Declaration
From
init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!)
To
convenience init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject])

Declaration
From
init!(textMarkupAttributes textMarkupAttributes: [NSObject : AnyObject]!, textSelector textSelector: String!)
To
init?(textMarkupAttributes textMarkupAttributes: [String : AnyObject], textSelector textSelector: String?)

Declaration
From
class func propertyListForTextStyleRules(_ textStyleRules: [AnyObject]!) -> AnyObject!
To
class func propertyListForTextStyleRules(_ textStyleRules: [AVTextStyleRule]) -> AnyObject

Declaration
From
var textMarkupAttributes: [NSObject : AnyObject]! { get }
To
var textMarkupAttributes: [String : AnyObject] { get }

Declaration
From
var textSelector: String! { get }
To
var textSelector: String? { get }

Declaration
From
class func textStyleRulesFromPropertyList(_ plist: AnyObject!) -> [AnyObject]!
To
class func textStyleRulesFromPropertyList(_ plist: AnyObject) -> [AVTextStyleRule]?

DeclarationSuperclassesProtocols
From
class AVTimedMetadataGroup : NSObject, NSCopying {
    init!(items items: [AnyObject]!, timeRange timeRange: CMTimeRange)
    init!(sampleBuffer sampleBuffer: CMSampleBuffer!)
    var timeRange: CMTimeRange { get }
    var items: [AnyObject]! { get }
}
extension AVTimedMetadataGroup {
    func copyFormatDescription() -> CMMetadataFormatDescription!
}
NSObjectAnyObject, NSCopying
To
class AVTimedMetadataGroup : AVMetadataGroup, NSCopying, NSMutableCopying {
    init(items items: [AVMetadataItem], timeRange timeRange: CMTimeRange)
    init?(sampleBuffer sampleBuffer: CMSampleBuffer)
    var timeRange: CMTimeRange { get }
    var items: [AVMetadataItem] { get }
}
extension AVTimedMetadataGroup {
    func copyFormatDescription() -> CMMetadataFormatDescription?
}
AVMetadataGroupAnyObject, NSCopying, NSMutableCopying

Declaration
From
func copyFormatDescription() -> CMMetadataFormatDescription!
To
func copyFormatDescription() -> CMMetadataFormatDescription?

Declaration
From
init!(items items: [AnyObject]!, timeRange timeRange: CMTimeRange)
To
init(items items: [AVMetadataItem], timeRange timeRange: CMTimeRange)

Declaration
From
init!(sampleBuffer sampleBuffer: CMSampleBuffer!)
To
init?(sampleBuffer sampleBuffer: CMSampleBuffer)

Declaration
From
var items: [AnyObject]! { get }
To
var items: [AVMetadataItem] { get }

Modified AVURLAsset
Declaration
From
class AVURLAsset : AVAsset {
    class func audiovisualTypes() -> [AnyObject]!
    class func audiovisualMIMETypes() -> [AnyObject]!
    class func isPlayableExtendedMIMEType(_ extendedMIMEType: String!) -> Bool
    init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!) -> AVURLAsset
    class func URLAssetWithURL(_ URL: NSURL!, options options: [NSObject : AnyObject]!) -> AVURLAsset!
    init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!)
    @NSCopying var URL: NSURL! { get }
}
extension AVURLAsset {
    var resourceLoader: AVAssetResourceLoader! { get }
}
extension AVURLAsset {
    func compatibleTrackForCompositionTrack(_ compositionTrack: AVCompositionTrack!) -> AVAssetTrack!
}
To
class AVURLAsset : AVAsset {
    convenience init()
    class func audiovisualTypes() -> [String]
    class func audiovisualMIMETypes() -> [String]
    class func isPlayableExtendedMIMEType(_ extendedMIMEType: String) -> Bool
    convenience init(URL URL: NSURL, options options: [String : AnyObject]?)
    class func URLAssetWithURL(_ URL: NSURL, options options: [String : AnyObject]?) -> Self
    init(URL URL: NSURL, options options: [String : AnyObject]?)
    @NSCopying var URL: NSURL { get }
}
extension AVURLAsset {
    var resourceLoader: AVAssetResourceLoader { get }
}
extension AVURLAsset {
    func compatibleTrackForCompositionTrack(_ compositionTrack: AVCompositionTrack) -> AVAssetTrack?
}

Declaration
From
class func audiovisualMIMETypes() -> [AnyObject]!
To
class func audiovisualMIMETypes() -> [String]

Declaration
From
class func audiovisualTypes() -> [AnyObject]!
To
class func audiovisualTypes() -> [String]

Declaration
From
func compatibleTrackForCompositionTrack(_ compositionTrack: AVCompositionTrack!) -> AVAssetTrack!
To
func compatibleTrackForCompositionTrack(_ compositionTrack: AVCompositionTrack) -> AVAssetTrack?

Declaration
From
init!(URL URL: NSURL!, options options: [NSObject : AnyObject]!)
To
init(URL URL: NSURL, options options: [String : AnyObject]?)

Declaration
From
class func isPlayableExtendedMIMEType(_ extendedMIMEType: String!) -> Bool
To
class func isPlayableExtendedMIMEType(_ extendedMIMEType: String) -> Bool

Declaration
From
var resourceLoader: AVAssetResourceLoader! { get }
To
var resourceLoader: AVAssetResourceLoader { get }

Declaration
From
@NSCopying var URL: NSURL! { get }
To
@NSCopying var URL: NSURL { get }

Declaration
From
protocol AVVideoCompositing : NSObjectProtocol {
    var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }
    var requiredPixelBufferAttributesForRenderContext: [NSObject : AnyObject]! { get }
    func renderContextChanged(_ newRenderContext: AVVideoCompositionRenderContext!)
    func startVideoCompositionRequest(_ asyncVideoCompositionRequest: AVAsynchronousVideoCompositionRequest!)
    optional func cancelAllPendingVideoCompositionRequests()
}
To
protocol AVVideoCompositing : NSObjectProtocol {
    var sourcePixelBufferAttributes: [String : AnyObject]? { get }
    var requiredPixelBufferAttributesForRenderContext: [String : AnyObject] { get }
    func renderContextChanged(_ newRenderContext: AVVideoCompositionRenderContext)
    func startVideoCompositionRequest(_ asyncVideoCompositionRequest: AVAsynchronousVideoCompositionRequest)
    optional func cancelAllPendingVideoCompositionRequests()
}

Declaration
From
func renderContextChanged(_ newRenderContext: AVVideoCompositionRenderContext!)
To
func renderContextChanged(_ newRenderContext: AVVideoCompositionRenderContext)

Declaration
From
var requiredPixelBufferAttributesForRenderContext: [NSObject : AnyObject]! { get }
To
var requiredPixelBufferAttributesForRenderContext: [String : AnyObject] { get }

Declaration
From
var sourcePixelBufferAttributes: [NSObject : AnyObject]! { get }
To
var sourcePixelBufferAttributes: [String : AnyObject]? { get }

Declaration
From
func startVideoCompositionRequest(_ asyncVideoCompositionRequest: AVAsynchronousVideoCompositionRequest!)
To
func startVideoCompositionRequest(_ asyncVideoCompositionRequest: AVAsynchronousVideoCompositionRequest)

Declaration
From
class AVVideoComposition : NSObject, NSCopying, NSMutableCopying {
    init!(propertiesOfAsset asset: AVAsset!) -> AVVideoComposition
    class func videoCompositionWithPropertiesOfAsset(_ asset: AVAsset!) -> AVVideoComposition!
    var customVideoCompositorClass: AnyObject.Type! { get }
    var frameDuration: CMTime { get }
    var renderSize: CGSize { get }
    var instructions: [AnyObject]! { get }
    var animationTool: AVVideoCompositionCoreAnimationTool! { get }
}
extension AVVideoComposition {
    func isValidForAsset(_ asset: AVAsset!, timeRange timeRange: CMTimeRange, validationDelegate validationDelegate: AVVideoCompositionValidationHandling!) -> Bool
}
To
class AVVideoComposition : NSObject, NSCopying, NSMutableCopying {
     init(propertiesOfAsset asset: AVAsset)
    class func videoCompositionWithPropertiesOfAsset(_ asset: AVAsset) -> AVVideoComposition
    var customVideoCompositorClass: AnyObject.Type? { get }
    var frameDuration: CMTime { get }
    var renderSize: CGSize { get }
    var instructions: [AVVideoCompositionInstructionProtocol] { get }
    var animationTool: AVVideoCompositionCoreAnimationTool? { get }
}
extension AVVideoComposition {
     init(asset asset: AVAsset, applyingCIFiltersWithHandler applier: (AVAsynchronousCIImageFilteringRequest) -> Void)
    class func videoCompositionWithAsset(_ asset: AVAsset, applyingCIFiltersWithHandler applier: (AVAsynchronousCIImageFilteringRequest) -> Void) -> AVVideoComposition
}
extension AVVideoComposition {
    func isValidForAsset(_ asset: AVAsset?, timeRange timeRange: CMTimeRange, validationDelegate validationDelegate: AVVideoCompositionValidationHandling?) -> Bool
}

Declaration
From
var animationTool: AVVideoCompositionCoreAnimationTool! { get }
To
var animationTool: AVVideoCompositionCoreAnimationTool? { get }

Declaration
From
var customVideoCompositorClass: AnyObject.Type! { get }
To
var customVideoCompositorClass: AnyObject.Type? { get }

Declaration
From
init!(propertiesOfAsset asset: AVAsset!) -> AVVideoComposition
To
init(propertiesOfAsset asset: AVAsset)

Declaration
From
var instructions: [AnyObject]! { get }
To
var instructions: [AVVideoCompositionInstructionProtocol] { get }

Declaration
From
func isValidForAsset(_ asset: AVAsset!, timeRange timeRange: CMTimeRange, validationDelegate validationDelegate: AVVideoCompositionValidationHandling!) -> Bool
To
func isValidForAsset(_ asset: AVAsset?, timeRange timeRange: CMTimeRange, validationDelegate validationDelegate: AVVideoCompositionValidationHandling?) -> Bool

Declaration
From
class AVVideoCompositionCoreAnimationTool : NSObject {
    init!(additionalLayer layer: CALayer!, asTrackID trackID: CMPersistentTrackID) -> AVVideoCompositionCoreAnimationTool
    class func videoCompositionCoreAnimationToolWithAdditionalLayer(_ layer: CALayer!, asTrackID trackID: CMPersistentTrackID) -> AVVideoCompositionCoreAnimationTool!
    init!(postProcessingAsVideoLayer videoLayer: CALayer!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool
    class func videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer(_ videoLayer: CALayer!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool!
    init!(postProcessingAsVideoLayers videoLayers: [AnyObject]!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool
    class func videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayers(_ videoLayers: [AnyObject]!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool!
}
To
class AVVideoCompositionCoreAnimationTool : NSObject {
    convenience init(additionalLayer layer: CALayer, asTrackID trackID: CMPersistentTrackID)
    class func videoCompositionCoreAnimationToolWithAdditionalLayer(_ layer: CALayer, asTrackID trackID: CMPersistentTrackID) -> Self
    convenience init(postProcessingAsVideoLayer videoLayer: CALayer, inLayer animationLayer: CALayer)
    class func videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer(_ videoLayer: CALayer, inLayer animationLayer: CALayer) -> Self
    convenience init(postProcessingAsVideoLayers videoLayers: [CALayer], inLayer animationLayer: CALayer)
    class func videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayers(_ videoLayers: [CALayer], inLayer animationLayer: CALayer) -> Self
}

Declaration
From
init!(additionalLayer layer: CALayer!, asTrackID trackID: CMPersistentTrackID) -> AVVideoCompositionCoreAnimationTool
To
convenience init(additionalLayer layer: CALayer, asTrackID trackID: CMPersistentTrackID)

Declaration
From
init!(postProcessingAsVideoLayer videoLayer: CALayer!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool
To
convenience init(postProcessingAsVideoLayer videoLayer: CALayer, inLayer animationLayer: CALayer)

Declaration
From
init!(postProcessingAsVideoLayers videoLayers: [AnyObject]!, inLayer animationLayer: CALayer!) -> AVVideoCompositionCoreAnimationTool
To
convenience init(postProcessingAsVideoLayers videoLayers: [CALayer], inLayer animationLayer: CALayer)

Declaration
From
class AVVideoCompositionInstruction : NSObject, NSSecureCoding, NSCoding, NSCopying, NSMutableCopying, AVVideoCompositionInstructionProtocol, NSObjectProtocol {
    var timeRange: CMTimeRange { get }
    var backgroundColor: CGColor!
    var layerInstructions: [AnyObject]! { get }
    var enablePostProcessing: Bool { get }
    var requiredSourceTrackIDs: [AnyObject]! { get }
    var passthroughTrackID: CMPersistentTrackID { get }
}
To
class AVVideoCompositionInstruction : NSObject, NSSecureCoding, NSCoding, NSCopying, NSMutableCopying, AVVideoCompositionInstructionProtocol {
    var timeRange: CMTimeRange { get }
    var backgroundColor: CGColor? { get }
    var layerInstructions: [AVVideoCompositionLayerInstruction] { get }
    var enablePostProcessing: Bool { get }
    var requiredSourceTrackIDs: [NSValue] { get }
    var passthroughTrackID: CMPersistentTrackID { get }
}

Declaration
From
var backgroundColor: CGColor!
To
var backgroundColor: CGColor? { get }

Declaration
From
var layerInstructions: [AnyObject]! { get }
To
var layerInstructions: [AVVideoCompositionLayerInstruction] { get }

Declaration
From
var requiredSourceTrackIDs: [AnyObject]! { get }
To
var requiredSourceTrackIDs: [NSValue] { get }

Declaration
From
protocol AVVideoCompositionInstructionProtocol : NSObjectProtocol {
    var timeRange: CMTimeRange { get }
    var enablePostProcessing: Bool { get }
    var containsTweening: Bool { get }
    var requiredSourceTrackIDs: [AnyObject]! { get }
    var passthroughTrackID: CMPersistentTrackID { get }
}
To
protocol AVVideoCompositionInstructionProtocol : NSObjectProtocol {
    var timeRange: CMTimeRange { get }
    var enablePostProcessing: Bool { get }
    var containsTweening: Bool { get }
    var requiredSourceTrackIDs: [NSValue]? { get }
    var passthroughTrackID: CMPersistentTrackID { get }
}

Declaration
From
var requiredSourceTrackIDs: [AnyObject]! { get }
To
var requiredSourceTrackIDs: [NSValue]? { get }

Declaration
From
class AVVideoCompositionRenderContext : NSObject {
    var size: CGSize { get }
    var renderTransform: CGAffineTransform { get }
    var renderScale: Float { get }
    var pixelAspectRatio: AVPixelAspectRatio { get }
    var edgeWidths: AVEdgeWidths { get }
    var highQualityRendering: Bool { get }
    var videoComposition: AVVideoComposition! { get }
    func newPixelBuffer() -> Unmanaged<CVPixelBuffer>!
}
To
class AVVideoCompositionRenderContext : NSObject {
    var size: CGSize { get }
    var renderTransform: CGAffineTransform { get }
    var renderScale: Float { get }
    var pixelAspectRatio: AVPixelAspectRatio { get }
    var edgeWidths: AVEdgeWidths { get }
    var highQualityRendering: Bool { get }
    var videoComposition: AVVideoComposition { get }
    func newPixelBuffer() -> CVPixelBuffer?
}

Declaration
From
func newPixelBuffer() -> Unmanaged<CVPixelBuffer>!
To
func newPixelBuffer() -> CVPixelBuffer?

Declaration
From
var videoComposition: AVVideoComposition! { get }
To
var videoComposition: AVVideoComposition { get }

Declaration
From
protocol AVVideoCompositionValidationHandling : NSObjectProtocol {
    optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidValueForKey key: String!) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingEmptyTimeRange timeRange: CMTimeRange) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol!) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol!, layerInstruction layerInstruction: AVVideoCompositionLayerInstruction!, asset asset: AVAsset!) -> Bool
}
To
protocol AVVideoCompositionValidationHandling : NSObjectProtocol {
    optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidValueForKey key: String) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingEmptyTimeRange timeRange: CMTimeRange) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol) -> Bool
    optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol, layerInstruction layerInstruction: AVVideoCompositionLayerInstruction, asset asset: AVAsset) -> Bool
}

Declaration
From
optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingEmptyTimeRange timeRange: CMTimeRange) -> Bool
To
optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingEmptyTimeRange timeRange: CMTimeRange) -> Bool

Declaration
From
optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol!) -> Bool
To
optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol) -> Bool

Declaration
From
optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol!, layerInstruction layerInstruction: AVVideoCompositionLayerInstruction!, asset asset: AVAsset!) -> Bool
To
optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction videoCompositionInstruction: AVVideoCompositionInstructionProtocol, layerInstruction layerInstruction: AVVideoCompositionLayerInstruction, asset asset: AVAsset) -> Bool

Declaration
From
optional func videoComposition(_ videoComposition: AVVideoComposition!, shouldContinueValidatingAfterFindingInvalidValueForKey key: String!) -> Bool
To
optional func videoComposition(_ videoComposition: AVVideoComposition, shouldContinueValidatingAfterFindingInvalidValueForKey key: String) -> Bool

Raw Value Type
From--
ToInt

Declaration
From
func decodeCMTimeForKey(_ key: String!) -> CMTime
To
func decodeCMTimeForKey(_ key: String) -> CMTime

Declaration
From
func decodeCMTimeMappingForKey(_ key: String!) -> CMTimeMapping
To
func decodeCMTimeMappingForKey(_ key: String) -> CMTimeMapping

Declaration
From
func decodeCMTimeRangeForKey(_ key: String!) -> CMTimeRange
To
func decodeCMTimeRangeForKey(_ key: String) -> CMTimeRange

Declaration
From
func encodeCMTime(_ time: CMTime, forKey key: String!)
To
func encodeCMTime(_ time: CMTime, forKey key: String)

Declaration
From
func encodeCMTimeMapping(_ timeMapping: CMTimeMapping, forKey key: String!)
To
func encodeCMTimeMapping(_ timeMapping: CMTimeMapping, forKey key: String)

Declaration
From
func encodeCMTimeRange(_ timeRange: CMTimeRange, forKey key: String!)
To
func encodeCMTimeRange(_ timeRange: CMTimeRange, forKey key: String)

Declaration
From
init!(CMTime time: CMTime) -> NSValue
To
init(CMTime time: CMTime)

Declaration
From
init!(CMTimeMapping timeMapping: CMTimeMapping) -> NSValue
To
init(CMTimeMapping timeMapping: CMTimeMapping)

Declaration
From
init!(CMTimeRange timeRange: CMTimeRange) -> NSValue
To
init(CMTimeRange timeRange: CMTimeRange)

Declaration
From
typealias AVAssetImageGeneratorCompletionHandler = (CMTime, CGImage!, CMTime, AVAssetImageGeneratorResult, NSError!) -> Void
To
typealias AVAssetImageGeneratorCompletionHandler = (CMTime, CGImage?, CMTime, AVAssetImageGeneratorResult, NSError?) -> Void

Declaration
From
typealias AVAudioNodeTapBlock = (AVAudioPCMBuffer!, AVAudioTime!) -> Void
To
typealias AVAudioNodeTapBlock = (AVAudioPCMBuffer, AVAudioTime) -> Void

Deprecation
From--
ToOS X 10.11

Deprecation
From--
ToOS X 10.11

Deprecation
From--
ToOS X 10.11