audioop.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-17 21:03+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: library/audioop.rst:2
msgid ":mod:`audioop` --- Manipulate raw audio data"
msgstr ""

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

#: 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 ""

#: 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 ""

#: library/audioop.rst:30
msgid ""
"This module provides support for a-LAW, u-LAW and Intel/DVI ADPCM encodings."
msgstr ""

#: 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 ""

#: library/audioop.rst:37
msgid "The module defines the following variables and functions:"
msgstr ""

#: library/audioop.rst:42
msgid ""
"This exception is raised on all errors, such as unknown number of bytes per "
"sample, etc."
msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:69
msgid "Return the average over all samples in the fragment."
msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:94
msgid ""
"Return the number of zero crossings in the fragment passed as an argument."
msgstr ""

#: 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 ""

#: library/audioop.rst:104
msgid "The time taken by this routine is proportional to ``len(fragment)``."
msgstr ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:124
msgid "The routine takes time proportional to ``len(fragment)``."
msgstr ""

#: library/audioop.rst:129
msgid "Return the value of sample *index* from the fragment."
msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:155
msgid "Convert samples between 1-, 2-, 3- and 4-byte formats."
msgstr ""

#: 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 ""

#: library/audioop.rst:163
msgid ""
"new_frames = audioop.lin2lin(frames, old_width, 1)\n"
"new_frames = audioop.bias(new_frames, 1, 128)"
msgstr ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:180
msgid ""
"Return the maximum of the *absolute value* of all samples in a fragment."
msgstr ""

#: library/audioop.rst:185
msgid "Return the maximum peak-peak value in the sound fragment."
msgstr ""

#: library/audioop.rst:190
msgid ""
"Return a tuple consisting of the minimum and maximum values of all samples "
"in the sound fragment."
msgstr ""

#: 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 ""

#: library/audioop.rst:202
msgid "Convert the frame rate of the input fragment."
msgstr ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:214
msgid "Reverse the samples in a fragment and returns the modified fragment."
msgstr ""

#: library/audioop.rst:219
msgid ""
"Return the root-mean-square of the fragment, i.e. ``sqrt(sum(S_i^2)/n)``."
msgstr ""

#: library/audioop.rst:221
msgid "This is a measure of the power in an audio signal."
msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: 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 ""

#: library/audioop.rst:249
msgid ""
"def mul_stereo(sample, width, lfactor, rfactor):\n"
"    lsample = audioop.tomono(sample, width, 1, 0)\n"
"    rsample = audioop.tomono(sample, width, 0, 1)\n"
"    lsample = audioop.mul(lsample, width, lfactor)\n"
"    rsample = audioop.mul(rsample, width, rfactor)\n"
"    lsample = audioop.tostereo(lsample, width, 1, 0)\n"
"    rsample = audioop.tostereo(rsample, width, 0, 1)\n"
"    return audioop.add(lsample, rsample, width)"
msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

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

#: library/audioop.rst:24
msgid "Intel/DVI ADPCM"
msgstr ""

#: library/audioop.rst:24
msgid "ADPCM, Intel/DVI"
msgstr ""

#: library/audioop.rst:24
msgid "a-LAW"
msgstr ""

#: library/audioop.rst:24
msgid "u-LAW"
msgstr ""