Other AVPlayerViewController Properties

An AVPlayerViewController has very few properties:

player

The view controller’s AVPlayer, whose AVPlayerLayer will be hosted in the view controller’s view. You can set the player while the view is visible, to change what video it displays (though you are more likely to keep the player and tell it to change the video). It is legal to assign an AVQueuePlayer, an AVPlayer subclass; an AVQueuePlayer has multiple items, and the AVPlayerViewController will treat these as chapters of the video. An AVPlayerLooper object can be used in conjunction with an AVQueuePlayer to repeat play automatically. (I’ll give an AVQueuePlayer example in Chapter 17, and an AVPlayerLooper example in Chapter 18.)

showsPlaybackControls

If false, the controls are hidden. This could be useful if you want to display a video for decorative purposes, or if you are substituting your own controls.

contentOverlayView

A UIView to which you are free to add subviews. These subviews will appear overlaid in front of the video but behind the playback controls. Starting in iOS 11, the content overlay is sized to fit its contents, or you can give it constraints to size it as you prefer.

videoGravity

How the video should be positioned within the view. Possible values are (AVLayerVideoGravity):

• .resizeAspect (the default)

• .resizeAspectFill

• .resize (fills the view, possibly distorting the video)

videoBounds

isReadyForDisplay

Read-only. The video position within the view, and the ability of the video to display its first frame and start playing, respectively. If the video is not ready for display, we probably don’t yet know its bounds either. In any case, isReadyForDisplay will initially be false and the videoBounds will initially be reported as .zero. This is because, with video, things take time to prepare. I’ll explain in detail later in this chapter.

updatesNowPlayingInfoCenter

If true (the default), the AVPlayerViewController keeps the MPNowPlayingInfoCenter (Chapter 15) apprised of the movie’s duration and current playhead position. If false, it doesn’t do that, leaving your code in charge of managing the MPNowPlayingInfoCenter. Starting in iOS 13, you can leave this property at true and still govern what information appears in the remote control interface, by setting the player item’s externalMetadata; here’s an example (without further comment):

let metadata = AVMutableMetadataItem()
metadata.keySpace = .common
metadata.key = AVMetadataKey.commonKeyTitle as NSString
metadata.value = "El Mirage" as NSString
av.player?.currentItem?.externalMetadata = [metadata]

entersFullScreenWhenPlaybackBegins

exitsFullScreenWhenPlaybackEnds

If true, a child AVPlayerViewController’s view switches to and from fullscreen mode automatically when play begins and ends.

Everything else there is to know about an AVPlayerViewController comes from its player, an AVPlayer. I’ll discuss AVPlayer in more detail in a moment.

Picture-in-Picture

An iPad capable of running iOS 14 supports picture-in-picture video playback (unless the user turns it off in the Settings app). This means that the user can move your video into a small system window that floats in front of everything else on the screen. This floating window persists if your app is put into the background.

Your iPad app will support picture-in-picture if it supports background audio, as I described in Chapter 15: you check the checkbox in the Signing & Capabilities tab of the target editor (Figure 15-2), and your audio session’s policy must be active and must be Playback. If you want to do those things without your app being forced to support picture-in-picture, set the AVPlayerViewController’s allowsPictureInPicturePlayback to false.

If picture-in-picture is supported, an extra button appears among the upper set of playback controls (Figure 16-3). When the user taps this button, the video is moved into the system window (and the AVPlayerViewController’s view displays a placeholder). The user is now free to leave your app while continuing to see and hear the video. Moreover, if the video is being played fullscreen when the user leaves your app, the video is moved into the picture-in-picture system window automatically.

Figure 16-3. The picture-in-picture button appears

The user can move the system window to any corner. Buttons in the system window, which can be shown or hidden by tapping, allow the user to play and pause the video or to dismiss the system window. There’s also a button to dismiss the system window plus return to your app; if the user taps it while the video is playing, the video goes right on playing as it moves back into place within your app.

Various delegate methods keep you informed of when the user causes your app to enter and leave picture-in-picture mode; the most important are:

• playerViewControllerDidStartPictureInPicture(_:)

• playerViewControllerDidStopPictureInPicture(_:)

If your AVPlayerViewController is being presented fullscreen when the video is taken into picture-in-picture mode, then the presented view controller, by default, is dismissed. If the user tries to return to your app from the system picture-in-picture window, the video has no place to return to. To handle this situation, give the AVPlayerViewController a delegate (AVPlayerViewControllerDelegate) and deal with it in a delegate method. You have two choices:

