Lines Matching +full:- +full:w
12 packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 3, 4)}
13 maxvalues = {w: (1 << (8 * w - 1)) - 1 for w in (1, 2, 3, 4)}
14 minvalues = {w: -1 << (8 * w - 1) for w in (1, 2, 3, 4)}
18 2: packs[2](0, 0x1234, 0x4567, -0x4567, 0x7fff, -0x8000, -1),
19 3: packs[3](0, 0x123456, 0x456789, -0x456789, 0x7fffff, -0x800000, -1),
20 4: packs[4](0, 0x12345678, 0x456789ab, -0x456789ab,
21 0x7fffffff, -0x80000000, -1),
35 for w in 1, 2, 3, 4:
36 self.assertEqual(audioop.max(b'', w), 0)
37 self.assertEqual(audioop.max(bytearray(), w), 0)
38 self.assertEqual(audioop.max(memoryview(b''), w), 0)
39 p = packs[w]
40 self.assertEqual(audioop.max(p(5), w), 5)
41 self.assertEqual(audioop.max(p(5, -8, -1), w), 8)
42 self.assertEqual(audioop.max(p(maxvalues[w]), w), maxvalues[w])
43 self.assertEqual(audioop.max(p(minvalues[w]), w), -minvalues[w])
44 self.assertEqual(audioop.max(datas[w], w), -minvalues[w])
47 for w in 1, 2, 3, 4:
48 self.assertEqual(audioop.minmax(b'', w),
49 (0x7fffffff, -0x80000000))
50 self.assertEqual(audioop.minmax(bytearray(), w),
51 (0x7fffffff, -0x80000000))
52 self.assertEqual(audioop.minmax(memoryview(b''), w),
53 (0x7fffffff, -0x80000000))
54 p = packs[w]
55 self.assertEqual(audioop.minmax(p(5), w), (5, 5))
56 self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
57 self.assertEqual(audioop.minmax(p(maxvalues[w]), w),
58 (maxvalues[w], maxvalues[w]))
59 self.assertEqual(audioop.minmax(p(minvalues[w]), w),
60 (minvalues[w], minvalues[w]))
61 self.assertEqual(audioop.minmax(datas[w], w),
62 (minvalues[w], maxvalues[w]))
65 for w in 1, 2, 3, 4:
66 self.assertEqual(audioop.maxpp(b'', w), 0)
67 self.assertEqual(audioop.maxpp(bytearray(), w), 0)
68 self.assertEqual(audioop.maxpp(memoryview(b''), w), 0)
69 self.assertEqual(audioop.maxpp(packs[w](*range(100)), w), 0)
70 self.assertEqual(audioop.maxpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
71 self.assertEqual(audioop.maxpp(datas[w], w),
72 maxvalues[w] - minvalues[w])
75 for w in 1, 2, 3, 4:
76 self.assertEqual(audioop.avg(b'', w), 0)
77 self.assertEqual(audioop.avg(bytearray(), w), 0)
78 self.assertEqual(audioop.avg(memoryview(b''), w), 0)
79 p = packs[w]
80 self.assertEqual(audioop.avg(p(5), w), 5)
81 self .assertEqual(audioop.avg(p(5, 8), w), 6)
82 self.assertEqual(audioop.avg(p(5, -8), w), -2)
83 self.assertEqual(audioop.avg(p(maxvalues[w], maxvalues[w]), w),
84 maxvalues[w])
85 self.assertEqual(audioop.avg(p(minvalues[w], minvalues[w]), w),
86 minvalues[w])
89 self.assertEqual(audioop.avg(packs[4](-0x50000000, -0x70000000), 4),
90 -0x60000000)
93 for w in 1, 2, 3, 4:
94 self.assertEqual(audioop.avgpp(b'', w), 0)
95 self.assertEqual(audioop.avgpp(bytearray(), w), 0)
96 self.assertEqual(audioop.avgpp(memoryview(b''), w), 0)
97 self.assertEqual(audioop.avgpp(packs[w](*range(100)), w), 0)
98 self.assertEqual(audioop.avgpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
105 for w in 1, 2, 3, 4:
106 self.assertEqual(audioop.rms(b'', w), 0)
107 self.assertEqual(audioop.rms(bytearray(), w), 0)
108 self.assertEqual(audioop.rms(memoryview(b''), w), 0)
109 p = packs[w]
110 self.assertEqual(audioop.rms(p(*range(100)), w), 57)
111 self.assertAlmostEqual(audioop.rms(p(maxvalues[w]) * 5, w),
112 maxvalues[w], delta=1)
113 self.assertAlmostEqual(audioop.rms(p(minvalues[w]) * 5, w),
114 -minvalues[w], delta=1)
121 for w in 1, 2, 3, 4:
122 self.assertEqual(audioop.cross(b'', w), -1)
123 self.assertEqual(audioop.cross(bytearray(), w), -1)
124 self.assertEqual(audioop.cross(memoryview(b''), w), -1)
125 p = packs[w]
126 self.assertEqual(audioop.cross(p(0, 1, 2), w), 0)
127 self.assertEqual(audioop.cross(p(1, 2, -3, -4), w), 1)
128 self.assertEqual(audioop.cross(p(-1, -2, 3, 4), w), 1)
129 self.assertEqual(audioop.cross(p(0, minvalues[w]), w), 1)
130 self.assertEqual(audioop.cross(p(minvalues[w], maxvalues[w]), w), 1)
133 for w in 1, 2, 3, 4:
134 self.assertEqual(audioop.add(b'', b'', w), b'')
135 self.assertEqual(audioop.add(bytearray(), bytearray(), w), b'')
136 self.assertEqual(audioop.add(memoryview(b''), memoryview(b''), w), b'')
137 self.assertEqual(audioop.add(datas[w], b'\0' * len(datas[w]), w),
138 datas[w])
142 packs[2](0, 0x2468, 0x7fff, -0x8000, 0x7fff, -0x8000, -2))
144 packs[3](0, 0x2468ac, 0x7fffff, -0x800000,
145 0x7fffff, -0x800000, -2))
147 packs[4](0, 0x2468acf0, 0x7fffffff, -0x80000000,
148 0x7fffffff, -0x80000000, -2))
151 for w in 1, 2, 3, 4:
152 for bias in 0, 1, -1, 127, -128, 0x7fffffff, -0x80000000:
153 self.assertEqual(audioop.bias(b'', w, bias), b'')
154 self.assertEqual(audioop.bias(bytearray(), w, bias), b'')
155 self.assertEqual(audioop.bias(memoryview(b''), w, bias), b'')
158 self.assertEqual(audioop.bias(datas[1], 1, -1),
162 self.assertEqual(audioop.bias(datas[1], 1, -0x80000000),
165 packs[2](1, 0x1235, 0x4568, -0x4566, -0x8000, -0x7fff, 0))
166 self.assertEqual(audioop.bias(datas[2], 2, -1),
167 packs[2](-1, 0x1233, 0x4566, -0x4568, 0x7ffe, 0x7fff, -2))
169 packs[2](-1, 0x1233, 0x4566, -0x4568, 0x7ffe, 0x7fff, -2))
170 self.assertEqual(audioop.bias(datas[2], 2, -0x80000000),
173 packs[3](1, 0x123457, 0x45678a, -0x456788,
174 -0x800000, -0x7fffff, 0))
175 self.assertEqual(audioop.bias(datas[3], 3, -1),
176 packs[3](-1, 0x123455, 0x456788, -0x45678a,
177 0x7ffffe, 0x7fffff, -2))
179 packs[3](-1, 0x123455, 0x456788, -0x45678a,
180 0x7ffffe, 0x7fffff, -2))
181 self.assertEqual(audioop.bias(datas[3], 3, -0x80000000),
184 packs[4](1, 0x12345679, 0x456789ac, -0x456789aa,
185 -0x80000000, -0x7fffffff, 0))
186 self.assertEqual(audioop.bias(datas[4], 4, -1),
187 packs[4](-1, 0x12345677, 0x456789aa, -0x456789ac,
188 0x7ffffffe, 0x7fffffff, -2))
190 packs[4](0x7fffffff, -0x6dcba989, -0x3a987656, 0x3a987654,
191 -2, -1, 0x7ffffffe))
192 self.assertEqual(audioop.bias(datas[4], 4, -0x80000000),
193 packs[4](-0x80000000, -0x6dcba988, -0x3a987655, 0x3a987655,
194 -1, 0, 0x7fffffff))
197 for w in 1, 2, 3, 4:
198 self.assertEqual(audioop.lin2lin(datas[w], w, w), datas[w])
199 self.assertEqual(audioop.lin2lin(bytearray(datas[w]), w, w),
200 datas[w])
201 self.assertEqual(audioop.lin2lin(memoryview(datas[w]), w, w),
202 datas[w])
205 packs[2](0, 0x1200, 0x4500, -0x4500, 0x7f00, -0x8000, -0x100))
207 packs[3](0, 0x120000, 0x450000, -0x450000,
208 0x7f0000, -0x800000, -0x10000))
210 packs[4](0, 0x12000000, 0x45000000, -0x45000000,
211 0x7f000000, -0x80000000, -0x1000000))
215 packs[3](0, 0x123400, 0x456700, -0x456700,
216 0x7fff00, -0x800000, -0x100))
218 packs[4](0, 0x12340000, 0x45670000, -0x45670000,
219 0x7fff0000, -0x80000000, -0x10000))
223 packs[2](0, 0x1234, 0x4567, -0x4568, 0x7fff, -0x8000, -1))
225 packs[4](0, 0x12345600, 0x45678900, -0x45678900,
226 0x7fffff00, -0x80000000, -0x100))
230 packs[2](0, 0x1234, 0x4567, -0x4568, 0x7fff, -0x8000, -1))
232 packs[3](0, 0x123456, 0x456789, -0x45678a,
233 0x7fffff, -0x800000, -1))
237 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
239 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
241 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
243 (packs[2](0, 0xb, 0x29, -0x16, 0x72, -0xb3), (-179, 40)))
245 (packs[3](0, 0xb00, 0x2900, -0x1600, 0x7200,
246 -0xb300), (-179, 40)))
248 (packs[4](0, 0xb0000, 0x290000, -0x160000, 0x720000,
249 -0xb30000), (-179, 40)))
252 for w in 1, 2, 3, 4:
253 self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
254 (b'\0' * w * 10, (0, 0)))
258 (b'\x07\x7f\x7f', (-221, 39)))
260 (b'\x07\x7f\x7f', (-221, 39)))
262 (b'\x07\x7f\x7f', (-221, 39)))
263 for w in 2, 3, 4:
264 self.assertEqual(audioop.lin2adpcm(datas[w], w, None),
268 for w in 1, 2, 3, 4:
269 self.assertEqual(audioop.lin2adpcm(b'\0' * w * 10, w, None),
277 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (0, -1))
279 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (0, -1))
282 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (-0x8001, 0))
284 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (-0x8001, 0))
294 for w in 2, 3, 4:
295 self.assertEqual(audioop.lin2alaw(datas[w], w),
301 src = [-688, -720, -2240, -4032, -9, -3, -1, -27, -244, -82, -106,
303 for w in 1, 2, 3, 4:
304 decoded = packs[w](*(x << (w * 8) >> 13 for x in src))
305 self.assertEqual(audioop.alaw2lin(encoded, w), decoded)
306 self.assertEqual(audioop.alaw2lin(bytearray(encoded), w), decoded)
307 self.assertEqual(audioop.alaw2lin(memoryview(encoded), w), decoded)
310 for w in 2, 3, 4:
311 decoded = audioop.alaw2lin(encoded, w)
312 self.assertEqual(audioop.lin2alaw(decoded, w), encoded)
321 for w in 2, 3, 4:
322 self.assertEqual(audioop.lin2ulaw(datas[w], w),
328 src = [-8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0,
330 for w in 1, 2, 3, 4:
331 decoded = packs[w](*(x << (w * 8) >> 14 for x in src))
332 self.assertEqual(audioop.ulaw2lin(encoded, w), decoded)
333 self.assertEqual(audioop.ulaw2lin(bytearray(encoded), w), decoded)
334 self.assertEqual(audioop.ulaw2lin(memoryview(encoded), w), decoded)
336 # Current u-law implementation has two codes fo 0: 0x7f and 0xff.
338 for w in 2, 3, 4:
339 decoded = audioop.ulaw2lin(encoded, w)
340 self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
343 for w in 1, 2, 3, 4:
344 self.assertEqual(audioop.mul(b'', w, 2), b'')
345 self.assertEqual(audioop.mul(bytearray(), w, 2), b'')
346 self.assertEqual(audioop.mul(memoryview(b''), w, 2), b'')
347 self.assertEqual(audioop.mul(datas[w], w, 0),
348 b'\0' * len(datas[w]))
349 self.assertEqual(audioop.mul(datas[w], w, 1),
350 datas[w])
354 packs[2](0, 0x2468, 0x7fff, -0x8000, 0x7fff, -0x8000, -2))
356 packs[3](0, 0x2468ac, 0x7fffff, -0x800000,
357 0x7fffff, -0x800000, -2))
359 packs[4](0, 0x2468acf0, 0x7fffffff, -0x80000000,
360 0x7fffffff, -0x80000000, -2))
363 for w in 1, 2, 3, 4:
364 self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 8000, None),
365 (b'', (-1, ((0, 0),))))
366 self.assertEqual(audioop.ratecv(bytearray(), w, 1, 8000, 8000, None),
367 (b'', (-1, ((0, 0),))))
368 self.assertEqual(audioop.ratecv(memoryview(b''), w, 1, 8000, 8000, None),
369 (b'', (-1, ((0, 0),))))
370 self.assertEqual(audioop.ratecv(b'', w, 5, 8000, 8000, None),
371 (b'', (-1, ((0, 0),) * 5)))
372 self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 16000, None),
373 (b'', (-2, ((0, 0),))))
374 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None)[0],
375 datas[w])
376 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 1, 0)[0],
377 datas[w])
384 for w in 1, 2, 3, 4:
385 d0, state0 = audioop.ratecv(datas[w], w, 1, 8000, 16000, None)
387 for i in range(0, len(datas[w]), w):
388 d1, state = audioop.ratecv(datas[w][i:i + w], w, 1,
395 1: packs[1](0, 0x0d, 0x37, -0x26, 0x55, -0x4b, -0x14),
396 2: packs[2](0, 0x0da7, 0x3777, -0x2630, 0x5673, -0x4a64, -0x129a),
397 3: packs[3](0, 0x0da740, 0x377776, -0x262fca,
398 0x56740c, -0x4a62fd, -0x1298c0),
399 4: packs[4](0, 0x0da740da, 0x37777776, -0x262fc962,
400 0x56740da6, -0x4a62fc96, -0x1298bf26),
402 for w in 1, 2, 3, 4:
403 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 3, 1)[0],
404 expected[w])
405 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 30, 10)[0],
406 expected[w])
413 for w in 1, 2, 3, 4:
414 self.assertEqual(audioop.reverse(b'', w), b'')
415 self.assertEqual(audioop.reverse(bytearray(), w), b'')
416 self.assertEqual(audioop.reverse(memoryview(b''), w), b'')
417 self.assertEqual(audioop.reverse(packs[w](0, 1, 2), w),
418 packs[w](2, 1, 0))
421 for w in 1, 2, 3, 4:
422 data1 = datas[w]
424 for k in range(w):
425 data2[k::2*w] = data1[k::w]
426 self.assertEqual(audioop.tomono(data2, w, 1, 0), data1)
427 self.assertEqual(audioop.tomono(data2, w, 0, 1), b'\0' * len(data1))
428 for k in range(w):
429 data2[k+w::2*w] = data1[k::w]
430 self.assertEqual(audioop.tomono(data2, w, 0.5, 0.5), data1)
431 self.assertEqual(audioop.tomono(bytearray(data2), w, 0.5, 0.5),
433 self.assertEqual(audioop.tomono(memoryview(data2), w, 0.5, 0.5),
437 for w in 1, 2, 3, 4:
438 data1 = datas[w]
440 for k in range(w):
441 data2[k::2*w] = data1[k::w]
442 self.assertEqual(audioop.tostereo(data1, w, 1, 0), data2)
443 self.assertEqual(audioop.tostereo(data1, w, 0, 0), b'\0' * len(data2))
444 for k in range(w):
445 data2[k+w::2*w] = data1[k::w]
446 self.assertEqual(audioop.tostereo(data1, w, 1, 1), data2)
447 self.assertEqual(audioop.tostereo(bytearray(data1), w, 1, 1), data2)
448 self.assertEqual(audioop.tostereo(memoryview(data1), w, 1, 1),
468 self.assertEqual(audioop.findfit(datas[2][:-2] * 5 + datas[2], datas[2]),
477 for w in 1, 2, 3, 4:
478 data = packs[w](0, 1, -1, maxvalues[w], minvalues[w])
479 self.assertEqual(audioop.getsample(data, w, 0), 0)
480 self.assertEqual(audioop.getsample(bytearray(data), w, 0), 0)
481 self.assertEqual(audioop.getsample(memoryview(data), w, 0), 0)
482 self.assertEqual(audioop.getsample(data, w, 1), 1)
483 self.assertEqual(audioop.getsample(data, w, 2), -1)
484 self.assertEqual(audioop.getsample(data, w, 3), maxvalues[w])
485 self.assertEqual(audioop.getsample(data, w, 4), minvalues[w])
490 2: packs[2](0, 0x3412, 0x6745, -0x6646, -0x81, 0x80, -1),
491 3: packs[3](0, 0x563412, -0x7698bb, 0x7798ba, -0x81, 0x80, -1),
492 4: packs[4](0, 0x78563412, -0x547698bb, 0x557698ba,
493 -0x81, 0x80, -1),
495 for w in 1, 2, 3, 4:
496 self.assertEqual(audioop.byteswap(b'', w), b'')
497 self.assertEqual(audioop.byteswap(datas[w], w), swapped_datas[w])
498 self.assertEqual(audioop.byteswap(swapped_datas[w], w), datas[w])
499 self.assertEqual(audioop.byteswap(bytearray(datas[w]), w),
500 swapped_datas[w])
501 self.assertEqual(audioop.byteswap(memoryview(datas[w]), w),
502 swapped_datas[w])
507 audioop.findmax, bytes(range(256)), -2392392)
559 for size in (-1, 0, 5, 1024):