AVFoundation — qu'est-ce que c'est, API audio et vidéo sur iOS

Qu'est-ce que AVFoundation ?

AVFoundation est le framework multimédia fondamental d'Apple, introduit dès iOS 4 (2010) en remplacement de l'obsolète UIWebView pour la lecture audio et vidéo. Depuis, AVFoundation a évolué pour devenir un ensemble complet d'outils pour travailler avec tous les types de médias : de la simple lecture de fichiers MP3 à la capture vidéo professionnelle avec microphone multicanal et à la transformation sonore via des effets en temps réel.

L'architecture d'AVFoundation est construite autour de plusieurs abstractions de base : AVAsset (données multimédia), AVPlayer (lecture), AVCaptureSession (capture) et AVAudioEngine (traitement). Chaque composant fonctionne de manière asynchrone, ce qui est essentiel pour maintenir la fluidité de l'interface utilisateur pendant le chargement ou le traitement de fichiers volumineux. Selon Apple (WWDC 2025), AVFoundation gère la vidéo jusqu'en 8K sur les appareils équipés de puces de la série M sans perte de performances.

Capacités principales

AVFoundation fournit la capture vidéo depuis la caméra avec prise en charge du 4K ProRes, HDR et jusqu'à 240 FPS au ralenti, l'enregistrement et le mixage audio depuis les microphones intégrés et externes, la lecture multimédia avec prise en charge de HLS, MPEG-4, QuickTime, MP3, AAC et FLAC, l'exportation et la conversion de fichiers via AVAssetExportSession, le traitement audio en temps réel via AVAudioEngine avec des effets de réverbération, d'égalisation et de changement de hauteur, ainsi que le streaming via AirPlay et les protocoles réseau.

Composants clés d'AVFoundation

AVFoundation se compose de plusieurs modules, chacun responsable d'un domaine spécifique du travail multimédia. Le choix du composant dépend de la tâche : capture, lecture, exportation ou traitement en temps réel.

AVCaptureSession — Capture avec caméra

AVCaptureSession est l'objet central pour la capture vidéo et audio. Il gère les flux de données entrants des dispositifs physiques (caméra, microphone), configure leurs réglages (résolution, FPS, format) et les dirige vers la sortie : aperçu (AVCaptureVideoPreviewLayer), enregistrement dans un fichier (AVCaptureMovieFileOutput) ou traitement image par image (AVCaptureVideoDataOutput).

AVPlayer — Lecture multimédia

AVPlayer est un lecteur universel d'AVFoundation capable de lire du contenu multimédia aussi bien localement que sur le réseau. AVPlayer prend en charge le streaming HLS, MPEG-4, QuickTime Movie et la plupart des formats audio. Le contrôle de la lecture s'effectue de manière asynchrone via AVPlayerItem. AVPlayerViewController fournit une interface utilisateur prête à l'emploi avec des commandes : lecture/pause, défilement, AirPlay et PiP.

Capture multimédia avec AVFoundation

La capture vidéo et audio est l'une des fonctionnalités les plus demandées d'AVFoundation. La configuration d'une session de capture comprend plusieurs étapes : création d'AVCaptureSession, ajout d'entrées (caméra, microphone), configuration des sorties et démarrage de la session.

Configuration d'AVCaptureSession

Parcourons la configuration étape par étape d'AVCaptureSession pour capturer la vidéo depuis la caméra arrière de l'iPhone tout en enregistrant simultanément le son du microphone. Le processus se compose de quatre étapes en Swift.

import AVFoundation

// 1. Créer et configurer la session
let session = AVCaptureSession()
session.sessionPreset = .hd1920x1080

// 2. Ajouter l'entrée caméra
guard let camera = AVCaptureDevice.default(
    for: .video
) else { return }
let cameraInput = try? AVCaptureDeviceInput(device: camera)
guard let input = cameraInput,
      session.canAddInput(input)
else { return }
session.addInput(input)

// 3. Ajouter une sortie pour l'enregistrement
let output = AVCaptureMovieFileOutput()
guard session.canAddOutput(output) else { return }
session.addOutput(output)

// 4. Démarrer la session
session.startRunning()

Le code Swift crée une AVCaptureSession avec un préréglage Full HD, connecte la caméra arrière comme source vidéo et ajoute une sortie pour l'enregistrement dans un fichier. Après session.startRunning(), la caméra commence à transmettre les images à l'aperçu et au fichier de sortie. L'enregistrement est arrêté via output.stopRecording() avec la possibilité de sauvegarder dans la galerie.

Pour la capture audio uniquement (sans vidéo), seul le microphone est ajouté à AVCaptureSession via AVCaptureDevice.default(.audio). La sortie est AVAudioFileOutput ou AVCaptureAudioDataOutput pour le traitement sonore en temps réel. AVFoundation prend en charge la capture multicanal : jusqu'à 8 canaux audio sur iPad Pro et jusqu'à 2 sur iPhone, permettant l'enregistrement stéréo depuis des microphones externes via Lightning, USB-C ou Bluetooth. La sélection de la source d'entrée s'effectue via AVAudioSession.sharedInstance().setPreferredInput, ce qui est crucial pour les applications fonctionnant avec des casques externes et des microphones Bluetooth.

