This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# `audioop` — Manipula datos de audio sin procesar

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

El módulo `audioop` contiene algunas operaciones útiles sobre fragmentos de sonido. Opera en fragmentos de sonido que consisten en muestras de enteros de 8, 16, 24, o 32 bits, guardados en objetos parecidos a bytes. Todos los elementos escalares son enteros, a menos que se especifique lo contrario.

Distinto en la versión 3.4: La compatibilidad para muestras de 24-bit fue añadida. Todas las funciones ahora aceptan cualquier bytes-like object. La entrada de cadenas de caracteres ahora resulta en un error inmediato.

Este módulo proporciona compatibilidad con las codificaciones a-LAW, u-LAW e Intel/DVI ADPCM.

Algunas de las operaciones más complicadas sólo toman muestras de 16-bit, si no, el tamaño de la entrada (en bytes) siempre es un parámetro de la operación.

El módulo define las siguientes variables y funciones:

exception `audioop.``error`

  Esta excepción es lanzada en todos los errores, tal como números desconocidos de bytes por entrada, etc.

`audioop.``add`(fragment1, fragment2, width)

  Retorna un fragmento que es la adición de dos entradas pasadas como parámetros. width es la longitud de la muestra en bytes, o `1`, `2`, `3`, o `4`. Ambos fragmentos deben tener la misma longitud. Las muestras son truncadas en caso de desbordamiento.

`audioop.``adpcm2lin`(adpcmfragment, width, state)

  Decodifica un fragmento codificado con Intel/DVI ADPCM en un fragmento lineal. Véase la descripción de `lin2adpcm()` por detalles sobre la codificación ADPCM. Retorna una tupla `(sample, newstate)` donde la entrada tiene la longitud especificada en width.

`audioop.``alaw2lin`(fragment, width)

  Convierte los fragmentos de sonido codificados con a-LAW en fragmentos de sonido linealmente codificados. La codificación a-LAW siempre usa muestras de 8 bits, por lo que width hace referencia sólo a la longitud de la entrada del fragmento de salida aquí.

`audioop.``avg`(fragment, width)

  Retorna el promedio de todas las muestras en el fragmento.

`audioop.``avgpp`(fragment, width)

  Retorna el promedio del valor de pico a pico de todas las muestras en el fragmento. No se hace ningún filtrado, por lo que la utilidad de esta rutina es cuestionable.

`audioop.``bias`(fragment, width, bias)

  Retorna un fragmento que es el fragmento original con un bias añadido a cada muestra. Las muestras se envuelven en caso de desbordamiento.

`audioop.``byteswap`(fragment, width)

  Intercambia los bytes («Byteswap») de todas las muestras en un fragmento y retorna el fragmento modificado. Convierte muestras big-endian en little-endian y viceversa.

  Nuevo en la versión 3.4.

`audioop.``cross`(fragment, width)

  Retorna el número de cruces por 0 en el fragmento pasado como un argumento.

`audioop.``findfactor`(fragment, reference)

  Retorna un factor F tal que `rms(add(fragment, mul(reference, -F)))` sea mínimo, i.e., retorna el factor con el cual debes multiplicar la reference para hacerlo coincidir tanto como sea posible a fragment. Los fragmentos deben contener muestras de 2-byte.

  El tiempo tomado por esta rutina es proporcional a `len(fragment`.

`audioop.``findfit`(fragment, reference)

  Intenta hacer coincidir reference tanto bien como sea posible a un fragment (que debe ser el fragmento más largo). Esto es (conceptualmente) hecho al tomar segmentos de fragment, usando `findfactor()` para computar la mejor coincidencia, y minimizando el resultado. Los fragmentos deben contener muestras de 2-byte. Retorna una tupla `(offset, factor)` donde offset (entero) es el offset en fragment donde la coincidencia más óptima empezó y factor es el (número flotante) factor según `findfactor()`.

`audioop.``findmax`(fragment, length)

  Inspecciona fragment por un segmento de longitud length muestras (¡no bytes!) con la energía máxima, i.e., retorna i por el cual `rms(fragment[i*2:(i+length)*2])` es máximo. Los fragmentos deben contener muestras de 2 bytes.

  La rutina tarda proporcionalmente a `len(fragment)`.

`audioop.``getsample`(fragment, width, index)

  Retorna el valor de la muestra index del fragmento.

`audioop.``lin2adpcm`(fragment, width, state)

  Convierte las muestras en codificaciones Intel/DVI ADPCM de 4 bits. La codificación ADPCM es un esquema de codificación adaptativo a través del cual cada número de 4 bits es la diferencia entre una muestra y la siguiente, dividido por un paso (inconsistente). El algoritmo de Intel/DVI ADPCM ha sido seleccionado para su uso por el IMA, por lo que bien puede convertirse en un estándar.

  state es una tupla que contiene el estado del codificador. El codificador retorna una tupla `(adpcmfrag, newstate)`, y el newstate debe pasarse a la siguiente llamada de `lin2adpcm()`. En la llamada inicial, se puede pasar `None` como estado. adpcmfrag es el fragmento codificado ADPCM empaquetado 2 valores de 4 bits por byte.

`audioop.``lin2alaw`(fragment, width)

  Convierte las muestras en el fragmento de audio en una codificación a-LAW y los retorna como un objeto de bytes. a-LAW es un formato de codificación de audio a través del cual obtienes un rango dinámico de cerca de 13 bits usando sólo muestras de 8 bits. Es usado por el hardware de audio Sun, entre otros.

