# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to get
# the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-08-07 10:34+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"

#: ../Doc/library/audioop.rst:2
msgid ":mod:`audioop` --- Manipulate raw audio data"
msgstr ":mod:`audioop` --- Manipula datos de audio sin procesar"

#: ../Doc/library/audioop.rst:11
msgid ""
"The :mod:`audioop` module is deprecated (see :pep:`PEP 594 <594#audioop>` "
"for details)."
msgstr ""

#: ../Doc/library/audioop.rst:14
msgid ""
"The :mod:`audioop` module contains some useful operations on sound "
"fragments. It operates on sound fragments consisting of signed integer "
"samples 8, 16, 24 or 32 bits wide, stored in :term:`bytes-like objects "
"<bytes-like object>`.  All scalar items are integers, unless specified "
"otherwise."
msgstr ""
"El módulo :mod:`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 :term:`objetos "
"parecidos a bytes <bytes-like object>`. Todos los elementos escalares son "
"enteros, a menos que se especifique lo contrario."

#: ../Doc/library/audioop.rst:19
msgid ""
"Support for 24-bit samples was added. All functions now accept any :term:"
"`bytes-like object`. String input now results in an immediate error."
msgstr ""
"La compatibilidad para muestras de 24-bit fue añadida. Todas las funciones "
"ahora aceptan cualquier :term:`bytes-like object`. La entrada de cadenas de "
"caracteres ahora resulta en un error inmediato."

#: ../Doc/library/audioop.rst:30
msgid ""
"This module provides support for a-LAW, u-LAW and Intel/DVI ADPCM encodings."
msgstr ""
"Este módulo proporciona compatibilidad con las codificaciones a-LAW, u-LAW e "
"Intel/DVI ADPCM."

#: ../Doc/library/audioop.rst:34
msgid ""
"A few of the more complicated operations only take 16-bit samples, otherwise "
"the sample size (in bytes) is always a parameter of the operation."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:37
msgid "The module defines the following variables and functions:"
msgstr "El módulo define las siguientes variables y funciones:"

#: ../Doc/library/audioop.rst:42
msgid ""
"This exception is raised on all errors, such as unknown number of bytes per "
"sample, etc."
msgstr ""
"Esta excepción es lanzada en todos los errores, tal como números "
"desconocidos de bytes por entrada, etc."

#: ../Doc/library/audioop.rst:48
msgid ""
"Return a fragment which is the addition of the two samples passed as "
"parameters. *width* is the sample width in bytes, either ``1``, ``2``, ``3`` "
"or ``4``.  Both fragments should have the same length.  Samples are "
"truncated in case of overflow."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:55
msgid ""
"Decode an Intel/DVI ADPCM coded fragment to a linear fragment.  See the "
"description of :func:`lin2adpcm` for details on ADPCM coding. Return a tuple "
"``(sample, newstate)`` where the sample has the width specified in *width*."
msgstr ""
"Decodifica un fragmento codificado con Intel/DVI ADPCM en un fragmento "
"lineal.  Véase la descripción de :func:`lin2adpcm` por detalles sobre la "
"codificación ADPCM. Retorna una tupla ``(sample, newstate)`` donde la "
"entrada tiene la longitud especificada en *width*."

#: ../Doc/library/audioop.rst:62
msgid ""
"Convert sound fragments in a-LAW encoding to linearly encoded sound "
"fragments. a-LAW encoding always uses 8 bits samples, so *width* refers only "
"to the sample width of the output fragment here."
msgstr ""
"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í."

#: ../Doc/library/audioop.rst:69
msgid "Return the average over all samples in the fragment."
msgstr "Retorna el promedio de todas las muestras en el fragmento."

#: ../Doc/library/audioop.rst:74
msgid ""
"Return the average peak-peak value over all samples in the fragment. No "
"filtering is done, so the usefulness of this routine is questionable."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:80
msgid ""
"Return a fragment that is the original fragment with a bias added to each "
"sample.  Samples wrap around in case of overflow."
msgstr ""
"Retorna un fragmento que es el fragmento original con un *bias* añadido a "
"cada muestra.  Las muestras se envuelven en caso de desbordamiento."

#: ../Doc/library/audioop.rst:86
msgid ""
"\"Byteswap\" all samples in a fragment and returns the modified fragment. "
"Converts big-endian samples to little-endian and vice versa."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:94
msgid ""
"Return the number of zero crossings in the fragment passed as an argument."
msgstr ""
"Retorna el número de cruces por 0 en el fragmento pasado como un argumento."