Don’t dismiss the presented view controller

Implement this method:

• playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(_:)

Return false. Now the presented view controller remains, and the video has a place in your app to which it can be restored.

Recreate the presented view controller

Implement this method:

• playerViewController(_:restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:)

Do what the name tells you: restore the user interface! The first parameter is your original AVPlayerViewController; all you have to do is get it back into the view controller hierarchy. At the end of the process, call the completion function.

I’ll demonstrate the second approach:

func playerViewController(_ pvc: AVPlayerViewController,
    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler
    ch: @escaping (Bool) -> ()) {
        self.present(pvc, animated:true) {
            ch(true)
        }
}

The outward difference between the two approaches lies in what happens if the user comes back to your app while picture-in-picture is still going on:

• With the first approach, the presented AVPlayerViewController is still there, but it’s black and empty, with a legend: “This video is playing picture in picture.” The user can then animate the video back to its place within your app.

• With the second approach, the presented AVPlayerViewController is gone, and if the user were to present it, you’d have two copies of the video, the one still playing picture-in-picture and the one now being presented. That’s bad, so you need to prevent it from happening. In other words, while you are still in picture-in-picture mode, the second delegate method should be the only way that your app presents the AVPlayerViewController. Luckily, you know when you are in picture-in-picture mode, because the other delegate methods tell you.

Some AV Foundation Classes

The heart of AV Foundation video playback is AVPlayer. AVPlayer is not a UIView, but rather is the locus of video transport; the actual video, if shown, appears in an AVPlayerLayer associated with the AVPlayer. AVPlayerViewController provides a play button, but what if you wanted to start video playback in code? You’d talk to the AVPlayerViewController’s player — an AVPlayer. You’d tell it to play or set its rate to 1.

An AVPlayer’s video is its currentItem, an AVPlayerItem. In the examples earlier in this chapter we initialized an AVPlayer directly from a URL, with no reference to any AVPlayerItem; but that was just a shortcut. AVPlayer’s real initializer is init(playerItem:), which takes an AVPlayerItem; when we called init(url:), the AVPlayerItem was created for us.

An AVPlayerItem, too, can be initialized from a URL with init(url:), but again, this is just a shortcut. AVPlayerItem’s real initializer is init(asset:), which takes an AVAsset. An AVAsset is an actual video resource, and comes in one of two subclasses:

AVURLAsset

An asset specified through a URL.

AVComposition

An asset constructed by editing video in code. I’ll give an example later in this chapter.

To configure an AVPlayer using the complete “stack” of objects that constitute it, you could say something like this:

let url = Bundle.main.url(forResource:"ElMirage", withExtension:"mp4")!
let asset = AVURLAsset(url:url)
let item = AVPlayerItem(asset:asset)
let player = AVPlayer(playerItem:item)

Once an AVPlayer exists and has an AVPlayerItem, that player item’s tracks, as seen from the player’s perspective, are AVPlayerItemTrack objects, which can be individually enabled or disabled. That’s different from an AVAssetTrack, which is a fact about an AVAsset. This distinction is a good example of how AV Foundation encapsulates its objects correctly: an AVAssetTrack is a hard and fast reality, but an AVPlayerItemTrack lets a track be manipulated for purposes of playback on a particular occasion.

Things Take Time

Working with video is time-consuming. Just because you give an AVPlayer a command or set a property doesn’t mean that it obeys immediately. All sorts of operations, from reading a video file and learning its metadata to transcoding and saving a video file, take a significant amount of time. The user interface must not freeze while a video task is in progress, so AV Foundation relies heavily on threading (Chapter 25). In this way, AV Foundation covers the complex and time-consuming nature of its operations; but your code must cooperate. You’ll frequently use key–value observing and callbacks to run your code at the right moment.

Here’s an example; it’s slightly artificial, but it illustrates the principles and techniques you need to know about. There’s an elementary interface flaw when we create an embedded AVPlayerViewController:

let url = Bundle.main.url(forResource:"ElMirage", withExtension:"mp4")!
let asset = AVURLAsset(url:url)
let item = AVPlayerItem(asset:asset)
let player = AVPlayer(playerItem:item)
let av = AVPlayerViewController()
av.view.frame = CGRect(10,10,300,200)
av.player = player
self.addChild(av)
self.view.addSubview(av.view)
av.didMove(toParent: self)

There are two issues here:

