Compression
Le cadre d'application Compression fait partie de l'écosystème proposé par Apple et permet à une application de mettre en oeuvre des mécanismes de compression sans perte lors de l'enregistrement, du transfert ou du partage de fichiers et de données. La compression est un procédé fondamental en informatique consistant à réduire la taille des données en les encodant, tout en garantissant qu'aucune information ne soit perdue. Le processus inverse, appelé décompression ou décodage, permet de restaurer fidèlement les données originales à partir de leur forme compressée. Par exemple, un éditeur de texte peut enregistrer automatiquement ses documents dans un format compressé afin d'économiser de l'espace disque, puis les décompresser de manière totalement transparente lorsque l'utilisateur ouvre un fichier.
D'un point de vue conceptuel, le fonctionnement de la compression peut être représenté par un schéma de flux clair et linéaire. Les données originales sont d'abord transmises à un encodeur, dont le rôle est de transformer ces informations brutes en données compressées, plus compactes et plus faciles à entreposer ou à transmettre. Ces données compressées sont ensuite prises en charge par un décodeur, qui effectue l'opération inverse en recréant les données décompressées, identiques aux données initiales. Ce va-et-vient entre encodage et décodage constitue le cour même du mécanisme de compression proposé par le cadre d'application.
Le cadre d'application Compression met à la disposition des développeurs deux grandes méthodes de compression, chacune adaptée à des usages bien spécifiques. La première approche repose sur la compression par tampon (buffer compression). Cette méthode s'effectue en une seule étape et se révèle particulièrement efficace pour les fichiers non compressés dont la taille est inférieure à environ 8 Mo, ou pour des fichiers déjà compressés dont la taille ne dépasse pas 1 Mo. Grâce à sa simplicité et à sa rapidité d'exécution, la compression par tampon est idéale pour des opérations ponctuelles et directes sur des volumes de données relativement modestes.
La seconde approche proposée par le cadre d'application est la compression par flux (stream compression). Contrairement à la compression par tampon, cette méthode fonctionne en plusieurs étapes successives et est conçue pour traiter des volumes de données beaucoup plus importants. Elle est particulièrement adaptée aux fichiers de grande taille ou aux données transmises de manière continue, comme un flux audio en temps réel ou le téléchargement progressif de fichiers depuis un réseau. Cette approche permet de compresser ou de décompresser les données au fur et à mesure de leur arrivée, sans avoir à tout charger en mémoire en une seule fois.
Dans le cas de la compression par tampon, l'utilisation est volontairement simple et directe. Le développeur appelle une seule fonction pour compresser ou décompresser les données d'entrée, ce qui facilite grandement l'intégration dans une application. Cette méthode est parfaitement adaptée aux scénarios où les données sont déjà disponibles en mémoire et où la simplicité du code est une priorité. Des exemples pratiques, comme l'encodage et le décodage d'une chaîne de caractères, illustrent clairement ce mode de fonctionnement et permettent une prise en main rapide.
À l'inverse, la compression par flux nécessite une approche plus itérative. Le développeur doit appeler à plusieurs reprises les fonctions de compression ou de décompression afin de transférer progressivement les données depuis un tampon source vers un tampon de destination. Entre chaque appel, le compresseur ou le décompresseur se charge de déplacer les données déjà traitées, de libérer de l'espace et de charger de nouveaux blocs de données. Cette gestion fine du flux rend la méthode plus complexe, mais aussi beaucoup plus flexible et performante pour les traitements lourds.
En résumé, le cadre d'application Compression d'Apple offre un ensemble d'outils puissants et polyvalents pour gérer efficacement la compression et la décompression des données. Qu'il s'agisse de petites quantités de données manipulées rapidement ou de flux volumineux nécessitant un traitement progressif, ces deux approches complémentaires permettent aux développeurs de choisir la solution la plus adaptée à leurs besoins, tout en bénéficiant de performances élevées et d'une intégration native au sein de l'écosystème Apple.
Objets simplifiant la compression en plusieurs étapes
Simplifiez l'encodage et le décodage des flux de données grâce aux classes de compression pour Swift.
| Swift | Description |
|---|---|
| class InputFilter | Cette classe représente un encodeur-décodeur orienté entrée qui lit les données depuis un flux (InputStream). Elle permet de compresser ou décompresser des données au fur et à mesure de leur lecture, ce qui est particulièrement adapté aux fichiers volumineux ou aux flux continus. |
| class OutputFilter | Cette classe représente un encodeur-décodeur orienté sortie écrivant les données vers un flux (OutputStream). Elle applique un algorithme de compression ou de décompression au moment de l'écriture, facilitant le traitement progressif des données sans chargement complet en mémoire. |
| enum Algorithm | Cette énumération définit les algorithmes utilisés pour la compression ou la décompression, tels que LZFSE, LZ4, ZLIB ou LZMA. Elle permet de sélectionner l'algorithme le plus approprié selon les besoins de performance, de taux de compression ou de compatibilité. |
| enum FilterError | Cette énumération regroupe les erreurs pouvant survenir lors des opérations de compression ou de décompression, par exemple des données invalides, une corruption de flux ou une incompatibilité d'algorithme. Elle facilite la gestion robuste des erreurs dans les filtres. |
| enum FilterOperation | Cette énumération précise le type d'opération effectuée par les filtres, à savoir la compression ou la décompression. Elle détermine le comportement des InputFilter et OutputFilter lors du traitement des données. |
Compression en plusieurs étapes
Les fonctions de compression de flux compressent ou décompressent des blocs de données séquentiels.
| Swift | Description |
|---|---|
| struct compression_stream | Cette structure représente un flux de compression ou de décompression. Elle contient l'état interne du traitement, les pointeurs vers les tampons d'entrée et de sortie, ainsi que les informations nécessaires pour gérer une opération incrémentale sur des données. |
| func compression_stream_init(UnsafeMutablePointer<compression_stream>, compression_stream_operation, compression_algorithm) -> compression_status | Cette fonction initialise un flux de compression pour une opération donnée (compression ou décompression) et un algorithme spécifique. Elle prépare la structure compression_stream et alloue les ressources internes nécessaires au traitement. |
| func compression_stream_process(UnsafeMutablePointer<compression_stream>, Int32) -> compression_status | Cette fonction exécute la compression ou la décompression effective à partir d'un flux initialisé. Elle traite les données présentes dans les tampons et peut être appelée plusieurs fois pour gérer des flux continus ou des blocs successifs. |
| func compression_stream_destroy(UnsafeMutablePointer<compression_stream>) -> compression_status | Cette fonction libère les ressources mémoire allouées lors de l'initialisation du flux. Elle doit être appelée une fois le traitement terminé afin d'éviter toute fuite mémoire. |
| struct compression_status | Cette structure définit un ensemble de codes d'état indiquant le résultat d'une opération de compression ou de décompression, comme le succès, la fin de flux ou une erreur nécessitant un traitement spécifique. |
| struct compression_stream_flags | Cette structure regroupe les indicateurs (flags) de configuration du flux, permettant d'ajuster le comportement de la compression, par exemple pour signaler la fin des données ou modifier la manière dont le flux est traité. |
| struct compression_stream_operation | Cette structure représente les types d'opérations possibles sur un flux, principalement la compression ou la décompression, et permet de définir le rôle du flux dès son initialisation. |
| struct compression_algorithm | Cette structure identifie les algorithmes de compression disponibles, tels que LZFSE, LZ4, ZLIB ou LZMA, et permet de sélectionner l'algorithme à utiliser lors de l'initialisation du flux. |
Compression en une seule étape
Les fonctions de compression de tampon compressent ou décompressent un bloc de données stocké de manière contiguë en mémoire.
| Swift | Description |
|---|---|
| func compression_encode_scratch_buffer_size(compression_algorithm) -> Int | Cette fonction retourne la taille du tampon temporaire (scratch buffer) nécessaire à la compression pour l'algorithme spécifié. Certains algorithmes exigent un espace de travail supplémentaire pour fonctionner efficacement. |
| func compression_encode_buffer(UnsafeMutablePointer<UInt8>, Int, UnsafePointer<UInt8>, Int, UnsafeMutableRawPointer?, compression_algorithm) -> Int | Cette fonction compresse le contenu d'un tampon source vers un tampon destination. Elle prend en paramètre les pointeurs mémoire, leurs tailles respectives, un tampon temporaire optionnel et l'algorithme de compression choisi. |
| func compression_decode_scratch_buffer_size(compression_algorithm) -> Int | Cette fonction renvoie la taille du tampon temporaire requis pour la décompression selon l'algorithme sélectionné. Elle permet d'allouer à l'avance la mémoire nécessaire au décodage. |
| func compression_decode_buffer(UnsafeMutablePointer<UInt8>, Int, UnsafePointer<UInt8>, Int, UnsafeMutableRawPointer?, compression_algorithm) -> Int | Cette fonction décompresse les données d'un tampon source vers un tampon destination. Elle reconstruit les données originales à partir du contenu compressé, en utilisant l'algorithme spécifié. |
| struct compression_algorithm | Cette structure regroupe les valeurs représentant les algorithmes de compression disponibles, comme LZFSE, LZ4, ZLIB ou LZMA, utilisés aussi bien pour la compression que pour la décompression par tampons. |
Variables
| Swift | Description |
|---|---|
| var COMPRESSION_MAMMOTH: compression_algorithm | Cette variable représente l'algorithme de compression Mammoth fourni par le cadre d'application Accelerate. Il s'agit d'un algorithme orienté haute performance, conçu pour offrir une compression rapide avec un bon compromis entre taux de compression et vitesse d'exécution. Elle est utilisée comme paramètre dans les fonctions de compression et de décompression par tampon ou par flux (compression_encode_buffer, compression_decode_buffer, compression_stream_*). |