#: ../Doc/library/audioop.rst:99
msgid ""
"Return a factor *F* such that ``rms(add(fragment, mul(reference, -F)))`` is "
"minimal, i.e., return the factor with which you should multiply *reference* "
"to make it match as well as possible to *fragment*.  The fragments should "
"both contain 2-byte samples."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:104
msgid "The time taken by this routine is proportional to ``len(fragment)``."
msgstr "El tiempo tomado por esta rutina es proporcional a ``len(fragment``."

#: ../Doc/library/audioop.rst:109
msgid ""
"Try to match *reference* as well as possible to a portion of *fragment* "
"(which should be the longer fragment).  This is (conceptually) done by "
"taking slices out of *fragment*, using :func:`findfactor` to compute the "
"best match, and minimizing the result.  The fragments should both contain 2-"
"byte samples. Return a tuple ``(offset, factor)`` where *offset* is the "
"(integer) offset into *fragment* where the optimal match started and "
"*factor* is the (floating-point) factor as per :func:`findfactor`."
msgstr ""
"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 :func:`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 :func:"
"`findfactor`."

#: ../Doc/library/audioop.rst:120
msgid ""
"Search *fragment* for a slice of length *length* samples (not bytes!) with "
"maximum energy, i.e., return *i* for which ``rms(fragment[i*2:"
"(i+length)*2])`` is maximal.  The fragments should both contain 2-byte "
"samples."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:124
msgid "The routine takes time proportional to ``len(fragment)``."
msgstr "La rutina tarda proporcionalmente a ``len(fragment)``."

#: ../Doc/library/audioop.rst:129
msgid "Return the value of sample *index* from the fragment."
msgstr "Retorna el valor de la muestra *index* del fragmento."

#: ../Doc/library/audioop.rst:134
msgid ""
"Convert samples to 4 bit Intel/DVI ADPCM encoding.  ADPCM coding is an "
"adaptive coding scheme, whereby each 4 bit number is the difference between "
"one sample and the next, divided by a (varying) step.  The Intel/DVI ADPCM "
"algorithm has been selected for use by the IMA, so it may well become a "
"standard."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:139
msgid ""
"*state* is a tuple containing the state of the coder.  The coder returns a "
"tuple ``(adpcmfrag, newstate)``, and the *newstate* should be passed to the "
"next call of :func:`lin2adpcm`.  In the initial call, ``None`` can be passed "
"as the state. *adpcmfrag* is the ADPCM coded fragment packed 2 4-bit values "
"per byte."
msgstr ""
"*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 :func:`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."

#: ../Doc/library/audioop.rst:147
msgid ""
"Convert samples in the audio fragment to a-LAW encoding and return this as a "
"bytes object.  a-LAW is an audio encoding format whereby you get a dynamic "
"range of about 13 bits using only 8 bit samples.  It is used by the Sun "
"audio hardware, among others."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:155
msgid "Convert samples between 1-, 2-, 3- and 4-byte formats."
msgstr "Convierte muestras entre formatos de 1, 2, 3, y 4 bytes."

#: ../Doc/library/audioop.rst:159
msgid ""
"In some audio formats, such as .WAV files, 16, 24 and 32 bit samples are "
"signed, but 8 bit samples are unsigned.  So when converting to 8 bit wide "
"samples for these formats, you need to also add 128 to the result::"
msgstr ""
"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::"

#: ../Doc/library/audioop.rst:166
msgid ""
"The same, in reverse, has to be applied when converting from 8 to 16, 24 or "
"32 bit width samples."
msgstr ""
"Lo mismo, al revés, tiene que ser aplicado cuando se convierta muestras de 8 "
"bits en muestras de 16, 24, o 32 bits."

#: ../Doc/library/audioop.rst:172
msgid ""
"Convert samples in the audio fragment to u-LAW encoding and return this as a "
"bytes object.  u-LAW is an audio encoding format whereby you get a dynamic "
"range of about 14 bits using only 8 bit samples.  It is used by the Sun "
"audio hardware, among others."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:180
msgid ""
"Return the maximum of the *absolute value* of all samples in a fragment."
msgstr ""
"Retorna el máximo de los *valores absolutos* de las entradas en un fragmento."

#: ../Doc/library/audioop.rst:185
msgid "Return the maximum peak-peak value in the sound fragment."
msgstr "Retorna el valor de pico a pico máximo en el fragmento de sonido."

