Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(audioop_getsample__doc__,
6 : : "getsample($module, fragment, width, index, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "Return the value of sample index from the fragment.");
10 : :
11 : : #define AUDIOOP_GETSAMPLE_METHODDEF \
12 : : {"getsample", _PyCFunction_CAST(audioop_getsample), METH_FASTCALL, audioop_getsample__doc__},
13 : :
14 : : static PyObject *
15 : : audioop_getsample_impl(PyObject *module, Py_buffer *fragment, int width,
16 : : Py_ssize_t index);
17 : :
18 : : static PyObject *
19 : 33 : audioop_getsample(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
20 : : {
21 : 33 : PyObject *return_value = NULL;
22 : 33 : Py_buffer fragment = {NULL, NULL};
23 : : int width;
24 : : Py_ssize_t index;
25 : :
26 [ + - - + : 33 : if (!_PyArg_CheckPositional("getsample", nargs, 3, 3)) {
- - ]
27 : 0 : goto exit;
28 : : }
29 [ + + ]: 33 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
30 : 1 : goto exit;
31 : : }
32 [ - + ]: 32 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
33 : 0 : _PyArg_BadArgument("getsample", "argument 1", "contiguous buffer", args[0]);
34 : 0 : goto exit;
35 : : }
36 : 32 : width = _PyLong_AsInt(args[1]);
37 [ - + - - ]: 32 : if (width == -1 && PyErr_Occurred()) {
38 : 0 : goto exit;
39 : : }
40 : : {
41 : 32 : Py_ssize_t ival = -1;
42 : 32 : PyObject *iobj = _PyNumber_Index(args[2]);
43 [ + - ]: 32 : if (iobj != NULL) {
44 : 32 : ival = PyLong_AsSsize_t(iobj);
45 : 32 : Py_DECREF(iobj);
46 : : }
47 [ - + - - ]: 32 : if (ival == -1 && PyErr_Occurred()) {
48 : 0 : goto exit;
49 : : }
50 : 32 : index = ival;
51 : : }
52 : 32 : return_value = audioop_getsample_impl(module, &fragment, width, index);
53 : :
54 : 33 : exit:
55 : : /* Cleanup for fragment */
56 [ + + ]: 33 : if (fragment.obj) {
57 : 32 : PyBuffer_Release(&fragment);
58 : : }
59 : :
60 : 33 : return return_value;
61 : : }
62 : :
63 : : PyDoc_STRVAR(audioop_max__doc__,
64 : : "max($module, fragment, width, /)\n"
65 : : "--\n"
66 : : "\n"
67 : : "Return the maximum of the absolute value of all samples in a fragment.");
68 : :
69 : : #define AUDIOOP_MAX_METHODDEF \
70 : : {"max", _PyCFunction_CAST(audioop_max), METH_FASTCALL, audioop_max__doc__},
71 : :
72 : : static PyObject *
73 : : audioop_max_impl(PyObject *module, Py_buffer *fragment, int width);
74 : :
75 : : static PyObject *
76 : 37 : audioop_max(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
77 : : {
78 : 37 : PyObject *return_value = NULL;
79 : 37 : Py_buffer fragment = {NULL, NULL};
80 : : int width;
81 : :
82 [ + - - + : 37 : if (!_PyArg_CheckPositional("max", nargs, 2, 2)) {
- - ]
83 : 0 : goto exit;
84 : : }
85 [ + + ]: 37 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
86 : 1 : goto exit;
87 : : }
88 [ - + ]: 36 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
89 : 0 : _PyArg_BadArgument("max", "argument 1", "contiguous buffer", args[0]);
90 : 0 : goto exit;
91 : : }
92 : 36 : width = _PyLong_AsInt(args[1]);
93 [ - + - - ]: 36 : if (width == -1 && PyErr_Occurred()) {
94 : 0 : goto exit;
95 : : }
96 : 36 : return_value = audioop_max_impl(module, &fragment, width);
97 : :
98 : 37 : exit:
99 : : /* Cleanup for fragment */
100 [ + + ]: 37 : if (fragment.obj) {
101 : 36 : PyBuffer_Release(&fragment);
102 : : }
103 : :
104 : 37 : return return_value;
105 : : }
106 : :
107 : : PyDoc_STRVAR(audioop_minmax__doc__,
108 : : "minmax($module, fragment, width, /)\n"
109 : : "--\n"
110 : : "\n"
111 : : "Return the minimum and maximum values of all samples in the sound fragment.");
112 : :
113 : : #define AUDIOOP_MINMAX_METHODDEF \
114 : : {"minmax", _PyCFunction_CAST(audioop_minmax), METH_FASTCALL, audioop_minmax__doc__},
115 : :
116 : : static PyObject *
117 : : audioop_minmax_impl(PyObject *module, Py_buffer *fragment, int width);
118 : :
119 : : static PyObject *
120 : 37 : audioop_minmax(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
121 : : {
122 : 37 : PyObject *return_value = NULL;
123 : 37 : Py_buffer fragment = {NULL, NULL};
124 : : int width;
125 : :
126 [ + - - + : 37 : if (!_PyArg_CheckPositional("minmax", nargs, 2, 2)) {
- - ]
127 : 0 : goto exit;
128 : : }
129 [ + + ]: 37 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
130 : 1 : goto exit;
131 : : }
132 [ - + ]: 36 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
133 : 0 : _PyArg_BadArgument("minmax", "argument 1", "contiguous buffer", args[0]);
134 : 0 : goto exit;
135 : : }
136 : 36 : width = _PyLong_AsInt(args[1]);
137 [ - + - - ]: 36 : if (width == -1 && PyErr_Occurred()) {
138 : 0 : goto exit;
139 : : }
140 : 36 : return_value = audioop_minmax_impl(module, &fragment, width);
141 : :
142 : 37 : exit:
143 : : /* Cleanup for fragment */
144 [ + + ]: 37 : if (fragment.obj) {
145 : 36 : PyBuffer_Release(&fragment);
146 : : }
147 : :
148 : 37 : return return_value;
149 : : }
150 : :
151 : : PyDoc_STRVAR(audioop_avg__doc__,
152 : : "avg($module, fragment, width, /)\n"
153 : : "--\n"
154 : : "\n"
155 : : "Return the average over all samples in the fragment.");
156 : :
157 : : #define AUDIOOP_AVG_METHODDEF \
158 : : {"avg", _PyCFunction_CAST(audioop_avg), METH_FASTCALL, audioop_avg__doc__},
159 : :
160 : : static PyObject *
161 : : audioop_avg_impl(PyObject *module, Py_buffer *fragment, int width);
162 : :
163 : : static PyObject *
164 : 39 : audioop_avg(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
165 : : {
166 : 39 : PyObject *return_value = NULL;
167 : 39 : Py_buffer fragment = {NULL, NULL};
168 : : int width;
169 : :
170 [ + - - + : 39 : if (!_PyArg_CheckPositional("avg", nargs, 2, 2)) {
- - ]
171 : 0 : goto exit;
172 : : }
173 [ + + ]: 39 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
174 : 1 : goto exit;
175 : : }
176 [ - + ]: 38 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
177 : 0 : _PyArg_BadArgument("avg", "argument 1", "contiguous buffer", args[0]);
178 : 0 : goto exit;
179 : : }
180 : 38 : width = _PyLong_AsInt(args[1]);
181 [ - + - - ]: 38 : if (width == -1 && PyErr_Occurred()) {
182 : 0 : goto exit;
183 : : }
184 : 38 : return_value = audioop_avg_impl(module, &fragment, width);
185 : :
186 : 39 : exit:
187 : : /* Cleanup for fragment */
188 [ + + ]: 39 : if (fragment.obj) {
189 : 38 : PyBuffer_Release(&fragment);
190 : : }
191 : :
192 : 39 : return return_value;
193 : : }
194 : :
195 : : PyDoc_STRVAR(audioop_rms__doc__,
196 : : "rms($module, fragment, width, /)\n"
197 : : "--\n"
198 : : "\n"
199 : : "Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n).");
200 : :
201 : : #define AUDIOOP_RMS_METHODDEF \
202 : : {"rms", _PyCFunction_CAST(audioop_rms), METH_FASTCALL, audioop_rms__doc__},
203 : :
204 : : static PyObject *
205 : : audioop_rms_impl(PyObject *module, Py_buffer *fragment, int width);
206 : :
207 : : static PyObject *
208 : 33 : audioop_rms(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
209 : : {
210 : 33 : PyObject *return_value = NULL;
211 : 33 : Py_buffer fragment = {NULL, NULL};
212 : : int width;
213 : :
214 [ + - - + : 33 : if (!_PyArg_CheckPositional("rms", nargs, 2, 2)) {
- - ]
215 : 0 : goto exit;
216 : : }
217 [ + + ]: 33 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
218 : 1 : goto exit;
219 : : }
220 [ - + ]: 32 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
221 : 0 : _PyArg_BadArgument("rms", "argument 1", "contiguous buffer", args[0]);
222 : 0 : goto exit;
223 : : }
224 : 32 : width = _PyLong_AsInt(args[1]);
225 [ - + - - ]: 32 : if (width == -1 && PyErr_Occurred()) {
226 : 0 : goto exit;
227 : : }
228 : 32 : return_value = audioop_rms_impl(module, &fragment, width);
229 : :
230 : 33 : exit:
231 : : /* Cleanup for fragment */
232 [ + + ]: 33 : if (fragment.obj) {
233 : 32 : PyBuffer_Release(&fragment);
234 : : }
235 : :
236 : 33 : return return_value;
237 : : }
238 : :
239 : : PyDoc_STRVAR(audioop_findfit__doc__,
240 : : "findfit($module, fragment, reference, /)\n"
241 : : "--\n"
242 : : "\n"
243 : : "Try to match reference as well as possible to a portion of fragment.");
244 : :
245 : : #define AUDIOOP_FINDFIT_METHODDEF \
246 : : {"findfit", _PyCFunction_CAST(audioop_findfit), METH_FASTCALL, audioop_findfit__doc__},
247 : :
248 : : static PyObject *
249 : : audioop_findfit_impl(PyObject *module, Py_buffer *fragment,
250 : : Py_buffer *reference);
251 : :
252 : : static PyObject *
253 : 5 : audioop_findfit(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
254 : : {
255 : 5 : PyObject *return_value = NULL;
256 : 5 : Py_buffer fragment = {NULL, NULL};
257 : 5 : Py_buffer reference = {NULL, NULL};
258 : :
259 [ + - - + : 5 : if (!_PyArg_CheckPositional("findfit", nargs, 2, 2)) {
- - ]
260 : 0 : goto exit;
261 : : }
262 [ - + ]: 5 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
263 : 0 : goto exit;
264 : : }
265 [ - + ]: 5 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
266 : 0 : _PyArg_BadArgument("findfit", "argument 1", "contiguous buffer", args[0]);
267 : 0 : goto exit;
268 : : }
269 [ - + ]: 5 : if (PyObject_GetBuffer(args[1], &reference, PyBUF_SIMPLE) != 0) {
270 : 0 : goto exit;
271 : : }
272 [ - + ]: 5 : if (!PyBuffer_IsContiguous(&reference, 'C')) {
273 : 0 : _PyArg_BadArgument("findfit", "argument 2", "contiguous buffer", args[1]);
274 : 0 : goto exit;
275 : : }
276 : 5 : return_value = audioop_findfit_impl(module, &fragment, &reference);
277 : :
278 : 5 : exit:
279 : : /* Cleanup for fragment */
280 [ + - ]: 5 : if (fragment.obj) {
281 : 5 : PyBuffer_Release(&fragment);
282 : : }
283 : : /* Cleanup for reference */
284 [ + - ]: 5 : if (reference.obj) {
285 : 5 : PyBuffer_Release(&reference);
286 : : }
287 : :
288 : 5 : return return_value;
289 : : }
290 : :
291 : : PyDoc_STRVAR(audioop_findfactor__doc__,
292 : : "findfactor($module, fragment, reference, /)\n"
293 : : "--\n"
294 : : "\n"
295 : : "Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal.");
296 : :
297 : : #define AUDIOOP_FINDFACTOR_METHODDEF \
298 : : {"findfactor", _PyCFunction_CAST(audioop_findfactor), METH_FASTCALL, audioop_findfactor__doc__},
299 : :
300 : : static PyObject *
301 : : audioop_findfactor_impl(PyObject *module, Py_buffer *fragment,
302 : : Py_buffer *reference);
303 : :
304 : : static PyObject *
305 : 4 : audioop_findfactor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
306 : : {
307 : 4 : PyObject *return_value = NULL;
308 : 4 : Py_buffer fragment = {NULL, NULL};
309 : 4 : Py_buffer reference = {NULL, NULL};
310 : :
311 [ + - - + : 4 : if (!_PyArg_CheckPositional("findfactor", nargs, 2, 2)) {
- - ]
312 : 0 : goto exit;
313 : : }
314 [ - + ]: 4 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
315 : 0 : goto exit;
316 : : }
317 [ - + ]: 4 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
318 : 0 : _PyArg_BadArgument("findfactor", "argument 1", "contiguous buffer", args[0]);
319 : 0 : goto exit;
320 : : }
321 [ - + ]: 4 : if (PyObject_GetBuffer(args[1], &reference, PyBUF_SIMPLE) != 0) {
322 : 0 : goto exit;
323 : : }
324 [ - + ]: 4 : if (!PyBuffer_IsContiguous(&reference, 'C')) {
325 : 0 : _PyArg_BadArgument("findfactor", "argument 2", "contiguous buffer", args[1]);
326 : 0 : goto exit;
327 : : }
328 : 4 : return_value = audioop_findfactor_impl(module, &fragment, &reference);
329 : :
330 : 4 : exit:
331 : : /* Cleanup for fragment */
332 [ + - ]: 4 : if (fragment.obj) {
333 : 4 : PyBuffer_Release(&fragment);
334 : : }
335 : : /* Cleanup for reference */
336 [ + - ]: 4 : if (reference.obj) {
337 : 4 : PyBuffer_Release(&reference);
338 : : }
339 : :
340 : 4 : return return_value;
341 : : }
342 : :
343 : : PyDoc_STRVAR(audioop_findmax__doc__,
344 : : "findmax($module, fragment, length, /)\n"
345 : : "--\n"
346 : : "\n"
347 : : "Search fragment for a slice of specified number of samples with maximum energy.");
348 : :
349 : : #define AUDIOOP_FINDMAX_METHODDEF \
350 : : {"findmax", _PyCFunction_CAST(audioop_findmax), METH_FASTCALL, audioop_findmax__doc__},
351 : :
352 : : static PyObject *
353 : : audioop_findmax_impl(PyObject *module, Py_buffer *fragment,
354 : : Py_ssize_t length);
355 : :
356 : : static PyObject *
357 : 4 : audioop_findmax(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
358 : : {
359 : 4 : PyObject *return_value = NULL;
360 : 4 : Py_buffer fragment = {NULL, NULL};
361 : : Py_ssize_t length;
362 : :
363 [ + - - + : 4 : if (!_PyArg_CheckPositional("findmax", nargs, 2, 2)) {
- - ]
364 : 0 : goto exit;
365 : : }
366 [ - + ]: 4 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
367 : 0 : goto exit;
368 : : }
369 [ - + ]: 4 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
370 : 0 : _PyArg_BadArgument("findmax", "argument 1", "contiguous buffer", args[0]);
371 : 0 : goto exit;
372 : : }
373 : : {
374 : 4 : Py_ssize_t ival = -1;
375 : 4 : PyObject *iobj = _PyNumber_Index(args[1]);
376 [ + - ]: 4 : if (iobj != NULL) {
377 : 4 : ival = PyLong_AsSsize_t(iobj);
378 : 4 : Py_DECREF(iobj);
379 : : }
380 [ - + - - ]: 4 : if (ival == -1 && PyErr_Occurred()) {
381 : 0 : goto exit;
382 : : }
383 : 4 : length = ival;
384 : : }
385 : 4 : return_value = audioop_findmax_impl(module, &fragment, length);
386 : :
387 : 4 : exit:
388 : : /* Cleanup for fragment */
389 [ + - ]: 4 : if (fragment.obj) {
390 : 4 : PyBuffer_Release(&fragment);
391 : : }
392 : :
393 : 4 : return return_value;
394 : : }
395 : :
396 : : PyDoc_STRVAR(audioop_avgpp__doc__,
397 : : "avgpp($module, fragment, width, /)\n"
398 : : "--\n"
399 : : "\n"
400 : : "Return the average peak-peak value over all samples in the fragment.");
401 : :
402 : : #define AUDIOOP_AVGPP_METHODDEF \
403 : : {"avgpp", _PyCFunction_CAST(audioop_avgpp), METH_FASTCALL, audioop_avgpp__doc__},
404 : :
405 : : static PyObject *
406 : : audioop_avgpp_impl(PyObject *module, Py_buffer *fragment, int width);
407 : :
408 : : static PyObject *
409 : 29 : audioop_avgpp(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
410 : : {
411 : 29 : PyObject *return_value = NULL;
412 : 29 : Py_buffer fragment = {NULL, NULL};
413 : : int width;
414 : :
415 [ + - - + : 29 : if (!_PyArg_CheckPositional("avgpp", nargs, 2, 2)) {
- - ]
416 : 0 : goto exit;
417 : : }
418 [ + + ]: 29 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
419 : 1 : goto exit;
420 : : }
421 [ - + ]: 28 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
422 : 0 : _PyArg_BadArgument("avgpp", "argument 1", "contiguous buffer", args[0]);
423 : 0 : goto exit;
424 : : }
425 : 28 : width = _PyLong_AsInt(args[1]);
426 [ - + - - ]: 28 : if (width == -1 && PyErr_Occurred()) {
427 : 0 : goto exit;
428 : : }
429 : 28 : return_value = audioop_avgpp_impl(module, &fragment, width);
430 : :
431 : 29 : exit:
432 : : /* Cleanup for fragment */
433 [ + + ]: 29 : if (fragment.obj) {
434 : 28 : PyBuffer_Release(&fragment);
435 : : }
436 : :
437 : 29 : return return_value;
438 : : }
439 : :
440 : : PyDoc_STRVAR(audioop_maxpp__doc__,
441 : : "maxpp($module, fragment, width, /)\n"
442 : : "--\n"
443 : : "\n"
444 : : "Return the maximum peak-peak value in the sound fragment.");
445 : :
446 : : #define AUDIOOP_MAXPP_METHODDEF \
447 : : {"maxpp", _PyCFunction_CAST(audioop_maxpp), METH_FASTCALL, audioop_maxpp__doc__},
448 : :
449 : : static PyObject *
450 : : audioop_maxpp_impl(PyObject *module, Py_buffer *fragment, int width);
451 : :
452 : : static PyObject *
453 : 29 : audioop_maxpp(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
454 : : {
455 : 29 : PyObject *return_value = NULL;
456 : 29 : Py_buffer fragment = {NULL, NULL};
457 : : int width;
458 : :
459 [ + - - + : 29 : if (!_PyArg_CheckPositional("maxpp", nargs, 2, 2)) {
- - ]
460 : 0 : goto exit;
461 : : }
462 [ + + ]: 29 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
463 : 1 : goto exit;
464 : : }
465 [ - + ]: 28 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
466 : 0 : _PyArg_BadArgument("maxpp", "argument 1", "contiguous buffer", args[0]);
467 : 0 : goto exit;
468 : : }
469 : 28 : width = _PyLong_AsInt(args[1]);
470 [ - + - - ]: 28 : if (width == -1 && PyErr_Occurred()) {
471 : 0 : goto exit;
472 : : }
473 : 28 : return_value = audioop_maxpp_impl(module, &fragment, width);
474 : :
475 : 29 : exit:
476 : : /* Cleanup for fragment */
477 [ + + ]: 29 : if (fragment.obj) {
478 : 28 : PyBuffer_Release(&fragment);
479 : : }
480 : :
481 : 29 : return return_value;
482 : : }
483 : :
484 : : PyDoc_STRVAR(audioop_cross__doc__,
485 : : "cross($module, fragment, width, /)\n"
486 : : "--\n"
487 : : "\n"
488 : : "Return the number of zero crossings in the fragment passed as an argument.");
489 : :
490 : : #define AUDIOOP_CROSS_METHODDEF \
491 : : {"cross", _PyCFunction_CAST(audioop_cross), METH_FASTCALL, audioop_cross__doc__},
492 : :
493 : : static PyObject *
494 : : audioop_cross_impl(PyObject *module, Py_buffer *fragment, int width);
495 : :
496 : : static PyObject *
497 : 37 : audioop_cross(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
498 : : {
499 : 37 : PyObject *return_value = NULL;
500 : 37 : Py_buffer fragment = {NULL, NULL};
501 : : int width;
502 : :
503 [ + - - + : 37 : if (!_PyArg_CheckPositional("cross", nargs, 2, 2)) {
- - ]
504 : 0 : goto exit;
505 : : }
506 [ + + ]: 37 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
507 : 1 : goto exit;
508 : : }
509 [ - + ]: 36 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
510 : 0 : _PyArg_BadArgument("cross", "argument 1", "contiguous buffer", args[0]);
511 : 0 : goto exit;
512 : : }
513 : 36 : width = _PyLong_AsInt(args[1]);
514 [ - + - - ]: 36 : if (width == -1 && PyErr_Occurred()) {
515 : 0 : goto exit;
516 : : }
517 : 36 : return_value = audioop_cross_impl(module, &fragment, width);
518 : :
519 : 37 : exit:
520 : : /* Cleanup for fragment */
521 [ + + ]: 37 : if (fragment.obj) {
522 : 36 : PyBuffer_Release(&fragment);
523 : : }
524 : :
525 : 37 : return return_value;
526 : : }
527 : :
528 : : PyDoc_STRVAR(audioop_mul__doc__,
529 : : "mul($module, fragment, width, factor, /)\n"
530 : : "--\n"
531 : : "\n"
532 : : "Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.");
533 : :
534 : : #define AUDIOOP_MUL_METHODDEF \
535 : : {"mul", _PyCFunction_CAST(audioop_mul), METH_FASTCALL, audioop_mul__doc__},
536 : :
537 : : static PyObject *
538 : : audioop_mul_impl(PyObject *module, Py_buffer *fragment, int width,
539 : : double factor);
540 : :
541 : : static PyObject *
542 : 29 : audioop_mul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
543 : : {
544 : 29 : PyObject *return_value = NULL;
545 : 29 : Py_buffer fragment = {NULL, NULL};
546 : : int width;
547 : : double factor;
548 : :
549 [ + - - + : 29 : if (!_PyArg_CheckPositional("mul", nargs, 3, 3)) {
- - ]
550 : 0 : goto exit;
551 : : }
552 [ + + ]: 29 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
553 : 1 : goto exit;
554 : : }
555 [ - + ]: 28 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
556 : 0 : _PyArg_BadArgument("mul", "argument 1", "contiguous buffer", args[0]);
557 : 0 : goto exit;
558 : : }
559 : 28 : width = _PyLong_AsInt(args[1]);
560 [ - + - - ]: 28 : if (width == -1 && PyErr_Occurred()) {
561 : 0 : goto exit;
562 : : }
563 [ + + ]: 28 : if (PyFloat_CheckExact(args[2])) {
564 : 4 : factor = PyFloat_AS_DOUBLE(args[2]);
565 : : }
566 : : else
567 : : {
568 : 24 : factor = PyFloat_AsDouble(args[2]);
569 [ - + - - ]: 24 : if (factor == -1.0 && PyErr_Occurred()) {
570 : 0 : goto exit;
571 : : }
572 : : }
573 : 28 : return_value = audioop_mul_impl(module, &fragment, width, factor);
574 : :
575 : 29 : exit:
576 : : /* Cleanup for fragment */
577 [ + + ]: 29 : if (fragment.obj) {
578 : 28 : PyBuffer_Release(&fragment);
579 : : }
580 : :
581 : 29 : return return_value;
582 : : }
583 : :
584 : : PyDoc_STRVAR(audioop_tomono__doc__,
585 : : "tomono($module, fragment, width, lfactor, rfactor, /)\n"
586 : : "--\n"
587 : : "\n"
588 : : "Convert a stereo fragment to a mono fragment.");
589 : :
590 : : #define AUDIOOP_TOMONO_METHODDEF \
591 : : {"tomono", _PyCFunction_CAST(audioop_tomono), METH_FASTCALL, audioop_tomono__doc__},
592 : :
593 : : static PyObject *
594 : : audioop_tomono_impl(PyObject *module, Py_buffer *fragment, int width,
595 : : double lfactor, double rfactor);
596 : :
597 : : static PyObject *
598 : 25 : audioop_tomono(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
599 : : {
600 : 25 : PyObject *return_value = NULL;
601 : 25 : Py_buffer fragment = {NULL, NULL};
602 : : int width;
603 : : double lfactor;
604 : : double rfactor;
605 : :
606 [ + - - + : 25 : if (!_PyArg_CheckPositional("tomono", nargs, 4, 4)) {
- - ]
607 : 0 : goto exit;
608 : : }
609 [ + + ]: 25 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
610 : 1 : goto exit;
611 : : }
612 [ - + ]: 24 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
613 : 0 : _PyArg_BadArgument("tomono", "argument 1", "contiguous buffer", args[0]);
614 : 0 : goto exit;
615 : : }
616 : 24 : width = _PyLong_AsInt(args[1]);
617 [ - + - - ]: 24 : if (width == -1 && PyErr_Occurred()) {
618 : 0 : goto exit;
619 : : }
620 [ + + ]: 24 : if (PyFloat_CheckExact(args[2])) {
621 : 16 : lfactor = PyFloat_AS_DOUBLE(args[2]);
622 : : }
623 : : else
624 : : {
625 : 8 : lfactor = PyFloat_AsDouble(args[2]);
626 [ - + - - ]: 8 : if (lfactor == -1.0 && PyErr_Occurred()) {
627 : 0 : goto exit;
628 : : }
629 : : }
630 [ + + ]: 24 : if (PyFloat_CheckExact(args[3])) {
631 : 16 : rfactor = PyFloat_AS_DOUBLE(args[3]);
632 : : }
633 : : else
634 : : {
635 : 8 : rfactor = PyFloat_AsDouble(args[3]);
636 [ - + - - ]: 8 : if (rfactor == -1.0 && PyErr_Occurred()) {
637 : 0 : goto exit;
638 : : }
639 : : }
640 : 24 : return_value = audioop_tomono_impl(module, &fragment, width, lfactor, rfactor);
641 : :
642 : 25 : exit:
643 : : /* Cleanup for fragment */
644 [ + + ]: 25 : if (fragment.obj) {
645 : 24 : PyBuffer_Release(&fragment);
646 : : }
647 : :
648 : 25 : return return_value;
649 : : }
650 : :
651 : : PyDoc_STRVAR(audioop_tostereo__doc__,
652 : : "tostereo($module, fragment, width, lfactor, rfactor, /)\n"
653 : : "--\n"
654 : : "\n"
655 : : "Generate a stereo fragment from a mono fragment.");
656 : :
657 : : #define AUDIOOP_TOSTEREO_METHODDEF \
658 : : {"tostereo", _PyCFunction_CAST(audioop_tostereo), METH_FASTCALL, audioop_tostereo__doc__},
659 : :
660 : : static PyObject *
661 : : audioop_tostereo_impl(PyObject *module, Py_buffer *fragment, int width,
662 : : double lfactor, double rfactor);
663 : :
664 : : static PyObject *
665 : 25 : audioop_tostereo(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
666 : : {
667 : 25 : PyObject *return_value = NULL;
668 : 25 : Py_buffer fragment = {NULL, NULL};
669 : : int width;
670 : : double lfactor;
671 : : double rfactor;
672 : :
673 [ + - - + : 25 : if (!_PyArg_CheckPositional("tostereo", nargs, 4, 4)) {
- - ]
674 : 0 : goto exit;
675 : : }
676 [ + + ]: 25 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
677 : 1 : goto exit;
678 : : }
679 [ - + ]: 24 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
680 : 0 : _PyArg_BadArgument("tostereo", "argument 1", "contiguous buffer", args[0]);
681 : 0 : goto exit;
682 : : }
683 : 24 : width = _PyLong_AsInt(args[1]);
684 [ - + - - ]: 24 : if (width == -1 && PyErr_Occurred()) {
685 : 0 : goto exit;
686 : : }
687 [ + + ]: 24 : if (PyFloat_CheckExact(args[2])) {
688 : 4 : lfactor = PyFloat_AS_DOUBLE(args[2]);
689 : : }
690 : : else
691 : : {
692 : 20 : lfactor = PyFloat_AsDouble(args[2]);
693 [ - + - - ]: 20 : if (lfactor == -1.0 && PyErr_Occurred()) {
694 : 0 : goto exit;
695 : : }
696 : : }
697 [ + + ]: 24 : if (PyFloat_CheckExact(args[3])) {
698 : 4 : rfactor = PyFloat_AS_DOUBLE(args[3]);
699 : : }
700 : : else
701 : : {
702 : 20 : rfactor = PyFloat_AsDouble(args[3]);
703 [ - + - - ]: 20 : if (rfactor == -1.0 && PyErr_Occurred()) {
704 : 0 : goto exit;
705 : : }
706 : : }
707 : 24 : return_value = audioop_tostereo_impl(module, &fragment, width, lfactor, rfactor);
708 : :
709 : 25 : exit:
710 : : /* Cleanup for fragment */
711 [ + + ]: 25 : if (fragment.obj) {
712 : 24 : PyBuffer_Release(&fragment);
713 : : }
714 : :
715 : 25 : return return_value;
716 : : }
717 : :
718 : : PyDoc_STRVAR(audioop_add__doc__,
719 : : "add($module, fragment1, fragment2, width, /)\n"
720 : : "--\n"
721 : : "\n"
722 : : "Return a fragment which is the addition of the two samples passed as parameters.");
723 : :
724 : : #define AUDIOOP_ADD_METHODDEF \
725 : : {"add", _PyCFunction_CAST(audioop_add), METH_FASTCALL, audioop_add__doc__},
726 : :
727 : : static PyObject *
728 : : audioop_add_impl(PyObject *module, Py_buffer *fragment1,
729 : : Py_buffer *fragment2, int width);
730 : :
731 : : static PyObject *
732 : 25 : audioop_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
733 : : {
734 : 25 : PyObject *return_value = NULL;
735 : 25 : Py_buffer fragment1 = {NULL, NULL};
736 : 25 : Py_buffer fragment2 = {NULL, NULL};
737 : : int width;
738 : :
739 [ + - - + : 25 : if (!_PyArg_CheckPositional("add", nargs, 3, 3)) {
- - ]
740 : 0 : goto exit;
741 : : }
742 [ + + ]: 25 : if (PyObject_GetBuffer(args[0], &fragment1, PyBUF_SIMPLE) != 0) {
743 : 1 : goto exit;
744 : : }
745 [ - + ]: 24 : if (!PyBuffer_IsContiguous(&fragment1, 'C')) {
746 : 0 : _PyArg_BadArgument("add", "argument 1", "contiguous buffer", args[0]);
747 : 0 : goto exit;
748 : : }
749 [ - + ]: 24 : if (PyObject_GetBuffer(args[1], &fragment2, PyBUF_SIMPLE) != 0) {
750 : 0 : goto exit;
751 : : }
752 [ - + ]: 24 : if (!PyBuffer_IsContiguous(&fragment2, 'C')) {
753 : 0 : _PyArg_BadArgument("add", "argument 2", "contiguous buffer", args[1]);
754 : 0 : goto exit;
755 : : }
756 : 24 : width = _PyLong_AsInt(args[2]);
757 [ - + - - ]: 24 : if (width == -1 && PyErr_Occurred()) {
758 : 0 : goto exit;
759 : : }
760 : 24 : return_value = audioop_add_impl(module, &fragment1, &fragment2, width);
761 : :
762 : 25 : exit:
763 : : /* Cleanup for fragment1 */
764 [ + + ]: 25 : if (fragment1.obj) {
765 : 24 : PyBuffer_Release(&fragment1);
766 : : }
767 : : /* Cleanup for fragment2 */
768 [ + + ]: 25 : if (fragment2.obj) {
769 : 24 : PyBuffer_Release(&fragment2);
770 : : }
771 : :
772 : 25 : return return_value;
773 : : }
774 : :
775 : : PyDoc_STRVAR(audioop_bias__doc__,
776 : : "bias($module, fragment, width, bias, /)\n"
777 : : "--\n"
778 : : "\n"
779 : : "Return a fragment that is the original fragment with a bias added to each sample.");
780 : :
781 : : #define AUDIOOP_BIAS_METHODDEF \
782 : : {"bias", _PyCFunction_CAST(audioop_bias), METH_FASTCALL, audioop_bias__doc__},
783 : :
784 : : static PyObject *
785 : : audioop_bias_impl(PyObject *module, Py_buffer *fragment, int width, int bias);
786 : :
787 : : static PyObject *
788 : 105 : audioop_bias(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
789 : : {
790 : 105 : PyObject *return_value = NULL;
791 : 105 : Py_buffer fragment = {NULL, NULL};
792 : : int width;
793 : : int bias;
794 : :
795 [ + - - + : 105 : if (!_PyArg_CheckPositional("bias", nargs, 3, 3)) {
- - ]
796 : 0 : goto exit;
797 : : }
798 [ + + ]: 105 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
799 : 1 : goto exit;
800 : : }
801 [ - + ]: 104 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
802 : 0 : _PyArg_BadArgument("bias", "argument 1", "contiguous buffer", args[0]);
803 : 0 : goto exit;
804 : : }
805 : 104 : width = _PyLong_AsInt(args[1]);
806 [ - + - - ]: 104 : if (width == -1 && PyErr_Occurred()) {
807 : 0 : goto exit;
808 : : }
809 : 104 : bias = _PyLong_AsInt(args[2]);
810 [ + + - + ]: 104 : if (bias == -1 && PyErr_Occurred()) {
811 : 0 : goto exit;
812 : : }
813 : 104 : return_value = audioop_bias_impl(module, &fragment, width, bias);
814 : :
815 : 105 : exit:
816 : : /* Cleanup for fragment */
817 [ + + ]: 105 : if (fragment.obj) {
818 : 104 : PyBuffer_Release(&fragment);
819 : : }
820 : :
821 : 105 : return return_value;
822 : : }
823 : :
824 : : PyDoc_STRVAR(audioop_reverse__doc__,
825 : : "reverse($module, fragment, width, /)\n"
826 : : "--\n"
827 : : "\n"
828 : : "Reverse the samples in a fragment and returns the modified fragment.");
829 : :
830 : : #define AUDIOOP_REVERSE_METHODDEF \
831 : : {"reverse", _PyCFunction_CAST(audioop_reverse), METH_FASTCALL, audioop_reverse__doc__},
832 : :
833 : : static PyObject *
834 : : audioop_reverse_impl(PyObject *module, Py_buffer *fragment, int width);
835 : :
836 : : static PyObject *
837 : 21 : audioop_reverse(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
838 : : {
839 : 21 : PyObject *return_value = NULL;
840 : 21 : Py_buffer fragment = {NULL, NULL};
841 : : int width;
842 : :
843 [ + - - + : 21 : if (!_PyArg_CheckPositional("reverse", nargs, 2, 2)) {
- - ]
844 : 0 : goto exit;
845 : : }
846 [ + + ]: 21 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
847 : 1 : goto exit;
848 : : }
849 [ - + ]: 20 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
850 : 0 : _PyArg_BadArgument("reverse", "argument 1", "contiguous buffer", args[0]);
851 : 0 : goto exit;
852 : : }
853 : 20 : width = _PyLong_AsInt(args[1]);
854 [ - + - - ]: 20 : if (width == -1 && PyErr_Occurred()) {
855 : 0 : goto exit;
856 : : }
857 : 20 : return_value = audioop_reverse_impl(module, &fragment, width);
858 : :
859 : 21 : exit:
860 : : /* Cleanup for fragment */
861 [ + + ]: 21 : if (fragment.obj) {
862 : 20 : PyBuffer_Release(&fragment);
863 : : }
864 : :
865 : 21 : return return_value;
866 : : }
867 : :
868 : : PyDoc_STRVAR(audioop_byteswap__doc__,
869 : : "byteswap($module, fragment, width, /)\n"
870 : : "--\n"
871 : : "\n"
872 : : "Convert big-endian samples to little-endian and vice versa.");
873 : :
874 : : #define AUDIOOP_BYTESWAP_METHODDEF \
875 : : {"byteswap", _PyCFunction_CAST(audioop_byteswap), METH_FASTCALL, audioop_byteswap__doc__},
876 : :
877 : : static PyObject *
878 : : audioop_byteswap_impl(PyObject *module, Py_buffer *fragment, int width);
879 : :
880 : : static PyObject *
881 : 23 : audioop_byteswap(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
882 : : {
883 : 23 : PyObject *return_value = NULL;
884 : 23 : Py_buffer fragment = {NULL, NULL};
885 : : int width;
886 : :
887 [ + - - + : 23 : if (!_PyArg_CheckPositional("byteswap", nargs, 2, 2)) {
- - ]
888 : 0 : goto exit;
889 : : }
890 [ - + ]: 23 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
891 : 0 : goto exit;
892 : : }
893 [ - + ]: 23 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
894 : 0 : _PyArg_BadArgument("byteswap", "argument 1", "contiguous buffer", args[0]);
895 : 0 : goto exit;
896 : : }
897 : 23 : width = _PyLong_AsInt(args[1]);
898 [ - + - - ]: 23 : if (width == -1 && PyErr_Occurred()) {
899 : 0 : goto exit;
900 : : }
901 : 23 : return_value = audioop_byteswap_impl(module, &fragment, width);
902 : :
903 : 23 : exit:
904 : : /* Cleanup for fragment */
905 [ + - ]: 23 : if (fragment.obj) {
906 : 23 : PyBuffer_Release(&fragment);
907 : : }
908 : :
909 : 23 : return return_value;
910 : : }
911 : :
912 : : PyDoc_STRVAR(audioop_lin2lin__doc__,
913 : : "lin2lin($module, fragment, width, newwidth, /)\n"
914 : : "--\n"
915 : : "\n"
916 : : "Convert samples between 1-, 2-, 3- and 4-byte formats.");
917 : :
918 : : #define AUDIOOP_LIN2LIN_METHODDEF \
919 : : {"lin2lin", _PyCFunction_CAST(audioop_lin2lin), METH_FASTCALL, audioop_lin2lin__doc__},
920 : :
921 : : static PyObject *
922 : : audioop_lin2lin_impl(PyObject *module, Py_buffer *fragment, int width,
923 : : int newwidth);
924 : :
925 : : static PyObject *
926 : 29 : audioop_lin2lin(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
927 : : {
928 : 29 : PyObject *return_value = NULL;
929 : 29 : Py_buffer fragment = {NULL, NULL};
930 : : int width;
931 : : int newwidth;
932 : :
933 [ + - - + : 29 : if (!_PyArg_CheckPositional("lin2lin", nargs, 3, 3)) {
- - ]
934 : 0 : goto exit;
935 : : }
936 [ + + ]: 29 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
937 : 1 : goto exit;
938 : : }
939 [ - + ]: 28 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
940 : 0 : _PyArg_BadArgument("lin2lin", "argument 1", "contiguous buffer", args[0]);
941 : 0 : goto exit;
942 : : }
943 : 28 : width = _PyLong_AsInt(args[1]);
944 [ - + - - ]: 28 : if (width == -1 && PyErr_Occurred()) {
945 : 0 : goto exit;
946 : : }
947 : 28 : newwidth = _PyLong_AsInt(args[2]);
948 [ - + - - ]: 28 : if (newwidth == -1 && PyErr_Occurred()) {
949 : 0 : goto exit;
950 : : }
951 : 28 : return_value = audioop_lin2lin_impl(module, &fragment, width, newwidth);
952 : :
953 : 29 : exit:
954 : : /* Cleanup for fragment */
955 [ + + ]: 29 : if (fragment.obj) {
956 : 28 : PyBuffer_Release(&fragment);
957 : : }
958 : :
959 : 29 : return return_value;
960 : : }
961 : :
962 : : PyDoc_STRVAR(audioop_ratecv__doc__,
963 : : "ratecv($module, fragment, width, nchannels, inrate, outrate, state,\n"
964 : : " weightA=1, weightB=0, /)\n"
965 : : "--\n"
966 : : "\n"
967 : : "Convert the frame rate of the input fragment.");
968 : :
969 : : #define AUDIOOP_RATECV_METHODDEF \
970 : : {"ratecv", _PyCFunction_CAST(audioop_ratecv), METH_FASTCALL, audioop_ratecv__doc__},
971 : :
972 : : static PyObject *
973 : : audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
974 : : int nchannels, int inrate, int outrate, PyObject *state,
975 : : int weightA, int weightB);
976 : :
977 : : static PyObject *
978 : 77 : audioop_ratecv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
979 : : {
980 : 77 : PyObject *return_value = NULL;
981 : 77 : Py_buffer fragment = {NULL, NULL};
982 : : int width;
983 : : int nchannels;
984 : : int inrate;
985 : : int outrate;
986 : : PyObject *state;
987 : 77 : int weightA = 1;
988 : 77 : int weightB = 0;
989 : :
990 [ + - - + : 77 : if (!_PyArg_CheckPositional("ratecv", nargs, 6, 8)) {
- - ]
991 : 0 : goto exit;
992 : : }
993 [ + + ]: 77 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
994 : 1 : goto exit;
995 : : }
996 [ - + ]: 76 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
997 : 0 : _PyArg_BadArgument("ratecv", "argument 1", "contiguous buffer", args[0]);
998 : 0 : goto exit;
999 : : }
1000 : 76 : width = _PyLong_AsInt(args[1]);
1001 [ - + - - ]: 76 : if (width == -1 && PyErr_Occurred()) {
1002 : 0 : goto exit;
1003 : : }
1004 : 76 : nchannels = _PyLong_AsInt(args[2]);
1005 [ - + - - ]: 76 : if (nchannels == -1 && PyErr_Occurred()) {
1006 : 0 : goto exit;
1007 : : }
1008 : 76 : inrate = _PyLong_AsInt(args[3]);
1009 [ - + - - ]: 76 : if (inrate == -1 && PyErr_Occurred()) {
1010 : 0 : goto exit;
1011 : : }
1012 : 76 : outrate = _PyLong_AsInt(args[4]);
1013 [ - + - - ]: 76 : if (outrate == -1 && PyErr_Occurred()) {
1014 : 0 : goto exit;
1015 : : }
1016 : 76 : state = args[5];
1017 [ + + ]: 76 : if (nargs < 7) {
1018 : 64 : goto skip_optional;
1019 : : }
1020 : 12 : weightA = _PyLong_AsInt(args[6]);
1021 [ - + - - ]: 12 : if (weightA == -1 && PyErr_Occurred()) {
1022 : 0 : goto exit;
1023 : : }
1024 [ - + ]: 12 : if (nargs < 8) {
1025 : 0 : goto skip_optional;
1026 : : }
1027 : 12 : weightB = _PyLong_AsInt(args[7]);
1028 [ - + - - ]: 12 : if (weightB == -1 && PyErr_Occurred()) {
1029 : 0 : goto exit;
1030 : : }
1031 : 12 : skip_optional:
1032 : 76 : return_value = audioop_ratecv_impl(module, &fragment, width, nchannels, inrate, outrate, state, weightA, weightB);
1033 : :
1034 : 77 : exit:
1035 : : /* Cleanup for fragment */
1036 [ + + ]: 77 : if (fragment.obj) {
1037 : 76 : PyBuffer_Release(&fragment);
1038 : : }
1039 : :
1040 : 77 : return return_value;
1041 : : }
1042 : :
1043 : : PyDoc_STRVAR(audioop_lin2ulaw__doc__,
1044 : : "lin2ulaw($module, fragment, width, /)\n"
1045 : : "--\n"
1046 : : "\n"
1047 : : "Convert samples in the audio fragment to u-LAW encoding.");
1048 : :
1049 : : #define AUDIOOP_LIN2ULAW_METHODDEF \
1050 : : {"lin2ulaw", _PyCFunction_CAST(audioop_lin2ulaw), METH_FASTCALL, audioop_lin2ulaw__doc__},
1051 : :
1052 : : static PyObject *
1053 : : audioop_lin2ulaw_impl(PyObject *module, Py_buffer *fragment, int width);
1054 : :
1055 : : static PyObject *
1056 : 201 : audioop_lin2ulaw(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1057 : : {
1058 : 201 : PyObject *return_value = NULL;
1059 : 201 : Py_buffer fragment = {NULL, NULL};
1060 : : int width;
1061 : :
1062 [ + - - + : 201 : if (!_PyArg_CheckPositional("lin2ulaw", nargs, 2, 2)) {
- - ]
1063 : 0 : goto exit;
1064 : : }
1065 [ + + ]: 201 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1066 : 1 : goto exit;
1067 : : }
1068 [ - + ]: 200 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1069 : 0 : _PyArg_BadArgument("lin2ulaw", "argument 1", "contiguous buffer", args[0]);
1070 : 0 : goto exit;
1071 : : }
1072 : 200 : width = _PyLong_AsInt(args[1]);
1073 [ - + - - ]: 200 : if (width == -1 && PyErr_Occurred()) {
1074 : 0 : goto exit;
1075 : : }
1076 : 200 : return_value = audioop_lin2ulaw_impl(module, &fragment, width);
1077 : :
1078 : 201 : exit:
1079 : : /* Cleanup for fragment */
1080 [ + + ]: 201 : if (fragment.obj) {
1081 : 200 : PyBuffer_Release(&fragment);
1082 : : }
1083 : :
1084 : 201 : return return_value;
1085 : : }
1086 : :
1087 : : PyDoc_STRVAR(audioop_ulaw2lin__doc__,
1088 : : "ulaw2lin($module, fragment, width, /)\n"
1089 : : "--\n"
1090 : : "\n"
1091 : : "Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.");
1092 : :
1093 : : #define AUDIOOP_ULAW2LIN_METHODDEF \
1094 : : {"ulaw2lin", _PyCFunction_CAST(audioop_ulaw2lin), METH_FASTCALL, audioop_ulaw2lin__doc__},
1095 : :
1096 : : static PyObject *
1097 : : audioop_ulaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
1098 : :
1099 : : static PyObject *
1100 : 219 : audioop_ulaw2lin(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1101 : : {
1102 : 219 : PyObject *return_value = NULL;
1103 : 219 : Py_buffer fragment = {NULL, NULL};
1104 : : int width;
1105 : :
1106 [ + - - + : 219 : if (!_PyArg_CheckPositional("ulaw2lin", nargs, 2, 2)) {
- - ]
1107 : 0 : goto exit;
1108 : : }
1109 [ - + ]: 219 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1110 : 0 : goto exit;
1111 : : }
1112 [ - + ]: 219 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1113 : 0 : _PyArg_BadArgument("ulaw2lin", "argument 1", "contiguous buffer", args[0]);
1114 : 0 : goto exit;
1115 : : }
1116 : 219 : width = _PyLong_AsInt(args[1]);
1117 [ + + - + ]: 219 : if (width == -1 && PyErr_Occurred()) {
1118 : 0 : goto exit;
1119 : : }
1120 : 219 : return_value = audioop_ulaw2lin_impl(module, &fragment, width);
1121 : :
1122 : 219 : exit:
1123 : : /* Cleanup for fragment */
1124 [ + - ]: 219 : if (fragment.obj) {
1125 : 219 : PyBuffer_Release(&fragment);
1126 : : }
1127 : :
1128 : 219 : return return_value;
1129 : : }
1130 : :
1131 : : PyDoc_STRVAR(audioop_lin2alaw__doc__,
1132 : : "lin2alaw($module, fragment, width, /)\n"
1133 : : "--\n"
1134 : : "\n"
1135 : : "Convert samples in the audio fragment to a-LAW encoding.");
1136 : :
1137 : : #define AUDIOOP_LIN2ALAW_METHODDEF \
1138 : : {"lin2alaw", _PyCFunction_CAST(audioop_lin2alaw), METH_FASTCALL, audioop_lin2alaw__doc__},
1139 : :
1140 : : static PyObject *
1141 : : audioop_lin2alaw_impl(PyObject *module, Py_buffer *fragment, int width);
1142 : :
1143 : : static PyObject *
1144 : 107 : audioop_lin2alaw(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1145 : : {
1146 : 107 : PyObject *return_value = NULL;
1147 : 107 : Py_buffer fragment = {NULL, NULL};
1148 : : int width;
1149 : :
1150 [ + - - + : 107 : if (!_PyArg_CheckPositional("lin2alaw", nargs, 2, 2)) {
- - ]
1151 : 0 : goto exit;
1152 : : }
1153 [ + + ]: 107 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1154 : 1 : goto exit;
1155 : : }
1156 [ - + ]: 106 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1157 : 0 : _PyArg_BadArgument("lin2alaw", "argument 1", "contiguous buffer", args[0]);
1158 : 0 : goto exit;
1159 : : }
1160 : 106 : width = _PyLong_AsInt(args[1]);
1161 [ - + - - ]: 106 : if (width == -1 && PyErr_Occurred()) {
1162 : 0 : goto exit;
1163 : : }
1164 : 106 : return_value = audioop_lin2alaw_impl(module, &fragment, width);
1165 : :
1166 : 107 : exit:
1167 : : /* Cleanup for fragment */
1168 [ + + ]: 107 : if (fragment.obj) {
1169 : 106 : PyBuffer_Release(&fragment);
1170 : : }
1171 : :
1172 : 107 : return return_value;
1173 : : }
1174 : :
1175 : : PyDoc_STRVAR(audioop_alaw2lin__doc__,
1176 : : "alaw2lin($module, fragment, width, /)\n"
1177 : : "--\n"
1178 : : "\n"
1179 : : "Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.");
1180 : :
1181 : : #define AUDIOOP_ALAW2LIN_METHODDEF \
1182 : : {"alaw2lin", _PyCFunction_CAST(audioop_alaw2lin), METH_FASTCALL, audioop_alaw2lin__doc__},
1183 : :
1184 : : static PyObject *
1185 : : audioop_alaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
1186 : :
1187 : : static PyObject *
1188 : 118 : audioop_alaw2lin(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1189 : : {
1190 : 118 : PyObject *return_value = NULL;
1191 : 118 : Py_buffer fragment = {NULL, NULL};
1192 : : int width;
1193 : :
1194 [ + - - + : 118 : if (!_PyArg_CheckPositional("alaw2lin", nargs, 2, 2)) {
- - ]
1195 : 0 : goto exit;
1196 : : }
1197 [ - + ]: 118 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1198 : 0 : goto exit;
1199 : : }
1200 [ - + ]: 118 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1201 : 0 : _PyArg_BadArgument("alaw2lin", "argument 1", "contiguous buffer", args[0]);
1202 : 0 : goto exit;
1203 : : }
1204 : 118 : width = _PyLong_AsInt(args[1]);
1205 [ + + - + ]: 118 : if (width == -1 && PyErr_Occurred()) {
1206 : 0 : goto exit;
1207 : : }
1208 : 118 : return_value = audioop_alaw2lin_impl(module, &fragment, width);
1209 : :
1210 : 118 : exit:
1211 : : /* Cleanup for fragment */
1212 [ + - ]: 118 : if (fragment.obj) {
1213 : 118 : PyBuffer_Release(&fragment);
1214 : : }
1215 : :
1216 : 118 : return return_value;
1217 : : }
1218 : :
1219 : : PyDoc_STRVAR(audioop_lin2adpcm__doc__,
1220 : : "lin2adpcm($module, fragment, width, state, /)\n"
1221 : : "--\n"
1222 : : "\n"
1223 : : "Convert samples to 4 bit Intel/DVI ADPCM encoding.");
1224 : :
1225 : : #define AUDIOOP_LIN2ADPCM_METHODDEF \
1226 : : {"lin2adpcm", _PyCFunction_CAST(audioop_lin2adpcm), METH_FASTCALL, audioop_lin2adpcm__doc__},
1227 : :
1228 : : static PyObject *
1229 : : audioop_lin2adpcm_impl(PyObject *module, Py_buffer *fragment, int width,
1230 : : PyObject *state);
1231 : :
1232 : : static PyObject *
1233 : 20 : audioop_lin2adpcm(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1234 : : {
1235 : 20 : PyObject *return_value = NULL;
1236 : 20 : Py_buffer fragment = {NULL, NULL};
1237 : : int width;
1238 : : PyObject *state;
1239 : :
1240 [ + - - + : 20 : if (!_PyArg_CheckPositional("lin2adpcm", nargs, 3, 3)) {
- - ]
1241 : 0 : goto exit;
1242 : : }
1243 [ + + ]: 20 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1244 : 1 : goto exit;
1245 : : }
1246 [ - + ]: 19 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1247 : 0 : _PyArg_BadArgument("lin2adpcm", "argument 1", "contiguous buffer", args[0]);
1248 : 0 : goto exit;
1249 : : }
1250 : 19 : width = _PyLong_AsInt(args[1]);
1251 [ - + - - ]: 19 : if (width == -1 && PyErr_Occurred()) {
1252 : 0 : goto exit;
1253 : : }
1254 : 19 : state = args[2];
1255 : 19 : return_value = audioop_lin2adpcm_impl(module, &fragment, width, state);
1256 : :
1257 : 20 : exit:
1258 : : /* Cleanup for fragment */
1259 [ + + ]: 20 : if (fragment.obj) {
1260 : 19 : PyBuffer_Release(&fragment);
1261 : : }
1262 : :
1263 : 20 : return return_value;
1264 : : }
1265 : :
1266 : : PyDoc_STRVAR(audioop_adpcm2lin__doc__,
1267 : : "adpcm2lin($module, fragment, width, state, /)\n"
1268 : : "--\n"
1269 : : "\n"
1270 : : "Decode an Intel/DVI ADPCM coded fragment to a linear fragment.");
1271 : :
1272 : : #define AUDIOOP_ADPCM2LIN_METHODDEF \
1273 : : {"adpcm2lin", _PyCFunction_CAST(audioop_adpcm2lin), METH_FASTCALL, audioop_adpcm2lin__doc__},
1274 : :
1275 : : static PyObject *
1276 : : audioop_adpcm2lin_impl(PyObject *module, Py_buffer *fragment, int width,
1277 : : PyObject *state);
1278 : :
1279 : : static PyObject *
1280 : 19 : audioop_adpcm2lin(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1281 : : {
1282 : 19 : PyObject *return_value = NULL;
1283 : 19 : Py_buffer fragment = {NULL, NULL};
1284 : : int width;
1285 : : PyObject *state;
1286 : :
1287 [ + - - + : 19 : if (!_PyArg_CheckPositional("adpcm2lin", nargs, 3, 3)) {
- - ]
1288 : 0 : goto exit;
1289 : : }
1290 [ - + ]: 19 : if (PyObject_GetBuffer(args[0], &fragment, PyBUF_SIMPLE) != 0) {
1291 : 0 : goto exit;
1292 : : }
1293 [ - + ]: 19 : if (!PyBuffer_IsContiguous(&fragment, 'C')) {
1294 : 0 : _PyArg_BadArgument("adpcm2lin", "argument 1", "contiguous buffer", args[0]);
1295 : 0 : goto exit;
1296 : : }
1297 : 19 : width = _PyLong_AsInt(args[1]);
1298 [ + + - + ]: 19 : if (width == -1 && PyErr_Occurred()) {
1299 : 0 : goto exit;
1300 : : }
1301 : 19 : state = args[2];
1302 : 19 : return_value = audioop_adpcm2lin_impl(module, &fragment, width, state);
1303 : :
1304 : 19 : exit:
1305 : : /* Cleanup for fragment */
1306 [ + - ]: 19 : if (fragment.obj) {
1307 : 19 : PyBuffer_Release(&fragment);
1308 : : }
1309 : :
1310 : 19 : return return_value;
1311 : : }
1312 : : /*[clinic end generated code: output=a581c3893ef8ad75 input=a9049054013a1b77]*/
|