Lecture multimédia

AVFoundation offre deux moyens principaux de lire des médias : AVPlayer pour la vidéo et AVAudioPlayer pour l'audio. Voyons un exemple de lecture d'un flux HLS distant avec AVPlayer.

Exemple d'AVPlayer avec HLS

Le code crée un AVPlayer, charge un flux HLS à partir d'une URL et lance la lecture à un niveau de volume réduit. AVPlayerItem gère l'état de chargement et de mise en mémoire tampon, et l'observation KVO du statut permet de gérer les erreurs.

import AVFoundation
import AVKit

// 1. Créer AVPlayer avec flux HLS
let url = URL(
    string: "https://example.com/stream.m3u8"
) !
let player = AVPlayer(url: url)
player.volume = 0.7

// 2. Lecture
player.play()

// 3. Afficher le lecteur
let playerVC = AVPlayerViewController()
playerVC.player = player
present(playerVC, animated: true)

// 4. Surveiller le statut
player.currentItem?.addObserver(
    self,
    forKeyPath: "status",
    options: .new,
    context: nil
)

Le code crée un AVPlayer avec une URL HLS, règle le volume à 70 % et lance la lecture. AVPlayerViewController fournit une interface intégrée avec des commandes, AirPlay et le mode picture-in-picture. Le statut du lecteur est surveillé via KVO pour gérer les cas où le flux HLS est temporairement indisponible.

Pour la lecture audio sans interface vidéo, on utilise AVAudioPlayer — un lecteur léger qui ne nécessite pas AVPlayerItem. AVAudioPlayer prend en charge les formats audio MP3, AAC, ALAC, FLAC, WAV et AIFF, fournit les méthodes play(), pause() et stop(), ainsi que le délégué AVAudioPlayerDelegate pour suivre la fin de la lecture et les erreurs de décodage. AVAudioPlayer est idéal pour la lecture de musique en arrière-plan, les podcasts et les effets sonores dans les jeux sur iOS et macOS.

Exemples de code supplémentaires

Voyons deux autres scénarios typiques de travail avec AVFoundation : le traitement audio via AVAudioEngine et l'exportation vidéo vers un autre format.

Traitement audio via AVAudioEngine

AVAudioEngine permet de traiter l'audio en temps réel en connectant des nœuds dans un graphe de traitement : nœud d'entrée (microphone) → effets → nœud de sortie (haut-parleur). Dans l'exemple ci-dessous, une réverbération est ajoutée à la voix.

let engine = AVAudioEngine()
let reverb = AVAudioUnitReverb()

// Configurer la réverbération
reverb.loadFactoryPreset(.largeHall)
reverb.wetDryMix = 40

// Connexion : microphone -> réverbération -> haut-parleur
engine.attach(reverb)
engine.connect(
    engine.inputNode,
    to: reverb,
    format: nil
)
engine.connect(
    reverb,
    to: engine.mainMixerNode,
    format: nil
)

try? engine.start()

AVAudioEngine crée un graphe de trois nœuds : entrée (microphone), effet (réverbération avec préréglage de grande salle) et sortie (haut-parleur). Après engine.start(), l'audio du microphone est traité par l'effet en temps réel et envoyé au casque ou au haut-parleur de l'appareil. La latence de traitement est inférieure à 10 ms sur tous les appareils Apple modernes.

Une capacité supplémentaire d'AVAudioEngine est l'analyse sonore via AVAudioUnitEQ et AVAudioUnitMixer. Le développeur peut ajouter un égaliseur, un compresseur et un limiteur à n'importe quel flux audio. Pour les applications musicales, AVFoundation fournit AVAudioSequencer pour la lecture de fichiers MIDI et AVSpeechSynthesizer pour la synthèse vocale. Tous les composants fonctionnent dans un seul graphe audio, offrant une latence entre la capture et le traitement inférieure à 5 ms sur les appareils Apple.

Lorsqu'on travaille avec AVFoundation, il est important de prendre en compte les autorisations système : pour accéder à la caméra, NSCameraUsageDescription est requis dans Info.plist, et pour le microphone, NSMicrophoneUsageDescription. AVFoundation affiche automatiquement la boîte de dialogue de demande d'autorisation système lors de la première tentative d'accès à un appareil. Le refus de l'utilisateur est géré via AVCaptureDevice.authorizationStatus(), ce qui permet d'afficher un message approprié sur l'indisponibilité de la caméra avec une suggestion d'aller dans les Réglages.

AVFoundation prend en charge la lecture audio en arrière-plan via le mode Audio Background Mode dans les capacités du projet. Pour l'activer, il suffit d'ajouter l'entrée audio dans UIBackgroundModes Info.plist et de configurer AVAudioSession avec la catégorie .playback. La vidéo n'est pas lue en arrière-plan par défaut, mais vous pouvez utiliser AVPlayer avec le mode picture-in-picture pour continuer la lecture vidéo dans une application réduite sur iPad. L'icône du mode PiP est configurée via AVPictureInPictureController avec le délégué du protocole.