audio - utilizados - ¿Cómo puedo detectar si un archivo WAV tiene un encabezado de 44 o 46 bytes?

formatos de audio y video

Question

Descubrí que es peligroso suponer que todos los archivos de audio PCM wav tienen 44 bytes de datos de encabezado antes de que comiencen las muestras. Aunque esto es común, muchas aplicaciones (ffmpeg, por ejemplo) generarán wavs con un encabezado de 46 bytes e ignorarán este hecho, mientras que el procesamiento dará como resultado un archivo corrupto e ilegible. Pero, ¿cómo se puede detectar cuánto tiempo realmente es el encabezado?

Obviamente hay una manera de hacer esto, pero busqué y encontré poca discusión sobre esto. MUCHOS proyectos de audio suponen 44 (o por el contrario, 46) dependiendo del contexto del autor.

Answer 1

El truco es mirar el "Subchunk1Size", que es un entero de 4 bytes que comienza en el byte 16 del encabezado. En un wav normal de 44 bytes, este entero será 16 [10, 0, 0, 0]. Si se trata de un encabezado de 46 bytes, este número entero será 18 [12, 0, 0, 0] o tal vez incluso mayor si hay metadatos adicionales extensibles (¿raro?).

Los datos adicionales en sí (si están presentes) comienzan en el byte 36.

Así que un simple programa de C # para detectar la longitud del encabezado se vería así:

static void Main(string[] args)
{
    byte[] bytes = new byte[4];
    FileStream fileStream = new FileStream(args[0], FileMode.Open, FileAccess.Read);
    fileStream.Seek(16, 0);
    fileStream.Read(bytes, 0, 4);
    fileStream.Close();
    int Subchunk1Size = BitConverter.ToInt32(bytes, 0);

    if (Subchunk1Size < 16)
        Console.WriteLine("This is not a valid wav file");
    else
        switch (Subchunk1Size)
        {
            case 16:
                Console.WriteLine("44-byte header");
                break;
            case 18:
                Console.WriteLine("46-byte header");
                break;
            default:
                Console.WriteLine("Header contains extra data and is larger than 46 bytes");
                break;
        }
}

Answer 2

Además de la excelente respuesta de Radiodef, me gustaría agregar 3 cosas que no son obvias.

1. La única regla para los archivos WAV es que el fragmento FMT viene antes del fragmento DATA. Aparte de eso, encontrarás fragmentos que no conoces al principio, antes del fragmento DATA y después de él. Debe leer el encabezado de cada fragmento para saltar hacia adelante y encontrar el siguiente fragmento.

2. El fragmento FMT se encuentra comúnmente en variaciones de 16 bytes y 18 bytes, pero la especificación realmente permite más de 18 bytes también. Si el campo del tamaño del encabezado del fragmento FMT dice que es mayor que 16, los bytes 17 y 18 también especifican cuántos bytes adicionales hay, por lo que si ambos son cero, terminará con un fragmento de FMT de 18 bytes idéntico al de 16 bytes. Es seguro leer solo los primeros 16 bytes del fragmento FMT y analizarlos, ignorando más. ¿Por qué importa esto? - no mucho más, pero Windows Media Player de Windows XP podía reproducir archivos WAV de 16 bits, pero solo archivos WAV de 24 bits si el fragmento FMT era la versión extendida (18+ bytes). Solía ​​haber muchas quejas de que "Windows no reproduce mis archivos WAV de 24 bits", pero si tuviera un fragmento de FMT de 18 bytes, sería ... Microsoft lo arregló en algún momento durante los primeros días de Windows 7, por lo que Los archivos de 24 bit con 16 bytes FMT funcionan bien ahora.

3. (Recién agregado) Los tamaños de trozos con tamaños impares ocurren con bastante frecuencia. Se ve principalmente cuando se hace un archivo mono de 24 bits. No está claro a partir de la especificación, pero el tamaño del fragmento especifica la longitud real de los datos (el valor impar) y se agrega un byte del pad (cero) después del fragmento y antes del inicio del siguiente fragmento. Por lo tanto, los fragmentos siempre comienzan en los límites pares, pero el tamaño del fragmento se almacena como el valor impar real.

Answer 3

Debería verificar todos los datos del encabezado para ver cuáles son los tamaños reales. Los archivos Broadcast Wave Format contendrán un subchunk de extensión aún mayor. Los archivos WAV y AIFF de Pro Tools tienen aún más fragmentos de extensiones que no están documentados, así como datos después del audio. Si quiere estar seguro de dónde comienzan y terminan los datos de muestra, debe buscar realmente el fragmento de datos (''datos'' para archivos WAV y ''SSND'' para AIFF).

Como revisión, todos los subchunks WAV se ajustan al siguiente formato:

Subchunk Descriptor (4 bytes) Subchunk Size (4 byte integer, little endian) Subchunk Data (size is Subchunk Size)

Esto es muy fácil de procesar. Todo lo que tiene que hacer es leer el descriptor, si no es el que está buscando, lea el tamaño de los datos y salte al siguiente. Una simple rutina de Java para hacer eso se vería así:

//
// Quick note for people who don''t know Java well:
// ''in.read(...)'' returns -1 when the stream reaches
// the end of the file, so ''if (in.read(...) < 0)''
// is checking for the end of file.
//
public static void printWaveDescriptors(File file)
        throws IOException {
    try (FileInputStream in = new FileInputStream(file)) {
        byte[] bytes = new byte[4];

        // read first 4 bytes
        // should be RIFF descriptor
        if (in.read(bytes) < 0) {
            return;
        }

        printDescriptor(bytes);

        // first subchunk will always be at byte 12
        // there is no other dependable constant
        in.skip(8);

        for (;;) {
            // read each chunk descriptor
            if (in.read(bytes) < 0) {
                break;
            }

            printDescriptor(bytes);

            // read chunk length
            if (in.read(bytes) < 0) {
                break;
            }

            // skip the length of this chunk
            // next bytes should be another descriptor or EOF
            in.skip(
                  (bytes[0] & 0xFF)
                | (bytes[1] & 0xFF) << 8
                | (bytes[2] & 0xFF) << 16
                | (bytes[3] & 0xFF) << 24
            );
        }

        System.out.println("end of file");
    }
}

private static void printDescriptor(byte[] bytes)
        throws IOException {
    String desc = new String(bytes, "US-ASCII");
    System.out.println("found ''" + desc + "'' descriptor");
}

Por ejemplo, aquí hay un archivo WAV aleatorio que tuve:

found ''RIFF'' descriptor found ''bext'' descriptor found ''fmt '' descriptor found ''minf'' descriptor found ''elm1'' descriptor found ''data'' descriptor found ''regn'' descriptor found ''ovwf'' descriptor found ''umid'' descriptor end of file

Notablemente, aquí tanto ''fmt'' como ''data'' aparecen legítimamente entre otros fragmentos porque la especificación RIFF de Microsoft dice que las subcuncias pueden aparecer en cualquier orden. Incluso algunos sistemas de audio importantes que conozco obtienen esto mal y no dan cuenta de eso.

Entonces, si quiere encontrar un cierto fragmento, recorra el archivo revisando cada descriptor hasta que encuentre el que está buscando.