Calculateur de taille audio
Une minute en qualité CD à 44100 Hz, 16 bits et stéréo occupe 10,584 Mo, soit plus de dix millions d'octets, sans compression. Saisissez durée, échantillonnage, résolution et canaux pour dimensionner le disque avant d'enregistrer. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Durée
- 60
- Fréquence d'échantillonnage
- 44 100
- Profondeur de bits
- 16
- Canaux
- 2
- Octets par échantillon
- 2
- Débit binaire (bps)
- 1 411 200
- Débit binaire (kbit/s)
- 1 411,2
- Taille (octets)
- 10 584 000
La taille d'un fichier audio non compressé est le produit de la durée d'enregistrement, de la fréquence d'échantillonnage, du nombre de bits par échantillon et du nombre de canaux conservés. Ce calculateur de taille de fichier audio prend ces quatre valeurs et renvoie la charge PCM en mégaoctets afin que vous puissiez dimensionner disques, quotas d'envoi et modèles de session avant d'appuyer sur enregistrement. Saisissez la durée en secondes, la fréquence d'échantillonnage en hertz, la profondeur de bits par échantillon et le nombre de canaux. Les codecs compressés seront plus petits ; cet outil répond à la question WAV et AIFF que l'archivage, le mixage et la diffusion posent encore en premier.
Comment se calcule la taille d'un PCM non compressé
La modulation par impulsions codées linéaire stocke un flux d'échantillons. Chaque échantillon est un entier ou une valeur en virgule flottante de largeur fixe ; la profondeur de bits est cette largeur en bits. La fréquence d'échantillonnage est le nombre de ces valeurs par seconde sur un canal.
Le nombre de canaux multiplie le flux : le mono est un train d'échantillons, la stéréo en compte deux et un stem 5.1 en compte six. La durée est le nombre de secondes que dure le train. Diviser par huit convertit les bits en octets.
Une minute de disque compact à 44100 hertz, 16 bits, stéréo vaut 44100 fois deux octets fois deux canaux fois 60 secondes, soit 10,584,000 octets, c'est-à-dire 10.584 mégaoctets. Une minute à 48 kilohertz, 24 bits, stéréo est plus grande car le débit et les octets par échantillon ont augmenté. Cette formule ne modélise pas la compression MP3, AAC, Opus ou FLAC, et n'ajoute pas les en-têtes de conteneur RIFF ou AIFF de quelques dizaines d'octets.
Ces en-têtes sont négligeables face à des minutes de PCM ; les codecs compressés dépendent du contenu et des réglages de l'encodeur, qu'aucune équation close ne peut garantir. Si vous avez besoin d'un plafond de stockage pour le mixage ou un WAV d'archive, le produit PCM est le chiffre qui compte, et ce calculateur le renvoie avec le débit qui l'a produit.
Où un calculateur de taille audio rend service
Les studios et les producteurs de podcast dimensionnent les disques de session avant d'enregistrer afin qu'une prise stéréo de deux heures à 48 kilohertz et 24 bits ne déborde pas l'espace restant. Les enseignants d'audio numérique montrent que doubler la fréquence d'échantillonnage ou la profondeur de bits double la taille lorsque durée et canaux restent fixes, ce que ce calculateur rend immédiat.
Les monteurs vidéo qui extraient du PCM des fichiers caméra ont besoin d'une borne de stockage pour le WAV qu'ils exporteront, pas d'une conjecture de débit tirée d'un codec compressé. Les équipes de son live et de diffusion estiment l'empreinte d'archive nocturne des stems multicanaux avant de figer un format d'enregistreur. Un échec de validation ne consomme pas le solde.
Gardez les requêtes petites, figez les mégaoctets arrondis dans les tests, et vous obtenez des chiffres de stockage reproductibles pour modèles DAW, démos LMS et workers en périphérie sans dresser votre propre infrastructure d'analyse média.
Cas d’usage
Dimensionner la session d'enregistrement avant de commencer
Convertissez durée, fréquence d'échantillonnage, profondeur de bits et nombre de canaux prévus en mégaoctets afin que le disque de session, la carte SD ou le compartiment object store ait de la place pour le WAV que vous comptez capturer.
Questions fréquentes
Le résultat inclut-il un en-tête WAV ou de la compression ?
Non. Le chiffre est la charge PCM linéaire non compressée. Les en-têtes WAV ou AIFF de quelques dizaines d'octets sont omis. Les tailles MP3, AAC, Opus et FLAC dépendent de l'encodeur et sortent du périmètre.
Que se passe-t-il si une valeur est nulle, négative ou absente ?
Chaque entrée doit être un nombre fini positif. Une entrée invalide n'est pas facturée.
Combien pèse une minute d'audio en qualité CD ?
10,584 Mo. À 44100 Hz, 16 bits et deux canaux, chaque seconde représente 1411,2 kbit/s, et 60 secondes donnent plus de dix millions d'octets d'audio non compressé.
Pourquoi mon ordinateur affiche-t-il moins de mégaoctets ?
Parce que le résultat principal utilise des mégaoctets d'un million d'octets, alors que certains systèmes divisent par 2 puissance 20. Le calculateur donne les deux chiffres pour les comparer avec ce qu'indique votre disque.
Que devient la taille si je double l'échantillonnage ou la résolution ?
Elle double, tant que la durée et le nombre de canaux restent identiques. La taille suit chacune des quatre valeurs en proportion directe : la stéréo pèse deux fois la mono et un mixage 5.1 compte six canaux.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/audio/audio-file-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}'const res = await fetch("https://api.kit.forhosting.com/audio/audio-file-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/audio-file-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/audio-file-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"duration":60,"sample_rate":44100,"bit_depth":16,"channels":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/audio-file-size", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"duration": 60,
"sample_rate": 44100,
"bit_depth": 16,
"channels": 2
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.audio_file_size",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_mb | 200 |
max_minutes | 180 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Chaque entrée doit être un nombre fini positif ; zéro, négatifs, NaN et Infinity échouent avec invalid_input et ne sont pas facturés. Le solveur indique size_mb en mégaoctets SI d'un million d'octets, plus size_bytes, size_mib et le débit PCM linéaire.
Comment se calcule la taille d'un PCM non compressé
La charge exacte en octets est donc duration fois sample_rate fois bit_depth divisé par huit fois channels. Diviser le nombre d'octets par un million donne size_mb, le mégaoctet SI retenu comme résultat principal de cette capacité. Diviser par deux à la vingtième donne size_mib, plus proche de ce que certains systèmes d'exploitation affichent encore comme MB.
Contrat d'entrée, unités et champs de réponse
Le nombre de canaux est de même un nombre fini positif plutôt qu'une disposition nommée, si bien que mono, stéréo et stems multicanaux partagent un champ. Associez la réponse à votre propre encodeur si vous avez besoin d'une estimation compressée ; ce point de terminaison n'indique que la taille PCM non compressée et n'inspecte pas un fichier déjà enregistré. Envoyez un corps JSON avec quatre nombres finis positifs obligatoires : duration en secondes, sample_rate en hertz, bit_depth en bits par échantillon et channels. Des alias sont acceptés pour que les synonymes courants restent valides : duration_seconds, seconds, length et time pour duration ; sample_rate_hz, sr, hz et sampling_rate pour sample_rate ; bits, bit_depth_bits, depth et bits_per_sample pour bit_depth ; channel_count, ch, n_channels et num_channels pour channels. Chaque champ peut arriver comme nombre JSON ou comme chaîne numérique. Champs manquants, chaînes vides, NaN, Infinity, zéro et valeurs négatives échouent avec invalid_input en nommant le champ et ne sont pas facturés. Il n'y a pas d'enum sur bit_depth car le contrat est toute largeur finie positive, y compris 8, 16, 24 et 32, et non une liste fermée de préréglages studio. En cas de succès le corps répète les quatre entrées, bytes_per_sample, bitrate_bps et bitrate_kbps du flux non compressé, size_bytes, size_kb, size_mb, size_mib, plus les chaînes formula et note. Exemple : duration 60, sample_rate 44100, bit_depth 16, channels 2 renvoie 10.584 dans size_mb.
Où un calculateur de taille audio rend service
Les scripts de sauvegarde et d'ingestion peuvent refuser une prise prévue qui dépasserait un quota d'object store en calculant d'abord size_mb. Comme l'implémentation est parse pure tier A, chaque appel réussi coûte le tarif de base publié $0.002 sans jetons de modèle ni réseau sortant.
Cas d'intégration
Enseigner comment le stockage PCM évolue
Montrez aux élèves que doubler la fréquence d'échantillonnage ou la profondeur de bits double la taille non compressée lorsque durée et canaux restent fixes, avec la même formule que l'API renvoie dans le champ formula.
Prévalider les quotas d'envoi et d'archive
Les scripts d'ingestion et les sauvegardes peuvent refuser un export PCM prévu qui dépasserait un quota en calculant d'abord size_mb, sans ouvrir d'encodeur ni lire de fichier.
Questions techniques
Comment calcule-t-on la taille d'un fichier audio à partir de la durée et du format ?
Envoyez des nombres finis positifs pour duration (secondes), sample_rate (Hz), bit_depth et channels. La charge est duration × sample_rate × (bit_depth / 8) × channels octets ; size_mb est ce total divisé par un million.
Quelle est la différence entre size_mb et size_mib ?
size_mb utilise les mégaoctets SI (1 MB = 1,000,000 octets), résultat principal. size_mib utilise les mébioctets (1 MiB = 1,048,576 octets), plus proches de certains affichages de taille de fichier des systèmes d'exploitation.
Combien coûte le calculateur de taille de fichier audio ?
L'outil du navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.