"chunk" --- Lee los datos de los trozos de IFF
**********************************************

**Código fuente:** Lib/chunk.py

Obsoleto desde la versión 3.11: The "chunk" module is deprecated (see
**PEP 594** for details).

======================================================================

Este módulo proporciona una interfaz para leer archivos que usan
trozos de EA IFF 85. [1]  Este formato se utiliza al menos en el
formato *Audio Interchange File Format (AIFF/AIFF-C)* y en el formato
*Real Media File Format (RMFF)*.  El formato de archivo de audio WAVE
está estrechamente relacionado y también puede ser leído usando este
módulo.

Un trozo tiene la siguiente estructura:

+-----------+----------+---------------------------------+
| Desplaza  | Longitud | Contenido                       |
| miento    |          |                                 |
|===========|==========|=================================|
| 0         | 4        | ID del trozo                    |
+-----------+----------+---------------------------------+
| 4         | 4        | El tamaño del trozo en el orden |
|           |          | de bytes big-endian, sin        |
|           |          | incluir el encabezado           |
+-----------+----------+---------------------------------+
| 8         | *n*      | Bytes de datos, donde *n* es el |
|           |          | tamaño dado en el campo         |
|           |          | anterior                        |
+-----------+----------+---------------------------------+
| 8 + *n*   | 0 o 1    | Se necesita un byte de relleno  |
|           |          | si *n* es impar y se utiliza la |
|           |          | alineación de trozos            |
+-----------+----------+---------------------------------+

La ID es una cadena de 4 bytes que identifica el tipo de trozo.

El campo de tamaño (un valor de 32 bits, codificado utilizando el
orden de bytes big-endian) da el tamaño de los datos de los trozos,
sin incluir el encabezamiento de 8 bytes.

Normalmente un archivo de tipo IFF consiste en uno o más trozos.  El
uso propuesto de la clase "Chunk" definido aquí es declarar una
instancia al principio de cada trozo y leer de la instancia hasta que
llegue al final, después de lo cual se puede declarar una nueva
instancia. Al final del archivo, la creación de una nueva instancia
fallará con una excepción "EOFError".

class chunk.Chunk(file, align=True, bigendian=True, inclheader=False)

   Clase que representa un trozo.  Se espera que el argumento *file*
   sea un objeto parecido a un archivo.  Una instancia de esta clase
   está específicamente permitida.  El único método que se necesita es
   "read()".  Si los métodos "seek()" y "tell()" están presentes y no
   plantean una excepción, también se utilizan. Si estos métodos están
   presentes y hacen una excepción, se espera que no hayan alterado el
   objeto.  Si el argumento opcional *align* es cierto, se supone que
   los trozos están alineados en los límites de 2 bytes.  Si *align*
   es falso, se asume que no hay alineación.  El valor por defecto es
   true.  Si el argumento opcional *bigendian* es falso, se asume que
   el tamaño de los trozos está en orden little-endian. Esto es
   necesario para los archivos de audio WAVE. El valor por defecto es
   true.  Si el argumento opcional *inclheader* es true, el tamaño
   dado en la cabecera del trozo incluye el tamaño de la cabecera.  El
   valor por defecto es false.

   Un objeto "Chunk" soporta los siguientes métodos:

   getname()

      Retorna el nombre (ID) del trozo.  Estos son los primeros 4
      bytes del trozo.

   getsize()

      Retorna el tamaño del trozo.

   close()

      Cierra y salta al final del trozo.  Esto no cierra el archivo
      subyacente.

   El resto de los métodos se levantarán "OsError" si se llama después
   de que el método "close()" haya sido llamado.  Antes de *Python*
   3.3, solían levantar "IOError", ahora un alias de "OSError".

   isatty()

      Retorna "False".

   seek(pos, whence=0)

      Establece la posición actual del trozo.  El argumento *whence*
      es opcional y por defecto es "0" (posicionamiento absoluto del
      archivo); otros valores son "1" (búsqueda relativa a la posición
      actual) y "2" (búsqueda relativa al final del archivo).  No hay
      ningún valor de retorno. Si el archivo subyacente no permite la
      búsqueda, sólo se permiten las búsquedas hacia adelante.

   tell()

      Retorna la posición actual en el trozo.

   read(size=-1)

      Leer como máximo *size* bytes del trozo (menos si la lectura
      llega al final del trozo antes de obtener *size* bytes).  Si el
      argumento *size* es negativo u omitido, lee todos los datos
      hasta el final del trozo.  Un objeto de bytes vacío se retorna
      cuando el final del trozo se encuentra inmediatamente.

   skip()

      Salta al final del trozo.  Todas las llamadas posteriores a
      "read()" para el trozo retorna "b''".  Si no estás interesado en
      el contenido del trozo, este método debe ser llamado para que el
      archivo apunte al comienzo del siguiente trozo.

-[ Notas a pie de página ]-

[1] "EA IFF 85" *Standard for Interchange Format Files*, *Jerry
    Morrison*, *Electronic Arts*, enero 1985.