• The AVPlayerViewController’s view is initially appearing empty in the interface, because the video is not yet ready for display. Then there’s a visible flash when the video appears, because now it is ready for display.

• The proposed frame of the AVPlayerViewController’s view doesn’t fit the actual aspect ratio of the video, which results in the video being letterboxed within that frame (visible in Figure 16-2).

Fixing those issues requires us to grapple with the fact that it takes time to learn when the video is ready for display and what its aspect ratio is.

av.view.isHidden = true
var ob : NSKeyValueObservation!
ob = av.observe(.isReadyForDisplay, options: [.initial, .new]) { vc, ch in
    guard let ok = ch.newValue, ok else {return}
    self.obs.remove(ob)
    DispatchQueue.main.async {
        vc.view.isHidden = false
    }
}
self.obs.insert(ob) // obs is a Set<NSKeyValueObservation>

let url = Bundle.main.url(forResource:"ElMirage", withExtension:"mp4")!
let asset = AVURLAsset(url:url)
let track = #keyPath(AVURLAsset.tracks)
asset.loadValuesAsynchronously(forKeys:[track]) {
    let status = asset.statusOfValue(forKey:track, error: nil)
    if status == .loaded {
        DispatchQueue.main.async {
            self.getVideoTrack(asset)
        }
    }
}

func getVideoTrack(_ asset:AVAsset) {
    let visual = AVMediaCharacteristic.visual
    let vtrack = asset.tracks(withMediaCharacteristic: visual)[0]
    let size = #keyPath(AVAssetTrack.naturalSize)
    vtrack.loadValuesAsynchronously(forKeys: [size]) {
        let status = vtrack.statusOfValue(forKey: size, error: nil)
        if status == .loaded {
            DispatchQueue.main.async {
                self.getNaturalSize(vtrack, asset)
            }
        }
    }
}

func getNaturalSize(_ vtrack:AVAssetTrack, _ asset:AVAsset) {
    let sz = vtrack.naturalSize
    let item = AVPlayerItem(asset:asset)
    let player = AVPlayer(playerItem:item)
    let av = AVPlayerViewController()
    av.view.frame = AVMakeRect(
        aspectRatio: sz, insideRect: CGRect(10,10,300,200))
    av.player = player
    // ... and the rest is as before ...
}

Time Is Measured Oddly

Another peculiarity of AV Foundation is that time is measured in an unfamiliar way. This is necessary because calculations using an ordinary built-in numeric class such as CGFloat will always have slight rounding errors that quickly begin to matter when you’re trying to specify a time within a large piece of media. Therefore, the Core Media framework provides the CMTime class, which under the hood is a pair of integers; they are called the value and the timescale, but they are simply the numerator and denominator of a rational number.

When you call the CMTime initializer init(value:timescale:) (equivalent to C CMTimeMake), that’s what you’re providing. The denominator represents the degree of granularity; a typical value is 600, sufficient to specify individual frames in common video formats.

In the convenience initializer init(seconds:preferredTimescale:) (equivalent to C CMTimeMakeWithSeconds), the two arguments are not the numerator and denominator; they are the time’s equivalent in seconds and the denominator. For instance, CMTime(seconds:2.5, preferredTimescale:600) yields the CMTime (1500,600).

Constructing Media

AV Foundation allows you to construct your own media asset in code as an AVComposition, an AVAsset subclass, using its subclass, AVMutableComposition. An AVComposition is an AVAsset, so given an AVMutableComposition, we could make an AVPlayerItem from it (by calling init(asset:)) and hand it over to an AVPlayerViewController’s player; we will be creating and displaying our own movie!

let type = AVMediaType.video
let arr = asset1.tracks(withMediaType: type)
let track = arr.last!
let duration : CMTime = track.timeRange.duration
let comp = AVMutableComposition()
let comptrack = comp.addMutableTrack(withMediaType: type,
    preferredTrackID: Int32(kCMPersistentTrackID_Invalid))!
try! comptrack.insertTimeRange(CMTimeRange(
    start: CMTime(seconds:0, preferredTimescale:600),
    duration: CMTime(seconds:5, preferredTimescale:600)),
    of:track, at:CMTime(seconds:0, preferredTimescale:600))
try! comptrack.insertTimeRange(CMTimeRange(
    start: duration - CMTime(seconds:5, preferredTimescale:600),
    duration: CMTime(seconds:5, preferredTimescale:600)),
    of:track, at:CMTime(seconds:5, preferredTimescale:600))