`audioop.``lin2lin`(fragment, width, newwidth)

  Convierte muestras entre formatos de 1, 2, 3, y 4 bytes.

  Nota

  En algunos formatos de audio, como archivos .WAV, las entradas de 16, 24, y 32 bits tienen signo, pero las entradas de 8 bits no tienen signo. Por lo que cuando se convierta en entradas de 8 bits para estas entradas, también necesitas añadir 128 al resultado:

      new_frames = audioop.lin2lin(frames, old_width, 1)
      new_frames = audioop.bias(new_frames, 1, 128)

  Lo mismo, al revés, tiene que ser aplicado cuando se convierta muestras de 8 bits en muestras de 16, 24, o 32 bits.

`audioop.``lin2ulaw`(fragment, width)

  Convierte muestras en el fragmento de audio en codificaciones u-LAW y lo retorna como un objeto de bytes. u-LAW es un formato de codificación de audio a través del cual obtienes un rango dinámico de cerca de 14 bits usando sólo muestras de 8 bits. Es usado por el hardware de audio Sun, entre otros.

`audioop.``max`(fragment, width)

  Retorna el máximo de los valores absolutos de las entradas en un fragmento.

`audioop.``maxpp`(fragment, width)

  Retorna el valor de pico a pico máximo en el fragmento de sonido.

`audioop.``minmax`(fragment, width)

  Retorna una tupla que consiste de los valores mínimos y máximos de todas las entradas en el fragmento de sonido.

`audioop.``mul`(fragment, width, factor)

  Retorna un fragmento que tiene todas las entradas en el fragmento original multiplicado por el valor de punto flotante factor. Las muestras son truncadas en caso de desbordamiento.

`audioop.``ratecv`(fragment, width, nchannels, inrate, outrate, state[, weightA[, weightB]])

  Convierte el ratio de fotogramas del fragmento de entrada.

  state es una tupla que contiene el estado del convertidor. El convertidor retorna una tupla `(newfragment, newstate)`, y newstate debe ser pasado a la siguiente llamada de `ratecv()`. La llamada inicial debe pasar `None` como el estado.

  Los argumentos weightA y weightB son parámetros para un filtro digital simple y sus valores por defecto son `1` y `0` respectivamente.

`audioop.``reverse`(fragment, width)

  Invierte las entradas en un fragmento y retorna el fragmento modificado.

`audioop.``rms`(fragment, width)

  Retorna la media cuadrática del fragmento, i.e. `sqrt(sum(S_i^2)/n)`.

  Este es una medida del poder en una señal de audio.

`audioop.``tomono`(fragment, width, lfactor, rfactor)

  Convierte un fragmento estéreo en una fragmento mono. El canal izquierdo es multiplicado por Ifactor y el derecho por rfactor antes de añadir los dos canales para dar una señal mono.

`audioop.``tostereo`(fragment, width, lfactor, rfactor)

  Genera un fragmento estéreo de un fragmento mono. Cada par de muestras en el fragmento estéreo son computados de la entrada mono, a través del cual las muestras del canal izquierdo son multiplicadas por Ifactor y del canal derecho por rfactor.

`audioop.``ulaw2lin`(fragment, width)

  Convierte los fragmentos de sonido en codificaciones u-LAW en fragmentos de sonidos linealmente codificados. Las codificaciones u-LAW siempre usan muestras de 8 bits, por lo que width hace referencia a la longitud de la muestra del fragmento de salida aquí.

Note que operaciones tales como `mul()` o `max()` no hacen distinción entre fragmentos mono y estéreo, i.e. todas las muestras son tratadas iguales. Si este es un problema, el fragmento estéreo debe ser dividido en dos fragmentos mono primero y recombinado después. Aquí hay un ejemplo de como hacerlo:

    def mul_stereo(sample, width, lfactor, rfactor):
        lsample = audioop.tomono(sample, width, 1, 0)
        rsample = audioop.tomono(sample, width, 0, 1)
        lsample = audioop.mul(lsample, width, lfactor)
        rsample = audioop.mul(rsample, width, rfactor)
        lsample = audioop.tostereo(lsample, width, 1, 0)
        rsample = audioop.tostereo(rsample, width, 0, 1)
        return audioop.add(lsample, rsample, width)

Si usas el codificador ADPCM para construir paquetes de redes y quieres que tu protocolo no tenga estado (stateless) (i.e. para ser capaz de tolerar pérdida de paquetes) no sólo debes transmitir los datos pero también el estado. Note que debes enviar el estado inicial (initial) (el que pasas a `lin2adpcm()`) junto con el decodificador, no el estado final (como es retornado por el codificador). Si quieres usar un `struct.Struct` para almacenar el estado en binario puedes codificar el primer elemento (el valor predicho) en 16 bits y el segundo (el índice delta) en 8.

Los codificadores ADPCM nunca se han probado en contra de otros codificadores ADPCM, sólo contra ellos mismos. Bien puede ser que malinterpreté los estándares en cuyo caso ellos no serán interoperables con los estándares respectivos.

La rutinas `find*()` pueden parecer un poco raras a primera vista. Sirven principalmente para hacer echo de la cancelación. Una manera razonablemente rápida para hacerlo es coger la pieza más energética de la muestra de la salida, localizarla en la muestra de la entrada y substraer la muestra de la salida completa de la muestra de entrada:

    def echocancel(outputdata, inputdata):
        pos = audioop.findmax(outputdata, 800)    # one tenth second
        out_test = outputdata[pos*2:]
        in_test = inputdata[pos*2:]
        ipos, factor = audioop.findfit(in_test, out_test)
        # Optional (for better cancellation):
        # factor = audioop.findfactor(in_test[ipos*2:ipos*2+len(out_test)],
        #              out_test)
        prefill = '\0'*(pos+ipos)*2
        postfill = '\0'*(len(inputdata)-len(prefill)-len(outputdata))
        outputdata = prefill + audioop.mul(outputdata, 2, -factor) + postfill
        return audioop.add(inputdata, outputdata, 2)