#: ../Doc/library/audioop.rst:190
msgid ""
"Return a tuple consisting of the minimum and maximum values of all samples "
"in the sound fragment."
msgstr ""
"Retorna una tupla que consiste de los valores mínimos y máximos de todas las "
"entradas en el fragmento de sonido."

#: ../Doc/library/audioop.rst:196
msgid ""
"Return a fragment that has all samples in the original fragment multiplied "
"by the floating-point value *factor*.  Samples are truncated in case of "
"overflow."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:202
msgid "Convert the frame rate of the input fragment."
msgstr "Convierte el ratio de fotogramas del fragmento de entrada."

#: ../Doc/library/audioop.rst:204
msgid ""
"*state* is a tuple containing the state of the converter.  The converter "
"returns a tuple ``(newfragment, newstate)``, and *newstate* should be passed "
"to the next call of :func:`ratecv`.  The initial call should pass ``None`` "
"as the state."
msgstr ""
"*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 :func:`ratecv`.  La llamada inicial debe pasar "
"``None`` como el estado."

#: ../Doc/library/audioop.rst:208
msgid ""
"The *weightA* and *weightB* arguments are parameters for a simple digital "
"filter and default to ``1`` and ``0`` respectively."
msgstr ""
"Los argumentos *weightA* y *weightB* son parámetros para un filtro digital "
"simple y sus valores por defecto son ``1`` y ``0`` respectivamente."

#: ../Doc/library/audioop.rst:214
msgid "Reverse the samples in a fragment and returns the modified fragment."
msgstr ""
"Invierte las entradas en un fragmento y retorna el fragmento modificado."

#: ../Doc/library/audioop.rst:219
msgid ""
"Return the root-mean-square of the fragment, i.e. ``sqrt(sum(S_i^2)/n)``."
msgstr ""
"Retorna la media cuadrática del fragmento, i.e. ``sqrt(sum(S_i^2)/n)``."

#: ../Doc/library/audioop.rst:221
msgid "This is a measure of the power in an audio signal."
msgstr "Este es una medida del poder en una señal de audio."

#: ../Doc/library/audioop.rst:226
msgid ""
"Convert a stereo fragment to a mono fragment.  The left channel is "
"multiplied by *lfactor* and the right channel by *rfactor* before adding the "
"two channels to give a mono signal."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:233
msgid ""
"Generate a stereo fragment from a mono fragment.  Each pair of samples in "
"the stereo fragment are computed from the mono sample, whereby left channel "
"samples are multiplied by *lfactor* and right channel samples by *rfactor*."
msgstr ""
"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*."

#: ../Doc/library/audioop.rst:240
msgid ""
"Convert sound fragments in u-LAW encoding to linearly encoded sound "
"fragments. u-LAW encoding always uses 8 bits samples, so *width* refers only "
"to the sample width of the output fragment here."
msgstr ""
"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í."

#: ../Doc/library/audioop.rst:244
msgid ""
"Note that operations such as :func:`.mul` or :func:`.max` make no "
"distinction between mono and stereo fragments, i.e. all samples are treated "
"equal.  If this is a problem the stereo fragment should be split into two "
"mono fragments first and recombined later.  Here is an example of how to do "
"that::"
msgstr ""
"Note que operaciones tales como :func:`.mul` o :func:`.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::"

#: ../Doc/library/audioop.rst:258
msgid ""
"If you use the ADPCM coder to build network packets and you want your "
"protocol to be stateless (i.e. to be able to tolerate packet loss) you "
"should not only transmit the data but also the state.  Note that you should "
"send the *initial* state (the one you passed to :func:`lin2adpcm`) along to "
"the decoder, not the final state (as returned by the coder).  If you want to "
"use :class:`struct.Struct` to store the state in binary you can code the "
"first element (the predicted value) in 16 bits and the second (the delta "
"index) in 8."
msgstr ""
"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 :"
"func:`lin2adpcm`) junto con el decodificador, no el estado final (como es "
"retornado por el codificador).  Si quieres usar un :class:`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."

#: ../Doc/library/audioop.rst:266
msgid ""
"The ADPCM coders have never been tried against other ADPCM coders, only "
"against themselves.  It could well be that I misinterpreted the standards in "
"which case they will not be interoperable with the respective standards."
msgstr ""
"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."

#: ../Doc/library/audioop.rst:270
msgid ""
"The :func:`find\\*` routines might look a bit funny at first sight. They are "
"primarily meant to do echo cancellation.  A reasonably fast way to do this "
"is to pick the most energetic piece of the output sample, locate that in the "
"input sample and subtract the whole output sample from the input sample::"
msgstr ""
"La rutinas :func:`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::"