let type2 = AVMediaType.audio
let arr2 = asset1.tracks(withMediaType: type2)
let track2 = arr2.last!
let comptrack2 = comp.addMutableTrack(withMediaType: type2,
    preferredTrackID:Int32(kCMPersistentTrackID_Invalid))!
try! comptrack2.insertTimeRange(CMTimeRange(
    start: CMTime(seconds:0, preferredTimescale:600),
    duration: CMTime(seconds:5, preferredTimescale:600)),
    of:track2, at:CMTime(seconds:0, preferredTimescale:600))
try! comptrack2.insertTimeRange(CMTimeRange(
    start: duration - CMTime(seconds:5, preferredTimescale:600),
    duration: CMTime(seconds:5, preferredTimescale:600)),
    of:track2, at:CMTime(seconds:5, preferredTimescale:600))

let item = AVPlayerItem(asset:comp)
let p = vc.player! // vc is an AVPlayerViewController
p.replaceCurrentItem(with: item)

let type3 = AVMediaType.audio
let s = Bundle.main.url(forResource:"aboutTiagol", withExtension:"m4a")!
let asset2 = AVURLAsset(url:s)
let arr3 = asset2.tracks(withMediaType: type3)
let track3 = arr3.last!
let comptrack3 = comp.addMutableTrack(withMediaType: type3,
    preferredTrackID:Int32(kCMPersistentTrackID_Invalid))!
try! comptrack3.insertTimeRange(CMTimeRange(
    start: CMTime(seconds:0, preferredTimescale:600),
    duration: CMTime(seconds:10, preferredTimescale:600)),
    of:track3, at:CMTime(seconds:0, preferredTimescale:600))

let params = AVMutableAudioMixInputParameters(track:comptrack3)
params.setVolume(1, at:CMTime(seconds:0, preferredTimescale:600))
params.setVolumeRamp(fromStartVolume: 1, toEndVolume:0,
    timeRange:CMTimeRange(
        start: CMTime(seconds:5, preferredTimescale:600),
        duration: CMTime(seconds:5, preferredTimescale:600)))
let mix = AVMutableAudioMix()
mix.inputParameters = [params]

let item = AVPlayerItem(asset:comp)
item.audioMix = mix

let vidcomp = AVVideoComposition(asset: comp) { req in
    // req is an AVAsynchronousCIImageFilteringRequest
    let f = "CISepiaTone"
    let im = req.sourceImage.applyingFilter(
        f, parameters: ["inputIntensity":0.95])
    req.finish(with: im, context: nil)
}

let item = AVPlayerItem(asset:comp)
item.videoComposition = vidcomp

Synchronizing animation with video

An intriguing feature of AV Foundation is AVSynchronizedLayer, a CALayer subclass that effectively crosses the bridge between video time (the CMTime within the progress of a movie) and Core Animation time (the time within the progress of an animation). This means that you can coordinate animation in your interface (Chapter 4) with the playback of a movie! You attach an animation to a layer in more or less the usual way, but the animation takes place in movie playback time: if the movie is stopped, the animation is stopped; if the movie is run at double rate, the animation runs at double rate; and the current “frame” of the animation always corresponds to the current frame of the video within its overall duration.

The synchronization is performed with respect to an AVPlayer’s AVPlayerItem. To demonstrate, I’ll draw a long thin gray rectangle containing a little black square; the horizontal position of the black square within the gray rectangle will be synchronized to the movie playhead position:

let vc = self.children[0] as! AVPlayerViewController
let p = vc.player!
// create synch layer, put it in the interface
let item = p.currentItem!
let syncLayer = AVSynchronizedLayer(playerItem:item)
syncLayer.frame = CGRect(10,220,300,10)
syncLayer.backgroundColor = UIColor.lightGray.cgColor
self.view.layer.addSublayer(syncLayer)
// give synch layer a sublayer
let subLayer = CALayer()
subLayer.backgroundColor = UIColor.black.cgColor
subLayer.frame = CGRect(0,0,10,10)
syncLayer.addSublayer(subLayer)
// animate the sublayer
let anim = CABasicAnimation(keyPath:#keyPath(CALayer.position))
anim.fromValue = subLayer.position
anim.toValue = CGPoint(295,5)
anim.isRemovedOnCompletion = false
anim.beginTime = AVCoreAnimationBeginTimeAtZero // important trick
anim.duration = item.asset.duration.seconds
subLayer.add(anim, forKey:nil)

Figure 16-4. The black square’s position is synchronized to the movie

The result is shown in Figure 16-4. The long gray rectangle is the AVSynchronizedLayer, tied to our movie. The little black square inside it is its sublayer; when we animate the black square, that animation will be synchronized to the movie, changing its position from the left end of the gray rectangle to the right end, starting at the beginning of the movie and with the same duration as the movie. Although we attach this animation to the black square layer in the usual way, that animation is frozen: the black square doesn’t move until we start the movie playing. Moreover, if we pause the movie, the black square stops. The black square is automatically representing the current play position within the movie. This may seem a silly example, but if you were to suppress the video controls it could prove downright useful.

let pre = AVAssetExportPresetHighestQuality
guard let exporter = AVAssetExportSession(asset:comp, presetName:pre) else {
    print("oops")
    return
}
// create a URL to export to
let fm = FileManager.default
var url = fm.temporaryDirectory
let uuid = UUID().uuidString
url.appendPathComponent(uuid + ".mov")
exporter.outputURL = url
exporter.outputFileType = AVFileType.mov
// warning: this can take a long time!
exporter.exportAsynchronously() {
    DispatchQueue.main.async {
        let item = AVPlayerItem(url: url)
        let p = vc.player! // vc is an AVPlayerViewController
        p.replaceCurrentItem(with:item)
    }
}

exporter.videoComposition = vidcomp

let vidtrack = comp.tracks(withMediaType: .video)[0]
let sz = vidtrack.naturalSize
let parent = CALayer()
parent.frame = CGRect(origin: .zero, size: sz)
let child = CALayer()
child.frame = parent.bounds
parent.addSublayer(child)

let tool = AVVideoCompositionCoreAnimationTool(
    postProcessingAsVideoLayer: child, in: parent)
let vidcomp = AVMutableVideoComposition()
vidcomp.animationTool = tool
vidcomp.renderSize = sz
vidcomp.frameDuration = CMTime(value: 1, timescale: 30)
let inst = AVMutableVideoCompositionInstruction()
let dur = comp.duration
inst.timeRange = CMTimeRange(start: .zero, duration: dur)
let layinst = AVMutableVideoCompositionLayerInstruction(assetTrack: vidtrack)
inst.layerInstructions = [layinst]
vidcomp.instructions = [inst]

let lay = CATextLayer()
lay.string = "This is cool!"
lay.alignmentMode = .center
lay.foregroundColor = UIColor.black.cgColor
lay.frame = child.bounds
child.addSublayer(lay)
// ... and the rest is as before ...

let ba = CABasicAnimation(keyPath: #keyPath(CALayer.opacity))
ba.duration = 1
ba.fromValue = 0
ba.toValue = 1
ba.beginTime = AVCoreAnimationBeginTimeAtZero + 1 // crucial
ba.fillMode = .backwards
lay.add(ba, forKey: nil)

AVPlayerLayer

An AVPlayer is not an interface object. The corresponding interface object — an AVPlayer made visible, as it were — is an AVPlayerLayer (a CALayer subclass). It has no controls for letting the user play and pause a movie and visualize its progress; it just shows the movie, acting as a bridge between the AV Foundation world of media and the CALayer world of things the user can see.

An AVPlayerViewController’s view hosts an AVPlayerLayer for you automatically; otherwise you would not see any video in the AVPlayerViewController’s view. But there may be situations where you find AVPlayerViewController too heavyweight, where you don’t need the standard transport controls, where you don’t want the video to be expandable or to have a fullscreen mode — you just want the simple direct power that can be obtained only by putting an AVPlayerLayer into the interface yourself.

Here, I’ll display the same movie as before, but without an AVPlayerViewController:

let m = Bundle.main.url(forResource:"ElMirage", withExtension:"mp4")!
let asset = AVURLAsset(url:m)
let item = AVPlayerItem(asset:asset)
let p = AVPlayer(playerItem:item)
self.player = p // might need a reference later
let lay = AVPlayerLayer(player:p)
lay.frame = CGRect(10,10,300,200)
self.playerLayer = lay // might need a reference later
self.view.layer.addSublayer(lay)

As before, if we want to prevent a flash when the video becomes ready for display, we can postpone adding the AVPlayerLayer to our interface until its isReadyForDisplay property becomes true — which we can learn through KVO.

In a WWDC 2016 video, Apple suggests an interesting twist on the preceding code: create the AVPlayer without an AVPlayerItem, create the AVPlayerLayer, and then assign the AVPlayerItem to AVPlayer, like this:

let m = Bundle.main.url(forResource:"ElMirage", withExtension:"mp4")!
let asset = AVURLAsset(url:m)
let item = AVPlayerItem(asset:asset)
let p = AVPlayer() // *
self.player = p
let lay = AVPlayerLayer(player:p)
lay.frame = CGRect(10,10,300,200)
self.playerLayer = lay
p.replaceCurrentItem(with: item) // *
self.view.layer.addSublayer(lay)

Apparently, there is some increase in efficiency if you do things in that order. The reason, it turns out, is that when an AVPlayerItem is assigned to an AVPlayer that doesn’t have an associated AVPlayerLayer, the AVPlayer assumes that only the audio track of the AVAsset is important — and then, when an AVPlayerLayer is assigned to it, the AVPlayer must scramble to pick up the video track as well.

The movie is now visible in the interface, but it isn’t doing anything. We haven’t told our AVPlayer to play, and there are no transport controls, so the user can’t tell the video to play either. That’s why I kept a reference to the AVPlayer in a property! We can start play either by calling play or by setting the AVPlayer’s rate. Here, I imagine that we’ve provided a simple play/pause button that toggles the playing status of the movie by changing its rate:

@IBAction func doButton (_ sender: Any) {
    let rate = self.player.rate
    self.player.rate = rate < 0.01 ? 1 : 0
}

Without trying to replicate the full transport controls, we might also like to give the user a way to jump the playhead back to the start of the movie. The playhead position is a feature of an AVPlayerItem:

@IBAction func restart (_ sender: Any) {
    let item = self.player.currentItem!
    let time: CMTime = CMTime(seconds:0, preferredTimescale:600)
    item.seek(to:time, completionHandler:nil)
}

If we want our AVPlayerLayer to support picture-in-picture, then (in addition to making the app itself support picture-in-picture, as I’ve already described) we need to call upon AVKit to supply us with an AVPictureInPictureController. This is not a view controller; it merely endows our AVPlayerLayer with picture-in-picture behavior. You create the AVPictureInPictureController (checking first to see whether the environment supports picture-in-picture in the first place), initialize it with the AVPlayerLayer, and retain it:

if AVPictureInPictureController.isPictureInPictureSupported() {
    let pic = AVPictureInPictureController(playerLayer: self.playerLayer)
    self.pic = pic
}

There are no transport controls, so there is no picture-in-picture button. Supplying one is up to you. Don’t show the button if picture-in-picture isn’t supported! When the button is tapped, tell the AVPictureInPictureController to startPictureInPicture:

@IBAction func doPicInPic(_ sender: Any) {
    if self.pic.isPictureInPicturePossible {
        self.pic.startPictureInPicture()
    }
}

You might also want to set yourself as the AVPictureInPictureController’s delegate (AVPictureInPictureControllerDelegate). As with the AVPlayerViewController delegate, you are informed of stages in the life of the picture-in-picture window so that you can adjust your interface accordingly. When the user taps the button that dismisses the system window and returns to your app, then if the AVPlayerLayer is still sitting in your interface, there may be no work to do. If you removed the AVPlayerLayer from your interface, and you now want to restore it, implement this delegate method:

• pictureInPictureController(_:restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:)

In your implementation, configure your interface so that the AVPlayerLayer is present. Make sure that the AVPlayerLayer that you now put into your interface is the same one that was removed earlier; in other words, your player layer must continue to be the same as the AVPictureInPictureController’s playerLayer.

Further Exploration of AV Foundation

Here are some other things you can do with AV Foundation:

• Extract single images (sometimes referred to as thumbnails or poster images) from a movie (AVAssetImageGenerator). Displaying a poster image of a video’s initial frame can help cover up for the delay before the video is ready to start playing.

• Export a movie in a different format (AVAssetExportSession), or read/write raw uncompressed data through a buffer to or from a track (AVAssetReader, AVAssetReaderOutput, AVAssetWriter, AVAssetWriterInput, and so on).

• Capture audio, video, and stills through the device’s hardware (AVCaptureSession and so on). I’ll say more about that in Chapter 18.

• Tap into video and audio being captured or played, including capturing video frames as still images (AVPlayerItemVideoOutput, AVCaptureVideoDataOutput, and so on; and see Apple’s Technical Q&A QA1702).

The media capabilities of AV Foundation are nicely summarized in a classic WWDC video, https://developer.apple.com/videos/play/wwdc2011/415/.